Skip to content
Skills Library
Programming · Review & audit

gap-analysis

/gap-analysis

Checks an implementation against its acceptance criteria and lists every gap. Takes either a plan folder (.plans/{task}) to check the user's own work, including Record updates, or a PR link plus a Jira ticket key to review a teammate's PR in plain language, with a verdict and review comments ready to post. Use after a task loop finishes, for the autopilot's spec check, or when the user shares a PR and a ticket to review.

Repository
skills ↗
Licence
MIT
Last repository change
12.11.2026

Assessment and security

100/ 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.
Content35 / 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 12.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Checks an implementation against its acceptance criteria and lists every gap. Takes either a plan folder (.plans/{task}) to check the user's own work, including Record updates, or a PR link plus a Jira ticket key to review a teammate's PR in plain language, with a verdict and review comments ready to post. Use after a task loop finishes, for the autopilot's spec check, or when the user shares a PR and a ticket to review.

Arguments

/gap-analysis <.plans/task or slug> | <PR link> <ticket key>
Original author description

Checks an implementation against its acceptance criteria and lists every gap. Takes either a plan folder (.plans/{task}) to check the user's own work, including Record updates, or a PR link plus a Jira ticket key to review a teammate's PR in plain language, with a verdict and review comments ready to post. Use after a task loop finishes, for the autopilot's spec check, or when the user shares a PR and a ticket to review.

How it works

  1. Get both sides
  2. Acceptance-criteria table
  3. Plan mode
  4. PR mode
Original SKILL.md headings · 59 lines, 576 words
SKILL.md preview
---
name: gap-analysis
description: Checks an implementation against its acceptance criteria and lists every gap. Takes either a plan folder (.plans/{task}) to check the user's own work, including Record updates, or a PR link plus a Jira ticket key to review a teammate's PR in plain language, with a verdict and review comments ready to post. Use after a task loop finishes, for the autopilot's spec check, or when the user shares a PR and a ticket to review.
argument-hint: "<.plans/task or slug> | <PR link> <ticket key>"
---

# Gap analysis

Compare what was built with what was asked. The arguments pick the mode:

- **A plan folder** (`.plans/<task>/` or its slug) → **Plan mode**: check the work against `plan.md`.
- **A PR link and a ticket key** → **PR mode**: review a teammate's PR against the ticket.

If the arguments don't make it clear, work it out from what's there: a `.plans/` folder on this branch means plan mode.

## Get both sides

- **What was asked:**
  - Plan mode: `plan.md` (acceptance criteria, phases, Record Updates) and `tasks.md`.
  - PR mode: run the read-ticket skill on the ticket key if you have it, else read the ticket with your issue tracker's tools, every custom field included. Custom fields are where acceptance criteria usually live. If it stops on blocking assets, stop with it.
- **What was built:**
  - Plan mode: the branch's diff against the main line (`git diff <main>...HEAD`).
  - PR mode: the PR's description, diff and review comments, through the GitHub CLI (`gh pr view <link> --comments`, `gh pr diff <link>`).

Read the code the diff touches until you can say, for each criterion, what the code does now. Never judge a criterion from a file name or the PR description.

## Acceptance-criteria table

| ID | Criterion | Met? | Evidence |
|---|---|---|---|
| AC1 | … | Yes / Partly / No / Can't tell | `file:line`, test name, or command output |

- One row per acceptance criterion: AC1, AC2, …
- Then one row per feature the plan, ticket or discussion expected that the criteria don't list: F1, F2, …
- "Can't tell" is an honest answer; a guess is not. Say what would settle it.

## Plan mode

After the table, reconcile the Record if the plan had Record Updates. Read `.agents/RECORD.md` if it exists. The implementer writes Record updates at the end of implementation, so they should be there by now.

- For each entry the plan promised, confirm it was written and matches what was actually built. A missing or mismatched entry is a gap.
- If the implementer reported a **divergence** (built differently, so it wrote no entry), check the divergence is real, then propose a correct entry, verbatim, for the user to approve.
- Any existing entry the work changed, broke, or made stale that the plan didn't cover is a gap. Propose the amended (or removed) entry verbatim.
- If the work established a new high-level fact with no entry yet, propose one in the Record's format.
- Skip cosmetic or unrelated edits.

End with:

- **Gaps:** one line each: its ID, briefly why it exists, and the fix.
- **Next:** a short list of what to do.

Report the gaps and stop; whoever ran you fixes them.

## PR mode

The user hasn't read the code or the acceptance criteria. Write so they can decide without opening either.

1. **Before and after:** what the product did before this PR and what it does now, in plain words, from a user's point of view.
2. **The acceptance-criteria table.**
3. **Verdict:** approve, request changes, or comment, with the one reason that decides it.
4. **Review comments, ready to post:** one per issue, each with its `file:line`, written to the PR author: friendly, specific, and with the fix. Say whether to post them as one review (request changes or approve) or as separate comments.

Never post on GitHub yourself unless the user asks.
Files in this package (2)
  • SKILL.md 4 KB
  • agents/openai.yaml 1 KB

Versions

RepositoryScoreLicence
This page · richardochristjia/skills100MIT
anassahel/agent-labs100MIT
magnus919/agent-skills100MIT
kael-odin/codex-plugins-zh100MIT
afonsoft/skills100MIT
adeerkhan/vitruvius100MIT
qa-aman/claude-skills100MIT
testdouble/han100MIT
adrien-barret/claude-kit100MIT

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

Downloads in the last 30 days: 1 · ranking

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

Similar skills

  • 90mr-review
    Reviews a merge request (a pull request on GitHub) against its ticket (Jira or Linear). Checks that every acceptance criterion has code and a test that would catch a regression, runs the kit's checks, reviews each file for correctness, readability, architecture, security and…
  • 100implement
    Implement a slice, spec or ticket from its acceptance criteria - agree the seams, build it test-first by running the tdd loop on each criterion - then check the result against the spec, simplify it, review it with /code-review and kets-review, guard the quality floor and commit.…
  • 100verify-acceptance-criteria
    Use when asked to "verify acceptance criteria", "check criteria", or "verify the implementation against the plan" during active feature development. Do NOT trigger for issue management (close issue, comment), worktree cleanup, or post-merge/post-PR operations.
  • 100sl-ds-ticket-to-plan
    Turns a GitHub issue of the SL Design System (sl-design-system/components) into draft acceptance criteria for the developer to confirm, then into an implementation plan mapped to this repository's files. Use it when a design-system developer starts work on an issue, asks what an…
  • 90implement-task
    Implements an agreed task from a local Markdown plan, GitHub Issue, or Jira ticket, checking dependencies and linked requirements, making scoped changes, and validating acceptance criteria. Use when asked to work on, execute, or implement a planned task and prepare it for review.
  • 90ticket-qa
    QA for a ticket (Jira or Linear). Turns its acceptance criteria into a pass/fail plan (golden path, edge cases, errors, compatibility), runs what it can locally, gives the human exact steps for the rest, records evidence, and posts the result to the ticket after the human types…

Feedback and reports

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