A cheap Sonnet classifier decides the kind-of-thing before an expensive Opus planner ever boots — because paying Opus to answer a Sonnet question is the wrong order.

Pattern

Classification Gate

The asymmetry

Two agents, two orders of magnitude.

ClassifierSonnet

Input

~200 tok

Output

~10 tok

Prompt

small

Round-trips

1

Job: read title + body, pick one of four labels.

PlannerOpus

Input

long ctx

Output

structured

Prompt

type-specific

Round-trips

many

Job: build a full, type-appropriate plan with repo context.

Running them in the wrong order — or fusing them — pays Opus prices for Sonnet answers. Order matters because cost does.

The classifier's contract

One job. Four possible answers. Nothing else.

/classify_issueinput: issue JSON (title + body) · output: one label

Does

• Reads title and body fields
• Returns /chore, /bug, /feature, or 0
• Three-field JSON response
• Writes issue_class to the state file

Does NOT

• Read the codebase
• Estimate scope
• Propose a plan
• Pick the implementer

Each rejected expansion of the classifier's role is what keeps it cheap — every inbound issue pays this tax.

The shape

Gate first. Branch second. Plan last.

Inbound Issue  ·  title + body

↓

/classify_issue

Sonnet · ~200 in / ~10 out · no codebase reads

↓

chore

/chore

tasks + validation

bug

/bug

root cause + repro + fix

feature

/feature

story + 3-phase + accept

0

escalate

human triage — no default

0 means cannot classify, not pick a safe default. Silent fallback picks the wrong template and the wrong prompt will be cheerfully followed.

What breaks if you violate it

Three failure modes — each skips the gate.

Classifier reads the codebase

Now it's an expensive classifier doing partial planner work. The per-issue tax you pay at the gate creeps toward Opus pricing.

Self-classifying planner

The planner hedges — "this appears to be a bug, so I'll include repro steps, but also a user story in case." Template soup.

No classification at all

Generic plan template for every inbound item. Chore-scoped work gets feature-scoped plans. Bugs get user stories.

The pattern is not "add a classifier" — it's keep the classifier small enough to be cheap. Drift in either direction collapses the gate.

The discipline

Classify before you plan. Classify cheap. Classify narrow.

The gate is a Sonnet-shaped filter in front of an Opus-shaped worker. Grow the gate and you've paid Opus to answer a Sonnet question on every single inbound — that's the whole cost of getting it backwards.