team-review — code review workflow team-review, Claude-Code-Workflow, catlog22, community, code review workflow, ai agent skill, ide skills, agent automation, CLI orchestration, JSON-driven development, context-first architecture, automated workflow execution

v1.0.0
GitHub

About this Skill

Perfect for Code Review Agents needing advanced multi-agent cadence and automated workflow execution. Team Review is a framework for orchestrating multi-agent code review with intelligent CLI tools

Features

JSON-driven multi-agent cadence-team development framework
Intelligent CLI orchestration with Gemini, Qwen, and Codex
Context-first architecture for efficient code review
Automated workflow execution with rollback-on-failure
Deep analysis with root cause enrichment
Automated fix with rollback-on-failure

# Core Topics

catlog22 catlog22
[1.5k]
[123]
Updated: 3/18/2026

Quality Score

Top 5%
55
Excellent
Based on code quality & docs
Installation
SYS Universal Install (Auto-Detect)
> npx killer-skills add catlog22/Claude-Code-Workflow/team-review
Supports 19+ Platforms
Cursor
Windsurf
VS Code
Trae
Claude
OpenClaw
+12 more

Agent Capability Analysis

The team-review skill by catlog22 is an open-source community AI agent skill for Claude Code and other IDE workflows, helping agents execute tasks with better context, repeatability, and domain-specific guidance. Optimized for code review workflow, CLI orchestration, JSON-driven development.

Ideal Agent Persona

Perfect for Code Review Agents needing advanced multi-agent cadence and automated workflow execution.

Core Value

Empowers agents to orchestrate multi-agent code reviews using JSON-driven frameworks, providing intelligent CLI orchestration, context-first architecture, and automated workflow execution with tools like scanner, reviewer, and fixer, leveraging LLM scan and deep analysis for root cause enrichment and automated fixes with rollback-on-failure.

Capabilities Granted for team-review

Orchestrating multi-agent code reviews for efficient collaboration
Automating workflow execution with scanner, reviewer, and fixer tools
Conducting deep analysis with root cause enrichment for precise issue identification

! Prerequisites & Limits

  • Requires JSON-driven framework compatibility
  • Needs intelligent CLI orchestration support
  • Limited to context-first architecture
SKILL.md
Readonly

Team Review

Orchestrate multi-agent code review: scanner -> reviewer -> fixer. Toolchain + LLM scan, deep analysis with root cause enrichment, and automated fix with rollback-on-failure.

Architecture

Skill(skill="team-review", args="task description")
                    |
         SKILL.md (this file) = Router
                    |
     +--------------+--------------+
     |                             |
  no --role flag              --role <name>
     |                             |
  Coordinator                  Worker
  roles/coordinator/role.md    roles/<name>/role.md
     |
     +-- analyze -> dispatch -> spawn workers -> STOP
                                    |
                    +-------+-------+-------+
                    v       v       v
                [scan]  [review]  [fix]
                team-worker agents, each loads roles/<role>/role.md

Role Registry

RolePathPrefixInner Loop
coordinatorroles/coordinator/role.md
scannerroles/scanner/role.mdSCAN-*false
reviewerroles/reviewer/role.mdREV-*false
fixerroles/fixer/role.mdFIX-*true

Role Router

Parse $ARGUMENTS:

  • Has --role <name> -> Read roles/<name>/role.md, execute Phase 2-4
  • No --role -> @roles/coordinator/role.md, execute entry router

Shared Constants

  • Session prefix: RV
  • Session path: .workflow/.team/RV-<slug>-<date>/
  • Team name: review
  • CLI tools: ccw cli --mode analysis (read-only), ccw cli --mode write (modifications)
  • Message bus: mcp__ccw-tools__team_msg(session_id=<session-id>, ...)

Worker Spawn Template

Coordinator spawns workers using this template:

Agent({
  subagent_type: "team-worker",
  description: "Spawn <role> worker",
  team_name: "review",
  name: "<role>",
  run_in_background: true,
  prompt: `## Role Assignment
role: <role>
role_spec: <skill_root>/roles/<role>/role.md
session: <session-folder>
session_id: <session-id>
team_name: review
requirement: <task-description>
inner_loop: <true|false>

Read role_spec file (@<skill_root>/roles/<role>/role.md) to load Phase 2-4 domain instructions.
Execute built-in Phase 1 (task discovery) -> role Phase 2-4 -> built-in Phase 5 (report).`
})

