Skip to content
Skills Library
Programming · Automation

implement-spec

/implement-spec

Use when a ticket DAG from a complete specification needs parallel execution into a verified integration branch, with an optional green draft pull request or merge request on explicit approval. Not for a settled ticket with no spec and not for ticket decomposition.

Licence
Apache-2.0
Last repository change
10.11.2026

Assessment and security

95/ 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.
Content30 / 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
3
Scripts
1
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 10.11.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 to check before installing
  • 1 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/inspect_mr_checks.py

What it does and when to use it

Use when a ticket DAG from a complete specification needs parallel execution into a verified integration branch, with an optional green draft pull request or merge request on explicit approval. Not for a settled ticket with no spec and not for ticket decomposition.

Original author description

Use when a ticket DAG from a complete specification needs parallel execution into a verified integration branch, with an optional green draft pull request or merge request on explicit approval. Not for a settled ticket with no spec and not for ticket decomposition.

How it works

  1. What you need before starting
  2. Validate first, without touching anything
  3. Set up the branch and brief the workers
  4. Execute the frontier in parallel
  5. Check, review, and correct to green
  6. Publish only with approval, then clean up only with approval
  7. One approved feature instead of a DAG
  8. Closing the run: work, review loop, simplify
  9. What you return
Original SKILL.md headings · 59 lines, 1,538 words
SKILL.md preview
---
name: implement-spec
description: 'Use when a ticket DAG from a complete specification needs parallel execution into a verified integration branch, with an optional green draft pull request or merge request on explicit approval. Not for a settled ticket with no spec and not for ticket decomposition.'
disable-model-invocation: true
---

# Implement spec

You take a complete specification with a finite ticket DAG and execute it into a verified integration branch using parallel workers in isolated worktrees. The default terminal state is local-only: a verified branch with passing checks and a clear review. Publication as a green draft pull request or merge request happens only when the human explicitly asks for it with an exact destination, previews the consequences, and approves.

This skill runs only on explicit human invocation. Credentials, remote publication, and cleanup deletions each need their own explicit approval bound to the exact target and consequence; every other write is reversible local work with version control as the rollback.

## What you need before starting

The complete specification; a finite ticket DAG with stable identifiers, dependencies, acceptance criteria, and owned file scopes; named TDD seams per ticket; the repository and integration base; the required check commands; and the review-clear criterion.

Publication inputs apply only when the human requests publication: the remote repository, target branch, and draft pull-request destination, or for GitLab the target project (`GROUP/PROJECT`), source and target branches, host, and draft merge-request destination, plus publication and cleanup approval when prompted. Pick GitHub or GitLab from the verified request URL or repository remote; an ambiguous destination blocks publication, never the local implementation path. Credentials are used only after that approval. The local path is complete on its own and needs no tracker, no remote, no credentials, and no cloud service.

Optional extras: ticket-specific verification commands, a pull-request or merge-request title or body, and an outside-repo path for exploration notes (default `<repo-parent>/spec-notes-<slug>/`).

## Validate first, without touching anything

Confirm every ticket traces to the specification, carries measurable acceptance criteria and a unique owned file scope, names its TDD seams, and references only existing ticket identifiers. Reject cycles, missing dependencies, overlapping ownership, and an unclean or wrong repository, all without mutation. Validate the publication destination only when publication is requested. If validation fails, make no mutation and stop as `invalid-input`.

Then record the bounded execution set, the integration base, the initial ready frontier (tickets whose dependencies are all complete), the required checks, the review-clear criterion, the publication scope (local-only by default), and the cleanup targets. Add no work outside this set and invent no missing evidence.

## Set up the branch and brief the workers

Create the integration branch from the base. Give every worker only what its ticket needs: the ticket itself, the exact specification sections and repository paths, its acceptance criteria, dependencies, owned files, named seams, and verification command. Pass results by artifact paths or commit identifiers plus context pointers to the spec, tickets, research notes, and prior commits; never duplicate unrelated context into worker packets.

