Przejdź do treści
Biblioteka skilli
Programowanie · Przegląd i audyt

review-changes

/review-changes

Ocenia zmiany na trzech osiach: poprawność, standardy i zgodność z planem, równolegle, a potem zestawia wyniki obok siebie z werdyktem.

Licencja
MIT
Ostatnia zmiana repozytorium
26.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
4
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 26.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Ocenia zmiany na trzech osiach: poprawność, standardy i zgodność z planem, równolegle, a potem zestawia wyniki obok siebie z werdyktem.

Oryginalny opis (EN)

Reviews code changes on three separate axes — correctness (bugs, edge cases, security), standards (the writing-clean-javascript rules, code smells, repo conventions), and plan conformance (against the plan in the repo's docs/plan directory) — using parallel reviewers, then reports them side by side with a verdict. Use when the user asks to review their changes, a branch, a PR, or work in progress, or before committing or opening a PR.

Jak działa

  1. Step 1: Pin the scope
  2. Step 2: Find the plan
  3. Step 3: Collect standards sources
  4. Step 4: Start the reviewers in parallel
  5. Step 5: Report
  6. Step 6: Offer next steps
Sekcje z nagłówków SKILL.md, w oryginale · 158 linii, 946 słów
Podgląd SKILL.md
---
name: review-changes
description: Reviews code changes on three separate axes — correctness (bugs, edge cases, security), standards (the writing-clean-javascript rules, code smells, repo conventions), and plan conformance (against the plan in the repo's docs/plan directory) — using parallel reviewers, then reports them side by side with a verdict. Use when the user asks to review their changes, a branch, a PR, or work in progress, or before committing or opening a PR.
allowed-tools: Bash(git status *) Bash(git diff *) Bash(git log *) Bash(git branch *) Bash(git rev-parse *) Bash(git merge-base *) Bash(git ls-files *) Bash(${CLAUDE_SKILL_DIR}/../plan-changes/scripts/find-plan.sh *)
---

# Review changes

Review a set of changes on three **separate** axes, each handled by its own
reviewer subagent running in parallel:

| Axis | Question | Reviewer instructions |
|---|---|---|
| **Correctness** | Does the code work? Bugs, edge cases, security, breaking changes | `references/correctness-reviewer.md` |
| **Standards** | Does it follow the writing-clean-javascript rules, avoid code smells, and match the repo's conventions? | `references/standards-reviewer.md` |
| **Plan** | Does it do what the plan in `docs/plan/` asked — no more, no less? | `references/plan-reviewer.md` |

The axes stay separate on purpose: code can follow every standard and still
build the wrong thing, or match the plan exactly and still be buggy. Merging
them lets one hide the other.

This skill runs in the main conversation and coordinates. It does not review
code itself, and it never changes git state or edits code. The only file edit
it may make is a plan's status, after the user confirms (step 6).

## Step 1: Pin the scope

Use what the user named: a commit, branch, tag, range, or files. Otherwise:

- **Working tree has changes** → review uncommitted work against `HEAD`:
  - Diff: `git diff HEAD` (staged and unstaged together)
  - New files: `git ls-files --others --exclude-standard` (reviewers read
    these in full)
- **Working tree is clean** → review the branch against its base:
  - Base: `git merge-base HEAD main` (or `master` / `develop`)
  - Diff: `git diff <base>...HEAD`
  - Commits: `git log <base>..HEAD --oneline`

Record: repo root (`git rev-parse --show-toplevel`), branch name, the exact
diff command(s), the list of changed and new files, and the commit list if any.

**Fail early:** if a ref doesn't resolve or the diff is empty, tell the user
and stop. Don't start reviewers on nothing.

## Step 2: Find the plan

Plans live in `docs/plan/` at the repo root (git-ignored, never committed) and
are keyed by branch.

1. If the user gave a plan path, use it.
2. Otherwise run
   `${CLAUDE_SKILL_DIR}/../plan-changes/scripts/find-plan.sh`
   (current branch, or pass the branch under review). It matches the plan's
   `branch:` frontmatter field, then falls back to the file name.
   - Exit 0: that's the plan.
   - Exit 1: no plan.
   - Exit 2: several candidates.
3. If the plan's `status` is `stub`, it was never expanded: treat it as the
   plan, but warn "⚠ Plan is still a stub — plan-changes was not run".
4. If the plan has an `epic:` field, also pass the `epic.md` in the same folder
   to the Plan reviewer, so it can tell when an unplanned change belongs to
   another ticket.

No plan, or several candidates: **don't guess and don't stop.** Record a
warning — "⚠ No plan found in docs/plan/ — implementation-only review"
(listing candidates if there were several) — skip the Plan reviewer, and
continue with the other two.

## Step 3: Collect standards sources

List, without reading in depth:

- Repo docs on how to write code: `CODING_STANDARDS.md`, `CONTRIBUTING.md`,
  `docs/*standard*`, `docs/*convention*`, and similar.
- Tooling config: `biome.json(c)`, ESLint config, Prettier config,
  `tsconfig*.json`.
- The writing-clean-javascript standards (always included):
  - `${CLAUDE_SKILL_DIR}/../writing-clean-javascript/SKILL.md`
  - `${CLAUDE_SKILL_DIR}/../writing-clean-javascript/references/conventions.md`
  - `${CLAUDE_SKILL_DIR}/../writing-clean-javascript/references/code-smells.md`

## Step 4: Start the reviewers in parallel

Start all reviewers **in a single message** with the Agent tool
(`subagent_type: "general-purpose"`) so they run at the same time. Each
reviewer gets a short prompt that points to its instruction file — don't
paste the instructions in.

| Reviewer | Model | When |
|---|---|---|
| Correctness | session default (omit `model`) | always |
| Standards | `sonnet` | always |
| Plan | `sonnet` | only when a plan was found |

Prompt template (fill in every field):

```
You are the <Correctness | Standards | Plan> reviewer.

Repo root: <path>
Branch: <branch>
Scope: <uncommitted changes vs HEAD | branch vs <base> | as requested>
Diff command(s): <exact commands>
New (untracked) files to read in full: <list or "none">
Changed files: <list>
Commits: <list or "none">

[Standards only] Standards sources: <list from step 3>
[Plan only] Plan: <path to the plan file>
[Plan only] Epic: <path to epic.md, or "none">

As a first step, read
${CLAUDE_SKILL_DIR}/references/<axis>-reviewer.md
and follow it exactly. You are read-only: never edit files or change git state.
```

## Step 5: Report

Present the reviewers' reports under their own headings, verbatim or lightly
cleaned. **Don't merge or re-rank findings across axes.**

```
# Review: <branch> — <scope>, <N> files

⚠ <warnings: no plan found / ambiguous plan candidates>   (omit if none)

## Correctness
<report>

## Standards
<report>

## Plan
<report, or "Skipped — no plan found in docs/plan/.">

## Summary
- Correctness: <counts by severity> — worst: <one line, or "none">
- Standards: <counts by severity> — worst: <one line, or "none">
- Plan: <coverage counts> — worst: <one line, or "skipped">

**Verdict:** ✅ Ready to commit | ❌ Fix blocking items first
```

Verdict rules:
- Only 🔴 **blocking** findings block, and they can come from any axis.
- Warnings never block: no plan found, plan items missing, unplanned changes,
  and code smells (always judgement calls).

## Step 6: Offer next steps

Ask whether the user wants you to fix the blocking or should-fix items. Don't
fix anything until they say so. When everything is resolved, they can commit
with the `commit-changes` skill.

**Plan status.** If the Plan reviewer reports every task and requirement
implemented (no ❌ missing, no ⚠️ wrong) and there are no 🔴 findings, suggest
marking the plan done. Only after the user confirms:
- set `status: done` in the plan's frontmatter, and
- if it belongs to an epic, set this ticket's `Status` to `done` in the
  epic's `## Tickets` table.

These are the only edits this skill ever makes, and only with confirmation.
Pliki w paczce (4)
  • SKILL.md 7 KB
  • references/correctness-reviewer.md 3 KB
  • references/plan-reviewer.md 3 KB
  • references/standards-reviewer.md 3 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · eldrego/claude-dev-workflow100MIT
grixu/cc-toolkit100MIT
joshgons/agent-skills100MIT
rimega92/Engineering-Skills100MIT
ncosentino/needlr100MIT
jerelvelarde/chalk-skills100MIT
Pluneto/skills90MIT
doist/todoist-cli90MIT
marliechorgan/claude-setup90MIT

Migawka bazy z 13.11.2026 · wersja paczki 7c32e021dfde (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90code-review
    Przegląda zmiany od wybranego punktu na osiach standardów i specyfikacji, równolegle, i pokazuje wyniki obok siebie.
  • 90code-review
    Przegląda zmiany od wybranego punktu na osiach standardów i specyfikacji, a wyniki pokazuje obok siebie.
  • 90code-review
    Przegląda zmiany od ustalonego punktu (commit, gałąź, tag lub merge-base) w dwóch osiach: standardy kodowania repozytorium i zgodność ze specyfikacją, równolegle w subagentach, z raportem obok siebie.
  • 90code-review
    Przegląda zmiany od ustalonego punktu (commit, gałąź, tag lub merge-base) w dwóch osiach: standardy kodowania repozytorium i zgodność ze specyfikacją, równolegle w subagentach, z raportem obok siebie.
  • 90code-review
    Przegląda zmiany od ustalonego punktu (commit, gałąź, tag lub merge-base) w dwóch osiach: standardy kodowania repozytorium i zgodność ze specyfikacją, równolegle w subagentach, z raportem obok siebie.
  • 90code-review
    Przegląda zmiany od ustalonego punktu (commit, gałąź, tag lub merge-base) w dwóch osiach: standardy kodowania repozytorium i zgodność ze specyfikacją, równolegle w subagentach, z raportem obok siebie.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.