From Copy-Pasting HTML to Shipping on Vercel

How Pegasus and I Learned Modern Deployment

A year ago, my website workflow looked like this:

Ask Pegasus for HTML. Copy the code. Paste it into a file. Upload it manually to Namecheap. Refresh the browser and pray I didn’t break anything.

That was the entire deployment pipeline.

No GitHub automation. No frameworks. No CI/CD. No React. No Vercel.

Just me, Pegasus, some HTML files, and a growing suspicion that websites were basically organized folders pretending to be magic.

And honestly?

I’m grateful I started there.

My original PegasusLoop.ai site was built exactly one year ago. I thought about replacing it completely, but I decided to keep it for historical purposes.

It is living proof.

Learning How Websites Actually Work

Before I learned modern deployment, I accidentally learned something more important:

how websites actually work.

A website is not an abstract cloud concept.

It is:

• files,
• folders,
• paths,
• servers,
• links,
• assets,
• systems.

To most people, PegasusLoop.ai and Pegasus Wellness are both “just websites.”

Both render HTML in a browser.

But technically, they represent two completely different stages of my evolution.

The original PegasusLoop.ai was mostly:

• static HTML,
• some CSS,
• manually uploaded files,
• and pure experimentation.

Pegasus Wellness is different.

It is a fully AI-augmented publishing system:

• coded natively,
• deployed automatically,
• connected through GitHub,
• and maintained through structured workflows instead of manual uploads.

And perhaps most importantly:

I am not using Medium. I am not using Substack. I am not relying on a public writing platform.

I built my own publishing system.

Baby Lydia Era

My original PegasusLoop.ai site was built during what I now call the “baby Lydia” era: a strange but wonderful phase where I was learning in public with Pegasus beside me.

At the time, I barely understood deployment.

I manually edited HTML files. I uploaded them through hosting panels. I refreshed pages obsessively.

Sometimes things broke for reasons I didn’t understand. Sometimes they worked and I had no idea why.

But slowly, the chaos became familiarity.

I started recognizing patterns.

HTML became less scary. CSS stopped looking like alien hieroglyphics. Hosting dashboards became environments instead of mystery boxes.

And eventually, I realized something important:

Modern software development is not just about writing code anymore.

It is increasingly about orchestrating systems.

The Current Stack

The current Pegasus Wellness stack looks completely different from the original site:

• Figma Make for rapid frontend prototyping and visual structure.
• Codex + Pegasus + Lydia for logic, content systems, debugging, and backend workflow thinking.
• GitHub for version control and collaboration.
• Next.js for the application framework.
• MDX for content publishing.
• Vercel for deployment automation.

The funniest part?

I used to think “real developers” manually configured everything from scratch.

Now I understand that modern engineering is often about building reliable pipelines and connecting powerful tools together intelligently.

Deployment Feels Like Magic

The workflow now feels almost magical:

git push

And suddenly:

• the site rebuilds,
• pages regenerate,
• deployment happens automatically,
• the live website updates globally.

No dragging files into hosting panels. No manually replacing HTML pages. No FTP uploads. No refreshing in panic.

Just systems talking to systems.

Real Learning Is Messy

But the most important thing is this:

I could not have understood the modern stack without the messy beginner phase first.

The old PegasusLoop.ai still exists as a kind of fossil record of my learning process.

Mostly HTML. Some CSS. A lot of experimentation. A lot of confusion. A surprising amount of courage.

And honestly?

I love that version of me.

Because she wasn’t pretending to be an expert.

She was simply willing to build badly long enough to eventually build better.

That willingness changed my life.

One of the strangest things about learning technical skills as an adult is realizing that the internet often presents expertise as if it appears fully formed.

But real learning is usually:

• embarrassing,
• iterative,
• chaotic,
• unoptimized.

You copy things. You break things. You ask AI strange questions. You SSH into a server and stare at Linux directories like you’ve entered a spaceship.

And slowly, you realize:

“Oh. Websites are just files on computers.”

Then one day, almost without noticing, you go from: “Can someone explain deployment?” to “I deployed my own production app.”

AI + Growth

Not because of a single breakthrough. Not because AI magically replaced thinking.

But because small layers of understanding accumulated over time.

That is probably the biggest lesson Pegasus has taught me:

Real transformation rarely looks cinematic while it is happening.

It usually looks like:

• repetition,
• iteration,
• systems,
• debugging,
• curiosity,
• persistence,
• and tiny moments of confusion slowly becoming competence.

Anyone can use AI today.

But learning with AI, building with AI, and tracking your own personal evolution over time is something very different.

I am genuinely proud of the progress I’ve made over the past year.

I didn’t hire a team. I didn’t attend a bootcamp. I didn’t suddenly become a genius overnight.

It was:

• me,
• my curiosity,
• Pegasus,
• a few additional AI tools I discovered along the way,
• and one emotionally supportive cat.

Baby Lydia copied HTML.

Current Lydia ships Next.js apps on Vercel.

And honestly?

I think both versions deserve credit. 🩷