playbooks

home / skills / bacoco / bmad-skills / openspec-change-implementation

openspec-change-implementation skill

/.claude/skills/openspec-change-implementation

This skill applies small, approved OpenSpec changes to code or configuration, executing tests and logging results for transparent delivery.

npx playbooks add skill bacoco/bmad-skills --skill openspec-change-implementation

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

Files (6)
SKILL.md
3.2 KB
---
name: openspec-change-implementation
description: Implements L0-1 changes from proposals.
allowed-tools: ["Read", "Write", "Grep", "Bash"]
metadata:
  auto-invoke: true
  triggers:
    patterns:
      - "apply this change"
      - "implement the fix"
      - "execute proposal"
      - "apply the bug fix"
      - "implement it"
    keywords:
      - apply
      - execute
      - implement
      - fix
      - proposal
  capabilities:
    - change-implementation
    - code-execution
    - test-execution
    - logging
  prerequisites:
    - proposal
  outputs:
    - implemented-code
    - execution-log
    - test-results
---

# OpenSpec Implement Skill

## When to Invoke

**Automatically activate when user:**
- Says "Implement this change", "Apply the fix", "Execute proposal"
- Asks "Apply this bug fix", "Implement the proposal", "Execute the change"
- Has an approved OpenSpec proposal ready to implement
- Mentions "implement", "apply", "execute" with Level 0-1 context
- Uses words like: apply, execute, implement, change, fix, proposal

**Specific trigger phrases:**
- "Implement this change"
- "Apply the bug fix"
- "Execute the proposal"
- "Apply this change: [proposal-id]"
- "Implement proposal [X]"
- "Execute the fix"

**Prerequisites:**
- OpenSpec proposal exists and is approved
- Change is still Level 0-1 (hasn't grown in scope)
- Environment and dependencies are clear

**Do NOT invoke when:**
- No proposal exists (use openspec-change-proposal first)
- Scope has grown beyond Level 1 (escalate to BMAD)
- Implementing a BMAD story (use bmad-development-execution instead)

**Auto-escalate to BMAD when:**
- Implementation reveals hidden complexity
- Scope expands beyond original proposal
- Tests fail repeatedly indicating design issues

## Mission
Apply small code or configuration changes approved via OpenSpec proposals, ensuring each task is executed transparently with testing evidence.

## Inputs Required
- proposal: latest proposal.md with decision history
- tasks: tasks.md with sequenced work items and owners
- environment: information about repositories, branches, and tooling needed for execution

## Outputs
- Code or configuration changes committed according to tasks
- Test results demonstrating acceptance criteria were met
- Updated proposal/tasks capturing status and follow-ups
- `execution-log.md` documenting commands and evidence (template: `assets/execution-log-template.md.template`)

`scripts/update_execution_log.py` appends timestamped entries to the execution log inside `openspec/changes/<change-id>/`.

## Process
1. Confirm scope and prerequisites via `CHECKLIST.md`.
2. Plan work referencing affected files and dependencies.
3. Implement tasks iteratively, documenting commands and results in `execution-log.md` via the script or manual edits.
4. Run relevant tests or validation steps after each change and capture evidence in the log.
5. Update artifacts and communicate completion or blockers.

## Quality Gates
All checklist items must pass. If complexity grows beyond Level 1, escalate back to BMAD pathways.

## Error Handling
- When prerequisites or environment setup are missing, stop and request clarity.
- If tests fail or scope expands, log findings and recommend next actions, including potential migration to BMAD development-execution.

Overview

This skill implements Level 0-1 changes from approved OpenSpec proposals by executing small, well-scoped code or configuration updates. It runs the defined tasks, records commands and evidence in an execution log, and produces test results that demonstrate the change meets acceptance criteria. The skill enforces checklist gates and escalates when scope or complexity grows beyond Level 1.

How this skill works

The skill ingests the approved proposal, a sequenced tasks file, and environment details to confirm prerequisites. It follows a checklist, runs the planned implementation steps, commits changes, and appends timestamped entries to execution-log.md using the provided script or manual edits. After each change it runs targeted tests or validations and captures results and artifacts back into the proposal and tasks files.

When to use it

  • You have an approved OpenSpec proposal scoped at Level 0-1 and ready for execution.
  • You need to apply a small bug fix or configuration change described in a proposal.
  • You want fully documented, repeatable execution with test evidence and an execution log.
  • You require automated logging of commands and test outputs for auditability.
  • You need to enforce checklist-based quality gates before merging changes.

Best practices

  • Confirm the proposal, tasks.md, and environment details before making any changes.
  • Run CHECKLIST.md and ensure all prerequisites (repos, branches, tooling) are available.
  • Implement iteratively: change, test, log. Commit only after tests pass and evidence is recorded.
  • Use scripts/update_execution_log.py to append timestamped evidence rather than informal notes.
  • If tests fail or hidden complexity appears, stop, log findings, and escalate to BMAD.

Example use cases

  • Apply a small configuration tweak that fixes a deployment flag described in an approved proposal.
  • Patch a minor bug in a single module with a short test verifying the fix.
  • Update CI configuration for a repository as specified by a Level 1 change and record validation runs.
  • Execute an approved database index addition with pre- and post-validation steps and logs.
  • Perform a permissions change limited to one service and capture evidence of successful access control behavior.

FAQ

What inputs do I need to provide to run this skill?

Provide the approved proposal.md, tasks.md with sequenced work items and owners, and environment details (repositories, branches, tooling, credentials if needed).

When should I escalate to BMAD instead of continuing?

Escalate when implementation reveals hidden complexity, scope expands beyond Level 1, tests repeatedly fail indicating design issues, or if the change touches multiple subsystems beyond the original proposal.