New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Fix

by genkovich in genkovich/sdd

A skill your agent uses to fix a reported bug spec-first: reproduce it, trace the symptom to the owning feature's acceptance criteria, pin it with a failing (RED) test, apply the minimal GREEN fix…

MITAuto-check passedDevelopment

Install Fix

skills CLI
$ npx skills add genkovich/sdd --skill fix -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install genkovich/sdd fix --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/genkovich/sdd.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/fix .claude/skills/fix && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
fix
GitHub stars
171
Token cost
~2.5k tokens
SKILL.md length
1,189 words
Files
3 (incl. references)
Skills in repo
21
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses to fix a reported bug spec-first: reproduce it, trace the symptom to the owning feature's acceptance criteria, pin it with a failing (RED) test, apply the minimal GREEN fix…

  • Works in 6 steps: Intake — reproduce before touching… → Trace to spec (triage). Grep… → RED — pin the bug with a failing test.… → …
  • Fix a reported bug spec-first: reproduce it
  • SKILL.md covers Owner, Inputs, Protocol and Definition of Done, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Fix is an agent skill from genkovich/sdd. Use to fix a reported bug spec-first: reproduce it, trace the symptom to the owning feature's acceptance criteria, pin it with a failing (RED) test, apply the minimal GREEN fix through the same per-task gate implement uses, then patch the spec so the bug class can't silently return. Triggers on "fix {bug}", "fix the bug in {slug}", "bug in {feature}", "/sdd:fix {slug}", "regression in {slug}", "полагодь баг", "виправ багу", "регресія в {slug}", "чому зламалось". Triage is three-way: AC exists and is violated…

Its SKILL.md is about 2.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files, including reference files (for example `references/triage.md` and `templates/fix-record.md`).

It sits in Development, covering Debugging, Spec-driven development and User stories. The repository describes itself as: Spec-Driven Development for Claude Code: 12 atomic Socratic skills + a TDD implement engine (agent-team & dynamic-workflow modes). The licence is MIT.

When your agent uses it

  • Fix a reported bug spec-first: reproduce it
  • Trace the symptom to the owning features acceptance criteria
  • Pin it with a failing (RED) test
  • Apply the minimal GREEN fix through the same per-task gate implement uses

