The more I work with Claude Code, the more convinced I am that it can write better code than I can, and I know that a chunk of you just reached for the back button. Stay with me for a second, because I want to define what I mean by better. I don't mean prettier, and I don't mean more concise or more clever. I mean more consistent. Consistent documentation, consistent use of good patterns, and most of all code that can still be changed two or three years from now, because maintaining software is the hard part. Building it was always the easy bit.
So I built the same thing three times. An order service: cart validation, tax, discounts, a Stripe charge, a database write, email, logging. The whole grubby pile.
Pass one was pure vibe coding. A single prompt into baseline Opus, no CLAUDE.md, nothing. What came back works, and I would never ship it. A logger sitting inside the order service, validation living inside the process method, subtotal math that belongs on the order itself, and not a single test. That's the default, and knowing the default matters, because the default is exactly what we're guarding against.
Pass two was Superpowers, again straight out of the box with no overrides, because I wanted to see what people actually get rather than what I get after I've bent it to my will. It's better. Nine tests out of nine passing, which is a real start. But it's all one enormous file, validation rules still show up inline with no idea where they came from, and the tests carry four assertions apiece. If that test goes red, why did it go red? That's my whole thing with testing. Would I ship it? Not a chance.
Pass three is mine, and this is the one I care about. Skills for the things I actually believe in: BDD, design principles, SOLID, YAGNI, DRY. A GitHub directory that knows what I want a commit message and a PR to read like. A directory of my own preferences, my stack, my writing. Commands for the things that are actions rather than skills, because a git commit is an action and should be defined as one. Then /init, /explore, /plan, and a build loop that hands Plan.md to Agent Teams and lets it run.
Seven tasks out of seven, seventy five specs, and a pile of git commits that map one to one onto the tasks. The code came out separated the way I like it, a proper state machine moving an order from pending to paid to refunded, and specs named feature, then scenario, then a single assertion each. That is how my brain works. That is how I'd want a team of engineers to work.
Is it better than what I would have written? Yes, and I'll say it flatly: I never would have been that consistent or that disciplined. I would not have written the architecture doc. I would not have logged the session memory. I'd have scribbled a few lines in the README, ticked off a to-do list, and called it done. Does that make me lazy? Sure. I'll cop to it. We all have an edge we work up to, and the thing about working this way is that a little extra time up front lets you go so much deeper.
One more thing, since it came up in the community the same day I recorded this: yes, this approach burns tokens. Good code costs tokens. We cannot be so precious about the meter that we let Claude do whatever it feels like.
Everything you see me use in this video is yours if you want it, free, over on the Claude Playbook. Mine are geared toward Bun and TypeScript, so I stripped out my specifics and left an interview step. Answer the questions and you'll come out the other side with agents, commands, and skills shaped like you. Once it's yours you can skip Superpowers, skip GSD, skip all of them. They're not bad. They're just not you, and you should be proud of the code that comes out.