review-fix

Automate code review and fixing with parallel specialized agents.

Updated Mar 11, 2026
One-click install
npx skills add https://github.com/8GG-Git/Test_Team --skill review-fix-8gg-git
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: review-fix
Source: https://github.com/8GG-Git/Test_Team/tree/main/skills/review-fix
Command: npx skills add https://github.com/8GG-Git/Test_Team --skill review-fix-8gg-git

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill automates the process of code review and fixing, iterating until the code meets quality standards, saving developers significant time and effort.

Core Features & Use Cases

  • Multi-Agent Review: Spawns 8 specialized reviewers in parallel for comprehensive feedback.
  • Automated Fixing: Automatically resolves "quick-fix" issues identified during review.
  • Iterative Improvement: Loops through review and fix phases until no issues remain or max iterations are reached.
  • Strategic Item Handling: Accumulates and presents complex issues for user decision.
  • Use Case: After a refactoring session, run this Skill to automatically clean up minor issues, fix common bugs, and identify larger architectural suggestions before creating a pull request.

Quick Start

Run the review-fix skill to automatically review and fix code issues.

Frequently Asked Questions about review-fix

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I automate code review and fixing before a pull request?

Automated code review and fixing is handled by spawning multiple specialized agents in parallel to identify issues, automatically resolving quick-fix items, and iterating until code quality is achieved. You simply run the process to clean up minor issues and fix common bugs before submitting your code.

How does multi-agent code review work for finding refactoring issues?

Multi-agent code review works by spawning eight specialized reviewers in parallel to comprehensively analyze your codebase. This parallel execution identifies quick-fix issues for automated resolution and accumulates complex strategic items for user decision.

Can I configure iteration limits and commit behavior for automated code fixing?

Yes, automated code fixing supports configurable parameters for iteration count, commit behavior, and base comparison. You can set the maximum iterations to control how many times the review and fix phases loop before stopping.

What happens to complex architectural issues found during automated code review?

Complex architectural issues identified during automated code review are accumulated as strategic items and presented to the user for decision. This ensures that quick-fix items are resolved automatically while larger refactoring suggestions require manual approval.

Does automated code fixing work without external dependencies?

Yes, automated code fixing runs without external dependencies. The process relies entirely on its internal specialized agents to handle review and fix loops, requiring no additional packages or environment setup to identify and resolve code quality issues.

When should I use an iterative code review loop instead of manual refactoring?

An iterative code review loop is best used after a refactoring session to automatically clean up minor issues, fix common bugs, and identify larger architectural suggestions. It saves significant time by handling repetitive quick-fixes that would otherwise require manual effort.