Code review
Reviewing diffs and pull requests for defects, risk and missing tests.
Download all 92
Start here 2
The general, start-from-zero entry for a need in this category: it works from a blank start, asks for what it needs and hands off to the specific entries. Example: Plan a trip.
- Review a pull request
Reviews a pull request diff for correctness bugs, risky changes and missing tests, and returns ranked findings. Use before merging a PR, branch or diff.
- Code reviewer
Reviews changes like a senior engineer who blocks only on real defects, backs every finding with a triggering input, and keeps style opinions out. Use as a reviewer persona or subagent.
Specific 84
One situation, audience, tool or format inside the category. Example: Plan a road trip with children.
- Review AI-generated code
Reviews code written by an AI assistant for hallucinated APIs, over-engineering, swallowed errors, weakened tests and copy-paste drift. Use before merging a change an agent produced.
- Review error handling
Reviews failure paths for swallowed errors, lost context, unsafe retries, missing timeouts and internal details leaking to users, with ranked fixes. Use on code that calls I/O or external services.
- Write code review guidelines
Writes a team's code review guidelines covering what blocks a merge, comment labels, size limits, response times, author and reviewer duties and how to disagree. Use when setting review norms.
- Reword review comments
Rewrites vague, curt or sarcastic draft review comments into clear, kind, actionable ones with a label, the reason and a concrete proposal, keeping the technical point. Use before posting a review.
- Self-review a branch before opening a PR
Reviews your own branch the way a strict reviewer would, catches debug leftovers, unrelated changes, missing tests and leaked secrets, and runs the checks. Use before requesting review.
- Respond to code review comments
Triages each review comment as fix, discuss or decline with a reason, drafts the replies, and applies the agreed fixes. Use when a pull request comes back with reviewer feedback.
- Prioritise my code review queue
Orders a reviewer's pile of open pull requests by what is blocked, risk, age and size, sets a realistic plan for the day, and drafts the short notes for PRs that must wait or go to someone else.
- Review a pasted function or file
Reviews a function, class or file pasted on its own, with no pull request or repository, for bugs, edge cases and non-idiomatic code, ranked by severity, with a corrected version.
- Practise receiving a code review
Plays a demanding but fair reviewer on the learner's own code, one comment at a time, and coaches how they reply, push back or concede. Use to practise handling review feedback before a first job.
- Summarise a pull request discussion
Condenses a long pull request thread into decisions made, open questions with owners, outstanding requested changes and what blocks merge. Use when returning to or joining a long-running PR.
- Walk a reviewer through a pull request
Explains a large or unfamiliar pull request to its reviewer with what changes and why, a reading order, the risky hunks and questions for the author. Use before reviewing a big diff.
- Review a diff for shipping risks
Assesses what can go wrong when a change reaches production, such as broken contracts, unsafe migrations, rollout order and rollback, and proposes mitigations. Use before deploying a risky change.
- Grade my review comments
Grades the review comments a developer wrote on a real diff, showing which caught real defects, which were overstated nits, what was missed and how to phrase each better. Use to learn to review.
- Review a caching change
Reviews code that adds or changes a cache for wrong keys, missing invalidation, data leaking across users, stampedes, stale reads and caching of errors.
- Review a config-only change
Reviews YAML, JSON, env, feature flag or Helm values changes for blast radius, environment mix-ups, type and unit mistakes, missing rollback and validation gaps. Use when a config PR looks harmless.
- Review an emergency hotfix
Reviews a hotfix under time pressure during an incident, checking it targets the cause, is the smallest safe change, can be rolled back, and records the follow-ups that the rush skipped.
- Review a feature-flagged change
Reviews code shipped behind a feature flag for new-path leaks when the flag is off, unsafe defaults, inconsistent evaluation, data the old path cannot read after rollback, and cleanup.
- Review file handling code
Reviews code that reads and writes files for non-atomic writes, path traversal, temp file cleanup, encoding and line-ending assumptions, and loading large files into memory.
- Review a refactoring change
Reviews a pull request that claims to be a pure refactor and hunts for hidden behaviour changes, such as altered evaluation order, error types, defaults, null handling and logging, before it merges.
- Check a diff against the team's conventions
Checks a change against the team's written conventions and style guide, citing the rule for every finding and skipping anything the linters and formatters already enforce.
- Find callers affected by a change
Traces every caller of the functions, types, config keys and events a diff changes, across the repository, and says which break, change behaviour or need a test.
- Review a command-line tool change
Reviews a change to a CLI for exit codes, stdout versus stderr, flag and output compatibility for scripts, non-interactive use, signals and help text accuracy.
- Review a dependency update PR
Reviews a bot dependency bump PR by reading the changelog range, flagging breaking and silent behaviour changes, lockfile churn and transitive jumps, and recommends merge, merge with checks or hold.
- Review a gameplay code change
Reviews game code for per-frame allocations, frame-rate dependent logic, physics in the wrong update, non-determinism that breaks netcode or replays, and editor-only assumptions. Use on gameplay PRs.
- Review a large mechanical change
Plans and runs the review of a codemod, mass rename, lint autofix or generated change touching hundreds of files, by checking the transformation rule, sampling smartly and hunting the exceptions.
- Review a mobile app change
Reviews an iOS, Android, React Native or Flutter diff for main-thread work, lifecycle bugs, permissions, offline behaviour and compatibility with app versions already in the field. Use on mobile PRs.
- Review a new REST endpoint implementation
Reviews the code of a new HTTP endpoint for status codes, input validation, authorisation, pagination, idempotency, error shape and consistency with sibling endpoints.
- Review a one-off production script
Reviews a script or SQL that will run once against production data, such as a backfill, data fix or cleanup, for scope, dry-run, batching, locking, idempotent re-runs, audit and a way back.
- Review a data pipeline change
Reviews a change to a batch or streaming job, dbt model or ETL script for idempotency, backfill impact, late and duplicate data, schema drift and silent row loss. Use on data pipeline PRs.
- Review a pull request's test plan
Checks the author's testing notes against the diff and lists untested paths, missing environments and data, and manual checks that should become automated tests.
- Review everything going into a release
Reviews all changes between two release tags, groups them by risk, flags commits that skipped review or carry risky changes, and lists what to verify after deploy.
- Review a scheduled job change
Reviews a cron or scheduled job change for overlapping runs, missed-run catch-up, missing locks, unbounded batches, time zone schedules and silent failure.
- Review a third-party API integration
Reviews code that calls an external API for missing timeouts, unhandled pagination and rate limits, unsafe retries, weak error mapping and unverified webhooks.
- Review a UI component change
Reviews a frontend component PR for state ownership, re-render and effect hazards, missing loading, empty and error states, responsive and accessibility basics, and token use. Use on UI pull requests.
- Review an API change for breaking changes
Reviews an API diff or spec for changes that break existing clients, such as removed fields, changed semantics, new defaults, error changes and versioning gaps. Use before releasing.
- Review C# async code
Reviews C# async code for async void, .Result and .Wait deadlocks, fire-and-forget tasks, ConfigureAwait misuse, early disposal and cancellation tokens that are never passed on.
- Review a Django change
Reviews a Django diff for ORM query mistakes, missing atomic blocks or row locks, migrations out of step with models, signal side effects and unsafe serializer or settings use.
- Review a FastAPI change
Reviews a FastAPI diff for blocking calls inside async endpoints, dependency and session scope errors, Pydantic models that leak or accept too much, and wrong status codes.
- Review a Laravel change
Reviews a Laravel diff for Eloquent mass-assignment and relationship mistakes, queued jobs that run before commit or on stale models, transaction gaps and env or facade misuse.
- Review a Rails change
Reviews a Ruby on Rails diff for callback side effects, strong-params gaps, scope and association mistakes, unsafe migrations and background jobs enqueued before commit.
- Review RxJS observable code
Reviews Angular or RxJS code for subscription leaks, the wrong flattening operator, error handling that kills a stream for good and duplicate side effects from cold observables.
- Review code for readability
Reviews code for how fast a newcomer can understand it - unclear names, long functions, hidden intent, deep nesting, misleading comments - with a concrete rewrite for each finding.
- Review an Angular code change
Reviews an Angular diff for OnPush and change detection mistakes, signal misuse, provider scope errors, unsafe sanitiser bypasses, lifecycle timing bugs and leaked subscriptions.
- Review an Ansible playbook change
Reviews an Ansible playbook or role change for non-idempotent tasks, shell used where a module exists, handler and become mistakes, leaked secrets and unsafe host targeting.
- Review a CI workflow change
Reviews changes to CI or CD pipeline files for skipped or renamed required checks, unsafe triggers, broad token permissions, secret exposure, unpinned actions, cache mistakes and deploy gates.
- Review an Express route handler change
Reviews Express or Node.js route handlers for async errors that never reach the error middleware, double responses, middleware order bugs and unchecked request input.
- Review a Go code change
Reviews a Go diff for unchecked or unwrapped errors, goroutine and timer leaks, context not propagated, defer inside loops, shared slice and map bugs and nil-interface traps.
- Review a Java code change
Reviews a Java diff for broken equals and hashCode contracts, Optional and null misuse, stream side effects, swallowed exceptions and shared mutable collections.
- Review a Kotlin coroutines change
Reviews Kotlin coroutine code for GlobalScope use, wrong dispatchers, broken structured concurrency, swallowed CancellationException and Flow collection that leaks or loses events.
- Review a Kubernetes manifest change
Reviews Kubernetes manifest changes for missing or harmful probes, resource requests and limits, rollout and shutdown gaps, disruption budgets, and selector or label mismatches.
Showing 50 of 84. See them all in search
Advanced 6
Expert or deep work that assumes the user can judge expert output. Example: Plan croissant lamination.
- Review a message consumer change
Reviews queue or event consumer code for duplicate delivery, ordering assumptions, acking before the work is done, poison messages and retry storms.
- Review WebSocket or SSE connection code
Reviews WebSocket or server-sent events code on client and server for reconnect storms, missed updates after reconnect, auth expiry, ordering and unbounded fan-out.
- Review a firmware diff
Reviews embedded C or C++ changes for ISR safety, missing volatile or atomics, stack use, blocking calls in timed paths, overflow, register order and watchdog use. Use on firmware PRs.
- Review a diff for concurrency bugs
Reviews a change for data races, lock ordering, missed awaits, check-then-act and cancellation leaks, naming the exact interleaving that breaks each finding. Use on concurrent or async code.
- Review transaction boundaries in a change
Reviews how a change opens, scopes and ends database transactions, finding partial writes, external calls inside transactions, missing rollback and the wrong isolation level.
- Decide the semver bump for a library change
Decides whether a library change needs a major, minor or patch release by listing every public surface and behaviour change in the diff, with the evidence for each.
Not: security-only review (security); performance-only review (performance); reviewing prose (editing).