Prompts

Build a feature or fix a bug test-first, one vertical slice at a time.

Make an interface work by keyboard, screen reader, and at high zoom.

Review a diff on two independent axes — repo standards, and the spec it came from.

Six-phase discipline for hard bugs — build a red-capable loop before theorising.

Stress-test a plan through a relentless one-question-at-a-time interview.

Compact a session into a document another agent can resume the work from.

Design an interface from the call site, then stress-test it against known futures.

Add a cache without introducing a correctness bug.

Remove debug instrumentation, dead code, and stale comments before shipping.

Design a command-line interface for both a human and a script.

Understand a specific piece of code well enough to change it, and say what you're unsure of.

Design deep modules — small interfaces, clean seams, testable through them.

Turn working changes into commits whose messages explain why.

Reason about code where more than one thing happens at once.

Handle configuration and secrets so misconfiguration fails loudly at startup.

Change a schema without data loss or downtime — expand, migrate, contract.

Move dependencies forward safely, reading changelogs before bumping.

Write documentation that answers the question the reader arrived with.

Sharpen a project's domain language and record the decisions worth keeping.

Decide what can fail, where it's caught, and what must never be swallowed.

Break work into pieces and state the uncertainty instead of hiding it.

Build from a spec in vertical slices, with tight feedback and honest reporting.

Respond to a live production problem — stabilise first, diagnose after.

Instrument the questions you'll ask at 3am, not the code you happen to be in.

Build an accurate mental model of an unfamiliar codebase, and say what you're unsure of.

Make something measurably faster — measure, profile, change one thing, re-measure.

Build throwaway code that answers one design question, then capture the answer.

Open a PR a reviewer can evaluate without reconstructing your reasoning.

Improve structure without changing behaviour, in small reversible steps.

Investigate against primary sources and write cited findings to a durable file.

Resolve a merge or rebase by understanding both intents before picking.

Undo a change safely, accounting for the state that doesn't revert.

Review a diff for security defects, with a reachable path for every finding.

Turn a discussion into a written spec, without inventing what wasn't decided.

Find the untested code that matters and close the gaps worth closing.

Turn a reported issue into something actionable, or close it honestly.

Make invalid states unrepresentable so bugs become compile errors.