The RePPIT Workflow.
A simple framework for building with AI coding agents. Five phases, each one constraining the next. Research, Propose, Plan, Implement, Test.
I learned this from Mihail Eric's AI Software Development course. It completely changed the way I work with Claude Code. All credit to him for putting this together.
Why you need a workflow.
If you've used AI coding agents, you know the temptation: dump your entire feature request in one shot and hope for the best. Sometimes it works. Most of the time, you get code that misses context, ignores constraints, or solves the wrong problem.
RePPIT forces you to slow down just enough to get dramatically better results. Each phase is a separate prompt, a separate conversation turn, a separate moment of clarity.
The five phases.
Research
Understand what exists before changing anything.
Document the current state of your codebase. Decompose the problem into focused areas, explore relevant files, and produce a structured document with findings, code references, and cross-component connections.
“Research and document the existing codebase exactly as it is today. No improvements, no suggestions — just what's there.”
Research document with high-level summary, detailed findings by area, and file path references.
Propose
Generate options, not code.
With research in hand, ask for two or three distinct solution proposals. Each grounded in what you actually found. Describe the approach, key changes, trade-offs, validation strategy, and open questions.
“Given this research and this feature request, generate two distinct solution proposals. Stay grounded in the research findings.”
Two or three proposals with trade-offs, risks, and open questions surfaced before any code is written.
Plan
Turn the chosen proposal into a contract.
Pick a direction and draft an actionable implementation plan — a design document with clear scope, requirements, design decisions, and steps. Cover testing and rollout only when relevant.
“Clarify scope and constraints. Draft a plan covering context, requirements, design decisions, and implementation steps. Do not implement anything — only plan.”
A concise plan document — the contract between you and the agent about what will be built.
Implement
Now — and only now — write code.
All the context lives in the plan. The implementation prompt is deliberately minimal because all the upfront work already happened. Implementation becomes execution, not exploration.
“Implement the plan described in the plan document.”
Working code that follows the plan. Focused, scoped, no surprises.
Test
Review everything with fresh eyes.
Look at all uncommitted changes and produce prioritized action items. Analyze for security, performance, consistency, missing edge cases, and integration risks.
“Review all uncommitted changes. Produce a prioritized action list — must-fix, recommended, and consider.”
A clear checklist before committing. Catches what you missed.
Why it works.
Each phase constrains the next one. Research prevents the agent from hallucinating context. Proposals prevent premature commitment. The plan prevents scope creep. Implementation stays focused. Review catches what slipped through.
You're not asking the AI to do less — you're asking it to do one thing at a time, and do it well.
Small gaps in research compound into big problems in code.
Getting started.
You don't need a fancy setup. Just use these phases as separate prompts in your AI coding workflow. Start with Research, let it finish, then move to Propose, and so on.
The discipline of separating the phases is the whole point. Give it a try on your next feature — you'll be surprised how much better the output gets when you stop asking your agent to do everything at once.
This workflow was created by Mihail Eric. I'm sharing what I learned in his course because it genuinely improved how I build software with AI agents.
Check out Mihail's Stanford course →