home / skills / bacoco / bmad-skills / bmad-development-execution

bmad-development-execution skill

/.claude/skills/bmad-development-execution

This skill implements approved stories end-to-end with code, tests, and documentation, ensuring traceability to requirements and architecture decisions.

npx playbooks add skill bacoco/bmad-skills --skill bmad-development-execution

Review the files below or copy the command above to add this skill to your agents.

Files (6)
SKILL.md
3.2 KB
---
name: bmad-development-execution
description: Implements stories with code and tests.
allowed-tools: ["Read", "Write", "Grep", "Bash"]
metadata:
  auto-invoke: true
  triggers:
    patterns:
      - "implement story"
      - "develop this"
      - "let's code"
      - "write the code"
      - "start coding"
    keywords:
      - implement
      - code
      - develop
      - build
      - program
      - coding
      - implementation
  capabilities:
    - code-implementation
    - test-writing
    - debugging
    - code-review
  prerequisites:
    - user-stories
    - architecture-decisions
    - test-strategy-doc
  outputs:
    - source-code
    - test-files
    - implementation-notes
---

# Development Execution Skill

## When to Invoke

**Automatically activate when user:**
- Says "Implement story X", "Start coding", "Develop this"
- Asks "Write the code", "Let's code", "Build [feature]"
- Mentions "implement", "code", "develop"
- Story file ready (Phase 4)
- Uses words like: implement, code, develop, build, program, coding

**Specific trigger phrases:**
- "Implement story [X]"
- "Start coding [feature]"
- "Develop this story"
- "Let's code"
- "Write the implementation"
- "Build [feature]"

**Prerequisites:**
- Story file exists (from bmad-story-planning)
- Architecture patterns defined

**Do NOT invoke when:**
- No story file (use bmad-story-planning first)
- Planning needed (use bmad-product-planning first)
- Architecture not defined (use bmad-architecture-design first)

## Mission
Implement approved stories end-to-end, maintaining transparency, testing discipline, and traceability back to requirements and architecture decisions.

## Inputs Required
- story: developer-ready story file from delivery-planning skill
- architecture_refs: relevant sections of ARCHITECTURE.md or component notes
- ux_guidance: UX specs or validations tied to the story
- quality_plan: scenarios or gates supplied by quality-assurance skill

## Outputs
- Code diffs and test results captured in the working repository
- Updated story file (Dev Agent Record, status transitions, learnings)
- **implementation-notes.md** - Development summary (generated from `assets/implementation-notes-template.md.template`)
- Summary of changes, tests, and outstanding risks for stakeholders

**Template location:** `.claude/skills/bmad-development-execution/assets/implementation-notes-template.md.template`

## Process
1. Confirm prerequisites via `CHECKLIST.md` and restate story scope.
2. Plan implementation steps, identifying affected files and tests.
3. Apply small, reviewable code changes with explanations and references.
4. Execute required test suites and capture command output verbatim.
5. Update story documentation, including Dev Agent Record and status.
6. Summarize work, highlight follow-ups, and notify orchestrator for next steps.

## Quality Gates
All items in `CHECKLIST.md` must pass before code is considered complete. Never mark a story done without full testing evidence.

## Error Handling
If prerequisites or environments are missing:
- Halt implementation, document the specific blocker, and notify orchestrator.
- Provide recommended remediation steps (e.g., refresh artifacts, fix failing baseline tests).
- Avoid speculative changes; keep diffs scoped to the approved story.

Overview

This skill implements developer-ready user stories end-to-end by producing code, tests, and traceable documentation. It emphasizes small, reviewable changes, strict testing discipline, and clear links back to requirements and architecture. Outputs include code diffs, test results, an updated story record, and an implementation-notes summary.

How this skill works

The skill first verifies prerequisites and restates the story scope from the provided story file. It plans the work, lists affected files and tests, applies incremental code changes with explanatory notes, runs required test suites capturing output verbatim, and updates the story status and implementation-notes. Blockers halt work and produce remediation steps rather than speculative changes.

When to use it

  • You have a developer-ready story file and want it implemented in code and tests
  • You say phrases like “Implement story X”, “Start coding”, or “Develop this story”
  • Architecture references and UX guidance are available for the story
  • You need traceable, test-driven delivery that maps to requirements and architecture
  • You want small, reviewable diffs and a documented development summary

Best practices

  • Confirm the story file and architecture refs before starting; do not proceed without them
  • Keep changes minimal and focused to make reviews fast and safe
  • Run the full test suite and include verbatim command output in the record
  • Update the story’s Dev Agent Record with status, learnings, and risks
  • Stop and document blockers; provide concrete remediation steps rather than guessing

Example use cases

  • Implement a new API endpoint described in a prepared story with accompanying tests
  • Complete a frontend feature using provided UX guidance and component architecture notes
  • Add validation logic and unit tests tied to quality-plan scenarios from QA
  • Deliver a backend change where architecture patterns and story acceptance criteria exist
  • Produce an implementation-notes summary for stakeholder handoff after completion

FAQ

What happens if a prerequisite is missing?

Work halts, the blocker is documented in the story, and the skill returns clear remediation steps and who to notify.

Are tests required before marking a story done?

Yes. All checklist items must pass and test outputs are captured verbatim before closing the story.