NYTC69

Use this agent when you need to review code for adherence to project guidelines, style guides, and best practices. This agent should be used proactively after writing or modifying code, especially before committing changes or creating pull requests. It will check for style violations, potential issues, and ensure code follows the established patterns in CLAUDE.md. Also the agent needs to know which files to focus on for the review. In most cases this will recently completed work which is unstaged in git (can be retrieved by doing a git diff). However there can be cases where this is different, make sure to specify this as the agent input when calling the agent.

Use this agent when code has been written or modified and needs to be simplified for clarity, consistency, and maintainability while preserving all functionality. This agent should be triggered automatically after completing a coding task or writing a logical chunk of code. It simplifies code by following project best practices while retaining all functionality. The agent focuses only on recently modified code unless instructed otherwise.

Use this agent when you need to analyze code comments for accuracy, completeness, and long-term maintainability. This includes after generating large documentation comments, before finalizing code that adds or modifies comments, when reviewing existing comments for potential technical debt or comment rot, and when verifying that comments accurately reflect the code they describe.

The Executor agent in a review-loop workflow. Use this agent when the Orchestrator needs to produce a solution plan for a work item, refine a plan based on reviewer feedback, or implement an approved plan with actual code changes. This agent does the planning and coding work.

Review frontend code for common web security vulnerabilities. Use before committing or creating PRs for frontend code.

Run Go static analysis tools and generate a categorized review report. Use before committing or creating PRs for Go code.

Use this agent when you need to review code for test coverage quality and completeness. This agent should be invoked after code is written or updated to ensure tests adequately cover new functionality and edge cases.

Run Python static analysis tools and generate a categorized review report. Use before committing or creating PRs for Python code.

The Reviewer agent in a review-loop workflow. Use this agent when the Orchestrator needs an independent critical review of a solution plan or a set of code changes produced by the Executor. This agent reads and analyzes but never modifies files. Returns a structured verdict.

Run Rust static analysis tools and generate a categorized review report. Use before committing or creating PRs for Rust code.

Use this agent when reviewing code changes to identify silent failures, inadequate error handling, and inappropriate fallback behavior. Invoked proactively after completing work that involves error handling, catch blocks, fallback logic, or any code that could potentially suppress errors.

Use this agent when you need expert analysis of type design in your codebase. Specifically use it when introducing a new type to ensure it follows best practices for encapsulation and invariant expression, during code review to check all types being added, or when refactoring existing types to improve their design quality. The agent will provide both qualitative feedback and quantitative ratings on encapsulation, invariant expression, usefulness, and enforcement.

Iterative review-fix loop: reviews code, auto-fixes issues, repeats until clean or stuck. Finishes with reorganize (for large changes), simplify + test consolidation.

Run the execution + quality polish + delivery stages of review-loop against one of three entry modes: resume an approved session (`--session`), execute a user-supplied plan (`--plan`), or run a pure-CR pass on the current working tree (`--review-only`). Supports batched runs via `--stop-after <stage>`. Use when you already have a plan, or only want CR on existing code.

Show review-loop usage guide: how it works, commands, configuration, and key features. Use when the user asks for help with review-loop.

Run the planning phase only: drive a work item from raw description to a reviewer-approved plan in `.review-loop/sessions/{uuid}.md`, then exit with a hint to resume via `review-loop:execute --session <uuid>`. Use when you want plan-only iteration without immediately entering execution.

Reorganize code file structure: rearrange modules, extract reuse, remove redundancy, add section comments. Preserves all functionality and logic.

Automates a Plan-Execute-Review workflow with built-in iteration loops. An Orchestrator coordinates an Executor sub-agent and a configurable Reviewer (external AI CLI like Codex, or Claude sub-agent) to drive work items from description to delivery — with every review finding visible to the user. Trigger: "run review-loop on", "start review loop", "let the agents handle", or any task the user wants driven by a plan→review→implement→CR cycle.

Comprehensive code review using specialized agents. Each agent focuses on a different quality aspect (code, errors, comments, types, tests, simplify). Runs sequentially by default or in parallel on request.