Code Review & Refactoring

Verify code review feedback technically before applying any suggestion

Check finished tasks and features against their requirements before merging

Review changes against repo coding standards and the original spec in parallel

Design deep modules with clean interfaces and testable seams in your codebase

Scan a codebase for deepening opportunities and review them in a visual HTML report

Wire dependency-cruiser into a TypeScript repo so packages expose only entry points

Measure page speed, API latency and build times against stored baselines

Speed up code through measured baselines, variant tests and correctness gates

Map the impact of a planned change across code, data and APIs before editing

Check structural code health before edits and verify score changes after refactors

Apply baseline coding conventions for naming, readability and immutability

Handle errors with typed errors, retries and circuit breakers in TS, Python or Go

Write idiomatic Kotlin with null safety, coroutines and DSL builders

Cut p95 and p99 latency in realtime feeds, queues and caches with live readbacks

Refactor code without changing behavior, keeping tests green at every step

Auto-format and lint files on every edit with write-time hooks and auto-fixes

Speed up React and Next.js apps by fixing waterfalls, bundle size and re-renders

Search and rewrite code structurally with ast-grep syntax trees

Count lines of code, languages and file ratios in any codebase with pygount

Run four parallel review passes that clean up recent code changes

Review code changes from the current session for bugs and quality issues

Audit a whole repo for bugs, security holes, slow paths and code to delete

List shortcut and deferred-work comments in code as a debt ledger

Review a change for logic, safety, load behavior, test coverage and needless lines

Find dependency footguns in requirements, pyproject and package.json files

Flag git diffs that grew beyond their stated intent, with unrelated files

Detect web performance regressions by benchmarking pages before and after changes

Find worthwhile shared-code extractions in recent changes to reduce duplication

Show a code quality dashboard for the current project

Review your pull request before landing and flag issues to fix first

Review llama.cpp diffs and PRs against project conventions and common pitfalls

Run a read-only, defect-first review of a code change and list every finding

Review a pull request in compressed form with one line per finding

Plan reversible, compatibility-safe schema, API and dependency migrations with rollback

Restructure code while proving behavior stays the same before and after each edit

Review diffs and pull requests across several quality axes before they merge

Simplify working code for clarity and maintenance without changing its behavior

Plan deprecations and zero-downtime migrations with safe expand and contract steps

Find and fix performance bottlenecks across frontend, backend and database queries

Snapshot an existing code repository structure so agents can analyze it quickly

Show accumulated edits as a reviewable diff and save the accept or reject decision

Run a code migration pipeline from import to token mapping, patching and handoff

Make small reviewable file edits one step at a time instead of rewriting files

Review UI code against web interface guidelines for layout, type, color and accessibility

Map a codebase into feature flowcharts and propose one unified architecture

Find and remove accidental complexity like dead code, duplicate state and redundant layers

Explain git diffs and pull requests with affected components and risks

Check code changes against accepted architecture decisions for violations

Explain how a feature works in a local app source with file and line evidence