# AI Coding Tip 029 - Stop Using One Model for Everything

> TL;DR: Assign a different model to each pipeline stage since none excels at planning, coding, reviewing, and testing alike.

# Common Mistake ❌

You open one chat with your favorite model and ask it to plan, write, review, and test the same feature end to end.

You treat model loyalty like a virtue, so the same blind spots follow the code from the first line to the last commit.

The [defects](https://maximilianocontieri.com/stop-calling-them-bugs) it can't see when it writes are the same defects it can't see when it reviews.

# Problems Addressed 😔

*   The reviewer inherits the coder's blind spots, so it misses the exact defects the same model would write.
    
*   You lose the benefit of a [second opinion](https://maximilianocontieri.com/ai-coding-tip-017-ask-for-the-analyst-not-the-analysis), since the analyst and the executor are the same mind.
    
*   One vendor's outage, rate limit, or price hike stalls your entire pipeline at once.
    
*   Your codebase drifts toward one model's default style, hiding the exact spots a different model would flag as [unclear](https://maximilianocontieri.com/ai-coding-tip-021-avoid-comprehension-debt).
    
*   Test cases target the failure modes the author already thinks to avoid, so real edge cases slip through untested.
    
*   You already bring in different people for [technical and code reviews](https://maximilianocontieri.com/ai-coding-tip-006-review-every-line-before-commit), so a single model auditing everything breaks that same principle.
    

# How to Do It 🛠️

1.  Pick a model strong at reasoning to scope the task through [read-only planning](https://maximilianocontieri.com/ai-coding-tip-003-force-read-only-planning).
    
2.  Hand the plan to a fast, cheap, code-tuned model working inside a [harness](https://maximilianocontieri.com/ai-coding-tip-022-give-ai-a-harness-to-work-with) that runs tests automatically.
    
3.  Trigger each stage as its own subagent with [fresh context](https://maximilianocontieri.com/ai-coding-tip-005-keep-context-fresh), a narrow local objective, and only the [information that stage needs](https://maximilianocontieri.com/ai-coding-tip-009-compact-your-context).
    
4.  Route the review to a model that didn't write the code.
    
5.  Use a cheap model to review once you have [clear rules](https://maximilianocontieri.com/ai-coding-tip-015-force-the-ai-to-obey-you), reusable [skills](https://maximilianocontieri.com/ai-coding-tip-004-use-modular-skills), and a solid [harness](https://maximilianocontieri.com/ai-coding-tip-022-give-ai-a-harness-to-work-with) in place.
    
6.  Ask the reviewing model to extend the test suite with edge cases the author missed.
    
7.  Record which model handled each stage and the assumptions it made in an [Architecture Decision Record](https://en.wikipedia.org/wiki/Architectural_decision) (ADR) or similar document, so you can [spot repeating blind spots](https://maximilianocontieri.com/ai-coding-tip-016-feed-your-pr-lessons-into-the-ai-brain) later.
    
8.  Rotate the pairings every few months as model strengths shift with new releases.
    
9.  Apply [TDD adversary rules](https://maximilianocontieri.com/the-dirty-secret-behind-loop-engineering): pick one model to write the test (Red), another to write the simplest implementation (Green), and a third to decide if it's worth refactoring (Refactor).
    

# Benefits 🎯

1.  **Catch more defects:** A model reviewing code it didn't write spots the exact class of defect its own instincts would miss.
    
2.  **Avoid vendor lock:** You spread load across providers, so one outage or price hike doesn't stall the whole pipeline.
    
3.  **Match cost to complexity:** You save your most expensive reasoning model for planning and give routine syntax work to a cheaper one.
    
4.  **Widen test coverage:** A model with different training data invents edge cases the original author never considered.
    
5.  **Keep** [**personas**](https://maximilianocontieri.com/ai-coding-tip-026-assign-a-persona-to-every-skill-definition) **honest:** Rotating models forces you to write role definitions specific enough that any model can fill them.
    
6.  **Prevent style lock-in:** Your codebase stops drifting toward one model's habits and stays closer to your own [standards](https://maximilianocontieri.com/ai-coding-tip-027-force-code-standards).
    

# Context 🧠

Every model carries a training history of pitfalls that shapes what it notices and what it misses.

Claude models tend toward broad, breadth-first scanning of a problem, while GPT models tend toward narrow, depth-first evidence gathering.

Those different instincts mean the [defects](https://maximilianocontieri.com/stop-calling-them-bugs) one model writes are often exactly the ones it also fails to catch in review.

Research from the code review vendor [Greptile](https://www.greptile.com/blog/model-inversion) found that Claude-authored pull requests get a 53.7% defect recall rate when Claude reviews itself, but a 62.0% recall rate when GPT reviews the same code.

The same pattern holds in reverse for GPT-authored code.

Cross-model review isn't a trick.

It's the direct result of two models having different blind spots.

Relying on a single model for every stage risks the same failure mode as [model collapse](https://maximilianocontieri.com/code-smell-314-model-collapse): without a different perspective correcting it, the quality slowly degrades.

Giving one model every stage of development is the AI equivalent of a class exhibiting [divergent change](https://maximilianocontieri.com/code-smell-124-divergent-change): one entity keeps changing for many unrelated reasons, and every reason it changes is a reason it can quietly break.

Treat each stage of development as its own [modular](https://maximilianocontieri.com/ai-coding-tip-004-use-modular-skills) role, and hire the model best suited to it, the same way you'd [assign a persona to a skill](https://maximilianocontieri.com/ai-coding-tip-026-assign-a-persona-to-every-skill-definition).

## Prompt Reference 📝

## Bad Prompt 🚫

%[https://gist.github.com/mcsee/9784900436131553e5399007d24cb218] 

## Good prompt 👉

%[https://gist.github.com/mcsee/9838775e688f5d54611b60d481a05ef6] 

# Considerations ⚠️

This adds coordination overhead, so it fits multi-day features better than one-line fixes.

You still need a [human-in-the-loop checkpoint](https://maximilianocontieri.com/ai-coding-tip-024-force-a-criteria-check-before-the-task-ends) before merge, since cross-model review [catches more defects](https://maximilianocontieri.com/ai-coding-tip-006-review-every-line-before-commit) but doesn't guarantee zero defects.

Track model versions alongside model names, since a provider's default model changes silently and a rotation you set up in January may mean something different by June.

Costs can rise if you route trivial edits through your most expensive reasoning model, so match the model to the actual complexity of each stage.

# Type 📝

\[X\] Semi-Automatic

# Limitations ⚠️

Switching between providers adds latency, since each new model call starts a [cold context](https://maximilianocontieri.com/ai-coding-tip-005-keep-context-fresh).

Not every team has budget or API access to more than one provider at once.

# Tags 🏷️

*   Prompt Engineering
    

# Level 🔋

\[X\] Intermediate

# Related Tips 🔗

%[https://maximilianocontieri.com/ai-coding-tip-003-force-read-only-planning] 

%[https://maximilianocontieri.com/ai-coding-tip-004-use-modular-skills] 

%[https://maximilianocontieri.com/ai-coding-tip-006-review-every-line-before-commit] 

%[https://maximilianocontieri.com/ai-coding-tip-017-ask-for-the-analyst-not-the-analysis] 

%[https://maximilianocontieri.com/ai-coding-tip-022-give-ai-a-harness-to-work-with] 

%[https://maximilianocontieri.com/ai-coding-tip-026-assign-a-persona-to-every-skill-definition] 

%[https://maximilianocontieri.com/ai-coding-tip-027-force-code-standards] 

# Conclusion 🏁

One model can't play every role in your pipeline and catch its own mistakes at the same time.

Split the work across models the way you'd split it across a team.

Plan with one, code with another, and let a third one check the work.

Rotate them as the models change, and let the mismatch between their blind spots do the reviewing for you.

# More Information ℹ️

[Model Inversion: Why Cross-Model Code Review Catches More Defects](https://www.greptile.com/blog/model-inversion)

[Ensemble Learning](https://en.wikipedia.org/wiki/Ensemble_learning)

# Also Known As 🎭

*   Stage-Specific Model Routing
    
*   Cross-Model Development Pipeline
    
*   Model-Per-Stage Assignment
    
*   Rotating Model Roles
    

# Tools 🧰

Claude Code, Codex CLI, Cursor, and OpenRouter all let you configure a different model for each agent or task inside the same workflow.

# Disclaimer 📢

\[GenDisclaimer\]

* * *

This article is part of the *AI Coding Tip* series.

%[https://maximilianocontieri.com/ai-coding-tips]