do fixes

Writing Community

Skill notes

Context Detection

Scan <work-folder>/reviews/ for the most recent review artifact: *.review.*.md (code-review output) → apply code fixes using the flow below (Future: plan-review artifacts → apply plan improvements) The review document contains findings with checkboxes — checked [x] findings get fixed, unchecked [ ] findings get skipped.

Find the review document

If a path was provided as argument, use it. Otherwise, auto-discover: Use the pre-loaded Work folder. If none (on main), ask the user which branch this review is for. Look in <work-folder>/reviews/ for review files (*.review.*.md). Use the most recent one (by date in filename). If no review doc found: "No review document found. Run /code-review first to generate one."

Read the review document

Read the review doc. Note: The phase: in frontmatter — if already committed or fixes-verified, warn: "This review has already been applied. Run /code-review full for a new review cycle." The checked [x] findings — these are the ones to fix Any Instructions: fields — user instructions take priority over reviewer suggestions The sha: — the HEAD at review time

Read project context

Read CLAUDE.md at the repo root — note verification commands (lint, typecheck, test, format) for use in Phase 1.

Check for uncommitted changes

If there are uncommitted changes (from pre-loaded context): "There are uncommitted changes. Want to stash them before proceeding, or continue as-is?" Wait for their answer. Create progress tasks: Fix findings Verify fixes Finalize — update review doc, commit, push

Fluxly profile Runtime and permissions are inferred by Fluxly static checks, not author declarations or runtime test results.
Domain
Writing
Author-declared agents
No explicit declaration found; this is not inferred or tested compatibility
Static check
88 / 100 · heuristic scan, not runtime safety proof
Runtime evidence
Not run; no isolated runtime test evidence is currently recorded
Author / version / license
@tomevault-io · no license declared
Token usage
Lean
Setup complexity
Guided setup
External API key
Not required
Operating systems
Unspecified (assume cross-platform)
Runtime requirements
No explicit requirements detected
Detected file/system behavior
  • Read-only
  • Write / modify
  • Shell exec
Network behavior
Local-only
Install commands
None (reference only)

Heads up: Tool permissions are not declared; actual access depends on the runtime.

01
Phase 0: Orient

Phase 0: Orient

02
Phase 1: Fix

Phase 1: Fix

03
Step 1: Group findings into fix batches

Findings touching the same file(s) MUST be in the same batch (prevents edit conflicts). Non-overlapping batches can run as parallel agents. Each batch: 1-5 findings.

04
Step 2: Regression tests (BLOCKER/ISSUE only)

Write tests that prove the bug exists before fixing it. Scope: only unit-testable BLOCKER/ISSUE findings. Skip: cache behavior, convention fixes, dead code, styling. SUGGESTIONs and NITs never need tests. Farm out test writing to parallel agents. Each agent: Receives the finding text and relevant source file content Instruction: write a focused test that fails against current code — do NOT fix the code

05
Step 3: Farm out edits to agents

YOU (the coordinator) do NOT make edits. Delegate ALL edits to agents. Maximize parallelism. Look at the batches from Step 1. All batches that touch non-overlapping files can (and should) be spawned as parallel agents simultaneously — a single message with multiple Agent tool calls, not sequential spawns. Only serialize batches that share files. For a typical review with 3-7 findings across different files, most or all batches should run in parallel.

06
Step 4: Track progress

Read `~/.claude/skills/shared/references/finding-format.md` for the status lifecycle. Update the review doc as agents report back: `[x]` -> `[fixed]` after editing, with one-line change summary `[fixed]` -> `[verified]` after verification passes (batch-update) If verification fails, leave as `[fixed]` and append what failed `[ ]` -> `[skipped]` for unchecked findings

07
Step 5: Verify (centrally, after ALL edits complete)

Do not run verification until all edit agents have reported back. CRITICAL: Verification is mandatory before any commit or push. No exceptions, no shortcuts. Read CLAUDE.md and `.claude/rules/` to find the repo's verification commands and policies. If a `verification.md` rule exists, follow it exactly — it may require running the full test suite, not just targeted tests.

08
Step 6: Resolve all findings

Before committing, scan the review document and ensure every checked `[x]` finding has been updated to a terminal status. No finding should still show bare `[x]` at this point. Terminal statuses: `[fixed]` -> `[verified]`, `[skipped]`, `[will-not-do]`, `[deferred]`, `[already-resolved]`, `[could-not-prove]`. If any checked findings are still `[x]`: update them now — mark `[skipped]` with a note if they were intentionally not addressed, or `[deferred]` if out of scope.

09
Phase 2: Finalize

The full sequence is: verify -> commit -> push -> post PR comment. All four steps are mandatory and must happen in order. Do not skip any step. Do not push without verifying. Do not end the session without posting the PR comment. Auto-proceed: Once fixes are complete and verification passes, immediately continue through all of Phase 2 — commit, push, then post the PR comment — without stopping to ask. The user

10
Step 7: Commit

Update review doc `phase:` to `fixes-verified`. All fixes for a review cycle go into a single commit — never split by finding. Update `phase:` to `committed`.

11
Step 8: Push + update PR checklist

Push the branch: Mark code review complete on the PR. Read the PR body: If it contains an unchecked `- [ ] Ran \`/code-review\`` item, check it off (`- [x]`) If it has no such item, append `- [x] Ran \`/code-review\`` to the checklist section (or the end of the body if no checklist exists) Update with `gh pr edit <pr-number> --body "<updated-body>"`.

12
Step 9: Post the PR comment — THIS STEP IS MANDATORY. DO NOT SKIP.

You have just finished a code review cycle. The team cannot see the outcome unless you post this comment. It is the only artifact that surfaces the review on the PR. Do it now. First, re-read the review document from disk — your in-context copy may be stale after parallel fix agents updated it: Then spawn a sub-agent (`model: sonnet`) with the following: "Read `~/.claude/skills/shared/references/code-review-summary-format.md` for the exact comment format — follow it precisely, do not invent a different layout.

13
Phase 3: Retrospective

After the fixes are complete: Ensure the PR comment is current. Check whether a PR summary comment has been posted covering this review cycle. If a comment was posted but findings changed after it (e.g., additional fixes were pushed), post an updated comment using the Step 9 sub-agent. Summarize what was found, fixed, and deferred. Ask the user if any review agents or the code-review skill should be updated based on what was missed or noisy.

Discussion

Powered by GitHub Discussions. Sign in with GitHub to comment, react, or subscribe.