implement

Implements approved TRD features via TDD with backend and frontend developer agents.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? It turns an approved Technical Requirements Document (TRD) into working, tested code without skipping rigor: it orchestrates backend-developer and frontend-developer agents to implement each vertical slice of a feature using TDD on a GitHub Flow branch, with an approved plan before any code is written. ## Core Features & Use Cases - Slice-by-slice implementation: Reads the TRD's task decomposition table, proposes the next pending vertical slice, and confirms scope with the user before creating a branch and PR. - Parallel full-stack orchestration: When a feature spans backend and frontend, it builds a combined plan, gets explicit approval, then invokes both developer agents in parallel with git worktree isolation. - Review-fix resumption: When code review, QA, security, or SRE reject a slice, it resumes the same implementing agent with the findings instead of restarting from scratch, while keeping independent re-review mandatory. - Use Case: After your TRD for a new checkout feature is approved, run this step to have the backend endpoint and frontend client implemented in parallel via TDD, producing a single PR with full test coverage and a timing log entry. ## Quick Start Ask the AI to run the implement step for the approved TRD at specs/checkout/trd.md and implement the next pending slice.

Frequently Asked Questions about 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 the implement step pointing at the TRD file or its spec slug. It reads the task decomposition table, proposes the next pending vertical slice, gets your approval on the plan, then invokes backend-developer and/or frontend-developer agents to write tests and code on a new branch and PR.

How does parallel backend and frontend implementation work in one feature?▼

The orchestrator builds a combined plan covering both tracks against the TRD's frontend-backend contract, gets explicit approval, then invokes both developer agents in a single parallel call with git worktree isolation so they never share a working directory.

What happens when code review or QA rejects an implemented slice?▼

For small objective fixes, the same implementing agent is resumed via message with the review findings, still following TDD. A fresh independent review agent instance then re-verifies the result; self-approval by the implementing agent is never accepted as the gate.

Can implementation start if a task has no GitHub issue linked?▼

No. Every task in the chosen slice must have an associated GitHub issue in the TRD table. If one is missing, the step stops and offers to invoke the architect agent to create the missing issues before any branch or agent is started.

What if a slice has no code changes, only infrastructure or validation?▼

Slices with no backend or frontend code track skip the developer agents entirely and are conducted directly by the orchestrator without a branch or PR. Versioned infrastructure changes, like CI or Dockerfile edits, still get their own branch and full review pipeline.