-
Notifications
You must be signed in to change notification settings - Fork 0
Model Selection Guide Agentic Development 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.
| 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. |
| 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).
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.
The Claude 5 generation models are strong enough that:
-
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.
-
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.
-
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."
| 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. |
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.
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
| 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. |
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.
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-opus-5-20260724", # or "claude-opus-4-20250514"
max_tokens=8192,
messages=[...]
)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).
Keep detailed steering:
- Explicit CDK patterns ("use
fromRoleNamenotnew Role") - IAM policy JSON templates
- Step-by-step task ordering
- Acceptance criteria with exact expected outputs
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
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.
| 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) |
- Anthropic: The new rules of context engineering for Claude 5 generation models (Jul 24, 2026)
- Anthropic: Introducing Claude Opus 5 (Jul 24, 2026)
- Anthropic: Best practices for Claude Code (Jul 2026)
- developersdigest.tech: The New Rules of Context Engineering (Jul 2026)
- agiflow.io: Which Model, Effort, and Limits (Jul 2026)
Written July 22, 2026 for the OMD Code Assist Team (CAT). Share freely with collaborators. Update as community best practices evolve.