hermes

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.

Search and filter in Code review
  • 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).