AI Coding Pipelines: Plan, Build, Review, Fix

Phase One: Planning

The planning phase begins the moment an agent receives a task. The agent reads the task description, identifies the relevant portions of the codebase, and constructs a step-by-step approach. This phase is where the agent determines the scope of changes, identifies dependencies between steps, and anticipates potential obstacles.

Good planning accounts for the order of operations. Database schema changes must happen before the API code that references new columns. Interface definitions must exist before implementations that satisfy them. Configuration files must be updated before code that reads new configuration values. An agent that gets the ordering wrong will encounter errors during the build phase that could have been avoided with better planning.

The planning phase also involves reading existing tests and understanding what coverage already exists. If the task involves modifying existing functionality, the agent identifies which tests will need to change and which ones should continue to pass without modification. This analysis prevents the common mistake of fixing a bug in a way that breaks an existing test, only to discover the breakage later in the pipeline.

Some agent frameworks make planning explicit by requiring the model to output a structured plan before any code modifications begin. Others allow the model to plan implicitly, reasoning through each step internally before taking action. Research suggests that explicit planning leads to more consistent results, particularly for complex tasks that involve multiple files and interconnected changes.

Phase Two: Building

The build phase is where the agent translates its plan into actual code changes. This involves creating new files, modifying existing ones, updating configurations, and managing dependencies. The build phase is iterative, not a single batch operation, because each change must integrate coherently with both the existing codebase and other changes being made as part of the same task.

Code generation during the build phase follows the patterns established in the existing codebase. If the project uses a specific error handling convention, the agent follows that convention. If there is a standard way to define API endpoints, the agent uses the same structure. This pattern-following behavior is one of the strongest features of AI coding agents because it produces code that feels native to the project rather than obviously machine-generated.

Dependency management is an important part of the build phase. When the agent determines that a new library is needed, it must install it through the appropriate package manager, add it to the dependency manifest, and configure any required settings. Agents handle this by reading the existing dependency configuration and using the same tools and conventions that the project already employs.

The build phase typically produces the largest volume of changes and consumes the most context window space. Agents manage this by committing completed portions of work and releasing the detailed context of finished changes, keeping their active context focused on the current step rather than the entire history of modifications.

Phase Three: Reviewing

The review phase runs automated verification against the code produced during the build phase. This starts with the most basic checks (does the code parse correctly?) and progresses through increasingly sophisticated validation (do all tests pass? are there linting violations? do type checks succeed?).

Test execution is the core of the review phase. The agent runs the full test suite, or at minimum the tests relevant to the changed code, and captures the output. Passing tests confirm that the implementation is functionally correct. Failing tests provide specific, actionable feedback about what went wrong.

Linting and static analysis add another layer of verification. These tools catch code style issues, potential bugs, unused variables, and other problems that tests might not reveal. Agents that run linting as part of their review phase produce code that is cleaner and more consistent than agents that skip this step.

Type checking, for projects that use typed languages, catches a category of errors that is distinct from both test failures and lint violations. Mismatched types, incorrect function signatures, and incompatible return values are all caught during type checking. These errors are common in agent-generated code because the model might not perfectly remember the type signature of every function it references.

The review phase also includes a self-assessment where the agent evaluates its own output against the original task description. Does the implementation fully satisfy the requirements? Are there edge cases that were not addressed? This self-assessment catches gaps that automated tools miss because it requires understanding the intent behind the code, not just its correctness.

Phase Four: Fixing

The fixing phase handles any issues discovered during review. When tests fail, the agent reads the error output, traces the problem to its root cause, and generates a targeted fix. This phase can loop multiple times if the initial fix introduces new issues or if the root cause was more complex than initially apparent.

Effective fixing requires the agent to distinguish between different types of failures. A test failure caused by a simple typo needs a different approach than one caused by a fundamental misunderstanding of the required behavior. Agents that can make this distinction accurately spend less time on fixing and produce better final output.

The fixing phase sometimes reveals that the original plan was flawed. In these cases, the agent may need to backtrack to the planning phase, revise its approach, and re-execute portions of the build phase. This kind of strategic backtracking, rather than repeatedly patching a fundamentally broken implementation, is a sign of a sophisticated agent.

After each fix attempt, the agent re-runs the review phase to verify that the fix worked and did not introduce new problems. This cycle of fix-then-verify continues until all checks pass or the agent determines that it needs human input to proceed. Most tasks complete within two to three fix cycles, though complex tasks might require more.

Pipeline Orchestration and Optimization

The overall pipeline benefits from orchestration that goes beyond simply running each phase in sequence. Smart orchestration includes parallel execution of independent tasks, incremental verification (running tests after each change rather than waiting until all changes are complete), and priority ordering (fixing critical failures before addressing style issues).

Pipeline optimization also involves context management. The agent must balance between keeping enough history to make informed decisions and releasing old context to free space for new information. Agents that manage this balance well can handle larger tasks without degradation in quality.

Integration with existing CI/CD systems extends the pipeline beyond the local development environment. Some agents can push changes to a branch, trigger the CI pipeline, and respond to any failures that occur in the CI environment but not locally. This integration ensures that agent-generated code meets the same standards as any other code merged into the project.