Skip to content
Skills Library
Programming · Review & audit

code-review

/code-review

Review a committed diff and any staged, unstaged, or untracked work along separate Standards and Spec axes. Use for a focused review since a commit, branch, tag, or merge-base. Before a commit, pull request, merge, or handoff, also use the repository's comprehensive review skill.

Licence
Apache-2.0
Last repository change
24.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 24.10.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Review a committed diff and any staged, unstaged, or untracked work along separate Standards and Spec axes. Use for a focused review since a commit, branch, tag, or merge-base. Before a commit, pull request, merge, or handoff, also use the repository's comprehensive review skill.

Original author description

Review a committed diff and any staged, unstaged, or untracked work along separate Standards and Spec axes. Use for a focused review since a commit, branch, tag, or merge-base. Before a commit, pull request, merge, or handoff, also use the repository's comprehensive review skill.

How it works

  1. Process
  2. Why two axes
Original SKILL.md headings · 91 lines, 1,130 words
SKILL.md preview
---
name: code-review
description: Review a committed diff and any staged, unstaged, or untracked work along separate Standards and Spec axes. Use for a focused review since a commit, branch, tag, or merge-base. Before a commit, pull request, merge, or handoff, also use the repository's comprehensive review skill.
---

Two-axis review of the complete change set since a fixed point:

- **Standards** — does the code conform to this repo's documented coding standards?
- **Spec** — does the code faithfully implement the originating issue / PRD / spec?

Run the axes in parallel when collaboration tools are available; otherwise run them sequentially with separate evidence notes. This focused review never substitutes for the repository's comprehensive `review` skill before a commit, pull request, merge, or handoff.

## Process

### 1. Pin the fixed point

Whatever the user said is the fixed point — a commit SHA, branch name, tag, `main`, `HEAD~5`, etc. If they did not specify one, resolve the first available baseline in this order: the configured upstream branch, `origin/main`, then `main`. Ask only if none resolves safely.

Resolve the merge-base and capture all four parts of the review scope:

- committed changes: `git diff <merge-base>..HEAD`
- staged changes: `git diff --cached`
- unstaged changes: `git diff`
- untracked files: `git status --short`, followed by reading every relevant untracked file

Also note the commit list with `git log <merge-base>..HEAD --oneline`. Preserve unrelated user changes and report which parts of the scope were present.

Before going further, confirm the fixed point resolves and the merge-base exists. Continue when any of the four scope parts is non-empty. Stop with a clear explanation only when the complete change set is empty.

### 2. Identify the spec source

Look for the originating spec, in this order:

1. Issue references in commit messages, the branch name, or pull-request metadata. Read them with an available authenticated connector, CLI, API, or browser.
2. A path the user passed as an argument.
3. A PRD/spec file under the repository's documented spec locations, including `Docs/Specs/` in this repository, matching the branch name or feature.
4. If nothing is found, ask the user where the spec is. If there is no spec, skip that axis and report "no spec available" without treating it as a pass.

### 3. Identify the standards sources

Anything in the repo that documents how code should be written, such as `CODING_STANDARDS.md` or `CONTRIBUTING.md`.

On top of whatever the repo documents, the Standards axis always carries the **smell baseline** below — a fixed set of Fowler code smells (_Refactoring_, ch.3) that applies even when a repo documents nothing. Two rules bind it:

- **The repo overrides.** A documented repo standard always wins; where it endorses something the baseline would flag, suppress the smell.
- **Always a judgement call.** Each smell is a labelled heuristic ("possible Feature Envy"), never a hard violation — and, like any standard here, skip anything tooling already enforces.

Each smell reads *what it is* → *how to fix*; match it against the diff:

- **Mysterious Name** — a function, variable, or type whose name doesn't reveal what it does or holds. → rename it; if no honest name comes, the design's murky.
- **Duplicated Code** — the same logic shape appears in more than one hunk or file in the change. → extract the shared shape, call it from both.
- **Feature Envy** — a method that reaches into another object's data more than its own. → move the method onto the data it envies.
- **Data Clumps** — the same few fields or params keep travelling together (a type wanting to be born). → bundle them into one type, pass that.
- **Primitive Obsession** — a primitive or string standing in for a domain concept that deserves its own type. → give the concept its own small type.
- **Repeated Switches** — the same `switch`/`if`-cascade on the same type recurs across the change. → replace with polymorphism, or one map both sites share.
- **Shotgun Surgery** — one logical change forces scattered edits across many files in the diff. → gather what changes together into one module.
- **Divergent Change** — one file or module is edited for several unrelated reasons. → split so each module changes for one reason.
- **Speculative Generality** — abstraction, parameters, or hooks added for needs the spec doesn't have. → delete it; inline back until a real need shows.
- **Message Chains** — long `a.b().c().d()` navigation the caller shouldn't depend on. → hide the walk behind one method on the first object.
- **Middle Man** — a class or function that mostly just delegates onward. → cut it, call the real target direct.
- **Refused Bequest** — a subclass or implementer that ignores or overrides most of what it inherits. → drop the inheritance, use composition.

