sdd-implement

Implements approved TRD features via TDD with backend and frontend agents on GitHub Flow branches.

Updated Aug 25, 2026
One-click install
npx skills add https://github.com/asengardeon/btt-sdd-pipeline --skill sdd-implement-asengardeon
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: sdd-implement
Source: https://github.com/asengardeon/btt-sdd-pipeline/tree/main/.claude/skills/sdd-implement
Command: npx skills add https://github.com/asengardeon/btt-sdd-pipeline --skill sdd-implement-asengardeon

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning an approved technical design (TRD) into working, tested code requires coordinating developers, enforcing TDD discipline, managing Git branches, and tracking slice-by-slice progress — this Skill orchestrates that entire implementation stage of a spec-driven development pipeline so nothing is skipped or repeated. ## Core Features & Use Cases - TDD Implementation Orchestration: Invokes backend-developer and/or frontend-developer agents (in parallel for full-stack features, with worktree isolation) to implement code and tests following the TRD, with an approved plan before any code is written. - Vertical Slice Management: Reads the TRD task decomposition table, proposes the next pending slice, verifies the previous slice's PR is merged, and enforces one branch/PR per slice on GitHub Flow. - Review-Finding Resume Flow: When code review, QA, security, or SRE reject a slice, resumes the same implementing agent with the findings instead of restarting from scratch, dosing context to the size of the fix. - Governance Gates: Requires GitHub issues per task, blocks provider swaps without an ADR, forbids self-approval as a substitute for independent review, and logs per-track timing to timing-log.md. - Use Case: After your architect approves specs/user-auth/trd.md, run this Skill to implement the first vertical slice: it creates the branch, runs backend and frontend agents in parallel with TDD, confirms full test coverage, opens the PR, and hands off to code review. ## Quick Start Run /sdd-implement with the slug of a spec whose TRD is approved to implement its next pending slice via TDD on a new branch.

Frequently Asked Questions about sdd-implement

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement a feature from an approved TRD with TDD?▼

Run /sdd-implement with the spec slug or TRD path. It reads the TRD task decomposition, proposes the next pending vertical slice, gets plan approval, then invokes backend-developer and/or frontend-developer agents that follow red-green-refactor TDD on a new branch.

How do I fix code review findings without restarting implementation?▼

Re-run /sdd-implement after a rejection. It resumes the same implementing agent via SendMessage with the specific findings from the review report, keeping TDD rigor, then requires a fresh independent review instance rather than accepting the implementer's own verdict.

Can backend and frontend implementation run in parallel?▼

Yes, parallel invocation is the default for full-stack slices. The orchestrator builds a combined plan against the TRD frontend-backend contract, gets explicit approval, then invokes both agents in one message with worktree isolation so they never share a working directory.

What happens if a TRD task has no GitHub issue?▼

Implementation stops at that gate. The skill first checks whether the slice was already merged without the TRD being updated; if genuinely missing, it offers to invoke the architect agent to create the issues before any branch or agent is started.

When should implementation slices be combined into one PR?▼

Only when the user explicitly requests it. The default is one branch and PR per vertical slice, and the next slice cannot start until the previous PR passes code review, QA, security, SRE, and is merged into main.