Code Review & Refactoring

Lint and type-check code after each change to catch syntax and style issues

Find performance bottlenecks in code, databases and APIs and prove the fix

Profile code performance with measurement, analysis and targeted optimization

Audit an entire codebase and refactor it toward production-grade quality

Build or update a persistent code review graph that hooks keep current

Navigate and understand a codebase's structure through its knowledge graph

Plan and run safe refactors using dependency analysis and blast-radius checks

Run a structured code review of changes using impact and blast-radius analysis

Review only the changes since your last commit, with automatic impact analysis

Review a PR or branch diff with full structural context and blast-radius analysis

Have a second AI model review work before commit and switch models on refusals

Catch and repair malformed YAML frontmatter before Markdown pages sync

Review code changes for correctness, style, tests and potential issues

Review pull requests against code quality standards and a style guide

Review code for performance bottlenecks and optimization opportunities

Review recent changes with hostile reviewer personas to catch blind spots

Review pull requests in many languages for complexity, risk and smells

Check diffs against simple, surgical coding principles before committing

Plan zero-downtime migrations with rollback strategies and compatibility checks

Review code through documented philosophies of engineers like Torvalds and Carmack

Find CPU, memory and I/O bottlenecks in Node, Python and Go apps

Review pull request diffs for security issues and code quality

Scan a codebase for tech debt, score severity and plan prioritized cleanups

Review code changes or a pull request for bugs, security and performance

Apply cleanup fixes to recent code changes for reuse, quality and efficiency

Review agent-written code changes with an adversarial protocol before they merge

Review code for architecture, SOLID principles, testability and performance

Find performance bottlenecks and rank fixes against frame or time budgets

Track and rank technical debt across the codebase in a maintained debt register

Migrate an app from AI SDK 6 to 7, fixing breaking changes and upgrade errors

Review code changes for real defects and refute false positives before reporting

Find gaps between documented intent and what the code actually does

Review a diff or pull request for bugs, regressions, missing tests and standards

Optimize a named system with a measured loop that keeps only winning changes

Simplify code and prune low-value tests and comments without changing behavior

Review code with feedback tailored to each developer profile from session state

Upgrade outdated packages on a branch, run the suite and open a PR only when green

Remove fully rolled-out feature flags and their dead branches when tests pass

Hill-climb code metrics or prompts and skills with an LLM judge in a loop

Review code for bugs, security issues and performance problems

Write, debug and explain regular expressions for any pattern matching task

Use TypeScript generics, utility types and strict mode patterns correctly

Run large codebase migrations in batched PRs with CI checks and tracking

Review changes in two stages: spec compliance first, then code quality

Write strict TypeScript with proper types, generics, type guards and no any

Audit a React codebase and write prioritized improvement plans for other agents

Diagnose slow React interactions using traces, render outlines and frame timing

Scan React code for lint, accessibility and bundle issues before committing

Review pull requests with a short list of concrete asks and a clear verdict