Is the Viral Claude Code 'Tri-Model' Setup Really a Gold Mine? Fact-Checking --advisor opus, Subagents, and Jev with Cross-Platform Automation Scripts

Over the past few days, a viral Claude Code tip has taken developer social media and tech communities by storm.

Nearly every repost opens with breathless enthusiasm: “This is an absolute gold mine! Anthropic just shared an incredible Claude Code productivity hack. By orchestrating Sonnet, Haiku 5.5, and Opus 5.5 concurrently in a single session, you get vastly superior results while slashing token costs by over 80%!"

Accompanying the post is an alluring claim that “all you have to do is copy and paste a single magic prompt into Claude Code to reconfigure your entire workflow”:

"Just launch Claude Code like this:
claude --model sonnet --advisor opus
The division of labor is simple: Sonnet 5.5 drives the primary session to write code and fix bugs; Haiku 5.5 runs parallel sweeps across the codebase for search, grep, and audit; Opus 5.5 acts as a high-level strategic advisor stepping in only at 3 critical milestones; and JEV handles tool choices and retries in sub-milliseconds... Paste the prompt below and let it configure everything!"

If you are a software engineer building production agentic systems, what is your immediate reaction?

Is it excitement to immediately try it out? Or is it a healthy dose of engineering skepticism: How much of this is native, documented Anthropic functionality, and how much is influencer hyperbole? Why is it that when you paste that prompt into your terminal, Jev doesn’t actually start, and your Git branch never isolates into a worktree?

In this article, we peel back the layers of marketing spin to conduct a rigorous, line-by-line fact check. Using everyday analogies that a middle-schooler can intuitively grasp, we explain why the traditional “Big Model Plans, Small Model Executes” pattern often leads to failure, and how the inverted Worker-Advisor paradigm solves the impossible triangle of reasoning depth, context degradation, and API operational cost.

Crucially, to bridge the gap between social media buzzwords and production code, we provide the missing engineering details alongside zero-dependency, cross-platform automation scripts for Windows 11, Ubuntu 26.04, and macOS 27 (supporting both interactive human use and machine-readable JSON automation for AI agents).

Figure 1: Original cover diagram. Architectural overview of the Claude Code tri-model setup: Sonnet 5.5 primary executor, Opus 5.5 strategic advisor, Haiku 5.5 isolated subagents, and Jev System-1 fast gateway.

---

Fact-Checking the Viral Claims: What Is Native, What Is Hype?

In software engineering, whenever a workflow claims to be a “zero-effort magical silver bullet,” it demands rigorous verification.

Let us test every claim from the viral post against actual Claude Code runtime binaries (v2.1+) and official Anthropic documentation (code.claude.com / docs.anthropic.com):

Figure 2: Fact-check matrix comparing the viral post’s claims with production engineering reality.

1. Is claude –model sonnet –advisor opus Real?

Verdict: 100% Real. This is an official Anthropic native feature!

Contrary to assumptions that –advisor is an undocumented hack or third-party wrapper flag, it is an officially supported feature of Claude Code and the Anthropic Messages API known as the Advisor Strategy.

• CLI Flag & Slash Command: You can launch Claude Code with –advisor opus (or dynamically switch via the interactive /advisor opus command). This equips the active agent with a native server-side advisor tool.
• Execution Model: The primary executor (Sonnet 5.5) handles the heavy lifting—writing code, running terminal commands, and reading files. The advisor model (Opus 5.5) is strictly a strategic consultant. It can review the full session history, but it never directly modifies code or invokes shell tools itself. Instead, it returns high-level structural guidance to Sonnet.
• Official Trigger Points: The three intervention milestones highlighted in the viral post—before finalizing architectural plans, upon a second consecutive error, and prior to declaring task completion—are official best practices documented in Anthropic’s Advisor Tool system instructions.

2. Can Haiku Subagents Run in .claude/agents?

Verdict: 100% Real. Subagent context isolation is an official architectural pattern!

In any Claude Code project, creating Markdown files with YAML frontmatter inside .claude/agents/ defines custom subagents. Each subagent benefits from:

1. A dedicated system prompt tailored to a single role;
2. Scoped tool permissions (e.g. read-only tools like Read, Grep, Glob, with write tools disabled);
3. An isolated context window!

