May 18, 2026
The Right Way to Vibe Code: SDD and the Superpowers Plugin
Andrej Karpathy coined "vibe coding" to describe something most developers already felt: you describe what you want, the AI figures out the code, and you stay in a creative flow rather than fighting syntax. It feels like the future.
And it is — until your project gets big enough that the AI starts contradicting itself, adding features you didn't ask for, or quietly breaking things three files away from where you were looking.
The problem isn't vibe coding. The problem is unstructured vibe coding.
What goes wrong in a long AI session
When you vibe code in a single long conversation, a few things quietly degrade:
Context pollution. The AI carries everything from the start of your session. Early decisions, dead-end explorations, half-finished ideas — all of it bleeds into later responses. By hour three, the model is making assumptions based on context that's no longer relevant.
No plan, no finish line. Without a written plan, the AI doesn't know when it's done. It fills the gap with its own judgment — adding error handling you didn't need, refactoring things you didn't ask it to touch, building abstractions for hypothetical future requirements.
No review gate. Each response flows straight into the next. If something was built wrong or built more than the spec required, there's no checkpoint to catch it.
Wandering scope. You ask for feature A, the AI implements A and also "helpfully" tidies up B and C. Now you're reviewing code you didn't ask for, and the diff is three times larger than it should be.
The sessions feel productive. The code, reviewed later, often isn't.
SDD: structure without slowing down
Subagent-Driven Development (SDD) is a workflow that fixes these problems without sacrificing the speed of AI-assisted coding. The core idea is simple:
One fresh subagent per task. Two review stages after each.
Instead of one long conversation where context accumulates and quality drifts, you work through a pre-written plan task by task. Each task goes to a fresh AI agent with exactly the context it needs — nothing more. After implementation, a spec compliance reviewer checks that the code matches what was planned. Then a code quality reviewer checks that it's well-built. Only then does the next task start.
No context pollution. No scope creep. No bugs sliding through unreviewed.
The workflow in practice
Here's what it looks like concretely:
Step 1: Write a plan before any code.
You describe what you want to build. Claude uses the writing-plans skill to produce a detailed implementation plan — which files to create or modify, exact code for each step, commands to run, expected outputs. The plan is saved as a markdown file in your repo.
This is the moment where you catch bad ideas cheaply. Reading a plan takes two minutes. Reviewing a week of code takes much longer.
Step 2: Review the plan yourself.
The plan is written for you to read, not just for the AI to execute. Check that the approach makes sense, the scope is right, and nothing important is missing. Push back before a line of code is written.
Step 3: Execute task by task with fresh subagents.
Claude uses the subagent-driven-development skill to work through the plan. Each task gets a new subagent that reads only what it needs — the task spec, the relevant files, the project context. No history from previous tasks. No drift.
The subagent implements, runs tests, self-reviews, then hands off. You get a spec compliance review ("did we build exactly what the plan said?") and a code quality review ("is this well-written?"). If either finds issues, the implementer fixes them before moving on.
Step 4: Ship.
After all tasks pass review, the finishing-a-development-branch skill wraps up — final checks, commit, deploy.
The Superpowers plugin
The Superpowers plugin for Claude Code makes this workflow a set of slash commands rather than a manual process you have to reconstruct each session.
The key skills it provides:
writing-plans— produces bite-sized implementation plans with exact code, exact commands, and expected outputs at every step. No placeholders, no "TBD", no vague instructions.subagent-driven-development— orchestrates the task loop: dispatch implementer, run spec review, run quality review, repeat.executing-plans— for when you want to run the plan in the same session rather than via subagents.test-driven-development— guides subagents to write failing tests first, then minimal implementation. Keeps each task provably correct.using-git-worktrees— gives each feature branch an isolated working copy so subagents can't interfere with each other.
The plugin is opinionated by design. It makes you write a plan. It makes you review before building. It enforces two-stage review on every task. That structure is the point.
Why this matters for solo founders
If you're building a SaaS alone, your most valuable resource isn't money — it's decision-making energy. Every bug you have to debug, every unexpected diff you have to read, every feature that crept in uninvited drains that energy.
SDD with Superpowers means the AI does more of the cognitive work — planning, implementing, reviewing — so you do less. But it does it in a structured way that keeps you in control of what gets built and how.
You're not just vibing. You're vibing with guardrails.
The mindset shift
The hardest thing about SDD for most developers is the discipline to write a plan before coding. It feels like overhead. It feels like it's slowing you down.
It isn't. The plan is where you have the cheapest possible conversation about what you're actually building. It's far cheaper to delete a paragraph in a plan than to revert three hours of AI-generated code.
Write the plan. Review it. Let the subagents do the building. Review again at each checkpoint.
That's not slower vibe coding. That's vibe coding that actually ships.
Nicheloom itself was built using this workflow — SDD with the Superpowers plugin, running in Claude Code. The credit wallet, AI preview generation, SEO layer, and every legal page were each planned, implemented by subagents, and reviewed before merging.