Coding

Instrument first, theorize second — logging with a stated plan for capturing the failure.

Type one file with runtime behavior frozen, and make the type-checker output the proof.

Have the AI attack your own code: ranked vulnerabilities, a concrete exploit for each, and the fix.

Walk the history between a known-good commit and main to find the culprit diff.

Split an oversized function into well-named pieces without changing external behavior.

Audit finished work against the plan it was supposed to follow — gaps only, no style notes.

Close out a session with a why-focused commit and a PR that carries a test plan.

A properly formatted commit whose body explains why, derived only from the staged diff.

An idiomatic port, not a transliteration — with anything that doesn't translate flagged rather than faked.

Find the N+1s, blocking calls, and hot loops, ranked by impact-per-effort.

CREATE TABLE statements with constraints, indexes, and the reasoning behind each choice.

Endpoint-by-endpoint design including the error responses most API specs forget.

A component design with data model, API surface, the hard parts, and what to defer to v2.

Complete JSDoc or docstrings with precise types, throws, constraints, and a usage example.

Update docs strictly from the diff, with no invented features.

A concept taught through code you'd actually ship, plus when not to use it.

Onboard onto unfamiliar code fast — inputs, side effects, and the footguns the author baked in.

Make the agent read and explain a subsystem before it touches a single line of it.

Build exactly the listed requirements against your existing patterns — and nothing more.

Find every affected code path and the same bug elsewhere before landing the minimal fix.

A typed, documented function built to spec — with three unit tests covering the edge and error cases.

Happy path, boundary values, and a deliberate failure case — each with a note on what it covers.

Cover the success path, validation, auth failures, 404s, and side effects of one endpoint.

Map a language you know onto one you don't, with the gotchas and habits that will hurt you.

Find every caller a signature change would break, and the safe order to migrate them.

Migrate off a deprecated dependency one file at a time, stopping the moment tests fail.

Read the execution plan, name the real bottleneck, and get a rewrite plus the exact index to add.

A numbered plan with a verification step per phase, produced before any code is written.

Convert what went wrong into a one-line rule your agent config carries forward.

A pre-ship review of security, error handling, scale, and observability — no style nitpicks.

Have the agent read the ticket itself, find the relevant code, and propose a plan.

Turn a diff into a scannable PR write-up with risks, rollback, and a reviewer checklist.

Point at a file you already like and have the agent bring another one in line with it.

Give match and non-match examples, get a regex plus a plain-English breakdown and extra test strings.

Require proof of zero callers before anything is deleted, and approval before it happens.

Rank the likely causes of a flaky bug and get a deterministic way to reproduce the top one.

Force a failing test that captures the bug before any fix is allowed to land.

An honest, unhedged comparison of two approaches with a named recommendation.

Keep review scoped to what actually changed — correctness issues only.

A minimal folder layout, boilerplate, and dependency list for a new project — nothing you didn't ask for.

Split a rough goal into tasks small enough that each is one focused session.

Get the failing test and edge cases before any implementation exists — the AI stops after the test.

List the untested edge cases in a diff, then write the tests that would catch them.

Follow a value through every function that touches it, with side effects and an ASCII flow diagram.

Delegate a read-only investigation so the findings come back without context bloat.

A no-fluff README with only the sections your project actually needs filled in.

Turn a vague idea into a written spec by making the model interrogate you first.

Generate a test suite for untested code covering normal paths, edge cases, and error conditions.

Generate clear docs for a chunk of code — overview, parameters, usage, and gotchas.

Explain your code out loud and let the AI catch where your logic and the code disagree.

Turn a plain-language task description into a working Python script with error handling and a usage example.

Generate a typed, styled Next.js component skeleton from a description.

Get a beginner-friendly, line-by-line explanation of any code snippet.

Clean up code for clarity and maintainability without changing behavior.

Get a clear root-cause explanation and the smallest fix for an error.