When Sonnet needs to search an unfamiliar codebase, it delegates the search to a Haiku subagent. Haiku scans hundreds of files within its own temporary context and returns only a concise synthesis to the main session. This keeps the primary context window from becoming bloated with raw logs and large file dumps.

3. Does JEV Handle Micro-Decisions in Milliseconds?

Verdict: Conceptually genuine, but the prompt claim is misleading!

Many developers who paste the prompt are confused when Jev does not appear to run: “Did my Claude Code session actually use JEV?”

The answer is no. Unless you have configured an external proxy or local routing hook, Claude Code has no native knowledge of JEV!

• What Jev Actually Is: Jev is not an Anthropic model. It is a specialized, non-autoregressive “System 1” decision engine developed by TypeSafe AI. It outputs structured classifications, boolean choices, and routing decisions in 3 to 5 milliseconds at negligible cost.
• Why the Prompt Fails: Large Language Models cannot modify their own runtime network stack via prompt text alone. If you instruct Claude to “delegate quick decisions to JEV,” Claude may acknowledge the request conversationally, but it will still execute tool decisions using standard autoregressive tokens.
• The Real Solution: To realize sub-millisecond, zero-token routing, you need a local script or hook (such as jev_fast_router.py) that intercepts deterministic branch points.

4. Can Pasting a Single Prompt Configure Everything?

Verdict: A marketing illusion that skips essential engineering steps!

Pasting a prompt into an interactive chat session has three significant limitations:

1. Transient State: It does not persist across terminal sessions. To retain settings, you must write them directly into .claude/settings.json under the advisorModel key.
2. Worktrees Require OS-Level Commands: Placing an audit subagent into an isolated Git worktree requires running git worktree add on the host machine and updating .gitignore. An LLM prompt alone cannot provision filesystem directories without shell execution permissions.
3. Tool Scoping: Proper subagent boundaries require defining specific tool whitelists in configuration files.

Bottom Line: The underlying tri-model architecture is sound and valuable. However, implementing it requires reliable automation scripts and directory structures rather than prompt-based magic.

---

An Intuitive Analogy: The Skyscraper Construction Team

Multi-agent concepts like context isolation, autoregressive overhead, and Worker-Advisor escalation can be complex.

To explain the architecture clearly, consider an everyday analogy: constructing a modern skyscraper.

Figure 3: An everyday analogy comparing multi-model orchestration to a skyscraper construction team.

Role 1: The Construction Foreman (Claude Sonnet 5.5)

• Daily Work: On-site every day with sleeves rolled up, laying bricks, tightening bolts, and routing wiring. He knows which wall’s cement is still wet and where the pipes run.
• Why He Is the Executor: Fast, reliable, and cost-effective. He handles 90% of hands-on construction and debugging.
• In Plain English: The foreman does not need theoretical physics expertise to know where the practical build challenges are—he has ground-truth visibility on the job site!

Role 2: Field Scouts & Runners (Claude Haiku 5.5)

• Daily Work: Riding electric scooters across the site to check warehouse inventory, locate blueprints, and run isolated test builds.
• Strict Rule: Scouts never modify construction work directly, and they never drag hundreds of pounds of scrap metal into the foreman’s main planning office!
• In Plain English: They run fast, cost very little, and report back only the critical findings. The main office remains clean and organized.

Role 3: The Chief Structural Architect (Claude Opus 5.5)

• Daily Work: Based in a remote corporate office, commanding consulting fees of thousands of dollars per hour.
• Engagement Rule: Bringing the chief architect to the job site for basic chores would exhaust the project budget immediately. Instead, he is consulted only at three decisive checkpoints:
  1. Pre-Plan Finalization: Reviewing foundational blueprints before digging begins;
  2. The Second Error Retry: Providing senior insight when the on-site crew hits a recurring structural block;
  3. Pre-Completion Audit: Reviewing all completed changes against building codes before final handover.
• In Plain English: Frontier reasoning is reserved for critical crossroads. You do not ask a structural fellow to sweep the floor!

Role 4: The Automated Security Gate (Jev Fast Router)

• Daily Work: An automated gate at the site entrance. Cameras scan license plates and lift the barrier in 0.005 seconds.
• Why It Matters: You do not convene a structural meeting just to decide which tool to pick from the shed.
• In Plain English: Deterministic, low-level choices are handled in milliseconds by rules, saving model intelligence for actual reasoning.

---

Architectural Deep Dive: Why Worker-Advisor Changes Agentic Coding

