qa-test-planner

What this skill does

# QA Test Planner

A comprehensive skill for QA Automation engineers to create test plans, generate manual test cases, build automated Playwright tests, create regression test suites, validate UI with browser automation, and document bugs effectively.

> **Activation:** This skill is triggered only when explicitly called by name (e.g., `/qa-test-planner`, `qa-test-planner`, or `use the skill qa-test-planner`).

---

## Quick Start

**Create a test plan:**

```
"Create a test plan for the user authentication feature using the test-plan.md template"
```

**Generate test cases:**

```
"Generate manual test cases for the checkout flow using the test-case.md template"
```

**Create automated Playwright tests:**

```
"Create Playwright automated tests for the login flow using the playwright-test.md template"
```

**Validate UI with browser:**

```
"Navigate to the login page and validate all form elements are visible using Playwright MCP"
```

**Build regression suite:**

```
"Build a regression test suite for the payment module using test-case.md templates grouped by priority"
```

**Create bug report:**

```
"Create a bug report for the form validation issue using the bug-report.md template"
```

---

## Quick Reference

| Task           | Template                       | Time          |
| -------------- | ------------------------------ | ------------- |
| Test Plan      | `templates/test-plan.md`       | 10-15 min     |
| Test Case      | `templates/test-case.md`       | 5-10 min each |
| Automated Test | `templates/playwright-test.md` | 5-15 min each |
| Bug Report     | `templates/bug-report.md`      | 5 min         |

---

## When to Use This Skill

Use this skill when you need to:

- Create or review **test plans** and **test strategies**
- Generate **test cases** from requirements or user stories
- Write **bug reports** with clear reproduction steps
- Build **regression suites** with risk-based selection
- Implement **Playwright automation** with best practices
- Document **test execution** and results
- Conduct **exploratory testing** sessions
- Validate **UI elements** with browser automation

---

## Prerequisites

| Requirement    | Notes                                       |
| -------------- | ------------------------------------------- |
| Node.js 18+    | Required for Playwright automation          |
| Playwright     | `npm init playwright@latest` for automation |
| Text editor    | For creating/editing markdown files         |
| Git            | Recommended for testware version control    |
| Playwright MCP | Optional, for browser-based validation      |

---

## How It Works

```
Your Request
    │
    ▼
┌─────────────────────────────────────────────────────┐
│ 1. ANALYZE                                        │
│    • Parse feature/requirement                      │
│    • Identify test types needed (manual/automated)  │
│    • Determine scope and priorities                 │
├─────────────────────────────────────────────────────┤
│ 2. SELECT TEMPLATE                                │
│    • Choose appropriate template from assets/        │
│    • Review template structure and sections         │
│    • Identify placeholders to fill                 │
├─────────────────────────────────────────────────────┤
│ 3. CUSTOMIZE                                      │
│    • Fill in placeholders with project details      │
│    • Add specific test steps and scenarios         │
│    • Apply Playwright best practices               │
├─────────────────────────────────────────────────────┤
│ 4. EXECUTE (with Playwright MCP)                 │
│    • Navigate and interact with browser             │
│    • Capture screenshots and evidence               │
│    • Validate UI elements and behavior              │
├─────────────────────────────────────────────────────┤
│ 5. VALIDATE                                       │
│    • Check completeness                             │
│    • Verify traceability                            │
│    • Ensure actionable steps                        │
└─────────────────────────────────────────────────────┘
    │
    ▼
QA Deliverable Ready
```

---

## Workflows

### 1) Create a Test Plan

1. Use `templates/test-plan.md` as your starting point
2. Identify test objectives, scope, assumptions, and constraints
3. Define test levels and types (functional, UI, performance, etc.)
4. Specify environments, test data, tooling, and configuration needs
5. Define entry/exit criteria, deliverables, and reporting cadence
6. Add a risk matrix and mitigation actions
7. Prioritize testing accordingly (risk-based testing)

**Template:** [`templates/test-plan.md`](templates/test-plan.md)

### 2) Generate Test Cases

1. Use `templates/test-case.md` for individual test cases
2. Convert requirements into test conditions (what to test)
3. Pick a test design technique:
   - Equivalence partitions and boundary values for inputs
   - Decision tables for rule combinations
   - State transitions for lifecycle/flows
   - Use-case/scenario tests for end-to-end journeys
4. Write test cases that are atomic, unambiguous, and traceable
5. Add expected results that are observable and measurable
6. Add priority and risk tags to support risk-based regression
7. Mark automation candidates using stability + value criteria

**Templates:**

- [`templates/test-case.md`](templates/test-case.md) - Individual test case

### 3) Implement Automation Test Scripts (Playwright)

1. Use `templates/playwright-test.md` as a template
2. Keep tests readable and aligned with test cases
3. Prefer stable locators (e.g., `getByTestId`) over brittle selectors
4. Avoid arbitrary sleeps; rely on Playwright auto-waits and explicit assertions
5. Make tests independent (setup preconditions explicitly)
6. Use tagging in test titles (e.g., `@smoke`, `@regression`) for suite runs
7. Capture artifacts for triage (screenshots/video/trace) when debugging

**Template:** [`templates/playwright-test.md`](templates/playwright-test.md)

### 4) Build and Maintain Regression Suites

1. Use `templates/regression-suite.md` to define the suite
2. Define suite tiers: smoke (critical paths), sanity (build verification), regression (broad), full (release)
3. Select tests using risk + frequency + criticality + defect history
4. Tag tests consistently and document selection rules
5. Review the suite regularly: remove obsolete coverage, add coverage for escaped defects

**Template:** Use individual `test-case.md` templates grouped by priority

### 5) Create Bug Reports

1. Use `templates/bug-report.md` as your starting point
2. Reproduce reliably; reduce to minimal steps
3. Note variability (frequency) and scope
4. Capture environment details (build/app version, OS, browser/device, account/role)
5. Describe expected vs actual behavior
6. Include impact; set severity and priority consistently
7. Attach evidence (screenshots, console logs, network traces, Playwright trace)
8. Track lifecycle: triage notes, owner, fix version, verification steps

**Template:** [`templates/bug-report.md`](templates/bug-report.md)

---

## Core Deliverables

### 1. Test Plans

- Test scope and objectives
- Testing approach and strategy
- Environment requirements
- Entry/exit criteria
- Risk assessment
- Timeline and milestones

**Template:** [`templates/test-plan.md`](templates/test-plan.md)

### 2. Manual Test Cases

- Step-by-step instructions
- Expected vs actual results
- Preconditions and setup
- Test data requirements (use placeholders)
- Priority and severity

**Templates:**

- [`templates/test-case.md`](templates/test-case.md) - Individual test case

### 3. Regression Suites

- Smoke tests (15-30 min) - P0 tests only
- Full regression (2-4 hours) - P0, P1, P2 tests
- Targeted regression (30-60 min) - Tests for specific feature
- Execution order by priority (P0 first, then P1, then P2)

**Template:** Use individual `test-case.md` templates grouped by priority

### 4. Automated Playwright Tests

- Role-based locator strateg