Code Review & Refactoring

Load unresolved pull request comments as task files that agents can fix in parallel

Verify addressed PR review comments and resolve the threads that are fixed

Review uncommitted local changes and suggest fixes before anything is pushed

Review an open GitHub pull request and post inline comments on its diff

Rank changed code by how much a human reviewer needs to look at it

Scan a Kotlin or Compose diff for known footgun patterns before you commit

Find the single bottleneck limiting throughput or latency and fix it first

Review code in a repository with a structured workflow and findings

Verify review findings against the source and apply only the fixes that hold up

Find every consumer of a shared change and run them before and after editing

Review R scripts for code quality, reproducibility and domain correctness

Review GitHub pull requests from several angles with parallel subagents

Review a PR diff by severity and return findings, fixes and a merge decision

Review code changes from several perspectives with structured findings

Configure cspell dictionaries, ignore paths and project words for spell checks

Write idiomatic Python with core idioms and code quality fundamentals

Review an implementation against its plan and log findings for follow-up

Run a five-stage code review rated Blocker, Major, Minor or Nit with fixes

Audit module dependencies, layering and structural decay across a codebase

Identify, classify and prioritize tech debt and build a refactoring roadmap

Score a codebase across PR quality, architecture, tech debt and tests in one pass

Review pull requests for decay risks and design smells with concrete remedies

Run a full quality sweep and apply safe fixes, confirming risky changes first

Apply Rust naming, formatting and clippy style rules during code review

Profile and speed up Rust code with benchmarks, flamegraphs and allocation fixes

Spot Rust anti-patterns like clone-everywhere and unwrap abuse during code review

Rename, move and extract Rust symbols safely with LSP-backed refactoring

Review code for likely problems, quality issues and best-practice fixes

Review pull requests against the live base branch and judge merge readiness

Run a blind dual code review with up to two scoped fix and re-judge rounds

Measure and debug web page performance with tested browser snippets

Measure and debug LCP, CLS and INP with guided Core Web Vitals workflows

Debug slow interactions, scroll jank and main thread blocking step by step

Diagnose slow page loads from TTFB, render blocking, scripts and fonts

Find image, video and SVG issues that slow LCP, layout shifts and loading

Adapt page loading to connection speed, bandwidth and save-data settings

Review Java Spring code for clean code, API contracts, null safety and performance

Apply classic and distributed design patterns like Saga, Outbox and CQRS in Java

Review Typer CLI commands for exit codes, error handling and help text

Diagnose slow frontend, backend and database code and cut load times

Find and retire duplicate logic, stale fallbacks and old code paths safely

Check code review feedback for accuracy before implementing each suggestion

Request an independent code review after each slice or before merging risky work

Decide what belongs in shared services versus actions and remove repeated logic

Find and rank performance issues like freezes, OOMs and retry loops

Review changed code for naming, stale references and needless complexity

Split oversized source files and add a pre-commit size ratchet

Refactor stale names and legacy leftovers without adding compatibility layers

Audit a vibe-coded project for secrets, env vars and migrations before shipping