Example prompts

  • “t silently return. Triggers on”
  • “fix the bug in {slug}”
  • “bug in {feature}”
  • “/fix”

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

  1. Intake — reproduce before touching anything. At most 1–2 AskUserQuestion (phrasing per ../_shared/ask-style.md), only for what the report…
  2. Trace to spec (triage). Grep docs/features/*/spec.md (+ the candidate slug's _fixes/ for a recurrence) for the reproduction's domain…
  3. RED — pin the bug with a failing test. Write the minimal test that reproduces the bug at the level the behaviour implies (unit for a rule…
  4. GREEN + GATE — minimal fix. Make the RED test pass with the smallest change; no drive-by refactors (anything the fix exposes goes to the…
  5. Spec patch + fix record. Apply the step-2 branch — (a) nothing to patch, re-verify the AC; (b) patch the AC wording; (c) add the new AC…
  6. Commit + handoff. Propose commit fix: with trailers SDD-Fix: - and SDD-AC: (when an AC was traced). Then emit the stage-handoff block per…

What it can do on your machine

Read from SKILL.md and the folder at commit 4403913. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Fix loads about 2.5k tokens when it runs, and up to ~3.6k if it reads all its reference files. Until then it costs about 204 tokens; SKILL.md has 1,189 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~204
When it runs · the whole SKILL.md, loaded when a task matches
~2.5k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~3.6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from genkovich/sdd at commit 4403913, republished under its MIT licence (© genkovich). 1,189 words, ~2,519 tokens.

Download SKILL.mdSave it as .claude/skills/fix/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
fix
description
Use to fix a reported bug spec-first: reproduce it, trace the symptom to the owning feature's acceptance criteria, pin it with a failing (RED) test, apply the minimal GREEN fix through the same per-task gate implement uses, then patch the spec so the bug class can't silently return. Triggers on "fix {bug}", "fix the bug in {slug}", "bug in {feature}", "/sdd:fix {slug}", "regression in {slug}", "полагодь баг", "виправ багу", "регресія в {slug}", "чому зламалось". Triage is three-way: AC exists and is violated (regression) / AC is ambiguous (spec-bug — patch the wording) / no AC covers it (gap — add one, marked added-by-fix). Works on a repo with no specs at all (soft mode — code-first, recommends survey after). Writes a fix record under docs/features/{slug}/_fixes/ and commits with an SDD-Fix trailer.
model
inherit
effort
high
agents
explorer

Skill: fix

The bugfix entry point — the backbone in miniature, sized for «it's broken», not «build a feature». A bug is treated as evidence about the spec, not only about the code: either an acceptance criterion is violated (the code regressed), the AC was ambiguous enough to permit the behaviour (the spec is the root cause), or nothing covers it (a gap). So the fix always lands in two places — the code (RED → GREEN through the same gate implement runs) and the spec (a surgical AC patch) — tied together by a small fix record.

This skill keeps only its own machinery. Question phrasing → ../_shared/ask-style.md; RED-classification semantics → ../implement/references/tdd-loop.md (reused, never duplicated); dispatch policy → ../_shared/agent-roster.md.

Fix-record prose follows artifact_language — but a spec patch matches the existing spec's language (the file wins over the setting); code, tests and commits stay English → ../_shared/artifact-language.md.

Owner

The engineer on the bug (drives). PM / Tech Lead is consulted only when triage lands on «spec-bug» or «gap» — changing an AC is a product decision, not a code one.

Inputs

  • <slug> — optional; pass it when you know which feature owns the bug, otherwise step 2 finds it from the symptom.
  • The bug report, in any form — a sentence, a stack trace, a failing request, a screenshot description.
  • Soft gate (never hard-refuse): docs/features/ with ≥1 spec.md. Absent (a brownfield repo that never ran the backbone) → still run, in no-spec mode: steps 1 → 3 → 4 → record, skip the spec patch, and recommend /sdd:survey in the handoff.
  • (Optional) .claude/sdd.local.md — gate command overrides; otherwise the commands are detected per implement's cascade.

No depth dial and no .size here — a fix is one size, and the interview is the bug report itself.

Protocol

  1. Intake — reproduce before touching anything. At most 1–2 AskUserQuestion (phrasing per ../_shared/ask-style.md), only for what the report doesn't already say: expected vs actual, the steps, the scope (one user? all? since when?). Outcome: a one-line reproduction statement — «doing X, expected Y, got Z». A bug you can't state this way isn't ready to fix.
  2. Trace to spec (triage). Grep docs/features/*/spec.md (+ the candidate slug's _fixes/ for a recurrence) for the reproduction's domain terms; locate the owning slug and the closest §5 AC. In parallel, dispatch explorer — subagent_type: "sdd:explorer" (fallback Explore / inline per ../_shared/agent-roster.md) — to localize the code path. Three outcomes (decision table → ./references/triage.md):
    • (a) Regression — an AC describes the expected behaviour and the code violates it. The spec is right; only the code changes.
    • (b) Spec-bug — the AC exists but a reasonable implementer could read it and produce the observed behaviour. The wording is the root cause — the AC gets patched (with the user, step 5).
    • (c) Gap — no AC covers the behaviour. A new AC is added to §5, marked <!-- added-by-fix: <date> -->.
    • No-spec mode — no docs/features/ (or no spec plausibly owns the symptom): skip the spec patch, say so in the record, recommend survey.
  3. RED — pin the bug with a failing test. Write the minimal test that reproduces the bug at the level the behaviour implies (unit for a rule, integration for a dependency behaviour, e2e for a flow). Run it and classify the first run per ../implement/references/tdd-loop.md — it must be a GOOD red (fails on the assertion that encodes the expected behaviour); quote the failing line. A bug that can't be pinned by a test → STOP and say so — an unverifiable fix is a guess.
  4. GREEN + GATE — minimal fix. Make the RED test pass with the smallest change; no drive-by refactors (anything the fix exposes goes to the record's follow-ups). Then the same per-task gate implement runs: unit + lint + vet (+ integration when available), via the detected commands (detection cascade → ../implement/references/command-detection.md). Red gate → fix it, never commit around it.
  5. Spec patch + fix record. Apply the step-2 branch — (a) nothing to patch, re-verify the AC; (b) patch the AC wording; (c) add the new AC with the marker. Any spec change is confirmed with the user in one AskUserQuestion (before/after wording shown). Then write docs/features/<slug>/_fixes/<date>-<short-slug>.md from ./templates/fix-record.md: symptom → root cause → the pinning test → the spec patch (or why there is none).
  6. Commit + handoff. Propose commit fix: <slug> <short summary> with trailers SDD-Fix: <date>-<short-slug> and SDD-AC: <id> (when an AC was traced). Then emit the stage-handoff block per ../_shared/handoff.md (utility variant — /clear optional): What I did + Review (the diff, _fixes/<date>-<short-slug>.md, the spec patch if any) + Run next: resume what you were doing; when the fix touched >5 files or crossed a module boundary, recommend /sdd:review <slug> — a recommendation, not a gate.
Show full SKILL.md (447 more words)Show less

Definition of Done

  • The bug is reproduced by a test that failed before the fix and passes after — GOOD red proven, failing line quoted.
  • The gate is clean: unit + lint + vet (+ integration where available).
  • The triage outcome is explicit — regression / spec-bug / gap / no-spec — and the matching spec patch is applied (or its absence explained in the record).
  • docs/features/<slug>/_fixes/<date>-<short-slug>.md exists: symptom, root cause, the test, the spec patch, follow-ups.
  • The commit carries the SDD-Fix: trailer (+ SDD-AC: when traced); any spec change was user-confirmed.
  • The RED-pin (failing test first) + the per-task GATE are this skill's structural self-check (../_shared/self-check.md); its result is reported in the handoff.

Anti-patterns

  • Fixing without a pinning test. «It works now» with no RED proof is a guess that re-breaks silently — the exact failure mode this skill exists to stop.
  • Patching code when the spec was the bug. If the AC permitted the behaviour, the wording is the root cause; leave it unpatched and the next implementation reintroduces the bug legally.
  • Silent spec edits. Every AC patch/addition is confirmed with the user — the spec is a contract, not a scratchpad.
  • Drive-by refactoring. The fix commit is minimal; refactors the fix exposed go to the record's follow-ups, not into the same diff.
  • Skipping the gate because the change is «one line». One-line fixes break suites just fine.
  • Hard-refusing on a repo without specs. A brownfield bug is this skill's front door — degrade to no-spec mode and recommend survey, never block.
  • Writing a parallel test when _fixes/ shows the same symptom was fixed before. That's a recurrence — read the old record and strengthen its test instead.

References & template

Example invocation

User: «/sdd:fix — discounts are applied twice when the user clicks pay twice fast» Skill: intake confirms: expected one discount per order, got two on a double-click (all users, since the checkout-discounts release). Trace: docs/features/checkout-discounts/spec.md AC-04 says «a discount is applied to an order at most once» → the code violates it → regression. explorer localizes the apply-discount handler (no idempotency check). RED: an integration test posting the same apply twice asserts one discount row — fails with got 2, want 1 (GOOD red). GREEN: guard on the existing uniqueness key; gate clean. Spec: nothing to patch (AC-04 was right). Record _fixes/2026-06-12-double-discount.md; commit fix: checkout-discounts double-applied discount + SDD-Fix: / SDD-AC: AC-04 trailers. Handoff: 2 files touched → no review push; resume.

© genkovich, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files (references) in skills/fix of genkovich/sdd.

  • SKILL.md
  • references/triage.md
  • templates/fix-record.md

Open the folder on GitHubat commit 4403913

Compare with similar skills

Fix next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Fix compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Fix this skillgenkovich/sdd171—~2.5kAutomated safety check: PassMIT
Spec Driven Workflowalirezarezvani/claude-skills28k—~3.9kAutomated safety check: PassMIT
Speckit Specifyforyourhealth111-pixel/Vibe-Skills3.6k—~3.3kAutomated safety check: PassApache-2.0
Tbdjlevy/strif131—~3.5kAutomated safety check: PassMIT
QA Methodologymagnus919/agent-skills113—~3.2kAutomated safety check: PassMIT
Extracting Requirementsprime-radiant-inc/iterative-development181—~2.7kAutomated safety check: PassApache-2.0

Similar skills

  • Spec Driven Workflow

    alirezarezvani/claude-skills

    A skill your agent uses when the user asks to write specs before code, define acceptance criteria, plan features before implementation, generate tests from specifications, or follow spec-first…

    28k GitHub stars~3.9k tokensUpdated 1 mo ago
    DevelopmentAuto-check passed

  • Speckit Specify

    foryourhealth111-pixel/Vibe-Skills

    Create or update feature specifications from natural language descriptions.

    3.6k GitHub stars~3.3k tokensUpdated 1 mo ago
    DevelopmentAuto-check passed

  • Tbd

    jlevy/strif

    Git-native issue tracking (beads), coding guidelines, knowledge injection, and spec-driven planning for AI agents.

    131 GitHub stars~3.5k tokensUpdated 4 mo ago
    DevelopmentAuto-check passed

  • QA Methodology

    magnus919/agent-skills

    Design and apply QA methodology for software teams: test strategy, regression testing, CI failure triage, test automation, quality gates and metrics, risk-based testing, exploratory testing, test…

    113 GitHub stars~3.2k tokensUpdated yesterday
    Testing & QAAuto-check passed

  • Extracting Requirements

    prime-radiant-inc/iterative-development

    Reads human-written spec documents and produces per-epic requirement files with proof obligations plus behavior scenarios with stable IDs, using parallel chunked extraction.

    181 GitHub stars~2.7k tokensUpdated 4 mo ago
    Agent WorkflowsAuto-check passed

  • Plan To Tickets

    AnastasiyaW/codex-claude-code-config

    A skill your agent uses when a large plan, PRD, feature, refactor, research plan, or multi-step coding task must be split into small ready-for-agent tickets with acceptance criteria, verification…

    154 GitHub stars~683 tokensUpdated today
    Product & Project ManagementAuto-check passed

More from genkovich/sdd

All 21 skills in this repo

  • Implement

    genkovich/sdd

    A skill your agent uses to implement a feature from its tasks.json with test-driven development — writes a failing test first, makes it pass, refactors, gates, and commits per task.

    171 GitHub stars~2.5k tokensUpdated 1 mo ago
    Auto-check passed

  • Interview

    genkovich/sdd

    Use BEFORE roadmap or specify to get the idea OUT OF YOUR HEAD and onto disk — a Socratic interview that surfaces hidden assumptions, names tradeoffs, exposes imprecisions and proposes fresh angles…

    171 GitHub stars~3.8k tokensUpdated 1 mo ago
    Auto-check passed

  • Classify Size

    genkovich/sdd

    A skill your agent uses to classify a feature into XS/S/M/L/XL and write docs/features/{slug}/.size plus the pipeline route docs/features/{slug}/.route (quick|standard|full) so later skills know how…

    171 GitHub stars~1.8k tokensUpdated 1 mo ago
    Auto-check passed

  • Decide Adr

    genkovich/sdd

    A skill your agent uses to record a post-hoc or asynchronous architecture decision as a MADR ADR when it was NOT captured during the synchronous design pass — a choice made in code, in a chat, on a…

    171 GitHub stars~2.6k tokensUpdated 1 mo ago
    Auto-check passed

  • Tasks

    genkovich/sdd

    A skill your agent uses to break a designed feature into atomic, ≤1-day tasks with a dependency graph, a per-task Definition of Done, and a machine-readable tasks.json that the implement engine…

    171 GitHub stars~4.8k tokensUpdated 1 mo ago
    Auto-check passed

  • API

    genkovich/sdd

    A skill your agent uses to derive the API contract for a feature — an OpenAPI 3.1 document at docs/features/{slug}/contracts/openapi.yaml plus a drift/sync report (and an events doc when the feature…

    171 GitHub stars~4.3k tokensUpdated 1 mo ago
    Auto-check passed

Categories

Questions about Fix

What does Fix do?

A skill your agent uses to fix a reported bug spec-first: reproduce it, trace the symptom to the owning feature's acceptance criteria, pin it with a failing (RED) test, apply the minimal GREEN fix…. Fix is an agent skill from genkovich/sdd. Use to fix a reported bug spec-first: reproduce it, trace the symptom to the owning feature's acceptance criteria, pin it with a failing (RED) test, apply the minimal GREEN fix through the same per-task gate implement uses, then patch the spec so the bug class can't silently return.

When should I use Fix?

Fix fits situations like: fix a reported bug spec-first: reproduce it; trace the symptom to the owning features acceptance criteria; pin it with a failing (RED) test; apply the minimal GREEN fix through the same per-task gate implement uses.

How do I install Fix in Claude Code?

Run `npx skills add genkovich/sdd --skill fix -a claude-code`. Or copy the skill folder (skills/fix in genkovich/sdd) into .claude/skills/fix in your project. Claude Code loads it when a task matches its description.

How do I install Fix in Codex?

Run `npx skills add genkovich/sdd --skill fix -a codex`. Or copy the skill folder (skills/fix in genkovich/sdd) into .agents/skills/fix in your project. Codex loads it when a task matches its description.

Can I use Fix in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add genkovich/sdd --skill fix -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/fix, .gemini/skills/fix, .github/skills/fix and .opencode/skills/fix in your project.

What does Fix need to run?

SKILL.md names no scripts, command-line tools or credentials: Fix is instructions for the agent only.

Does Fix access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Fix safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Fix use?

Fix is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Fix use?

About 2.5k tokens (SKILL.md is roughly 10k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.1k tokens, read only when the agent opens those files.

What are the alternatives to Fix?

Skills that share tags, products or a category with Fix: Spec Driven Workflow (alirezarezvani/claude-skills, 28k stars), Speckit Specify (foryourhealth111-pixel/Vibe-Skills, 3.6k stars), Tbd (jlevy/strif, 131 stars) and QA Methodology (magnus919/agent-skills, 113 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Fix?

genkovich (a GitHub user) maintains it in genkovich/sdd, which has 171 GitHub stars. The repository holds 21 skills in this directory. The repository was last updated on September 5, 2026.

Source: genkovich/sdd on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.