sdlc-implement
/sdlc-implement
Execute approved tasks.md slice by slice: readiness gate, test-first per task, tick tasks with evidence, full verification at the end, checkpoint on blockers. Use after human approval of a T3 feature, or when the user says 'implement' or 'build the tasks'.
- Author
- phongtn89 ↗
- Repository
- sdlc-kit ↗
- Licence
- MIT
- Last repository change
- 13.11.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 13.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Execute approved tasks.md slice by slice: readiness gate, test-first per task, tick tasks with evidence, full verification at the end, checkpoint on blockers. Use after human approval of a T3 feature, or when the user says 'implement' or 'build the tasks'.
Triggers from the description
Arguments
/sdlc-implement Feature folder, or the task IDs to run (defaults to the next unchecked slice)
Original author description
Execute approved tasks.md slice by slice: readiness gate, test-first per task, tick tasks with evidence, full verification at the end, checkpoint on blockers. Use after human approval of a T3 feature, or when the user says 'implement' or 'build the tasks'.
How it works
- When to use
- Inputs
- Process
- Rationalizations
- Red flags
- Verification
- Principles applied
SKILL.md preview
--- name: sdlc-implement description: "Execute approved tasks.md slice by slice: readiness gate, test-first per task, tick tasks with evidence, full verification at the end, checkpoint on blockers. Use after human approval of a T3 feature, or when the user says 'implement' or 'build the tasks'." argument-hint: "Feature folder, or the task IDs to run (defaults to the next unchecked slice)" user-invocable: true --- # sdlc-implement: build what was approved ## When to use - T3 after the human has approved `spec.md`, `plan.md` and `tasks.md` (the `sdlc-analyze` gate). - To resume a partly done `tasks.md`. - T2 goes straight to `sdlc-tdd` with the mini-spec; it doesn't need this skill. ## Inputs - `tasks.md` (required), `spec.md`, `plan.md`, `data-model.md` / `contracts/` if present. These are binding. - `.sdlc/config.json` → `commands`, `budget`. - `.sdlc/checklists/definition-of-done.md`. - Any handoff file for this feature. ## Process 1. **Readiness gate.** Stop and ask if any of these fails: - [ ] Approval holds: run `python3 <kit_path>/bin/sdlc gate approved . --spec <NNN>` (`--repo <repo>` in a workspace) and quote its last line. If it reports no approval digest (a spec approved before digests existed), ask the human to confirm; don't go on your own say-so. If it reports that a part changed since approval, stop: ask the human and run `gate approve` again. - [ ] There are no open CRITICAL findings from `sdlc-analyze`, and no `[NEEDS CLARIFICATION]` marker on anything a P1 scenario or an in-scope task depends on. - [ ] The verification commands exist and run. Run the test command once now to record a **baseline** (pre-existing failures are noted, not fixed silently). - [ ] `git status` was checked, and unrelated changes are preserved and won't be staged. - [ ] Private registry and credential prerequisites are present (check presence only; never print values). 2. **Pick the next slice**: the lowest unchecked slice whose `blocked-by` tasks are all done. After all slices, take the unchecked `C` tasks under `## Convergence`. Within it, run `[P]` tasks in parallel only through subagents with disjoint write sets. With usage metrics on (`.sdlc/config.json` → `usage.enabled` is `true`), run `[P]` tasks one after another instead, because overlapping units double count. 3. **For each task**, first (only if `usage.enabled` is `true`) run `python3 .claude/skills/sdlc-usage/usage.py start <task id> --record <feature folder>/tasks.md` (`.github/skills/...` when that is the only path). Then follow `sdlc-tdd`: RED (watch it fail for the expected reason), then GREEN (minimal code), then REFACTOR. Stay inside the task's `files`. If you must touch another file, say why and update the task line (that is an edit to an approved document: ask the human and run `gate approve` again). 4. **Tick a task** (`[x]`) only when its `verify` step passed at the current revision. Append to the *Progress log*: the task ID, the short hash of the commit that holds the work, the command and its result (`gate evidence-for-ticks` needs the ID and an existing commit on one line). Never tick work that is blocked, skipped or unverified. Then, if `usage.enabled` is `true`, run `python3 .claude/skills/sdlc-usage/usage.py stop <task id> --record <feature folder>/tasks.md` and quote the line it adds. A **review finding** you are fixing (not a planned task) is a unit too: its id is `<pass>-<finding id>` (for example `review1-F3`), its record is the feature's `tasks.md`, section `Progress log`. Write the finding's one-line text as a Progress-log bullet, then run the same start and stop commands with that id and `--record <feature folder>/tasks.md` (the folder's path relative to the project root: `<repo>/specs/NNN-slug/tasks.md` in a workspace). Findings from `sdlc-analyze` are fixed in specify, plan or tasks and are not measured. 5. **Check after each slice**: run the slice's acceptance check, then the narrow test set. Look at the diff (`git diff --stat`, then the slice's hunks) for scope creep, debug output, dead code or stale comments. 6. **Watch the budget.** Run `python3 <kit_path>/bin/sdlc budget .` (`kit_path` from `.sdlc/lock.json`; in a workspace add `--repo <repo>`) after each task and quote its last line instead of estimating. `budget: REASSESS` (the diff is past `budget.reassess_lines`) means pause: simplify, or checkpoint with `sdlc-handoff`; `budget: ABOVE TARGET` means simplify before adding more. When a task is done, add `--unit <task id> --spec <NNN>` to compare its recorded turns with `budget.target_turns` and `budget.max_turns`; a turn count of a session still running is not available, so at `budget.max_turns` you still checkpoint and stop on your own count. 7. **On a blocker**, follow `.sdlc/principles/fail-safe-keep-work.md`: - Auth errors are terminal: report `BLOCKED_<AREA>_AUTH` and retry zero times. - A transient error gets at most one retry. - Leave the task unchecked, write a handoff, and stop dependent work. 8. **Finish** with the full gate: run `python3 <kit_path>/bin/sdlc verify .` (`kit_path` from `.sdlc/lock.json`; in a workspace add `--repo <repo>`; raise the tool timeout or run it in the background, since a suite can take minutes) and quote its exact final line. Only a final line ending `(clean tree)` counts as verified at HEAD. Its final line is informational here, because the tree is still dirty before the commit; it runs every configured command once, non-interactively, with a timeout. Then run `python3 <kit_path>/bin/sdlc gate evidence-for-ticks . --spec <NNN>` and quote its last line; fix every tick it lists. Then the definition-of-done checklist, then `sdlc-converge`. If `enforce` is on and a hook refusal appears (an edit or a push turned down), it is the cue to get the approval or run `sdlc verify`; never edit `.claude/settings.json` or work around the hook. 9. **Report**: the slices done, the commands with their outcomes, any skipped or blocked items and why, and the next step (`sdlc-converge`, then `sdlc-review`). ## Rationalizations | Excuse | Reality | |---|---| | "Approval is implied, they asked for the feature" | T3 needs explicit approval of the artifacts. Ask once; it takes one message. | | "Tick it, the test will pass once X lands" | A tick is a claim of evidence. Unverified stays unchecked. | | "Fix the unrelated failing test while I'm here" | Note it as baseline. Fixing it silently hides it from review and widens the diff. | | "Quick refactor of the neighbour module" | Out of the write set means out of scope. Propose it separately. | | "Retry the install with another registry" | A 401 or 403 is terminal. Switching registries bypasses an access control. | | "Reset and start clean" | Never discard work. Checkpoint, then decide with the user. | ## Red flags - The implementation needs behaviour the spec doesn't state. Stop: update the spec through `sdlc-specify` or `sdlc-clarify`. - The plan's approach proves wrong. Stop: update `plan.md` (and the ADR) before you continue. - Tests pass on the first run (RED was never seen). The test may not be testing anything. - A task needs a second repository or a contract change that isn't in the plan. Re-route. ## Verification - Every ticked task has a progress-log entry with its command and result at the current revision. - The full gate ran, with each command and outcome listed. Failures and skips are named, not hidden. - The definition-of-done checklist was completed. - `git diff` contains only the files in the tasks' write sets plus the documented additions. ## Principles applied prove-it-works, evidence-over-claims, fail-safe-keep-work, thin-vertical-slices, guard-context
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · phongtn89/sdlc-kit | 100 | MIT |
| blueskyxn/codex-is-all-you-need | 90 | GPL-3.0 |
Database snapshot: 13.11.2026 · package version 4938d7c1edf8 (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
- 90Implement
The Implement step of R-PIV. Execute strictly from an approved plan in a fresh context, delegating to buddy's TDD implementation when a tasks list exists. Build only what the plan specifies; if it drifts, stop and return to planning. USE WHEN sdlc implement, execute plan, build… - 100implement-fleet
Orchestrator-workers variant of implement-approved-slice that runs independent approved slices in parallel, one worktree-isolated worker per slice per wave, merged after each wave. Use when the active task has an approved multi-slice plan whose Execution waves show at least one… - 82implement-spec
Execute an approved spec's tasks.md test-first, one task per commit, with review subagents. Use when the user asks to implement or continue a spec. - 100implement-approved-slice
Implement only the approved slice with minimal changes, then persist execution evidence in slice notes and TASK_STATE.md. The official execution path. Opt-in test-first mode via --tdd. Use when the plan and slice are approved, ambiguity is resolved and files in scope are known.… - 90build-slice
Build ONE vertical slice of an approved feature design. First agree the code-level implementation choices with the user, then write and get approval for a code-level slice plan (slices/slice-N.md), then build test-first, following the plan exactly, with verification,… - 86build-feature
Stage 3b (Build) - implement an approved plan.md on a feature branch in the app (the app in `<app.dir>/`, database in `<app.migrationsDir>`), commit, push and open a GitHub PR. Use only after plan.md is approved, or when the user says "build it", "implement the plan", or…