domains / software-engineering / multi-agent-code-review / error-debugging-multi-agent-review

error-debugging-multi-agent-review

Skill card

combined

The two copies describe the same task (multi-perspective code review) but disagree on the core procedure. The first copy is a high-level orchestration framework that mandates dynamic agent routing, parallel/sequential execution, weighted conflict resolution, and quality-score validation, and it includes Python pseudocode for an orchestration engine. The second copy is a bounded, safety-focused procedure that explicitly rejects those mechanisms (no routing code, no quality scores, no weighted votes), requires user authorization for delegation, and mandates central reproduction of findings. Because the first copy's core steps (routing, scoring, weighted voting) are explicitly forbidden by the second, crowning one would hide a real, conflicting alternative. The combined instruction must therefore present the two as distinct approaches and flag the conflicts.

Repositories

Other copies

Combined skill

# Multi-Agent Code Review

## When to Use
Use this skill when a codebase or diff needs review across multiple disciplines such as correctness, security, architecture, and performance.

## Approach A: Orchestration Framework (rmyndharis/antigravity-skills)
1. **Clarify inputs**: Identify the target code, file paths, or repository.
2. **Route agents**: Analyze code characteristics and select relevant agent types (security, architecture, performance, compliance, best practices).
3. **Execute reviews**: Run independent agents in parallel and dependent agents sequentially.
4. **Aggregate results**: Merge insights, resolve conflicts using weighted scoring, and generate a prioritized report.
5. **Validate quality**: Compute a quality score and verify cross-agent consistency.

## Approach B: Bounded Review Procedure (sickn33/agentic-awesome-skills)
1. **Pin scope**: Define repository, base/head, changed paths, intended behavior, and available tests.
2. **Authorize delegation**: Use independent agents only if the user explicitly authorizes delegation and the host supports it. Otherwise, conduct perspectives sequentially.
3. **Read the diff**: Examine the complete diff, affected call paths, and tests.
4. **Assign bounded questions**: Give each reviewer a specific question, owned paths, time limit, and expected evidence format.
5. **Record findings**: Note exact locations, triggers, consequences, and reproduction steps. Keep hypotheses separate from demonstrated failures.
6. **Reproduce centrally**: Reproduce important findings in a single environment. Deduplicate by root cause.
7. **Resolve disagreements**: Use code or tests as the arbiter. Do not use weighted votes or agent consensus as evidence.
8. **Report**: Return blockers first, then material improvements and untested areas. Preserve original failing results.

## Conflicts
- **Agent routing**: Approach A mandates dynamic routing; Approach B explicitly excludes routing code and warns against unnecessary agent spawning.
- **Conflict resolution**: Approach A uses weighted scoring; Approach B forbids weighted votes and requires code/test-based resolution.
- **Quality scoring**: Approach A includes a quality-score calculator; Approach B forbids inventing confidence scores.
- **Parallel execution**: Approach A assumes parallel execution; Approach B makes it conditional on user authorization.

## Limitations
- Neither approach can prove whole-repository safety from a diff alone.
- Parallel review adds cost and can duplicate blind spots.
- Read-only review is the default; fixes and deployment require separate user authority.