TRAVIS J. MACDONALD / WRITING

Stop Using One AI for Everything

Give planning, implementation, and independent review clear roles—and measure the cost of a result you can actually accept.

← All Writing

AI & ENGINEERING

By Travis J. MacDonald · Originally published September 12, 2026 · Updated

A practical mixed-model workflow for software development: route inexpensive models to volume work, capable coding models to implementation, and strong reasoning models to decisions where judgment matters.

My rule is simple: spend cheap tokens on volume. Spend expensive tokens on judgment.

The best model should not do every job

Many AI-assisted development workflows act as if one model should plan the feature, read the repository, generate boilerplate, implement business logic, hunt for bugs, review its own work, and write the documentation.

I use a different approach: mixed-model development. The model is a worker inside a pipeline. Different classes of work are routed to different capability tiers, and expensive reasoning is reserved for decisions where a mistake is costly.

The roles matter more than the product names. Model capabilities, prices, and availability change. Choose the model for the work you have actually observed it doing well.

Architect or manager

Architecture, requirements interpretation, trade-offs, task decomposition, deep debugging, and acceptance decisions. This role needs the judgment to understand consequences across the system.

Scout or preprocessor

Repository inventory, extraction, first-pass scanning, scaffolding, classification, and repetitive transformations. The scout returns evidence and locations that another person or model can inspect.

Implementation workhorse

Well-defined modules, business logic, tests, and refactoring inside an established architecture. A clear specification and bounded ownership make this work easier to review.

Independent reviewer

Architecture review, regression risk, difficult defects, and a challenge to the implementer's assumptions. Sometimes a different model family can provide a useful second perspective; agreement between models still requires evidence.

Utility worker

Formatting, documentation cleanup, simple conversions, and other high-volume tasks where failures are relatively easy to detect.

Route work by consequence

The durable workflow is a sequence of responsibility: establish truth, plan, scout, implement, verify, review, and accept.

  1. Establish the current truth. Record requirements, constraints, interfaces, architectural decisions, and acceptance criteria.
  2. Plan and decompose. Break the work into bounded tasks and identify risky decisions.
  3. Scout and map. Locate relevant files, dependencies, patterns, and possible problems. Return evidence that can be checked.
  4. Implement. Build inside the defined interfaces. Escalate architectural surprises instead of silently redesigning the system.
  5. Run appropriate deterministic checks. Use the compiler, type checker, tests, linting, dependency tools, and security analysis where they can establish something useful.
  6. Review independently. Challenge the change, look beyond the earlier findings, and decide whether the result meets the requirements.

What you gain—and what you take on

Moving volume work away from the most expensive models can reduce inference costs. It can also improve throughput and preserve stronger reasoning capacity for difficult decisions.

Smaller task packages can reduce distracting context. Providers can be changed without rebuilding the whole process. Different reviewers may expose different blind spots.

But mixed-model development brings costs of its own.

Routing becomes an engineering problem. Poor handoffs lose context. Parallel agents can duplicate work or produce conflicting changes. A cheap scan can generate false positives, and it can miss important problems entirely.

Without a shared account of the current project state, several apparently useful contributions can gradually pull the system in different directions.

Optimize for the cost of a correct outcome, including the review and rework needed to reach it.

A cheaper request that creates retries, a regression, and an hour of human cleanup may be an expensive way to finish the task.

Never let the cheapest model become the gatekeeper

An inexpensive model can be excellent for reconnaissance. Its report should help the better reviewer work faster without defining the limits of what that reviewer is allowed to notice.

Suppose the first scan finds possible issues A, B, and C. If the next model is told only to review A, B, and C, the process may become very good at confirming those findings while missing problem D.

The independent reviewer needs permission and enough context to search for what the first pass overlooked.

A useful instruction is:

Validate the earlier findings, but treat the report as supporting evidence. Perform an independent review and specifically look for important problems the earlier analysis missed.

The progression is straightforward: run appropriate automated checks, gather possible findings, validate and organize them, investigate independently, then fix and verify the result.

Capability should rise with risk

You don't need six agents to rename a button.

The effort and quality of review should increase with the consequence of failure. Formatting and simple UI changes need a different process from authentication, concurrency, customer data, public interfaces, or an irreversible migration.

Routine implementation failures can return to the builder. A discovery that changes the architecture needs a decision from the role responsible for that architecture.

My routing rule is to use the least expensive workflow that keeps the expected cost of failure acceptably low.

Measure the work that was accepted

The original version of this article included examples of model names and token prices. This edition leaves those figures out: prices change, and a price table doesn't establish which workflow will work best for your project.

Measure the cost per accepted task. Include retries, defects that escaped review, human intervention, input context, caching, and tool use where those contribute to the bill.

The useful comparison is between workflows that delivered an acceptable result. A low request price tells you only one part of that story.

Context is infrastructure

Every model doesn't need every historical conversation. A bounded task package should contain the current state, relevant code, constraints, and success criteria.

Keep the project above the models.

An implementation model can propose a better interface. A reviewer can propose an architectural correction. A scout can flag a dependency. Those proposals need to be reviewed before they become the new shared account of the project.

Agents consume the current project state, do bounded work, and return proposed changes. A human or designated coordinator decides what is accepted and updates that shared state.

AI output is a proposal until something accepts it.

Don't make the implementer grade its own exam

A separately prompted reviewer has a chance to challenge the framing that produced the code. A different model family can sometimes help, but independence depends on how the review is conducted as well as which model conducts it.

A useful sequence is: one model implements, deterministic tools check what they can, another reviewer examines the result, and the responsible person or coordinator decides what to accept.

This resembles the mechanisms we use to make human engineering teams reliable: specialization, code review, testing, escalation, written decisions, and clear ownership.

AI makes it possible for a solo developer to reproduce more of that structure. The structure still needs care.

The question I keep returning to is: which model should be allowed to make this particular decision?