### 4. Run both review axes independently

When collaboration tools are available and the repository rules permit delegation, dispatch two bounded review agents in parallel. Otherwise perform the two reviews sequentially while keeping their evidence and verdicts separate.

**Standards sub-agent prompt** — include:

- The complete four-part change scope and commit list.
- The list of standards-source files you found in step 3, **plus the smell baseline from step 3** pasted in full — the sub-agent has no other access to it.
- The brief: "Report — per file/hunk where relevant — (a) every place the diff violates a documented standard: cite the standard (file + the rule); and (b) any baseline smell you spot: name it and quote the hunk. Distinguish hard violations from judgement calls — documented-standard breaches can be hard, but baseline smells are always judgement calls, and a documented repo standard overrides the baseline. Skip anything tooling enforces. Under 400 words."

**Spec sub-agent prompt** — include:

- The complete four-part change scope and commit list.
- The path or fetched contents of the spec.
- The brief: "Report: (a) requirements the spec asked for that are missing or partial; (b) behaviour in the diff that wasn't asked for (scope creep); (c) requirements that look implemented but where the implementation looks wrong. Quote the spec line for each finding. Under 400 words."

If the spec is missing, skip the Spec sub-agent and note this in the final report.

### 5. Aggregate

Present the two reports under `## Standards` and `## Spec` headings, verbatim or lightly cleaned. Do **not** merge or rerank findings — the two axes are deliberately separate (see _Why two axes_).

End with a one-line summary: total findings per axis, and the worst issue _within each axis_ (if any). Do not pick a single winner across axes. State explicitly that PR/merge readiness still requires the comprehensive `review` skill and the repository Definition of Done.

## Why two axes

A change can pass one axis and fail the other:

- Code that follows every standard but implements the wrong thing → **Standards pass, Spec fail.**
- Code that does exactly what the issue asked but breaks the project's conventions → **Spec pass, Standards fail.**

Reporting them separately stops one axis from masking the other.
Files in this package (2)
  • SKILL.md 7 KB
  • agents/openai.yaml 1 KB

Versions

RepositoryScoreLicence
This page · sek788432/stock-back-test-system90Apache-2.0
microsoft/aspire100MIT
kdlbs/kandev100AGPL-3.0
dotnet/runtime100MIT
drosam/agents100MIT
ggml-org/llama.cpp100MIT
ShamelesAbyss/Nyx100Apache-2.0
dzhng/jevgrep100MIT
iuliandita/skills100MIT

Database snapshot: 13.11.2026 · package version 718d410adc8e (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90review-changes
    Review the changes since a fixed point (commit, branch, tag, or merge-base) along two axes: Standards (does the code follow this repo's documented coding standards?) and Spec (does the code match what the plan, ticket or spec asked for?). Runs both reviews in parallel sub-agents…
  • 90review-code
    Review the changes since a fixed point (commit, branch, tag, or merge-base) along two axes — Standards (does the code follow this repo's documented coding standards?) and Spec (does the code match what the originating spec/PRD asked for?). Use when the user wants to review a…
  • 85workflow-code-review
    Review the changes since a fixed point (commit, branch, tag, or merge-base) along two axes: Standards (does the code follow this repo's documented coding standards?) and Spec (does the code match what the originating issue/spec asked for?). Runs both reviews in parallel…
  • 100review
    Review a branch's complete change set—committed branch changes plus staged, unstaged, and untracked work—and its related implementation, documentation, tests, and build wiring. Apply all repository C++ skills, verify implementation-to-documentation alignment, evaluate test…
  • 100review
    Review the changes since a fixed point (commit, branch, tag or merge-base) on three axes: Standards, Spec and Simplicity. Use when the user wants to review a branch, a PR or work in progress, or asks to \"review since X\".
  • 95standards-spec-review
    Two-axis review of the changes since a fixed point (commit, branch, tag, merge-base, or the working tree) on Standards (does the code follow this repository's documented coding standards, design documents, and the smell baseline?) and Spec (does the code do what the originating…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.