How AI Coding Agents Write and Review Code

Reading and Understanding the Codebase

Before writing a single line, an AI coding agent must understand the existing codebase. This starts with building a structural overview of the project. Most agents create what is called a repository map, a compressed representation of the entire codebase that lists files, directories, function signatures, class definitions, and import relationships without including the full source code of every file.

The repository map serves as a table of contents that the agent can reference when deciding which files to examine more closely. When a task comes in, the agent consults this map to identify which files, modules, and functions are likely relevant. Only those files get loaded into the full context for detailed analysis. This selective loading is essential because even large context window models cannot hold an entire enterprise codebase simultaneously.

Once the relevant files are loaded, the agent analyzes code patterns, naming conventions, architectural structures, testing approaches, and dependency usage. This analysis informs how the agent will write new code, ensuring that additions are consistent with the existing style. An agent working in a project that uses functional programming patterns will generate different code than one working in an object-oriented codebase, even for functionally identical tasks.

Modern agents also read configuration files, build scripts, and CI/CD definitions to understand the project infrastructure. Knowing which test runner is configured, which linting rules are enforced, and which build system is in use lets the agent validate its work against the same standards the team uses for human-written code.

Planning the Changes

After understanding the codebase, the agent creates a plan for the task. This planning step varies in formality across different agent implementations. Some agents produce an explicit written plan that describes each step before execution, while others plan implicitly through the chain-of-thought reasoning embedded in the language model.

A well-constructed plan identifies which files need to be created or modified, the order of operations (schema changes before API endpoints, for example), potential risks or dependencies, and the verification approach. For complex tasks, the plan might include conditional branches: "if the project uses TypeScript, add type definitions; if it uses JavaScript, add JSDoc annotations instead."

Planning quality is one of the strongest predictors of overall agent performance. Agents that skip planning or produce shallow plans tend to encounter more errors during execution and require more correction cycles. The best agents invest substantial reasoning effort in the planning phase, reducing the total amount of work needed to reach a successful outcome.

Some agent frameworks support iterative planning, where the initial plan is refined after each execution step based on what the agent learns. This approach handles unexpected complexity better than a fixed plan because the agent can adjust its strategy in response to what it discovers in the codebase during execution.

Generating and Modifying Code

Code generation in a modern agent is not a single-shot process. The agent generates code incrementally, file by file and often function by function, checking each piece against the existing codebase for consistency before moving to the next change. This incremental approach catches integration issues early rather than producing a large batch of changes that might conflict with each other.

When modifying existing files, agents use techniques like search-and-replace with context awareness, where the agent identifies the specific lines to change by understanding the surrounding code structure rather than relying on line numbers that might have shifted. This approach is more robust than simple text replacement because it handles cases where the file has been modified since the agent last read it.

Import management is a critical part of the generation process. When an agent adds code that depends on a library or internal module, it must also update the import statements. Modern agents handle this automatically by maintaining awareness of the dependency graph and adding necessary imports as part of each code modification.

The agent also handles the mechanical aspects of code creation that developers often find tedious: creating directory structures, updating configuration files, adding entries to package manifests, and modifying build scripts. These housekeeping tasks are easy for agents because they follow predictable patterns that the model can learn from the existing project structure.

Running Tests and Interpreting Results

After generating code, the agent runs the project test suite to verify that the changes work correctly and do not break existing functionality. This step is fundamental to the agent workflow because it provides objective feedback that the model can use to improve its output.

When tests pass, the agent knows its implementation is functionally correct (at least within the coverage of the existing tests). When tests fail, the agent reads the error output, stack traces, and assertion messages to diagnose the problem. This diagnosis might reveal a simple typo, a misunderstanding of an API, a missing dependency, or a more fundamental design flaw.

The ability to interpret test failures and generate targeted fixes is one of the most valuable capabilities of coding agents. A developer might need to read through a stack trace, cross-reference documentation, and experiment with different approaches. The agent performs a similar process but at machine speed, often resolving test failures within seconds of encountering them.

Beyond unit tests, sophisticated agents run additional verification steps including linting (checking code style and common errors), type checking (for statically typed languages), and security scanning (for known vulnerability patterns). Each verification layer adds another opportunity to catch and fix issues before the code reaches human review.

The Review Process

AI coding agents increasingly participate in code review, both as reviewers of human-written code and as preparers of their own code for human review. When reviewing code, agents analyze changes for logical errors, style inconsistencies, potential security vulnerabilities, missing test coverage, and adherence to project conventions.

When preparing their own code for review, the best agents generate clear commit messages, pull request descriptions, and inline comments that explain non-obvious decisions. This documentation helps human reviewers understand not just what changed but why the agent chose that particular approach.

The review capabilities of agents are strongest for pattern-based checks: detecting common bug patterns, identifying code that violates established conventions, and catching obvious security issues. They are weaker at evaluating architectural decisions, assessing long-term maintainability, and understanding the business context behind code changes. These limitations mean that human review remains essential even when agents generate the code.

Some teams use a two-agent approach for review, where one agent generates code and a separate agent reviews it. This separation reduces the bias that can occur when the same model evaluates its own output. The reviewing agent brings a fresh perspective and often catches issues that the generating agent overlooked.

Continuous Iteration and Learning

The most advanced coding agents learn from feedback within a session. When a human reviewer requests changes, the agent incorporates that feedback into its subsequent work. If a reviewer says "we prefer early returns over deeply nested conditionals," the agent adjusts its code generation style for the remainder of the session.

Between sessions, agents can retain learned preferences through configuration files, prompt templates, or fine-tuned model weights. Teams that invest in customizing their agent configuration see progressively better results as the agent becomes attuned to the specific patterns, preferences, and standards of the project.