The "One Big Feature" Methodology: A Five-Step System for Agent-Driven Feature Development

Agent coding breaks down when a feature outgrows a single context window. The "One Big Feature" methodology solves this by splitting the work across five slash commands that coordinate a main agent and multiple subagents. Each step produces artifacts that feed the next, keeping context tight and quality high all the way to production.

The Five-Step Pipeline

The methodology runs as a sequence of five Claude Code slash commands: /orchestrate, /plan, /spec, /implement, and /reviewloop. Each command triggers a specific phase of work, and each phase produces outputs that become inputs for the next. The system treats feature development like an assembly line where no single agent needs to hold the entire feature in its head at once.

/orchestrate: Discovery and Context Gathering

The process starts with /orchestrate, which has your main agent interview you about the feature. It asks discovery questions, gathers context from your codebase, and runs research. All of that information gets written into files and folders within your project. This step is about building a shared knowledge base that downstream agents can reference without needing to repeat the discovery process.

/plan: Synthesizing a Master Plan

/plan deploys a planning subagent that reads all the documents produced during orchestration. It synthesizes them into a single master plan. This is where the feature gets shaped into something concrete, with clear scope and sequencing, before any code gets written.

/spec: Breaking the Plan into Contracted Specs

/spec takes the master plan and breaks it into smaller spec documents. Each spec has contracts with the spec before it and the spec after it. These contracts define the interfaces and expectations between pieces of work. The goal is to let each spec fit within a single context window while maintaining coherent connections across the full feature.

/implement: Parallel or Sequential Execution

/implement tells your main agent to spin up one subagent per spec document. These subagents can run in parallel or in sequence, depending on the dependency chain. Each one works through its assigned spec and produces a pull request. Because the specs have contracts with their neighbors, the resulting PRs should compose into a coherent whole.

/reviewloop: The Quality Gate That Iterates

/reviewloop is the most important step. It deploys one review subagent for each PR that the implementation step produced. Each reviewer checks its own PR and the adjacent contracted PRs to answer a specific question: do these pieces actually work together? Do the tests pass? Does the code synthesize into the intended feature?

The review subagents return ratings to the main orchestrator agent. If any review fails, the orchestrator sends the work back through the implement and review cycle. This loop continues until every review subagent passes. The iterative nature of this step is what catches integration issues that individual spec agents would miss.

Key Takeaways

• Context window limits are a design problem, not a blocker. Breaking features into contracted specs lets each agent work within its limits while the system maintains coherence across the full feature.
• Contracts between specs are the critical mechanism. Without explicit interfaces between adjacent pieces of work, parallel agents produce code that does not integrate cleanly.
• The review loop is where quality comes from. Implementation subagents build the feature, but review subagents verify that the pieces compose correctly. The iterative cycle between these two steps is what makes the output production-grade.
• Each phase produces artifacts that persist in your codebase. Discovery docs, the master plan, and spec files all live in your project, making the process auditable and resumable.
• This approach treats agent coding like a managed team. The orchestrator delegates, the planners plan, the builders build, and the reviewers review. No single agent carries the full cognitive load.

Resources

• @agentic.james on TikTok for more agent coding workflows
• Claude Code Documentation for slash commands and subagent patterns
• Cortex OS (referenced in video) for the full custom agent management system