Claude Code SkillAi Research29 installs

Qa Test Planner

Generate comprehensive test plans, manual test cases, regression test suites, and bug reports for QA engineers. Includes Figma MCP integration for design validation.

Install with the Claude Code Templates CLI
$ npx claude-code-templates@latest --skill="ai-research/qa-test-planner" --yes

Requires Claude Code. The command adds this skill to your project's .claudedirectory — nothing runs on ToolZip's servers.

What's inside this skill

Component source (preview)

QA Test Planner

A comprehensive skill for QA engineers to create test plans, generate manual test cases, build regression test suites, validate designs against Figma, 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"
Generate test cases:
"Generate manual test cases for the checkout flow"
Build regression suite:
"Build a regression test suite for the payment module"
Validate against Figma:
"Compare the login page against the Figma design at [URL]"
Create bug report:
"Create a bug report for the form validation issue"

Quick Reference

TaskWhat You GetTime
Test PlanStrategy, scope, schedule, risks10-15 min
Test CasesStep-by-step instructions, expected results5-10 min each
Regression SuiteSmoke tests, critical paths, execution order15-20 min
Figma ValidationDesign-implementation comparison, discrepancy list10-15 min
Bug ReportReproducible steps, environment, evidence5 min

How It Works

Your Request
    │
    ▼
┌─────────────────────────────────────────────────────┐
│ 1. ANALYZE                                          │
│    • Parse feature/requirement                      │
│    • Identify test types needed                     │
│    • Determine scope and priorities                 │
├─────────────────────────────────────────────────────┤
│ 2. GENERATE                                         │
│    • Create structured deliverables                 │
│    • Apply templates and best practices             │
│    • Include edge cases and variations              │
├─────────────────────────────────────────────────────┤
│ 3. VALIDATE                                         │
│    • Check completeness                             │
│    • Verify traceability                            │
│    • Ensure actionable steps                        │
└─────────────────────────────────────────────────────┘
    │
    ▼
QA Deliverable Ready

Commands

Interactive Scripts

ScriptPurposeUsage
./scripts/generate_test_cases.shCreate test cases interactivelyStep-by-step prompts
./scripts/create_bug_report.shGenerate bug reportsGuided input collection

Natural Language

RequestOutput
"Create test plan for {feature}"Complete test plan document
"Generate {N} test cases for {feature}"Numbered test cases with steps
"Build smoke test suite"Critical path tests
"Compare with Figma at {URL}"Visual validation checklist
"Document bug: {description}"Structured bug report

Core Deliverables

1. Test Plans

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

2. Manual Test Cases

  • Step-by-step instructions
  • Expected vs actual results
  • Preconditions and setup
  • Test data requirements
  • Priority and severity

3. Regression Suites

  • Smoke tests (15-30 min)
  • Full regression (2-4 hours)
  • Targeted regression (30-60 min)
  • Execution order and dependencies

4. Figma Validation

  • Component-by-component comparison
  • Spacing and typography checks
  • Color and visual consistency
  • Interactive state validation

5. Bug Reports

  • Clear reproduction steps
  • Environment details
  • Evidence (screenshots, logs)
  • Severity and priority


Anti-Patterns

AvoidWhyInstead
Vague test stepsCan't reproduceSpecific actions + expected results
Missing preconditionsTests fail unexpectedlyDocument all setup requirements
No test dataTester blockedProvide sample data or generation
Generic bug titlesHard to trackSpecific: "[Feature] issue when [action]"
Skip edge casesMiss critical bugsInclude boundary values, nulls

Verification Checklist

Test Plan:
  • Scope clearly defined (in/out)
  • Entry/exit criteria specified
  • Risks identified with mitigations
  • Timeline realistic

Test Cases:
  • Each step has expected result
  • Preconditions documented
  • Test data available
  • Priority assigned

Bug Reports:
  • Reproducible steps
  • Environment documented
  • Screenshots/evidence attached
  • Severity/priority set


References


Deep Dive: Test Case Structure

Standard Test Case Format

## TC-001: [Test Case Title]

**Priority:** High | Medium | Low
**Type:** Functional | UI | Integration | Regression
**Status:** Not Run | Pass | Fail | Blocked

