home / skills / bacoco / bmad-skills / bmad-test-strategy

bmad-test-strategy skill

safe

This skill helps you create risk-focused test strategy and ATDD scenarios, aligning requirements, architecture, and delivery plans for quality gates.

npx playbooks add skill bacoco/bmad-skills --skill bmad-test-strategy

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

Files (6)

SKILL.md

3.4 KB

---
name: bmad-test-strategy
description: Creates test strategy and ATDD scenarios.
allowed-tools: ["Read", "Write", "Grep"]
metadata:
  auto-invoke: true
  triggers:
    patterns:
      - "how should we test"
      - "create test strategy"
      - "test plan"
      - "ATDD"
      - "quality assurance"
    keywords:
      - test
      - testing
      - strategy
      - QA
      - quality
      - ATDD
      - automation
  capabilities:
    - test-strategy
    - atdd-scenarios
    - quality-gates
    - test-planning
  prerequisites:
    - architecture-decisions
  outputs:
    - test-strategy-doc
    - atdd-scenarios
    - quality-checklist
---

# Quality Assurance Skill

## When to Invoke

**Automatically activate when user:**
- Says "How should we test?", "Create test strategy"
- Asks "Test plan?", "ATDD?", "Quality assurance?"
- Mentions "testing", "test strategy", "QA"
- Planning or architecture phase (for test strategy)
- Uses words like: test, testing, strategy, QA, quality, ATDD

**Specific trigger phrases:**
- "How should we test this?"
- "Create test strategy"
- "Test plan for [project]"
- "ATDD scenarios"
- "Quality assurance approach"
- "Testing framework"

**Can invoke:**
- During Phase 2 (Planning) for test strategy
- During Phase 4 (Implementation) for ATDD

**Do NOT invoke when:**
- No requirements yet (need PRD first)
- Simple testing questions (answer directly)
- Already have test strategy (reference existing)

## Mission
Provide risk-focused quality strategies, acceptance tests, and governance that ensure BMAD deliverables meet agreed standards before release.

## Inputs Required
- prd_and_epics: requirements and roadmap produced by product-requirements skill
- architecture: technical decisions and constraints
- stories: delivery-planning outputs for upcoming work
- existing_quality_assets: current test suites, tooling, and metrics

## Outputs
- **Test strategy** (from `assets/test-strategy-template.md.template`)
- **ATDD scenarios** (from `assets/atdd-scenarios-template.md.template`)
- **Quality checklist** (from `assets/quality-checklist-template.md.template`)
- Coverage matrices or CI/CD gate definitions stored with project docs
- Recommendations for instrumentation, monitoring, or regression prevention

**Template locations:** `.claude/skills/bmad-test-strategy/assets/*.template`

## Process
1. Confirm prerequisites using `CHECKLIST.md`.
2. Review requirements, architecture, and delivery plans to identify risk areas.
3. Define quality approach (test types, automation, environments, data) proportionate to risk.
4. Author executable artifacts (ATDD scenarios, scripts, dashboards) or instructions.
5. Partner with development-execution and orchestrator to integrate quality gates and track follow-ups.

**Note on automation:** This skill currently operates through quality planning conversation using templates. No automation scripts are required—test strategies and ATDD scenarios are created manually using templates from `assets/`. See `scripts/README.md` for future automation roadmap.

## Quality Gates
Ensure all checklist items are satisfied before sign-off. Traceability from requirements to test coverage must be explicit.

## Error Handling
- When prerequisites are missing, halt work and request specific artifacts.
- If tools or environments are unavailable, document gaps and remediation plan.
- Escalate high-risk issues (compliance, data privacy) immediately with evidence.

Overview

This skill creates risk-focused test strategies and Acceptance Test-Driven Development (ATDD) scenarios to ensure deliverables meet agreed standards before release. It produces a test strategy document, executable ATDD scenarios, and a quality checklist tailored to the project’s requirements and architecture. The output is designed to integrate with CI/CD gates and project documentation for traceability.

How this skill works

I confirm prerequisites, review product requirements, epics, architecture, and planned stories to identify highest-risk areas. Then I define a proportionate quality approach (test types, automation scope, environments, data needs) and author ATDD scenarios and checklists using standard templates. Finally, I recommend instrumentation, monitoring, coverage matrices, and CI/CD gate definitions and flag any gaps or escalations required.

When to use it

During planning or architecture phases to define a test strategy for a new project or major feature
When preparing acceptance criteria and executable ATDD scenarios before implementation
If you need to map requirements to test coverage and establish traceability
When integrating quality gates into CI/CD pipelines or defining release criteria
If existing test assets are incomplete and you need a prioritized QA roadmap

Best practices

Provide the PRD, epics, architecture notes, and planned stories up front to avoid blocked work
Prioritize tests by feature risk and user impact; automate high-value regression paths first
Keep ATDD scenarios executable and reviewable by product owners and developers
Document gaps in tools/environments and include remediation steps in the output
Ensure traceability from requirements to ATDD scenarios and CI/CD gates for auditability

Example use cases

Create a test strategy and ATDD scenarios for a new payment integration with compliance risks
Define quality gates and coverage matrix for a major refactor to prevent regressions
Produce an ATDD suite for a high-priority epic so developers can drive acceptance tests
Assess existing test assets, identify gaps, and deliver a prioritized QA checklist and roadmap
Recommend monitoring and instrumentation to detect production regressions post-release

FAQ

What inputs are required to create a test strategy?

I need the PRD and epics, architecture decisions, planned stories, and any existing quality assets or tooling details.

What happens if prerequisites are missing?

Work halts and I return a precise checklist of required artifacts; I also document interim mitigations if possible.