🔥 Prompting, skills, hooks - that's kindergarten, everyone knows it. I've spent months building turnkey projects - agents, pipelines, automations - and here are three things that actually keep me from rewriting everything from scratch
Rule 1 - 70% of development is planning:
Keep this ratio in your head: 70% planning, 30% actual development. Not the other way around. First, a detailed prompt for the idea - what you're building, why, what it actually is. Then a detailed development prompt - architecture, stack, dependencies, order of stages. Then it all goes into one shared file with rollback points at every stage and a test after each piece is built
This is what GitHub in 2026 calls spec-driven development. Why it matters: "Language models are great at completing patterns, but they can't read minds". A vague prompt creates thousands of unspoken assumptions - and the AI honestly fills them in with its own guesses. Usually wrong ones. A detailed spec kills the guessing at the input - and that's cheaper than rewriting three times afterwards
Rule 2 - an audit via the /audit command:
I built a process into the system that runs several analysts one after another. Each next one works with the output of the previous one - that's the whole point:
✅ Analyst #1 - "Are you sure about your plan? Tear it apart, find every weak spot. At the end, write a new plan that takes the critique into account"
✅ Analyst #2 - "Are you 200% sure?" - the second level. The first audit gets audited itself
✅ Analyst #3 - "Is this the best you can come up with? Are there alternative solutions?" - finds what the first two missed
✅ Codex analyst (or any other model) - an outside view. Finds what the main model can't see because of its own patterns
The first few times it felt like paranoia. But the third analyst consistently finds at least one weak spot the previous two missed. No exceptions. Anthropic documents this approach: independent agents check the same thing, the results get aggregated - and it works precisely because each agent doesn't know what the other one said
Rule 3 - GSD (Get Shit Done):
📌 After the audit and final planning - break it down into as many small phases as possible
📌 Each phase: a specific task, implementation, a test, a rollback point if something goes wrong
📌 Development goes strictly linearly from the first phase to the final production project, no jumping around
Every step is atomic. Either it worked and you move on. Or you rolled back and know exactly where you went wrong - not "something went wrong", but a specific stage, a specific reason. This is engineering discipline applied to vibe coding
GSD is a real, free open-source project on GitHub. Installs globally with one command:
npx get-shit-done-cc@latest --claude --global
💭 Six months ago I was rewriting every other project from scratch. Thought I needed a better prompt or a new model. Turned out I needed to stop starting to code before I clearly understood what I'm building, where I might screw up, and how to roll back if I do. Obvious? Yes. Does it work? Yes
What it did for my timelines
I've built every project this way since, and timelines became predictable. I built my subtitle assistant in a day: I film a video, type one word in Telegram, and in about 2 minutes it's ready to publish. A turnkey content factory takes about a week, a voice agent on top of an existing system about 2 weeks, a team of agents or call and CRM automation about 2–3 weeks. I no longer rewrite from scratch: if something goes wrong, I roll back to a specific step instead of starting over. The plan comes before the code, and checks come after every step
If your team needs that structure, see how I design AI system architecture with access controls, tests and rollback points