### Objective
[What are we testing and why]

### Preconditions
- [Setup requirement 1]
- [Setup requirement 2]
- [Test data needed]

### Test Steps
1. [Action to perform]
   **Expected:** [What should happen]

2. [Action to perform]
   **Expected:** [What should happen]

3. [Action to perform]
   **Expected:** [What should happen]

### Test Data
- Input: [Test data values]
- User: [Test account details]
- Configuration: [Environment settings]

### Post-conditions
- [System state after test]
- [Cleanup required]

### Notes
- [Edge cases to consider]
- [Related test cases]
- [Known issues]

Test Types

TypeFocusExample
FunctionalBusiness logicLogin with valid credentials
UI/VisualAppearance, layoutButton matches Figma design
IntegrationComponent interactionAPI returns data to frontend
RegressionExisting functionalityPrevious features still work
PerformanceSpeed, load handlingPage loads under 3 seconds
SecurityVulnerabilitiesSQL injection prevented

Deep Dive: Test Plan Template

Test Plan Structure

# Test Plan: [Feature/Release Name]

## Executive Summary
- Feature/product being tested
- Testing objectives
- Key risks
- Timeline overview

## Test Scope

**In Scope:**
- Features to be tested
- Test types (functional, UI, performance)
- Platforms and environments
- User flows and scenarios

**Out of Scope:**
- Features not being tested
- Known limitations
- Third-party integrations (if applicable)

## Test Strategy

**Test Types:**
- Manual testing
- Exploratory testing
- Regression testing
- Integration testing
- User acceptance testing

**Test Approach:**
- Black box testing
- Positive and negative testing
- Boundary value analysis
- Equivalence partitioning

## Test Environment
- Operating systems
- Browsers and versions
- Devices (mobile, tablet, desktop)
- Test data requirements
- Backend/API environments

## Entry Criteria
- [ ] Requirements documented
- [ ] Designs finalized
- [ ] Test environment ready
- [ ] Test data prepared
- [ ] Build deployed

## Exit Criteria
- [ ] All high-priority test cases executed
- [ ] 90%+ test case pass rate
- [ ] All critical bugs fixed
- [ ] No open high-severity bugs
- [ ] Regression suite passed

## Risk Assessment

| Risk | Probability | Impact | Mitigation |
|------|-------------|--------|------------|
| [Risk 1] | H/M/L | H/M/L | [Mitigation] |

## Test Deliverables
- Test plan document
- Test cases
- Test execution reports
- Bug reports
- Test summary report

Deep Dive: Bug Reporting

Bug Report Template

# BUG-[ID]: [Clear, specific title]

**Severity:** Critical | High | Medium | Low
**Priority:** P0 | P1 | P2 | P3
**Type:** Functional | UI | Performance | Security
**Status:** Open | In Progress | Fixed | Closed

## Environment
- **OS:** [Windows 11, macOS 14, etc.]
- **Browser:** [Chrome 120, Firefox 121, etc.]
- **Device:** [Desktop, iPhone 15, etc.]
- **Build:** [Version/commit]
- **URL:** [Page where bug occurs]

## Description
[Clear, concise description of the issue]

## Steps to Reproduce
1. [Specific step]
2. [Specific step]
3. [Specific step]

## Expected Behavior
[What should happen]

## Actual Behavior
[What actually happens]

## Visual Evidence
- Screenshot: [attached]
- Video: [link if applicable]
- Console errors: [paste errors]

## Impact
- **User Impact:** [How many users affected]
- **Frequency:** [Always, Sometimes, Rarely]
- **Workaround:** [If one exists]

## Additional Context
- Related to: [Feature/ticket]
- Regression: [Yes/No]
- Figma design: [Link if UI bug]

Severity Definitions

LevelCriteriaExamples
Critical (P0)System crash, data loss, securityPayment fails, login broken
High (P1)Major feature broken, no workaroundSearch not working
Medium (P2)Feature partial, workaround existsFilter missing one option
Low (P3)Cosmetic, rare edge casesTypo, minor alignment

Deep Dive: Figma MCP Integration

Design Validation Workflow

