# Code Review Workflow

> Use this skill when performing code review on branch changes. Runs parallel CodeRabbit and architecture reviews, consolidates findings, and executes improvements. Invoke when reviewing code changes before finalizing a PR.

- Skill: `majiayu000/code-review-workflow-2` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds add majiayu000/code-review-workflow-2`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/code-review-workflow-2/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Productivity
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/majiayu000/code-review-workflow-2

---


# Code Review Workflow

This skill provides a structured code review process that combines automated tooling with architectural analysis.

## When to Use

- After implementing features or fixes, before finalizing a PR
- When `/fly` or `/refuel` reaches the code review phase
- When explicitly asked to review code changes

## Phase 1: Parallel Reviews

**Send notification:** Run `${CLAUDE_PLUGIN_ROOT}/scripts/notify.sh review "Starting code review"`

Launch two review processes simultaneously:

### Review A: CodeRabbit Review

```
Run `coderabbit review --prompt-only` and return the complete output.
Do not summarize - return everything.
```

### Review B: Architecture & Code Quality Review

```
Review all changes in this branch against clean code principles and clean architecture.

First, run `${CLAUDE_PLUGIN_ROOT}/scripts/get-changed-files.sh` to identify changed files.

Review criteria:

1. **Clean Code**
   - Single responsibility principle
   - DRY (Don't Repeat Yourself)
   - Meaningful naming
   - Function size and complexity
   - Comments (only where logic isn't self-evident)
   - Error handling

2. **Clean Architecture**
   - Dependency direction (inward only)
   - Layer separation
   - Abstraction boundaries
   - Coupling and cohesion
   - Testability

3. **Specification Compliance** (if spec exists)
   - Read all files in the spec directory
   - Verify implementation matches requirements

Return structured report with:
- File-by-file findings
- Severity (critical/major/minor/suggestion)
- Line numbers where applicable
- Concrete recommendations
```

## Phase 2: Consolidate Findings

Synthesize both reviews:

1. **Deduplicate** overlapping findings

2. **Categorize** each unique issue:
   - `[CRITICAL]` - Bugs, security issues, spec violations, incomplete fixes
   - `[MAJOR]` - Architecture/design problems
   - `[MINOR]` - Code quality improvements
   - `[STYLE]` - Formatting, naming

3. **Create prioritized TODO list**

4. **Analyze parallelization:**
   - Issues in different files → can parallelize
   - Same file or dependencies → must serialize
   - Max 3-4 parallel subagents

## Phase 3: Execute Improvements

For each batch of parallelizable issues, spawn subagents:

```
Task: Fix ISSUE-XXX

Issue: [description]
File(s): [files to modify]

Requirements:
- Minimal change for this specific issue
- Do NOT refactor unrelated code
- Run build/check commands before completing
- Note (don't fix) any new issues discovered
```

After each batch:
- Review changes for correctness
- Resolve any conflicts
- Update TODO list
- Proceed to next batch

## Phase 4: Commit Review Fixes

If any changes were made during the review process:

```bash
git add -A
git commit -m "refactor: address code review feedback

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>"
git push
```

## Output

After completing the review workflow, report:
- Total issues found (by source: CodeRabbit vs Architecture review)
- Issues by severity
- Issues addressed
- Any remaining issues (with justification if deferred)