🔥 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
⭐️ Simon Willison, author of Agentic Engineering Patterns:
"Agentic engineering is professional engineers using AI agents to improve and speed up their work, amplifying their own expertise. It's fundamentally different from vibe coding - when non-programmers run an LLM at random and hope for the best"
💭 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