MatIntellect

🔥 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

Share:

No comments yet

Leave a Comment

Fields marked with an asterisk (*) are required