🔍 Read the full analysis: Which AI Model Should You Use For Writing Code? Expert Tips on ThorstenMeyerAI.com
Get business pricing on tech for your team
- Business-only prices and quantity discounts
- Tax-exempt purchasing
- Multiple users, one account, clear invoices
TL;DR
Experts recommend using specific AI models tailored to distinct software development tasks. Sol handles implementation, Luna for routine work, Astra and Fable for complex reasoning, and Opus for independent review. Proper allocation improves efficiency and quality.
Recent expert guidance from Thorsten Meyer emphasizes the importance of selecting the appropriate AI model for specific software development tasks, moving away from one-size-fits-all approaches. The recommendations, based on a detailed framework, aim to optimize efficiency and quality in AI-assisted coding projects.
The guidance identifies five AI models—GPT‑6 Sol, Luna, Astra, Fable, and Claude Opus—each suited for different stages of development. Sol is recommended for implementation work, such as features, UI, and bug fixes, due to its efficiency in handling clear, defined tasks. Luna is ideal for bounded, repeatable tasks like documentation and testing, where cost-effective reliability is key.
For complex decisions involving architecture, security boundaries, or distributed systems, Astra is advised, especially at high effort levels for difficult problems. Fable is suited for demanding, multi-step reasoning tasks such as architectural investigations or extensive refactoring. Opus serves as an independent reviewer, providing critical, adversarial perspectives on implementation and design, ensuring thorough validation.
This model allocation approach aims to prevent common mistakes: relying on a single model for all tasks or attempting to solve every problem with excessive effort. Instead, it advocates matching models to task complexity and required verification, thus saving costs and improving outcomes.
DEVELOPMENT · MODEL & EFFORT GUIDE
A practical guide to AI‑assisted development
Sol for implementation, Luna for bounded routine work, Astra and Fable for demanding reasoning, and Opus for implementation or a second perspective. Use a clear contract and observed evidence throughout delivery.
Escalate the uncertainty, not the effort
A second perspective at any level: a separate review task with explicit adversarial questions.
When you escalate, hand over the failing case and the evidence, not “try harder.” Astra and Fable can review each other’s work, with separate files and independent acceptance evidence.
What each model is for
Complex decisions
GPT‑6 Astra
Architecture, security boundaries, difficult debugging, data migrations, distributed behavior, multi‑system integration.
High for consequential changes; Extra High for unresolved, interacting constraints.
Everyday implementation
GPT‑6 Sol
Features, UI and API work, refactoring, meaningful tests, automation, bug fixes within a defined scope.
Medium as the working default; High for complex logic and cross‑module changes.
Focused execution
GPT‑6 Luna
Documentation from evidence, structured extraction, small mechanical edits, translation checks, fixed test scripts.
High as a starting point. Escalate permissions, business meaning or destructive operations.
Implementation & independent review
Claude Opus 5.5
Can own a bounded implementation package; especially useful as a separate reviewer challenging another agent’s assumptions and tests.
Medium for well‑defined implementation; High for critical reviews.
Demanding extended development
Claude Fable 5.1
Complex packages spanning many steps, architectural investigations, or a deep independent review.
High as a starting point, with checkpoints and a usage budget.
Verify which effort settings your client and account actually offer.
Allocate work across the lifecycle
| WORK | PRIMARY MODEL / EFFORT | REQUIRED CHECK |
|---|---|---|
| Requirements and scope | Sol Medium; Astra High for ambiguity | Examples, exclusions, unresolved decisions, acceptance criteria |
| Architecture and public contracts | Astra High | Alternatives, failure modes, compatibility, independent review |
| UI, accessibility and localization | Sol Medium | Real interaction, keyboard use, relevant languages and screen sizes |
| Business logic and API implementation | Sol High for complex work | Public‑interface tests, validation, errors and retries |
| Authentication and tenant isolation | Astra High / Extra High | Negative cross‑tenant, role, session and object‑access tests; independent review |
| Database migrations and concurrency | Astra High | Real database, contention, failed transactions, restore and rollback |
| Small mechanical refactors | Luna High or Sol Medium | Diff review and a focused regression check |
| Difficult or intermittent defects | Sol High → Astra High if unresolved | Reproduction, hypothesis, isolated cause, regression test |
| Fixed browser / device acceptance | Sol Medium; Luna for records | Actual target device/browser and exact build identity |
| Benchmark and evaluator design | Astra High or Fable High + independent reviewer | Independent oracle, held‑out cases, meaningful thresholds, no target‑score tuning |
| Extended multi‑module development | Fable High or Astra High; Sol for bounded subtasks | Milestone evidence, fixed interfaces, one integration owner, independent review |
| Deployment and production recovery | Astra High for planning and high‑risk changes | Bound artifact, actual target, backup/restore, health checks, authorized rollout |
| Release notes and maintenance records | Luna High | Trace every claim to executed evidence; Sol checks completeness |
One delivery workflow, clear ownership
- 1Define the contract
Outcome, scope, interfaces, acceptance tests, budget and stop conditions. Read repository instructions first.
- 2Assign ownership
Bounded packages, distinct files, one integration owner. Parallelize only independent work.
- 3Implement the whole flow
Authorization, loading, empty states, failure, cancellation, retry, recovery. Preserve unrelated changes.
- 4Test the actual risk
Public entry points and real dependencies. Keep simulated results separate from real evidence.
- 5Review independently
Counterexamples and dangerous failure directions, with independently derived expectations.
- 6Integrate and release
Validate the combined artifact, migrations and recovery path. Passing tests are not approval.
- 7Observe and maintain
Check the deployed version and critical flows. Record limits, signals, ownership, follow‑ups.
Four rules that prevent expensive mistakes
Reusable task brief
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]
Strategic Model Allocation Enhances Development Efficiency
This tailored approach to AI model selection matters because it directly impacts project costs, development speed, and code quality. By assigning specialized models to distinct tasks, teams can avoid wasting resources on routine work or over-investing in unnecessary complexity. The guidance also helps prevent errors by emphasizing verification steps, especially for security and critical architecture decisions, which are often the most costly to fix later.
Implementing this framework can lead to more reliable, maintainable software and better use of AI capabilities, ultimately enabling teams to deliver higher-quality products faster and more cost-effectively.
As an affiliate, we earn on qualifying purchases.
Evolution of AI in Software Development
The use of AI models in coding has grown rapidly, with developers experimenting with various tools to automate tasks like code generation, testing, and review. Early approaches often employed a single AI model for all tasks, which proved inefficient and sometimes unreliable. Recent developments, including the release of specialized models like GPT‑6 Sol, Luna, Astra, and Fable, along with independent review models like Claude Opus, reflect a shift toward task-specific AI deployment.
This evolution aligns with broader trends in AI, emphasizing specialized, modular tools that can be combined strategically. Experts have recognized that different stages of development require different reasoning and verification levels, leading to the current consensus on model allocation based on task complexity and importance.
“Using the right AI model for each development stage is essential to optimize costs and outcomes. The key is matching model capabilities to task complexity and verification needs.”
— Thorsten Meyer
As an affiliate, we earn on qualifying purchases.
Remaining Questions on Model Effectiveness and Integration
While the framework offers clear guidance, some uncertainties remain. It is not yet fully established how well these models perform across all types of projects or how they integrate into existing development workflows. The effectiveness of the models at different effort levels and in varied environments (e.g., enterprise vs. startup) is still being evaluated. Additionally, the impact of continuous updates and improvements to these models on the recommended allocation strategy is uncertain.
As an affiliate, we earn on qualifying purchases.
Next Steps in Adopting and Testing the Model Framework
Developers and teams are encouraged to implement this model allocation framework gradually, starting with pilot projects to assess effectiveness. Further research and real-world testing will refine effort level settings and verification procedures. Industry groups and tool vendors are expected to develop integrated solutions that facilitate model switching and effort calibration, making the approach more accessible. Monitoring ongoing updates to models like GPT‑6 and Claude will be essential to adapt strategies accordingly.
As an affiliate, we earn on qualifying purchases.
Key Questions
How do I choose the right AI model for my project?
Identify the specific tasks involved—implementation, routine work, complex reasoning, or review—and match them to the recommended models (Sol, Luna, Astra, Fable, Opus) at appropriate effort levels based on task complexity and verification needs.
Can I use a single AI model for all development tasks?
While possible, it is generally inefficient and may lead to suboptimal results. The expert guidance advocates for task-specific models to optimize costs, quality, and reliability.
What are the main benefits of this approach?
Improved cost efficiency, better verification, higher code quality, and reduced risk of costly errors—especially in critical areas like security and architecture.
Is this framework applicable to all types of software projects?
It is designed to be broadly applicable, including web, mobile, API, and data projects, but some adjustments may be needed based on project scale and environment.
How will ongoing AI model updates affect this strategy?
Continuous improvements may enhance model capabilities, requiring teams to revisit effort settings and verification procedures periodically to maintain optimal performance.
Source: ThorstenMeyerAI.com
Fall Picks
fall essentials
As an affiliate, we earn on qualifying purchases.