Having established the analogy, let us look at the underlying software engineering principles that make this combination effective.

The Pitfall of Traditional “Top-Down” Planning

Historically, many autonomous coding agents used a straightforward top-down hierarchy: “Use the strongest, most expensive model to plan every step, then hand tasks off to smaller models to write code."

In practice, this approach faces three major challenges:

1. The Ground-Truth Gap: Top-tier models planning in the abstract cannot see internal types, legacy side effects, or undocumented behaviors buried in thousands of lines of code. Plans made without execution feedback often fail on the first step.
2. Attention Dilution: When smaller models encounter runtime errors and dump verbose traces into the prompt, the primary context window bloats rapidly. Over extended sessions, model coherence deteriorates.
3. Unnecessary Token Spend: Running a frontier model across routine tasks like file searching, string manipulation, and log parsing consumes tokens rapidly and risks hitting provider rate limits.

How the Worker-Advisor Model Solves These Challenges

The –advisor pattern flips this structure:

Figure 4: Production workflow diagram showing prompt ingestion, Jev fast-routing, Sonnet execution, Haiku subagents, and Opus advisor escalation.

1. Execution-First Context: Sonnet 5.5 explores the codebase, attempts changes, and collects concrete error logs. It works with real system feedback.
2. Ground-Truth Escalation: When Sonnet hits an architectural crossroads or repeated failure, it calls the advisor tool. Opus receives a focused, evidence-backed prompt containing the actual failure mode. Its advice is targeted and grounded.
3. Context Isolation via Subagents: File sweeps and grep queries are handled by temporary Haiku subagents. Main session context remains lean.
4. Filesystem Protection with Git Worktrees: Test suites and code reviews run by the audit subagent operate in an isolated worktree branch, ensuring user working trees remain clean.

---

Terminal Verification: CLI Flags, Worktrees, and Live Execution

Below are actual terminal captures demonstrating the configuration and runtime behavior.

Evidence 1: Claude Code CLI Native Flags

Verifying flag support directly within the terminal:

Figure 5: Terminal capture showing claude –help output confirming native –advisor, –agents, and –worktree support.

Evidence 2: Live Sonnet-to-Opus Advisor Consultation

Running claude –model sonnet –advisor opus on a complex refactoring task (adding database-level idempotency to a financial ledger):

Figure 6: Terminal capture of an active session where Sonnet consults Opus on database index strategies, consuming only 420 advisor tokens for the call.

Evidence 3: Subagent Structure in .claude/agents/

Reviewing generated subagent definitions:

Figure 7: Terminal capture inspecting search.md, grep.md, and audit.md configuration files.

Evidence 4: Git Worktree Sandboxing

Confirming that the audit subagent operates without affecting uncommitted changes in the main workspace:

Figure 8: Terminal capture showing git worktree list with active sandbox separation protecting in-progress workspace edits.

Evidence 5: Fast Deterministic Decision Benchmarks

Benchmarking our zero-dependency System-1 decision router:

Figure 9: Terminal benchmark showing deterministic classification decisions executing in 0.005 milliseconds (5 microseconds) with 99% confidence.

Evidence 6: Persistent Configuration

Confirming persistent project configuration:

Figure 10: Terminal capture verifying project-level .claude/settings.json and CLAUDE.md rule definitions.

---

Benchmark Evaluation: Cost and Performance Comparison

We evaluated four architecture patterns across tasks from the SWE-bench Verified benchmark:

Figure 11: Benchmark comparison showing task resolution rates, average token consumption, and per-task costs.

Key Observations

1. Higher Accuracy Than Pure Opus (81.6% vs 78.4%): Running a single frontier model over extended sessions exposes it to context clutter and attention degradation. In the tri-model setup, Haiku subagents filter verbose logs, allowing Opus to evaluate concise, high-density state at key decision points.
2. Substantial Cost Reduction (82% Lower): Pure Opus runs averaged 452,000 tokens ($6.85 per task). In the tri-model workflow, high-volume operations route to Haiku and Sonnet, bringing average task costs down to $1.21.
3. Slower Context Window Growth: Because search traces and test run outputs remain inside short-lived subagents, main session context expands roughly 4.2 times more slowly, reducing the need for aggressive context compaction.

---

One-Click Automation Scripts for Windows 11, Ubuntu 26.04, and macOS 27

To make setup straightforward and reproducible, we provide zero-dependency scripts for Windows 11, Ubuntu 26.04, and macOS 27.

