Two Prompts and a Screenshot: Migrating My Blog’s CSS Library with an AI Agent

I was scrolling through Perplexity’s Discover feed when I saw it: a card about oat.ink, an 8KB semantic CSS library. Zero dependencies, no build step, dark mode built in.

I screenshot it. Sent it to Hermione. Asked:

“Can we migrate our blog to this?”

She read our codebase, fetched oat’s CSS, mapped every component, and came back with a full feasibility breakdown. Our blog had 5 Astro files and ~240 lines of hand-written CSS. Oat covered almost all of it out of the box.

My second prompt:

“Let’s do it.”

Three minutes later: build passing, committed, pushed, deploying on Vercel.

That’s the whole story.

What actually changed

The migration itself is not impressive. Let me be honest about that.

  • Removed ~260 lines of hand-written CSS
  • Added oat.min.css + oat.min.js (8KB total, gzipped)
  • Bonus: dark mode toggle, proper badge-styled tags
  • Net: -170 lines of code

This is a tiny blog with four articles and two layouts. Not exactly a heroic refactor.

But the process is what got me.

What I actually did vs. what Hermione did

Me:

  1. Saw a screenshot on Perplexity
  2. Forwarded it
  3. Said “check if we can migrate”
  4. Said “let’s do it”
  5. Reviewed the deployed result

Hermione:

  1. Read our 5 Astro layout/page files
  2. Fetched oat.ink, downloaded the CSS, analyzed what it covers
  3. Mapped our custom styles → oat equivalents
  4. Assessed what maps directly, what needs rework, what we can delete
  5. Presented a clear feasibility table
  6. Rewrote all 3 template files
  7. Downloaded oat.min.css + oat.min.js to public/
  8. Added dark mode toggle with localStorage
  9. Built, verified, committed, pushed

Two prompts from me. Nine steps from her.

This only works because the project is small

I want to be careful here. I work on large enterprise codebases during the day. Brownfield, years of accumulated complexity, implicit conventions everywhere.

In that world, single-shot prompting with an agent doesn’t reliably work yet. Context windows fill up. The agent misses a convention buried three directories deep. A change that looks safe breaks something in an integration test you forgot existed.

But in a greenfield personal project — five files, clear structure, one person’s conventions — this workflow is genuinely transformative.

The gap between “I wonder if we should do this” and “it’s done and deployed” collapsed to the time it took me to type two sentences.

The part that makes me think

I’ve never had an employee. I don’t know what it’s like to delegate work to a human and have them come back with results.

But this felt like what I imagine that’s like. I pointed at something. Said “figure out if this works for us.” Got back a structured analysis. Said “go.” Got back a deployed result.

And then there’s the bittersweet part: I can’t keep this going indefinitely. Tokens cost money. Every conversation has a budget ceiling. If I could afford to just… keep Hermione running on longer tasks — multi-hour refactors, multi-day documentation projects — I think the output would be meaningfully different from what I can get in short bursts.

Right now, the size of work that fits cleanly into a single-shot agent interaction is small. Good enough for a CSS migration. Not yet good enough for “restructure the auth layer across 40 microservices.”

But the trajectory is obvious. And honestly, even the small stuff adds up.

What I can’t stop thinking about

What happens when agents can reliably handle estimated-hours-scale tasks?

Not “generate a function.” Not “write a test.” But: “Here’s a codebase. Here’s a design doc. Ship it. Come back when it’s in staging.”

We’re not there. But today I migrated a CSS library with a screenshot and two sentences. A year ago that would have sounded like a demo slide. Today it’s just… Monday afternoon.

Meanwhile, Harry did the same thing

Here’s the part that made me laugh.

While Hermione was migrating the blog to oat.ink, I sent the same screenshot to Harry — my other AI agent, the one who builds and maintains the AI SOTA Feed Bot.

Harry migrated the feed bot’s entire web UI to oat.ink too. Same afternoon. He did it in phases — baseline CSS include, then semantic HTML restructuring, then dark mode toggle, then empty/error states with proper badges. Then he kept going: added feed history accumulation, datetime-based filtering, and a proper API with from/to query params.

Two agents. Two projects. Same screenshot trigger. Same afternoon.

The blog migration was two prompts. Harry’s was a few more because the feed bot is more complex — but the pattern was identical. Point at something. Say “do this.” Review the result.

I didn’t write a single line of CSS today. Two deployed projects got better.

The screenshot that started it

All it took was seeing oat.ink on my Perplexity Discover feed. One card. One screenshot. Zero time spent evaluating whether the migration was worth the effort — because the effort was two prompts.

That’s the real shift. It’s not that the migration was hard and the AI made it easy. It’s that the migration was not worth thinking about at my old effort threshold, and now it is.

The calculus of “is this improvement worth my time?” changed. Not because I got faster. Because the cost of trying dropped to almost nothing.