How I Rebuilt My Blog Backend in 4 Days with Claude Code
Two weeks ago, I redesigned my WordPress site in 3 days using Claude Code's frontend-design plugin. Then I rebuilt DIALØGUE in 14 days and wrote about feeling terrified by the acceleration.
But I wasn't done. That WordPress redesign was just a fresh coat of paint on a 17-year-old house. The foundation was still PHP, MySQL, and a GCP VM I was paying for monthly.
So I did what any reasonable person would do: I migrated the entire thing to Next.js. In 4 days.
| Project | What | Time |
|---|---|---|
| DIALØGUE v1 | MVP podcast generator | ~6 months |
| STRAŦUM | 9 AI agents, multi-tenant | 75 days |
| Site redesign | WordPress frontend overhaul | 3 days |
| DIALØGUE v2 | Complete app rebuild | 14 days |
| This project | WordPress → Next.js, 485 posts, Sydney RAG | 4 days |
The difference this time? A community plugin called Superpowers that changed how I work with Claude Code.
The Starting Point
My blog had been running on WordPress for 17 years. PHP, MySQL, a GCP VM. It worked, but:
- Sydney (my AI chatbot) was retired in Nov 2025—the vector database costs weren't worth it
- Every change meant SSH, file transfers, cache clearing
- 485 posts locked in a MySQL database
- Basic SEO via Yoast plugin
The End Result
| Layer | Before | After |
|---|---|---|
| Content | MySQL database | 485 MDX files in Git |
| AI Assistant | Retired | Sydney 2.0 with Supabase pgvector |
| Images | WordPress uploads (14k+ files) | Vercel Blob (~2,000 optimized) |
| SEO | Yoast plugin | Sitemap, RSS, structured data, FAQ schema, llms.txt |
| Deploy | SSH + file transfer | git push |
But the architecture isn't the story. The story is how a plugin made this possible without burning out.
What Makes Superpowers Different
Most AI coding tools are reactive. You ask, they answer. It's ping-pong.
Superpowers flips this. It's a methodology disguised as a plugin—a structured workflow that forces both you and Claude to think before typing.
1. Brainstorming (Business First, Code Later)
When I said "migrate my WordPress blog to Next.js," Claude didn't open a code editor. It started with why:
- "What's the business goal here? Cost reduction, speed of iteration, or something else?"
- "What's Sydney 2.0's purpose—generic chatbot, or something more specific?"
- "Who's the target audience? What should they feel when they visit?"
Only after nailing the objectives did it move to technical questions:
- "Do you need to preserve all 485 URLs for SEO?"
- "What's your image situation—local uploads or CDN?"
The result? A design document that captured not just what to build, but why—including competitive analysis, target audiences, and success metrics. This took maybe 20 minutes of conversation, but it aligned everything that followed.
2. Planning (The Document That Runs Everything)
After brainstorming, Superpowers generated an implementation plan—not vague bullets, but 400+ lines of specific tasks:
- Exact file paths to create or modify
- Verification steps for each task
- Dependencies between tasks
- Each task scoped to 2-5 minutes of work
I could review it, adjust priorities, then say "execute."
3. Parallel Agents (This Is Where It Gets Fast)
Here's what I didn't expect: Claude Code knows when to use different models.
For complex architectural decisions, it uses Sonnet 4.5—the heavy thinker. But for parallel tasks like reading multiple files, generating boilerplate, or summarizing content? It spins up Haiku 4.5 agents—4-5x faster at a fraction of the cost.
During the migration, I'd watch it dispatch multiple Haiku agents simultaneously—one extracting blog posts, another analyzing CSS patterns, another generating component stubs—while Sonnet orchestrated the overall plan.
This isn't autocomplete. It's a team.
4. Execution with Built-in Code Review
Superpowers doesn't just execute tasks—it reviews its own work after each one. Two automatic checks:
- Spec compliance: "Did I do what the plan said?"
- Code quality: "Is this actually good code?"
I'd watch Claude write a component, then immediately critique itself: "This component works but violates DRY—extracting shared logic into a utility." Sometimes it caught issues I wouldn't have noticed until production.
The Moments That Caught Me Off Guard
I've used AI coding tools for two years now. I thought I knew what to expect. These moments proved me wrong.
"It Stopped Asking Permission"
On day 2, I needed to update 11 blog posts that mentioned Sydney. The old posts referenced capabilities that no longer existed, linked to URLs that had changed, and described a chatbot that had evolved significantly.
For the first 5-6 posts, Claude showed me the proposed changes and asked: "Does this look right? Should I proceed?"
I approved each one. Same pattern: update the capability description, fix the link, add a note about Sydney's evolution.
By post 7, something changed. Claude just... did it. No confirmation request. It had learned my preferences from the pattern of approvals.
The original plan said Claude would share changes for review. But it adapted. It recognized that I was approving the same type of change repeatedly, and it stopped interrupting me.
This wasn't in any documentation I'd read. It was emergent behavior—the kind of intuition you'd expect from a human collaborator who's been working with you for months, not hours.
Long-Running Sessions That Actually Work
Previous AI tools would lose context after 20-30 minutes of complex work. You'd have to re-explain the architecture, re-establish conventions, re-share the goals.
This migration ran for hours at a stretch. Claude remembered that we were using the TRANSMISSION design system. It remembered that content/blog/ was the MDX directory. It remembered that Sydney needed conversation memory, not just search.
I could step away, come back, and pick up exactly where we left off. The plan document acted as persistent memory—Claude would re-read it and understand the full context instantly.
Sydney RAG in 15 Minutes, Not Months
Here's what haunts me most.
My first attempt at a RAG chatbot (Sydney 1.0) took months of learning: vector databases, embedding models, chunking strategies, retrieval pipelines. I wrote about the Weaviate costs, the debugging nightmares, the cold start issues.
This time? I checked the git history. The core RAG pipeline—Supabase pgvector schema, HNSW index, embedding generation script—was done in 15 minutes.
pnpm db:seed # Sync 485 posts to Supabase
pnpm db:embeddings # Generate embeddings
Two commands. Sydney could search my entire 17-year blog archive.
The knowledge I spent months acquiring in 2024? Claude had it built-in. The infrastructure that used to cost me monthly on Weaviate? Free tier on Supabase.
I'm not sure how to feel about that.
What This Means (And What It Doesn't)
I'm not saying everyone should migrate their blog to Next.js. I'm not saying Superpowers is magic. I'm not even saying AI will replace developers.
What I am saying: the way we build software is changing faster than most people realize.
The pattern I keep seeing:
| Project | Time | What Changed |
|---|---|---|
| DIALØGUE v1 | 6 months | Learning everything from scratch |
| STRAŦUM | 75 days | Better tools, more experience |
| Site redesign | 3 days | frontend-design plugin |
| DIALØGUE v2 | 14 days | Multiple plugins working together |
| Blog rebuild | 4 days | Superpowers workflow |
Each jump wasn't about working harder. It was about working differently—with tools that think in workflows, not just completions.
Try It Yourself
If you're curious about Superpowers:
- In Claude Code, type
/pluginand select Superpowers from the list - Start with
/superpowers:brainstormbefore writing any code - Let it ask you questions—resist the urge to jump to implementation
- Trust the plan, but review it before executing
The first time Claude stops asking for confirmation because it learned your preferences, you'll understand why I wrote this post.
Frequently Asked Questions
What is Superpowers for Claude Code?
Superpowers is a community plugin for Claude Code created by Jesse Vincent. It's a structured workflow methodology that guides you through brainstorming, planning, execution, and code review—forcing both you and Claude to think before writing code.
How long does it take to learn Superpowers?
About 20 minutes of brainstorming conversation to understand the workflow. The real learning happens when you see Claude generate a 400+ line implementation plan and start dispatching parallel agents to execute it.
Does Superpowers work with any project?
Yes, but it shines on complex, multi-step projects. For a simple bug fix, it's overkill. For migrating a 17-year blog with 485 posts, building RAG search, and optimizing thousands of images? That's where the structured workflow pays off.
What's the difference between Sonnet and Haiku agents?
Claude Code uses Sonnet 4.5 for complex architectural decisions and Haiku 4.5 for parallel tasks like file reading and boilerplate generation. Haiku is 4-5x faster at a fraction of the cost. The system automatically chooses which model to use based on task complexity.
Can Claude Code really learn my preferences?
Yes—through pattern recognition. After I approved 5-6 similar changes, Claude stopped asking for confirmation and just applied the same pattern to the remaining posts. This isn't explicitly programmed; it's emergent behavior from the model understanding your approval patterns.
Still coding, still learning, still occasionally terrified by how fast this is moving.