# Fix

> Diagnose a Kandev bug, reconcile its requirements and system design, create a reviewable fix plan and work orders, then hand off for explicit TDD implementation.

- Skill: `kdlbs/fix` (Agent Skill)
- Install (CLI): `npx skillmds@latest add kdlbs/fix`
- Raw SKILL.md: https://api.skillmd.com/api/skills/kdlbs/fix/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: kdlbs (https://skillmd.com/u/kdlbs)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/kdlbs/fix

---


# Fix

Use the same durable workflow as feature work. Diagnose the defect first. Then
reconcile specifications and create the fix plan and work orders before you
change production code.

## Core flow

```text
Evidence -> Root cause -> Requirement conformance -> System-design check -> Fix plan + work orders -> Handoff -> Explicit implementation request -> TDD -> PR review
```

Do not patch production code before the planning checkpoint unless the user
explicitly opts out.

## Phase 0: Evidence and root cause

When a bug comes from an issue tracker, read the canonical issue and each image
attachment. Reproduce the behavior with existing tests, a read-only trace, or a
minimal temporary reproduction.

State:

- The incorrect behavior and its conditions.
- The root cause.
- The smallest reliable reproduction.
- The intended regression-test level and path.

If the cause remains uncertain, stop and ask the user.

## Phase 1: Reconcile specifications

Run the `/interview-me` assumption check for intended behavior and repair scope.
Reuse active acceptance criteria for clear regressions. Ask only about material
choices that evidence and prior instructions do not settle.

Read `docs/specs/README.md`, the owning system index, and the relevant
requirement and system-design documents. Use the legacy catalog only when the
system has not migrated.
Read the owning system `README.md` and use this command for discovery:

    python3 scripts/list-docs.py specs --format paths

Add `--kind legacy` when the system has not migrated.

Search adjacent systems before you create or move an artifact. A UI symptom does
not make the repair UI-owned. Update the system that owns the failed contract,
and include observable UI recovery there when applicable.

Classify the bug:

1. **Implementation violates an active acceptance criterion.** Reference the
   existing `AC-*` ID. Do not create or rewrite a requirement.
2. **The intended behavior is missing from requirements.** Add the smallest
   requirement and acceptance criteria that define it.
3. **The intended product behavior changes.** Amend or supersede the affected
   requirement. Record the compatibility effect.
4. **The technical design is wrong or incomplete.** Update the system design.
   Keep observable behavior in requirements.

Do not create a standalone repair specification. The requirement is the durable
behavioral source. The plan and work orders record this repair.

For predicates over collections or inventory, state the quantifier explicitly:
distinguish existential conditions such as “at least one live row” from
universal conditions such as “all rows.” When behavior depends on that
distinction, require a mixed-state regression containing both live and failed or
deleted rows.

Do not create parallel feature and UI requirements for one repair. A separate UI
requirement is valid only when the repair changes an independent reusable UI
contract.

Use `/record` when the correction establishes a durable boundary, ownership
rule, public contract, persistence rule, or security invariant with meaningful
alternatives.

## Phase 2: Create the fix package

Create `docs/plans/<fix-slug>/plan.md` and sibling work orders through `/plan`.

The package must:

- Reference the affected `REQ-*` and `AC-*` IDs.
- Reference the applicable system design.
- State the confirmed root cause.
- Name the regression test that fails before the correction.
- Name exact files, dependencies, acceptance conditions, and commands.
- Use dependency waves only when they clarify implementation order.
- For rendered UI changes, include ASCII previews in the plan and relevant UI
  work orders per `docs/specs/guide/plans-and-work-orders.md#ascii-ui-previews`.
  Show before/after when it explains the defect and correction.

Keep work orders sequential by default. A wave does not authorize delegation.

## Phase 3: Design-package handoff

Before you change production or permanent test code, report:

- Root cause and reproduction evidence.
- Requirement IDs and system-design paths.
- Plan and work-order paths.
- Dependency order and exact commands.
- Risks and exclusions.
- For UI changes, a compact inline ASCII preview of the correction, including
  phone composition when different, and links to the full plan/work-order views.

Then end the turn. Do not ask the user to approve the package or switch models.
Wait for a later explicit implementation request.

## Phase 4: Implement with TDD

After the explicit request:

1. Change the work order to `in_progress`.
2. Write and run the regression test.
3. Make sure that the test fails for the expected reason.
4. Implement the minimum correction.
5. Run the work order's exact commands.
6. Change the work order to `done` and synchronize `plan.md`.

For persisted defaults or coupled settings, inspect every write and reset path.
Cover explicit empty and null values when they affect the contract.

If the user authorizes subagents, obey `/planner-orchestration`. Use native
delegation, compact work-order context, no recursive delegation, and no
full-history fork.

## Phase 5: PR review

After all work-order checks pass, commit, push, and open the PR. Do not add an
automatic local simplify, QA, broad review, security review, or verification
pass.

Use `/pr-fixup` only for a CI error or an actionable reviewer finding. Run the
affected work-order check after a correction.

## Stop conditions

Stop when the root cause is uncertain, specifications and code disagree, the
repair needs a new material design, or the same targeted check fails three
times.

## Final report

Report the root cause, requirement IDs, system-design path, plan and work-order
paths, changed files, commands, results, authorized subagents, and PR status.