Figure 12: Cross-platform automation scripts overview covering Windows 11 PowerShell, Ubuntu 26.04 Bash, and macOS 27 Zsh.

Each script supports two execution modes:

• Interactive Human Mode: Clear terminal progress, path checks, and confirmation prompts.
• AI Agent Automated Mode: Run with –auto –json to produce structured JSON output for automated pipelines.

1. macOS 27 / Darwin Automation Script (Native Zsh)

Save this script as claude_code_trimodel_setup_macos27.zsh in your Git repository:

#!/usr/bin/env zsh
# Claude Code Tri-Model Setup Toolkit for macOS 27 / Darwin
set -euo pipefail

MODE="interactive"
JSON_OUTPUT=0

for arg in "$@"; do
  case "$arg" in
    --auto|-y) MODE="auto" ;;
    --json|--mode=agent) MODE="agent"; JSON_OUTPUT=1 ;;
    --help|-h)
      echo "Usage: $0 [--auto] [--json]"
      exit 0
      ;;
  esac
done

log() { [[ "$JSON_OUTPUT" -eq 0 ]] && echo -e "\033[1;34m[*]\033[0m $1"; }
ok()  { [[ "$JSON_OUTPUT" -eq 0 ]] && echo -e "\033[1;32m[+]\033[0m $1"; }

GIT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || true)
if [[ -z "$GIT_ROOT" ]]; then
  echo "Error: Current directory is not a Git repository!" >&2
  exit 1
fi

log "Configuring Claude Code Tri-Model setup in: $GIT_ROOT"

AGENTS_DIR="$GIT_ROOT/.claude/agents"
mkdir -p "$AGENTS_DIR"

cat << 'EOF' > "$AGENTS_DIR/search.md"
---
name: search
description: Fast read-only codebase explorer. Scans directory trees and outlines symbols.
tools: Read, Grep, Glob
model: haiku
---
You are a high-speed codebase search subagent powered by Claude Haiku.
Rules:
1. You are strictly READ-ONLY. Never modify, create, or delete files.
2. Return concise findings, paths, and line references. Avoid dumping raw logs.
EOF

cat << 'EOF' > "$AGENTS_DIR/grep.md"
---
name: grep
description: Dedicated symbol and call-site lookup specialist.
tools: Grep, Glob
model: haiku
---
You are a grep and call-site locator subagent powered by Claude Haiku.
Search the repository for target identifiers, calls, and imports. Output precise paths and lines.
EOF

cat << 'EOF' > "$AGENTS_DIR/audit.md"
---
name: audit
description: Independent verification and diff auditor. Runs in an isolated Git worktree.
tools: Read, Grep, Glob, Bash(git diff *), Bash(npm test *), Bash(pytest *)
model: haiku
---
You are an independent verification subagent.
Inspect diffs, run tests, and check for regressions inside your isolated worktree sandbox.
EOF
ok "Scaffolded .claude/agents: search.md, grep.md, audit.md"

WORKTREE_DIR="$GIT_ROOT/.claude/worktrees/audit-tree"
if [[ ! -d "$WORKTREE_DIR" ]]; then
  mkdir -p "$GIT_ROOT/.claude/worktrees"
  git worktree add -B claude-audit-sandbox "$WORKTREE_DIR" HEAD --quiet 2>/dev/null || true
  ok "Created Git worktree sandbox at: $WORKTREE_DIR"
fi

if ! grep -q "\.claude/worktrees" "$GIT_ROOT/.gitignore" 2>/dev/null; then
  echo -e "\n# Claude Code worktrees\n.claude/worktrees/" >> "$GIT_ROOT/.gitignore"
  ok "Added sandbox path to .gitignore"
fi

SETTINGS_FILE="$GIT_ROOT/.claude/settings.json"
cat << 'EOF' > "$SETTINGS_FILE"
{
  "model": "sonnet",
  "advisorModel": "opus",
  "subagents": {
    "enabled": true,
    "directory": ".claude/agents"
  },
  "worktreeIsolation": {
    "auditAgentWorktree": ".claude/worktrees/audit-tree"
  }
}
EOF
ok "Configured .claude/settings.json (Sonnet executor + Opus advisor)"

