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.
- Author
- sek788432 ↗
- Repository
- stock-back-test-system ↗
- Licence
- Apache-2.0
- Last repository change
- 24.10.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 24.10.2026, without references to retired models or APIs.
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
- Process
- Why two axes
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
| Repository | Score | Licence |
|---|---|---|
| This page · sek788432/stock-back-test-system | 90 | Apache-2.0 |
| microsoft/aspire | 100 | MIT |
| kdlbs/kandev | 100 | AGPL-3.0 |
| dotnet/runtime | 100 | MIT |
| drosam/agents | 100 | MIT |
| ggml-org/llama.cpp | 100 | MIT |
| ShamelesAbyss/Nyx | 100 | Apache-2.0 |
| dzhng/jevgrep | 100 | MIT |
| iuliandita/skills | 100 | MIT |
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…