When tickets need codebase or external research, run one exploration subagent first. It saves markdown notes in the outside-repo notes path, never inside the repository, so implementers share findings without polluting the tree.

## Execute the frontier in parallel

Each implementer works in its own worktree on its own branch: confirm the worktree is based on the integration branch tip and reset onto it when drifted, write the failing behavioral test first at each named seam, implement only its owned files, run its ticket verification, merge the integration branch tip into its own branch before reporting, and return the commit identifier, changed paths, verification result, and any blocker. A ticket without a passing acceptance proof stays incomplete.

Merge completed ticket commits onto the integration branch in dependency order with a merger pass. Resolve a conflict only when the specification and ownership make the intended result unambiguous; otherwise stop the affected path as blocked and preserve both commits plus the integration branch at the last verified state. After each integration, mark the ticket complete and release newly ready tickets. Keep going until every ticket is integrated or no incomplete ticket is ready; when the frontier is empty while tickets remain, return `blocked` with the unmet dependency or failed-ticket evidence. Never bypass the DAG, and preserve failed ticket worktrees with their commit evidence while blocking dependents.

## Check, review, and correct to green

Run all required checks on the integrated branch: the TDD cadence evidence (failing-first seam tests), the required check commands, and a full review of the integrated change against the specification, acceptance criteria, ownership boundaries, and repository safety. When the destination is a GitLab MR, the pipeline used as proof must match the MR head SHA; a missing, skipped, or unrelated successful pipeline is not proof, and a head change invalidates prior check evidence.

Turn each actionable finding into a bounded correction on the owning ticket branch, verify it, reintegrate it, and repeat checks and review until clear. Continue while each correction shows verified progress against a distinct finding. Stop as `non-converged` when a finding repeats without progress, results oscillate, checks are unavailable, or correction would widen the bounded scope. Never apply a fixed cycle count as the stopping rule, and never widen scope to unrelated code.

## Publish only with approval, then clean up only with approval

Local-only is the default: stop with the verified integration branch, report its name, head commit, checks, and review-clear evidence, and never touch a remote. Invocation is never publication approval.

For GitHub publication (only when the human explicitly requests it with an exact destination): preview the integration branch, commits, remote, target branch, draft pull-request title and body, and publication consequences; after explicit human approval, publish with the approved credentials, then verify the remote pull request points to the reviewed commit and reports the required checks. For GitLab MR publication (only when the human explicitly requests an MR with an exact destination): preview the source project and branch, target project and branch, host, title, body file, draft state, and publication consequences; no MR creation command has a general dry-run, so the preview is computed locally and nothing is submitted before approval. After approval, create with body-file and non-interactive flags (`glab mr create --repo <target GROUP/PROJECT> --head <source GROUP/PROJECT> --source-branch <branch> --target-branch <branch> --title <title> --description-file <body-file> --draft -y`), then verify by read-back that the MR IID exists with `state` opened, `draft` true, and `sha` equal to the reviewed integration head commit, plus `detailed_merge_status`, `blocking_discussions_resolved`, approval state, and a head pipeline matching the MR SHA with required checks green (GitLab check evidence via the bundled helper `python3 "<path-to-skill>/scripts/inspect_mr_checks.py" --host <host> --project <GROUP/PROJECT> --mr <iid> --json`). Fork MRs bind source and target projects separately. A failed publication stops as `publication-failed` with the local branch preserved; a declined one stops as `publication-declined` with the local-complete result standing.

Preview the exact temporary worktrees and branches eligible for cleanup. After explicit human approval, remove only those whose commits are reachable from the verified integration branch. Preserve any target holding unintegrated or uncommitted work and report it; if anything is uncertain, stop as `cleanup-blocked` with every uncertain target preserved.

## One approved feature instead of a DAG