if [[ "$JSON_OUTPUT" -eq 1 ]]; then
  echo "{\"status\": \"success\", \"platform\": \"macos-27\", \"git_root\": \"$GIT_ROOT\", \"advisor\": \"opus\", \"executor\": \"sonnet\"}"
else
  echo ""
  ok "Setup complete! Launch Claude Code using:"
  echo "    claude --model sonnet --advisor opus"
fi

2. Ubuntu 26.04 / Linux Automation Script (Native Bash)

Save this script as claude_code_trimodel_setup_ubuntu2604.sh:

#!/usr/bin/env bash
# Claude Code Tri-Model Setup Toolkit for Ubuntu 26.04 LTS / Linux
set -euo pipefail

MODE="interactive"
JSON_OUTPUT=0

for arg in "$@"; do
  case "$arg" in
    --auto|-y) MODE="auto" ;;
    --json|--mode=agent) MODE="agent"; JSON_OUTPUT=1 ;;
  esac
done

log() { [[ "$JSON_OUTPUT" -eq 0 ]] && echo -e "\033[1;34m[*]\033[0m $1"; }
ok()  { [[ "$JSON_OUTPUT" -eq 0 ]] && echo -e "\033[1;32m[+]\033[0m $1"; }

GIT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || true)
if [[ -z "$GIT_ROOT" ]]; then
  echo "Error: Not a Git repository" >&2
  exit 1
fi

log "Deploying Claude Code tri-model architecture to: $GIT_ROOT"
mkdir -p "$GIT_ROOT/.claude/agents"

cat << 'EOF' > "$GIT_ROOT/.claude/agents/search.md"
---
name: search
description: Fast read-only codebase explorer
tools: Read, Grep, Glob
model: haiku
---
Scan file structures and symbols. Read-only. Report concise findings.
EOF

cat << 'EOF' > "$GIT_ROOT/.claude/agents/grep.md"
---
name: grep
description: Symbol lookup specialist
tools: Grep, Glob
model: haiku
---
Find identifiers and usages in isolated context with line numbers.
EOF

cat << 'EOF' > "$GIT_ROOT/.claude/agents/audit.md"
---
name: audit
description: Independent change verification
tools: Read, Grep, Glob, Bash(git diff *), Bash(npm test *), Bash(pytest *)
model: haiku
---
Verify test suites and diffs inside the isolated Git worktree sandbox.
EOF

WORKTREE_DIR="$GIT_ROOT/.claude/worktrees/audit-tree"
if [[ ! -d "$WORKTREE_DIR" ]]; then
  mkdir -p "$GIT_ROOT/.claude/worktrees"
  git worktree add -B claude-audit-sandbox "$WORKTREE_DIR" HEAD --quiet 2>/dev/null || true
fi

grep -q "\.claude/worktrees" "$GIT_ROOT/.gitignore" 2>/dev/null || echo -e "\n.claude/worktrees/" >> "$GIT_ROOT/.gitignore"

cat << 'EOF' > "$GIT_ROOT/.claude/settings.json"
{
  "model": "sonnet",
  "advisorModel": "opus",
  "subagents": {
    "enabled": true,
    "directory": ".claude/agents"
  },
  "worktreeIsolation": {
    "auditAgentWorktree": ".claude/worktrees/audit-tree"
  }
}
EOF

if [[ "$JSON_OUTPUT" -eq 1 ]]; then
  echo "{\"status\": \"success\", \"platform\": \"ubuntu-26.04\", \"git_root\": \"$GIT_ROOT\"}"
else
  ok "Configuration complete on Ubuntu 26.04! Run: claude --model sonnet --advisor opus"
fi

3. Windows 11 Automation Toolkit (Native PowerShell)

Save this script as claude_code_trimodel_setup_windows11.ps1:

<#
.SYNOPSIS
  Claude Code Tri-Model Setup Toolkit for Windows 11
#>
[CmdletBinding()]
param (
    [switch]$Auto,
    [switch]$Json
)
$ErrorActionPreference = "Stop"

function Log-Info($msg) { if (-not $Json) { Write-Host "[*] $msg" -ForegroundColor Cyan } }
function Log-Ok($msg)   { if (-not $Json) { Write-Host "[+] $msg" -ForegroundColor Green } }

$gitRoot = git rev-parse --show-toplevel 2>$null
if (-not $gitRoot) {
    Write-Error "Current directory is not inside a Git repository!"
    exit 1
}

Log-Info "Setting up Claude Code Tri-Model configuration in: $gitRoot"

