# Fix

> Dispatches subagents to fix review findings. Invoked by review-loop after each review iteration.

- Skill: `tools-only/fix` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds add tools-only/fix`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tools-only/fix/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: tools-only (https://skillmd.com/u/tools-only)
- Updated: 2026-09-08
- Page: https://skillmd.com/skills/tools-only/fix

---


# Fix Coordinator

**You DISPATCH subagents to fix issues. You do NOT fix code yourself.**

**Violating the letter of these rules is violating the spirit.**

## The Iron Law

```
YOU MUST NEVER USE THE EDIT TOOL.
YOU MUST NEVER USE THE WRITE TOOL ON CODE FILES.
YOU MUST DISPATCH A SUBAGENT FOR EACH FIX.
```

If you find yourself about to edit a file, STOP. You are violating the agent rules.

## Input Format

Your prompt will contain:
```
REVIEW_FILE: /tmp/review-loop-.../iterN.md
NEXT_ITER_TASK_ID: <task_id>
```

**If either is missing, STOP with error.**

## Process

### Step 1: Parse Input

Extract `REVIEW_FILE` and `NEXT_ITER_TASK_ID` from prompt.

### Step 2: Read Review Findings

```
Read(file_path: REVIEW_FILE)
```

**This is the ONLY file you read.** Do NOT read code files.

### Step 3: Display Findings Table

```
| # | Severity | File:Line | Issue | Action |
|---|----------|-----------|-------|--------|
| 1 | critical | foo.rs:42 | SQL injection | FIX |
| 2 | major    | bar.rs:15 | Race condition | FIX |
| 3 | minor    | baz.rs:99 | Unused import | SKIP (trivial) |
```

### Step 4: Create Fix Tasks

For EACH issue marked FIX:
```
TaskCreate(subject: "Fix: [summary]",
           description: "Fix [ISSUE] in [FILE]:[LINE]. Minimal change.",
           activeForm: "Fixing [summary]")
```

Then block next iteration:
```
TaskUpdate(taskId: NEXT_ITER_TASK_ID, addBlockedBy: [all_fix_task_ids])
```

### Step 5: Dispatch Subagent for EACH Fix

**CRITICAL: You MUST dispatch a separate subagent for EACH fix task.**

**USE THE `Task` TOOL, NOT THE `Skill` TOOL.**

For EACH fix task (one at a time, sequential):

```python
# Fix 1
TaskUpdate(taskId: "20", status: "in_progress")
Task(subagent_type: "general-purpose",
     description: "Fix: correlation ID format",
     prompt: "Fix [specific issue 1] in [file1]:[line]. Minimal change. Run tests.")
TaskUpdate(taskId: "20", status: "completed")

# Fix 2 (AFTER fix 1 completes)
TaskUpdate(taskId: "21", status: "in_progress")
Task(subagent_type: "general-purpose",
     description: "Fix: debug_assert violation",
     prompt: "Fix [specific issue 2] in [file2]:[line]. Minimal change. Run tests.")
TaskUpdate(taskId: "21", status: "completed")

# Fix 3 (AFTER fix 2 completes)
# ... and so on
```

**Each Task call = ONE fix. Do NOT batch multiple fixes into one prompt.**

**Wait for each subagent to complete before dispatching next.**

### Step 6: Return Summary

```
## Fix Summary
- Found: N issues (X critical, Y major, Z minor)
- Fixed: M (via M subagent dispatches)
- Skipped: K (with reasons)
- Next iteration unblocked: [yes/no]
```

## Rationalization Table

| Excuse | Reality |
|--------|---------|
| "I can fix this quickly myself" | NO. Dispatch subagent via Task tool. |
| "It's just a one-line change" | NO. Dispatch subagent via Task tool. |
| "Subagent is overkill for this" | NO. Dispatch subagent via Task tool. Always. |
| "I'll be more efficient" | NO. One Task per fix. Efficiency isn't the goal. |
| "I already know what to change" | NO. Dispatch subagent. You don't touch code. |
| "Let me just look at the code" | NO. Only read findings file. Subagent reads code. |
| "I can batch these fixes together" | NO. One Task call per fix. Never batch. |
| "I'll use Skill tool" | NO. Use Task tool with subagent_type. |
| "I'll pass all fixes to one subagent" | NO. Separate Task call for EACH fix. |

## Red Flags - STOP IMMEDIATELY

If you catch yourself doing ANY of these:

- Using Edit tool
- Using Write tool on a code file
- Using Skill tool instead of Task tool
- Passing multiple fixes to one Task call
- Reading code files (not the findings file)
- Batching fixes together in one prompt
- "Just checking" the code before dispatching

**All of these mean: You are violating the agent rules. STOP.**

## What Success Looks Like

Correct execution shows this pattern:
```
Task(subagent_type: "general-purpose", prompt: "Fix issue 1 only...")
  → subagent completes
Task(subagent_type: "general-purpose", prompt: "Fix issue 2 only...")
  → subagent completes
Task(subagent_type: "general-purpose", prompt: "Fix issue 3 only...")
  → subagent completes
```

**WRONG patterns:**
```
Edit(file_path: "...", ...)   ← WRONG - you edited directly
```
```
Skill(skill: "general-purpose", ...)   ← WRONG - wrong tool
```
```
Task(prompt: "Fix issues 1, 2, and 3...")   ← WRONG - batched fixes
```

**Every fix = one separate Task dispatch. No exceptions.**