Engineering Beyond the Vibe: The REPPIT Framework for Production AI Coding
The rise of advanced Large Language Models (LLMs) has popularized a style of development often called "vibe coding". In this ad-hoc approach, developers fluidly prompt an AI agent, accept diffs without a deep look, and copy-paste error messages until a prototype works. While vibe coding is highly effective for weekend hacks or isolated greenfield projects, it quickly falls apart when applied to complex, large-scale, production-bound legacy codebases.
To build reliable production software with AI, developers must transition from ad-hoc interactions to structured, spec-driven workflows. One highly methodical approach designed for this is the REPPIT framework.
The REPPIT Framework Breakdowns
REPPIT stands for Research, Propose, Plan, Implement, and Test. Instead of letting an AI agent jump straight into modifying source code—a default tendency that often leads to off-rails behavior—this framework introduces deliberate checkpoints for multi-solution thinking and human alignment.
1. Research
The AI agent begins by exploring the codebase to distill system architecture, data models, and recurring engineering patterns into a markdown document (typically around 300 lines).
- Transient Nature: This research artifact is non-persistent; it is regenerated fresh per task rather than stored as permanent memory.
- Dual Purpose: It serves to onboard both the AI agent and the human developer to unfamiliar or complex territories within the code.
2. Propose
Rather than assuming a single path forward, the agent generates two distinct solution proposals grounded directly in the research document.
- Each proposal outlines trade-offs, specific impacted files, and outstanding open questions.
- The human engineer reviews these options and selects the optimal approach, resolving ambiguity before code is altered.
3. Plan
Arguably the most critical stage, the plan step takes the selected proposal and expands it into a structured, highly granular implementation design document. Breaking major features down into compartmentalized todo lists prevents the agent from exceeding the practical bounds of its smart token context window.
4. Implement
With the approved plan acting as a source of truth, the agent executes the actual code modifications. For expansive tasks, documentation artifacts are updated incrementally as each sub-task finishes, ensuring the agent retains context for subsequent steps.
5. Test
The validation phase ensures that changes perform as intended without introducing regressions. This step can follow implementation or precede it entirely via Test-Driven Development (TDD) workflows.
Matching Framework Rigor to Task Complexity
The full multi-step framework is not a one-size-fits-all requirement. The complexity of the engineering task should always dictate how much overhead is introduced.
| Task Complexity | Examples | Recommended AI Delegation Strategy |
| Low | Small bug fixes, copy changes, simple scripts | Direct, simple prompting (one-shot execution) |
| Medium | Small features covering 3–5 files, basic greenfield setups | Default built-in agent planning (e.g., Claude's native planning) |
| High | Cross-repository features, major refactors, production-bound legacy systems | Full structured REPPIT workflow with dedicated research steps and multi-phase plan artifacts |
Integrating Context and Retaining Tribal Knowledge
A core strength of structured agent workflows is the ability to feed rich external business context into the initial Research phase.
- Context Connectors: Using Model Context Protocol (MCP) connectors, agents can ingest Product Requirement Documents (PRDs), user stories, and specifications straight from external project management tools like Linear or Confluence.
- Capturing Tribal Knowledge: Because codebase exploration documents are transient, teams are encouraged to retroactively refresh project READMEs and maintain long-term files like
AGENTS.md. Agents can help bootstrap these documents, permanently locking down design decisions and reducing institutional knowledge loss over time.
Alternative Spec-Driven Frameworks
While REPPIT offers a clean linear progression, other frameworks employ distinct methodologies to manage spec-driven agent execution:
- Superpowers: An opinionated, end-to-end workflow built entirely around Test-Driven Development (TDD). It utilizes discrete agent skills for spec creation, implementation, and parallel testing architectures.
- OpenSpec: A lightweight approach focusing on the sync loop between source-of-truth specifications and active code developments. It offers precise mechanisms for tracking changes in specifications and cleanly merging them post-diff.
Ultimately, the goal of moving past ad-hoc prompting is to establish a deterministic, predictable, and highly collaborative relationship with AI systems. By enforcing research and design phases prior to code compilation, engineers remain firmly in control of the architecture.