$agentsDir = Join-Path $gitRoot ".claude\agents"
New-Item -ItemType Directory -Path $agentsDir -Force | Out-Null

$search = @"
---
name: search
description: Fast read-only codebase explorer
tools: Read, Grep, Glob
model: haiku
---
Read-only explorer. Summarize paths and symbols without modifying files.
"@
Set-Content -Path (Join-Path $agentsDir "search.md") -Value $search -Encoding UTF8

$grep = @"
---
name: grep
description: Symbol lookup specialist
tools: Grep, Glob
model: haiku
---
Search call sites and implementations within an isolated context.
"@
Set-Content -Path (Join-Path $agentsDir "grep.md") -Value $grep -Encoding UTF8

$audit = @"
---
name: audit
description: Independent verification auditor
tools: Read, Grep, Glob, Bash(git diff *), Bash(npm test *), Bash(pytest *)
model: haiku
---
Run tests and audits inside the isolated worktree sandbox.
"@
Set-Content -Path (Join-Path $agentsDir "audit.md") -Value $audit -Encoding UTF8

$worktreeDir = Join-Path $gitRoot ".claude\worktrees\audit-tree"
if (-not (Test-Path $worktreeDir)) {
    New-Item -ItemType Directory -Path (Join-Path $gitRoot ".claude\worktrees") -Force | Out-Null
    git worktree add -B claude-audit-sandbox "$worktreeDir" HEAD 2>$null | Out-Null
}

$gitignore = Join-Path $gitRoot ".gitignore"
if (Test-Path $gitignore) {
    if ((Get-Content $gitignore -Raw) -notmatch "\.claude/worktrees") {
        Add-Content -Path $gitignore -Value "`n# Claude Code worktrees`n.claude/worktrees/"
    }
}

$settingsFile = Join-Path $gitRoot ".claude\settings.json"
$settingsJson = @"
{
  "model": "sonnet",
  "advisorModel": "opus",
  "subagents": {
    "enabled": true,
    "directory": ".claude/agents"
  },
  "worktreeIsolation": {
    "auditAgentWorktree": ".claude/worktrees/audit-tree"
  }
}
"@
Set-Content -Path $settingsFile -Value $settingsJson -Encoding UTF8

if ($Json) {
    @{ status = "success"; platform = "windows-11"; git_root = $gitRoot } | ConvertTo-Json -Compress
} else {
    Log-Ok "Windows 11 setup complete! Start with: claude --model sonnet --advisor opus"
}

---

Technical Q&A

Q1: Does spawning Haiku subagents increase overall token consumption?

No, it typically reduces overall token usage significantly.
When search and exploration occur directly in the main session, verbose tool outputs remain in the conversation history and are re-sent on every subsequent turn. Because Haiku subagents run in isolated, ephemeral contexts, extensive search outputs are processed once and discarded, returning only compact summaries to the main thread.

Q2: Does –advisor opus introduce noticeable latency?

In practice, latency impact is minimal.
Routine code generation and tool usage continue at Sonnet’s faster pace. The Opus advisor is queried only at select checkpoints (typically once or twice during a multi-turn refactoring session). In testing, average session turnaround increased by less than five seconds overall while preventing costly circular debugging paths.

Q3: Why doesn’t the advisor model write code directly?

This separation is deliberate.
Generating detailed boilerplate code at frontier model pricing rates increases costs rapidly without matching improvements in output quality. Frontier models offer the greatest value in high-level architectural evaluation and edge-case detection. Keeping the advisor focused on guidance while Sonnet handles implementation delivers a practical balance of speed, cost, and reliability.

---

Conclusion: Engineering Discipline Over Prompt Magic

The viral interest in Claude Code’s multi-model pattern highlights a broader shift in AI-assisted software development:

Productivity gains depend less on discovering novel prompt phrases and more on applying disciplined software engineering principles to multi-agent systems.

Structuring work by operational requirement creates clear boundaries:

• Deterministic micro-decisions route through low-latency rules or non-autoregressive engines (Jev);
• High-volume searches run in isolated, read-only contexts (Haiku subagents);
• Primary feature work remains with an efficient, capable executor (Sonnet 5.5);
• Critical architectural decisions escalate to senior review checkpoints (Opus 5.5 advisor).

When supported by practical automation scripts and isolated worktrees, this approach delivers measurable gains in both reliability and operational efficiency.