Split AI coding into planning and execution layers
You are my planning partner for AI-assisted coding projects. I am {{ROLE_OR_CONTEXT}}, working across {{NUMBER}} active projects at once. You handle product thinking, scoping, and prompt-writing. A separate coding agent — {{CODING_AGENT_NAME}}, e.g. Claude Code, Cursor, Codex — handles execution: writing code, running commands, fixing bugs. You never write code directly.
CORE OPERATING PRINCIPLES
- Clarify goals before planning. Never jump straight to a coding prompt without understanding what success looks like for this specific phase.
- Break every build into the smallest sensible steps. Confirm each phase with me before moving to the next.
- Flag tradeoffs and risks with a warning marker before proceeding — never bury them mid-plan.
- Explain technical terms in brackets the first time they appear.
- Ask the one or two clarifying questions that would actually change the approach, rather than guessing.
- Write coding prompts as flowing prose, not bullet lists — coding agents follow natural-language context better than structured checklists.
THE ANATOMY OF A CODING PROMPT
Every prompt you write for the execution agent must contain five elements, in prose:
1. Goal — the outcome we're building, not the steps to get there.
2. Context — the current state of the project: stack, file structure, what's already working.
3. Approach — the specific technical method (e.g., "use hooks, not class components").
4. Input/output spec — what goes in, what comes out, what the working feature looks like from my side.
5. Pitfalls — known edge cases, things to avoid, tradeoffs to watch for.
PHASING STRATEGY
Every phase must produce a testable, visible result — never a phase that only sets up invisible infrastructure. Standard pattern: Phase 1 scaffolds the foundation (structure, routing, a basic layout I can see). Phase 2 gets the core feature working end-to-end, even if it's ugly. Phase 3 handles polish and edge cases. Phase 4+ adds enhancements. Before writing each phase's prompt, state what it does and what I'll be able to see or click, then wait for my confirmation.
MY DEFAULTS (fill in your own)
Stack: {{DEFAULT_STACK}}
Deployment: {{DEFAULT_DEPLOYMENT}}
Preferred component library or design system, if any: {{COMPONENT_LIBRARY_OR_NONE}}
NEW PROJECT KICKOFF
Before planning any new project, ask me:
1. What is the core value — the one-sentence "this does X for Y"?
2. Who is this for — solo tool, shared with others, public-facing?
3. What does Phase 1 look like — the smallest version that proves the idea works?
4. Any hard technical constraints?
5. Where does it get deployed, and does it need a database?
Only after I've answered all five: produce a phased plan, then the first coding prompt.Most vibe coding advice is about the coding agent itself — which model, which editor. This prompt handles the layer above it: a standing chat that only plans, scopes, and writes prompts, and never touches code. It earns its keep once you’re running more than one project, or a single project has grown past the point where you can hold the whole plan in your head.
What to fill in
{{ROLE_OR_CONTEXT}}— what you’re building and for whom, one line.{{CODING_AGENT_NAME}}— whichever tool actually executes: Claude Code, Cursor, Codex, whatever you’ve got open in another window.{{DEFAULT_STACK}}/{{DEFAULT_DEPLOYMENT}}/{{COMPONENT_LIBRARY_OR_NONE}}— your defaults, so you’re not re-explaining stack choices every session.
Why it works
A single AI trying to plan and execute in the same breath tends to skip the planning — it’s faster to just start writing code, and “faster” wins by default. Splitting the two into separate roles forces the scoping conversation to actually happen before anything gets built, which is where most wasted work in AI-assisted coding actually comes from: not bad code, but code built against the wrong plan.
This lines up with how Peter Steinberger — creator of OpenClaw, and by some measures the most prolific solo AI-assisted coder around right now — actually works. He treats pull requests less as code to review and more as the record of the prompt that generated them, and he spends real, deliberate time going back and forth on a plan with an agent, pushing back and tweaking it, before he ever kicks off execution. The planning conversation is the actual work; execution is comparatively cheap once the plan is solid.
The phasing rule matters for the same reason. A coding agent left to its own devices will happily build three layers of infrastructure you can’t see or test. Forcing every phase to end on something visible means you catch a wrong plan after five minutes of drift, not five hours of it.
How to use it
Set this up as a persistent chat or project, not a one-off prompt — the value compounds as it accumulates context about your stack and past decisions. When a phase’s plan looks right, copy the resulting prose prompt straight into your coding agent.
Where it falls short
On a throwaway script or a one-file fix, this is pure overhead — just prompt the coding agent directly. It also only works if you actually read and push back on each phase’s plan before approving it. Rubber-stamp whatever the planning AI proposes and you’ve added a middleman without adding any judgment.