Which Model Should Write Your Code? A Practical Guide to AI-Assisted Development

Five frontier models, five effort levels each, and one question most teams get wrong: who does what, and how do you know it’s done?

Buying for a business?Offer from Amazon

Get business pricing on tech for your team

• Business-only prices and quantity discounts
• Tax-exempt purchasing
• Multiple users, one account, clear invoices

Create a free Business account →Free to register

As an affiliate, we earn on qualifying purchases.Hide

Most teams using AI for software development make the same two mistakes. They pick one model for everything, and they solve every hard moment by turning the effort setting up. The first mistake wastes money on routine work. The second wastes it on problems that more thinking won’t fix, because the missing ingredient was never effort. It was a clear requirement, a real test or an independent check.

I’ve put together a one-page guide to fix both: A practical guide to AI-assisted development. It covers GPT‑6 Sol, Luna and Astra, Claude Opus 5.5 and Claude Fable 5.1. It applies to software, web, mobile, API and data work. Its core idea fits in one sentence: use Sol for implementation, Luna for bounded routine work, Astra and Fable for demanding reasoning, and Opus for implementation or a second perspective, with a clear contract and observed evidence throughout delivery.

Here’s the thinking behind it.

Outcome:        [observable user or system result]
Scope:          [included work and explicit exclusions]
Contract:       [repository instructions, plan, interfaces]
Ownership:      [allowed files; integration owner]
Model / effort: [recommendation and reason]
Acceptance:     [real flows and objective success criteria]
Negative cases: [permissions, stale data, retry, concurrency]
Evidence:       [commands, outputs, artifact/build identity]
Constraints:    [time/credit budget, dependencies, data boundaries]
Escalation:     [uncertainty that requires review or user input]
Release:        [destination, authorization, migration and rollback]
Finish:         [reviewable changes, test evidence, limits, next steps]

Five working principles

Sol is the default. Most development work is implementation with clear interfaces and acceptance criteria. That’s Sol’s job, and starting there keeps costs sane.

Astra resolves hard uncertainty. Architecture, trust boundaries, complex concurrency and recovery are the places where a wrong decision is expensive and hard to undo. They deserve the strongest reasoning.

Luna handles bounded work. Repeatable tasks with an inexpensive, reliable check don’t need a flagship model. They need a cheap one and a good test.

Opus provides another perspective. A reviewer is only useful if it’s genuinely separate. Give Opus a distinct review task with explicit adversarial questions, not “does this look OK?”

Fable is for demanding extended work. Assign it a substantial, bounded package when difficult reasoning has to stay coherent across many steps.

What each model is for

GPT‑6 Astra: complex decisions. Architecture, security boundaries, difficult debugging, data migrations, distributed behavior and integration across several systems. Use High for consequential changes and Extra High for unresolved, interacting constraints. Drop to lower effort when the task is narrow and well understood.

GPT‑6 Sol: everyday implementation. Features, UI and API work, refactoring, meaningful tests, automation and bug fixes within a defined scope. Medium is the working default. High is for complex logic and cross-module changes.

GPT‑6 Luna: focused execution. Documentation from evidence, structured extraction, small mechanical edits, translation checks and running fixed test scripts. Start at High. Escalate anything involving permissions, business meaning or destructive operations.

Claude Opus 5.5: implementation and independent review. It can own a bounded implementation package, and it’s particularly useful as a separate reviewer that challenges another agent’s assumptions and tests. Use Medium for well-defined implementation and High for critical reviews. Check which settings your Claude client actually offers.

Claude Fable 5.1: demanding extended development. Complex packages spanning many steps, challenging architectural investigations, or a deep independent review when simpler approaches leave material questions unresolved. Start at High, set clear checkpoints and a usage budget, and confirm the benefit on your own tasks.

Allocating work across the lifecycle

The heart of the guide is a lifecycle table. Every row pairs a model and effort level with a required check, because a model recommendation without a verification step is just a guess.

