Model Selection Guide Agentic Development 2026 - TerrenceMcGuinness-NOAA/global-workflow GitHub Wiki

Model Selection Guide for Agentic Software Development (July 2026)

Date: July 22, 2026 Audience: OMD CAT developers, NOAA EIB engineers, and collaborators using AI-assisted coding tools (Kiro, Claude Code, GitHub Copilot) for the MDC MCP-RAG platform and Global Workflow development. Context: With Anthropic's release of Claude Opus 5 (July 24, 2026) and the Claude 5 generation's new context-engineering rules, this guide helps the team select the right model for the right task.

TL;DR β€” Which Model When

Task type Recommended model Why
CDK/IaC scaffolding, IAM policies, Terraform Opus 4 / Opus 4.8 Deterministic infrastructure code needs precision over creativity. Opus 4 follows specs literally.
Multi-file refactoring, port Python←→Node Opus 5 Strong cross-file reasoning, reduced need for detailed instructions.
Long-horizon agentic loops (Ralph, 30+ iterations) Opus 5 or Fable 5 Better self-correction with fewer guardrails; handles context accumulation gracefully.
Novel architecture design, exploration Fable 5 Highest-capability frontier model; best for genuinely novel problem-solving.
Quick fixes, test writing, documentation Sonnet 5 Fast, cheap, good enough for bounded single-file tasks.
EE2 compliance analysis, code review Opus 5 Pattern-matching + contextual judgment; benefits from simplified instructions.
Our Cognito/JWT endpoint spec (Tasks 1–5) Opus 4 / 4.8 CDK TypeScript + IAM JSON needs literal precision. Opus 5 may over-abstract.

The Anthropic Model Lineup (July 2026)

Model Tier Pricing (input/output per 1M tokens) Context Sweet spot
Sonnet 5 Standard $3 / $15 200K Everyday coding, short tasks, fast iteration
Opus 4.8 Premium $5 / $25 200K Production IaC, deterministic multi-step tasks
Opus 5 Premium $5 / $25 (same as 4.8) 200K Agentic coding, complex refactoring, self-correcting loops
Fable 5 Mythos $10 / $50 200K Frontier capability; hardest problems; falls back to Opus on ~5-9% of queries

Key points:

  • Opus 5 replaced Opus 4.8 at the same price β€” no cost increase for the upgrade.
  • Fable 5 is 2Γ— the cost of Opus 5 and is the "hardest problems" tier.
  • Thinking is on by default in Opus 5 β€” it reasons through problems before answering.
  • Fable 5 falls back to Opus 4.8 on ~5–9% of sensitive queries (safety classifiers route them down).

The Big Shift: Simplified Instructions for Claude 5 Models

What Anthropic discovered

On July 24, 2026, Anthropic published that they removed over 80% of Claude Code's system prompt for Claude 5 generation models (Opus 5, Fable 5, Sonnet 5) with no measurable loss on coding evaluations.

The system prompt went from ~800 tokens to ~164 tokens. The removed content was rules, guardrails, and examples that were necessary for older models but now actively hurt Claude 5's performance.

Content was rephrased for compliance with licensing restrictions. Sources: Anthropic blog, developersdigest.tech analysis.

Why less is more with Opus 5

The Claude 5 generation models are strong enough that:

  1. Hard rules become conflicting instructions. "Always do X" rules written to prevent older-model mistakes now collide with legitimate cases where X isn't appropriate. The model is smart enough to know when β€” the rule prevents it.

  2. Examples constrain rather than guide. Opus 5 is "more imaginative than the examples we give it." Few-shot examples that helped Opus 4 now cause Opus 5 to slavishly imitate the format instead of finding the better solution.

  3. Context beats constraints. Instead of "do not do this," Claude 5 responds better to context about the situation and trusts you to let it figure out the right approach. Give it the "why" and the landscape; let it handle the "how."

Practical implications for our instruction files