User Commands

CommandAction
check / statusView pipeline status graph
resume / continueAdvance to next step
--fullEnable scan + review + fix pipeline
--fixFix-only mode (skip scan/review)
-q / --quickQuick scan only
--dimensions=sec,cor,prf,mntCustom dimensions
-y / --yesSkip confirmations

Completion Action

When pipeline completes, coordinator presents:

AskUserQuestion({
  questions: [{
    question: "Review pipeline complete. What would you like to do?",
    header: "Completion",
    multiSelect: false,
    options: [
      { label: "Archive & Clean (Recommended)", description: "Archive session, clean up team" },
      { label: "Keep Active", description: "Keep session for follow-up work" },
      { label: "Export Results", description: "Export deliverables to target directory" }
    ]
  }]
})

Session Directory

.workflow/.team/RV-<slug>-<date>/
├── .msg/messages.jsonl     # Team message bus
├── .msg/meta.json          # Session state + cross-role state
├── wisdom/                 # Cross-task knowledge
├── scan/                   # Scanner output
├── review/                 # Reviewer output
└── fix/                    # Fixer output

Specs Reference

Error Handling

ScenarioResolution
Unknown --role valueError with available role list
Role not foundError with expected path (roles/<name>/role.md)
CLI tool failsWorker fallback to direct implementation
Scanner finds 0 findingsReport clean, skip review + fix
User declines fixDelete FIX tasks, complete with review-only results
Fast-advance conflictCoordinator reconciles on next callback
Completion action failsDefault to Keep Active

FAQ & Installation Steps

These questions and steps mirror the structured data on this page for better search understanding.

? Frequently Asked Questions

What is team-review?

Perfect for Code Review Agents needing advanced multi-agent cadence and automated workflow execution. Team Review is a framework for orchestrating multi-agent code review with intelligent CLI tools

How do I install team-review?

Run the command: npx killer-skills add catlog22/Claude-Code-Workflow/team-review. It works with Cursor, Windsurf, VS Code, Claude Code, and 19+ other IDEs.

What are the use cases for team-review?

Key use cases include: Orchestrating multi-agent code reviews for efficient collaboration, Automating workflow execution with scanner, reviewer, and fixer tools, Conducting deep analysis with root cause enrichment for precise issue identification.

Which IDEs are compatible with team-review?

This skill is compatible with Cursor, Windsurf, VS Code, Trae, Claude Code, OpenClaw, Aider, Codex, OpenCode, Goose, Cline, Roo Code, Kiro, Augment Code, Continue, GitHub Copilot, Sourcegraph Cody, and Amazon Q Developer. Use the Killer-Skills CLI for universal one-command installation.

Are there any limitations for team-review?

Requires JSON-driven framework compatibility. Needs intelligent CLI orchestration support. Limited to context-first architecture.

How To Install

  1. 1. Open your terminal

    Open the terminal or command line in your project directory.

  2. 2. Run the install command

    Run: npx killer-skills add catlog22/Claude-Code-Workflow/team-review. The CLI will automatically detect your IDE or AI agent and configure the skill.

  3. 3. Start using the skill

    The skill is now active. Your AI agent can use team-review immediately in the current project.

Related Skills

Looking for an alternative to team-review or another community skill for your workflow? Explore these related open-source skills.

View All

widget-generator

Logo of f
f

Generate customizable widget plugins for the prompts.chat feed system

149.6k
0
Design

linear

Logo of lobehub
lobehub

Linear issue management. MUST USE when: (1) user mentions LOBE-xxx issue IDs (e.g. LOBE-4540), (2) user says linear, linear issue, link linear, (3) creating PRs that reference Linear issues. Provides

73.4k
0
Communication

testing

Logo of lobehub
lobehub

Testing guide using Vitest. Use when writing tests (.test.ts, .test.tsx), fixing failing tests, improving test coverage, or debugging test issues. Triggers on test creation, test debugging, mock setup

73.3k
0
Communication

zustand

Logo of lobehub
lobehub

Zustand state management guide. Use when working with store code (src/store/**), implementing actions, managing state, or creating slices. Triggers on Zustand store development, state management questions, or action implementation.

72.8k
0
Communication