When the specification is a single approved feature described by a product spec and a tech spec (for example `PRODUCT.md` and `TECH.md`), the DAG holds exactly one ticket. Run the same flow with that single ticket: validate it traces to both specs, execute it in one worktree, and integrate. Two extra rules apply only here: when implementation reveals that intended behavior or design should change, update the checked-in spec in the same change (product spec for user-facing behavior and success criteria, tech spec for architecture and validation strategy), keeping staged spec updates, code, and tests together so specs and code never diverge. When either spec file is absent, stop and report the missing file before writing code. The draft pull request or merge request still follows the publication rule above: local integration is the default terminal state.

## Closing the run: work, review loop, simplify

Complete this skill's own implementation path before any closing pass. Then run its native review and fix gate (required checks plus review-clear on the integrated branch) to green, continuing while each correction shows verified progress against a distinct finding and stopping as blocked or `non-converged` on repeats, oscillation, unavailable checks, or scope widening. Finally simplify offensively: re-derive the general case from contracts, delete old structure with no shims, aliases, or flags, collapse special cases, migrate every caller in the same change, one concern per atomic commit. Stay inside this skill's authority (the bounded execution set and each ticket's owned file scope), ask first before removing any live consumer surface, run the native gate after each increment and revert the increment on red, and close with a compression pass over dead branches, duplicated logic, and one-use wrappers with behavior preserved and the gate green.

## What you return

On success: the ticket-to-commit ledger, the empty frontier, the integrated branch name and commit identifier, passing check evidence, review-clear evidence, the cleanup result, and either the draft pull-request or merge-request URL and head commit (publication approved and verified) or the local-complete statement (no remote touched). On failure, exactly one terminal classification (`invalid-input`, `blocked`, `ticket-failed`, `integration-conflict`, `check-failed`, `review-blocked`, `non-converged`, `publication-declined`, `publication-failed`, or `cleanup-blocked`) with the partial-result ledger (completed tickets, remaining frontier, commits, checks, findings, publication scope and remote state, retained worktrees) and the next human-resolvable blocker. Never discard unintegrated work, swallow an error, or claim done while findings or tickets remain open.
Files in this package (3)
  • SKILL.md 11 KB
  • agents/openai.yaml 1 KB
  • scripts/inspect_mr_checks.py 22 KB

Versions

RepositoryScoreLicence
This page · gosuda/dalcom-skills95Apache-2.0
cravingmaker/skills100MIT
FRogora98/spec-driven100MIT
OutlineDriven/outline-driven-development100Apache-2.0
dzhng/skills90MIT
dzhng/jevgrep90MIT
dzhng/skills90MIT
aomni-com/open-duet90MIT
FradSer/dotclaude86MIT

Database snapshot: 13.11.2026 · package version 659eab029810 (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

  • 86pr-lifecycle
    Take a verified change from local branch through pull-request readiness, with optional merge only when the user explicitly authorizes it. Use for end-to-end GitHub PR work.
  • 90implement
    Build one approved piece of work from its spec or ticket, prove the result, and self-review it. Use when the user asks to implement a ticket, a spec slice or an agreed change, or when a coordinator briefs a worker to build one ticket.
  • 90finishing-a-development-branch
    Use when verified work needs integration or cleanup of an existing task-created branch/worktree, or the user explicitly requests merge, PR, or branch lifecycle handling.
  • 90two-axis-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 ticket or spec asked for?). Runs both reviews in parallel…
  • 9002-pull-request
    Create a draft pull or merge request from the current branch, in whatever VCS tool the project uses. Use when the user wants to open a pull or merge request. Not for committing, pushing, or merging a branch.
  • 100create-pr
    Stage, commit, push, and open a pull request following project conventions and the Conventional Commits spec. Accepts an optional skip-checks argument to bypass validation when called from /build. Use when the user says "create a PR", "open a PR", "submit a pull request", or…

Feedback and reports

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