Capability needs
a little direction.

These skills are a response to specific failure modes we keep hitting with coding agents. Each one targets a problem we got tired of repeating and encodes the workaround so the agent does it without being asked.

1. The agent doesn't actually understand what you want

The default failure of any AI coding session is misalignment. You think you described the change clearly; the agent confidently builds something else. Catching it ten minutes in is cheap, catching it after a full implementation is not.

The fix is a grilling session before any code gets written — let the agent ask you the questions you forgot to answer.

• /grill-me — design / non-code grilling
• /grill-with-docs — same loop, but layered on the project's domain glossary and ADRs

2. The agent uses ten words where one would do

Agents drop into a project with no shared vocabulary, so they describe everything in long generic English. The longer the description, the more tokens you burn and the easier it is to lose precision.

The fix is a shared language captured in a CONTEXT.md and grown incrementally. Once "the materialization cascade" is a defined term, the agent says "the materialization cascade" instead of three sentences.

/grill-with-docs builds that language for you as a side-effect of grilling — whenever a fuzzy term gets sharpened during the session, it gets written to CONTEXT.md immediately.

3. The code doesn't work

When the agent and you are aligned on what to build, the next failure mode is the agent producing code that compiles but doesn't behave. The cure is fast, deterministic feedback loops: types, tests, browser access — and discipline about how to use them.

• /tdd — red-green-refactor with vertical-slice tracer bullets, not horizontal "write all tests first"
• /diagnose — bug-hunt loop where Phase 1 is building the feedback loop itself; everything else is mechanical

4. The codebase becomes a ball of mud

Agents accelerate coding, which means they also accelerate entropy. Without deliberate design effort, the codebase grows complex faster than any human can keep in their head.

The cure is caring about design every day — surfacing architectural friction early and refactoring shallow modules into deep ones before they calcify.

• /zoom-out — get oriented before changing unfamiliar code
• /to-prd — capture the modules you're about to touch in a PRD before any code gets written
• /improve-codebase-architecture — find deepening opportunities in an existing codebase, run periodically

5. The PR cycle eats your day

Even when the agent ships good code, getting it through review, CI, and merge is its own slog: address reviewer comments, fix flaky checks, rebase when conflicts appear, repeat for hours.

The cure is letting the agent own the entire ticket — from worktree to merge — and reviewing each PR with the same discipline a human reviewer would.

• /workon — drives a Linear ticket end-to-end, including a 5-minute watch loop that addresses review comments, fixes CI failures, and resolves merge conflicts until the PR merges
• /review — read-only, high-signal PR review with explicit Critical / Suggestions / Nits tiers, scoped against the ticket's stated intent

The first four failure modes are general — the engineering ideas behind them are largely from mattpocock/skills, where most of those skills originated. /workon and /review are smeltery originals written for our own delivery loop.