Prerequisites:
  • Figma MCP server configured
  • Access to Figma design files
  • Figma URLs for components/pages

Process:
  • Get Design Specs from Figma
"Get the button specifications from Figma file [URL]"

Response includes:
- Dimensions (width, height)
- Colors (background, text, border)
- Typography (font, size, weight)
- Spacing (padding, margin)
- Border radius
- States (default, hover, active, disabled)

  • Compare Implementation
TC: Primary Button Visual Validation
1. Inspect primary button in browser dev tools
2. Compare against Figma specs:
   - Dimensions: 120x40px
   - Border-radius: 8px
   - Background color: #0066FF
   - Font: 16px Medium #FFFFFF
3. Document discrepancies

  • Create Bug if Mismatch
BUG: Primary button color doesn't match design
Severity: Medium
Expected (Figma): #0066FF
Actual (Implementation): #0052CC
Screenshot: [attached]
Figma link: [specific component]

What to Validate

ElementWhat to CheckTool
ColorsHex values exactBrowser color picker
SpacingPadding/margin pxDevTools computed styles
TypographyFont, size, weightDevTools font panel
LayoutWidth, height, positionDevTools box model
StatesHover, active, focusManual interaction
ResponsiveBreakpoint behaviorDevTools device mode

Example Queries

"Get button specifications from Figma design [URL]"
"Compare navigation menu implementation against Figma design"
"Extract spacing values for dashboard layout from Figma"
"List all color tokens used in Figma design system"

Deep Dive: Regression Testing

Suite Structure

Suite TypeDurationFrequencyCoverage
Smoke15-30 minDailyCritical paths only
Targeted30-60 minPer changeAffected areas
Full2-4 hoursWeekly/ReleaseComprehensive
Sanity10-15 minAfter hotfixQuick validation

Building a Regression Suite

Step 1: Identify Critical Paths
  • What can users NOT live without?
  • What generates revenue?
  • What handles sensitive data?
  • What's used most frequently?

Step 2: Prioritize Test Cases
PriorityDescriptionMust Run
P0
Business-

Preview truncated. View the full source on GitHub →

Type
Skill
Category
Ai Research
Installs
29
Source
GitHub ↗

Related Claude Code Skills

SkillAi Research

Agents Langchain

Framework for building LLM-powered applications with agents, chains, and RAG. Supports multiple providers (OpenAI, Anthropic, Google), 500+ integrations, ReAct agents, tool calling, memory management, and vector store retrieval. Use for building chatbots, question-answering systems, autonomous agents, or RAG applications. Best for rapid prototyping and production deployments.

91 installsView →
SkillAi Research

Claude Code Guide

Master guide for using Claude Code effectively. Includes configuration templates, prompting strategies "Thinking" keywords, debugging techniques, and best practices for interacting with the agent.

86 installsView →
SkillAi Research

Agent Memory Systems

"Memory is the cornerstone of intelligent agents. Without it, every interaction starts from zero. This skill covers the architecture of agent memory: short-term (context window), long-term (vector stores), and the cognitive architectures that organize them. Key insight: Memory isn't just storage - it's retrieval. A million stored facts mean nothing if you can't find the right one. Chunking, embedding, and retrieval strategies determine whether your agent remembers or forgets. The field is fragm"

85 installsView →
SkillAi Research

Ai Agents Architect

"Expert in designing and building autonomous AI agents. Masters tool use, memory systems, planning strategies, and multi-agent orchestration. Use when: build agent, AI agent, autonomous agent, tool use, function calling."

76 installsView →
SkillAi Research

Prompt Engineering

Expert guide on prompt engineering patterns, best practices, and optimization techniques. Use when user wants to improve prompts, learn prompting strategies, or debug agent behavior.

67 installsView →
SkillAi Research

Context7 Auto Research

Automatically fetch latest library/framework documentation for Claude Code via Context7 API

60 installsView →

Catalog data and component content are sourced from the open-source davila7/claude-code-templates project (MIT license). ToolZip curates the listing and writes original descriptions; every component links back to its original source. Claude Code is a product of Anthropic. ToolZip is an independent catalog and is not affiliated with or endorsed by Anthropic.