File Opus 4 approach Opus 5 approach
.kiro/steering/*.md Detailed rules, explicit constraints, examples Shorter: domain context + principles. Cut step-by-step recipes.
CLAUDE.md / system prompts Long guardrail lists, format requirements Short: project identity, key patterns, what NOT to touch.
progress.md (Corrections table) Works great β€” self-correcting Works even better β€” model reads corrections proactively.
Ralph loop prompt Detailed 6-phase protocol Can be shorter β€” Opus 5 infers the protocol from the task structure.
Spec requirements.md Keep detailed β€” these define "done" Keep detailed β€” acceptance criteria are the one thing that should NOT be simplified.

The developer community consensus (paraphrased)

Based on early Opus 5 feedback across developer communities:

  • "I deleted my 2000-word CLAUDE.md and my code got better." β€” Multiple reports of quality improvements from removing over-specific instructions.
  • "Give it the terrain, not the route." β€” Context about your codebase structure, conventions, and constraints; not step-by-step implementation orders.
  • "Keep your Corrections table β€” it's the one thing that scales." β€” The Ralph-loop pattern of accumulating mistakes-to-avoid still works; in fact it works better because Opus 5 proactively reads and applies them.
  • "Requirements are sacred; instructions are optional." β€” Define what "done" looks like (acceptance criteria, exit conditions) and let the model figure out how.
  • "Opus 5 asks clarifying questions instead of guessing." β€” With fewer instructions constraining it, the model will ask you rather than hallucinate.

Operational Model Selection for Our Platform

The decision framework

Is the task...

β”œβ”€β”€ Infrastructure-as-Code (CDK, IAM, CloudFormation)?
β”‚   └── Use Opus 4 / 4.8 β€” literal precision on JSON/TypeScript structure
β”‚
β”œβ”€β”€ Multi-file code refactoring or porting?
β”‚   └── Use Opus 5 β€” strong cross-file reasoning, self-correcting
β”‚
β”œβ”€β”€ A long-running autonomous loop (Ralph, 10+ iterations)?
β”‚   └── Use Opus 5 β€” handles context accumulation, reads corrections proactively
β”‚
β”œβ”€β”€ Genuinely novel design (no prior art in the codebase)?
β”‚   └── Use Fable 5 β€” frontier capability, but 2Γ— cost
β”‚
β”œβ”€β”€ Quick bounded task (single file, test, doc)?
β”‚   └── Use Sonnet 5 β€” fast, cheap, good enough
β”‚
└── Code review / compliance analysis?
    └── Use Opus 5 β€” judgment + pattern-matching + contextual awareness

Our specific use cases mapped

Use case Model Rationale
mcp-external-access-revised Tasks 1–5 (CDK + Cognito + IAM) Opus 4.8 IAM policy JSON needs byte-level precision; CDK TypeScript is template-heavy; Opus 4.8 follows specs literally without over-abstracting.
cots-reingest-ralph-framework (44 units via Ralph loop) Opus 5 Long-horizon, self-correcting loop. Each iteration reads progress.md corrections. Opus 5's reduced-instruction profile means the Ralph prompt can be shorter.
Phase 74 Per-User RAG Isolation (novel design work) Opus 5 or Fable 5 Novel tenant-isolation architecture, cross-cutting concerns. Fable 5 if we need the frontier; Opus 5 for cost-efficiency.
aws-doc-refresh-ingest (run an ingester) Sonnet 5 or manual Executing a known script with known parameters β€” doesn't need a frontier model.
EE2 embedding iteration (chunking experiments) Opus 5 Pattern-matching on standards text + judgment about chunk boundaries. Benefits from simplified instructions.
CI error log analysis / extract_ci_error_signal Opus 5 Multi-step reasoning: parse log β†’ extract signal β†’ classify taxonomy β†’ recommend fix.
Wiki report generation (what we do in this session) Opus 4.8 or Opus 5 Structured output from data; either works.

How to Specify the Model

In Kiro CLI (our Ralph loop)

Kiro CLI uses the model configured in your Kiro account settings. As of this writing, model selection is controlled by your Kiro subscription tier:

  • Pro / Team Standard β†’ defaults to Sonnet 5
  • Max / Team Premium β†’ defaults to Opus 5

To use a specific model, check kiro-cli settings or the Kiro IDE model picker.

In direct API calls

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-5-20260724",     # or "claude-opus-4-20250514"
    max_tokens=8192,
    messages=[...]
)

In the AgentCore runtime

The AgentCore MCP server (our Python runtime) doesn't select a model β€” it IS the tool server. The model selection happens on the client side (Kiro, Claude Code, or the GitHub Actions runner that calls the MCP tools).

Instruction File Strategy (going forward)

For Opus 4.8 / pre-5 workflows (CDK, IaC)

Keep detailed steering:

  • Explicit CDK patterns ("use fromRoleName not new Role")
  • IAM policy JSON templates
  • Step-by-step task ordering
  • Acceptance criteria with exact expected outputs

For Opus 5 workflows (agentic loops, refactoring)

Simplify to:

  • Project identity (what is this repo, what does it do)
  • Key conventions (collection naming, tenant model, git policy)
  • What NOT to touch (serving paths, AWS resources, auto-commit)
  • Corrections table (mistakes to avoid β€” the one thing that scales)
  • Exit criteria (what "done" looks like β€” keep these detailed)

Delete:

  • Step-by-step "how to implement" instructions (let the model figure it out)
  • Format examples (the model's format is usually better than your template)
  • Guardrails against mistakes the model no longer makes
  • Redundant restatements of requirements

The test

If you can remove an instruction and the model's output doesn't degrade (or improves), the instruction was hurting you. Try removing it for one iteration and compare.

Summary

Principle Old (Opus 4 era) New (Opus 5 era)
Instructions More is better Less is better (give context, not constraints)
Examples Few-shot helps Few-shot constrains (remove or minimize)
Corrections Useful Essential (the one scaling mechanism)
Requirements Detailed Still detailed (define "done" precisely)
Model selection One model fits all Route by task type (IaC β†’ 4.8, agentic β†’ 5, frontier β†’ Fable)
Cost Premium for everything Match capability to need (Sonnet for simple, Opus for complex)

References

Written July 22, 2026 for the OMD Code Assist Team (CAT). Share freely with collaborators. Update as community best practices evolve.