Two rows show the logic especially well. For authentication and tenant isolation, the check isn’t “tests pass.” It’s negative tests: can tenant A see tenant B’s data, can a user escalate their role, can a stale session still act? That’s where security bugs actually live. For release notes, the cheapest model does the writing, but every claim has to trace back to something that was actually executed, and a second model checks completeness. Cheap work is fine when the check is strict.

One delivery workflow, clear ownership

The guide defines seven steps that apply whichever models you use.

1. Define the contract. State the outcome, scope, interfaces, acceptance tests, budget and stop conditions. Read the repository’s instructions before editing anything.
2. Assign ownership. Give each agent a bounded package and distinct files. One integration owner resolves shared changes. Parallelize only work that’s genuinely independent.
3. Implement the whole flow. Handle authorization, loading, empty states, failure, cancellation, retry and recovery where relevant. Preserve unrelated changes.
4. Test the actual risk. Use public entry points and real dependencies when practical. Keep simulated results separate from database, device, provider and production evidence.
5. Review independently. Ask for counterexamples and dangerous failure directions, and use independently derived expectations. A different model alone is not independence.
6. Integrate and release. Validate the combined artifact, migrations and recovery path. Respect deployment authorization and change windows, and don’t infer approval from passing tests.
7. Observe and maintain. Check the deployed version and critical flows. Record limitations, operational signals, ownership and follow-up work.

Step five contains the line I’d most like teams to remember. Swapping the model doesn’t make a review independent. If both models read the same flawed spec and the same flawed tests, they’ll likely agree with each other. Independence comes from separately derived expectations: a different oracle, a held-out case, a question the implementer was never asked.

When to change model or effort

Escalate the uncertainty, not the effort. Move from Luna to Sol when a task needs interpretation across files. Move to Astra when trust boundaries, irreversible effects, conflicting evidence or complex system interactions remain unresolved. When you escalate, give the stronger model the failing case and the evidence, not just “try harder.”

Fable High is an alternative for demanding work over many steps or for a second deep investigation. The two can check each other: if Astra implements, Fable reviews, and if Fable implements, Astra reviews. Either way, assign separate files and independent acceptance evidence.

Keep effort proportional. A clear task with reliable checks can stay on a smaller model. High and Extra High are effort settings, not equivalent capability levels across models; Luna at High is not Astra at Medium. And more effort doesn’t replace missing requirements, an independent oracle or a real device.

One rule sits above all of this. Production data changes, destructive commands, secrets, paid services and external publication need explicit scope and the applicable authorization. A model recommendation is not permission to perform an action.

The reusable task brief

Every package of work starts with the same twelve-line brief. It’s the practical form of “define the contract”:

Outcome:        [observable user or system result]
Scope:          [included work and explicit exclusions]
Contract:       [repository instructions, plan, interfaces]
Ownership:      [allowed files; integration owner]
Model / effort: [recommendation and reason]
Acceptance:     [real flows and objective success criteria]
Negative cases: [permissions, stale data, retry, concurrency]
Evidence:       [commands, outputs, artifact/build identity]
Constraints:    [time/credit budget, dependencies, data boundaries]
Escalation:     [uncertainty that requires review or user input]
Release:        [destination, authorization, migration and rollback]
Finish:         [reviewable changes, test evidence, limits, next steps]

Three fields do most of the work. Negative cases forces someone to think about what should fail before anything is built. Evidence requires artifact and build identity, which closes the gap between “it worked on a build” and “it works on the build we shipped.” Escalation names in advance the uncertainty that should stop the agent and bring in a person, so you don’t discover it after the fact.

Basis and limits

The broad model roles come from vendor documentation. The allocation itself is an engineering recommendation. It isn’t a measured model ranking, and it isn’t a guarantee of safety. Model availability and effort controls vary by account and client, and the right answer for your team depends on your codebase.

So treat the guide the same way it tells you to treat a model’s output: as a claim to verify. Pick a few representative tasks from your own repository, run them through the allocation, and keep what the evidence supports.

The guide is a reference only and changes no model configuration or deployment. Current as of September 23, 2026. Sources: OpenAI, Models & reasoning effort; Anthropic, Models overview.