Qa Expert
- 702 installs
- 65 repo stars
- Updated June 21, 2026
- charon-fan/agent-playbook
qa-expert is an agent skill that delivers risk-based testing strategies, testing pyramid balance, and enforceable quality gates for developers who plan test coverage before writing tests.
About
qa-expert is a quality assurance specialist skill for coding agents that helps developers design risk-based testing strategies, balance the testing pyramid, and define enforceable quality gates before writing tests. The skill activates when teams ask for QA strategy, coverage planning, or quality standards and can use Read, Write, Edit, Bash, Grep, Glob, WebFetch, and WebSearch to research practices and draft gates. A session-logger hook records QA activity after completion. Developers reach for qa-expert when they need a testing plan—not individual test cases—covering what to test, at which layer, and what must pass before merge or release.
- Risk-based testing matrix with Critical/High/Medium/Low tiers
- Testing Pyramid Allocation: 10% E2E, 30% Integration, 60% Unit
- Pre-Commit and Pre-Merge quality gate checklists
- Activates on QA strategy, quality gates, test coverage, and testing approach requests
- After_complete hook automatically triggers session-logger
Qa Expert by the numbers
- 702 all-time installs (skills.sh)
- Ranked #571 of 2,184 Testing & QA skills by installs in the Skillselion catalog
- Security screen: LOW risk (skills.sh audit)
- Data as of Jul 28, 2026 (Skillselion catalog sync)
npx skills add https://github.com/charon-fan/agent-playbook --skill qa-expertAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 702 |
|---|---|
| repo stars | ★ 65 |
| Security audit | 3 / 3 scanners passed |
| Last updated | June 21, 2026 |
| Repository | charon-fan/agent-playbook ↗ |
How do you plan risk-based testing and quality gates?
Get expert guidance on risk-based testing strategies, testing pyramid balance, and enforceable quality gates before writing tests.
Who is it for?
Developers or tech leads defining test strategy, coverage priorities, and merge gates before implementation begins.
Skip if: Writing individual unit test files or debugging a single failing assertion without broader QA planning needs.
When should I use this skill?
A user asks for QA strategy, quality gates, test coverage planning, or testing approach guidance.
What you get
Risk-ranked test plan, pyramid allocation, and documented quality gates.
- test strategy document
- quality gate definitions
By the numbers
- Allows 8 agent tools including WebFetch and WebSearch
Files
QA Expert
Quality assurance specialist for developing comprehensive testing strategies and quality gates.
When This Skill Activates
Activates when you:
- Ask for QA strategy
- Need quality gates
- Want to improve test coverage
- Plan testing approach
Quality Assurance Strategy
1. Risk-Based Testing
Prioritize testing based on risk:
| Risk Level | Testing Approach |
|---|---|
| Critical (Money, Security, Data) | 100% automation, chaos testing |
| High (Core features) | Full E2E, integration, unit |
| Medium (Secondary features) | Integration, unit |
| Low (Edge features) | Unit tests only |
2. Testing Pyramid Allocation
| Level | % of Tests | Focus |
|---|---|---|
| E2E | 10% | Critical user journeys |
| Integration | 30% | API interactions |
| Unit | 60% | Business logic, utilities |
3. Quality Gates
Pre-Commit
- Lint: npm run lint
- Format check: npm run format:check
- Type check: npm run type-check
- Unit tests: npm run test:unitPre-Merge
- All tests: npm test
- Coverage threshold: > 80%
- Security scan: npm audit
- License check: npm run check:licensesPre-Production
- Full test suite: npm run test:all
- E2E tests: npm run test:e2e
- Performance tests: npm run test:perf
- Security audit: npm audit --audit-level highTest Categories
Functional Testing
Purpose: Verify features work as specified
- Happy path testing
- Edge case testing
- Boundary value analysis
- Error handling
Non-Functional Testing
Performance
- Response time < 200ms (p95)
- Throughput > 1000 req/s
- Memory usage stable
- No memory leaks
Security
- OWASP Top 10 coverage
- Penetration testing
- Dependency vulnerability scan
- Secrets detection
Compatibility
- Browser testing (Chrome, Firefox, Safari, Edge)
- Device testing (Mobile, Desktop, Tablet)
- OS testing (Windows, macOS, Linux)
- Version testing (N-1 browser versions)
Regression Testing
- Previous bugs don't reappear
- New features don't break existing features
- Performance doesn't degrade
Exploratory Testing
- Find unexpected issues
- Test edge cases
- User experience issues
Test Planning
Test Plan Template
# Test Plan: [Feature Name]
## Overview
[Feature description]
## Scope
[In scope / Out of scope]
## Test Cases
### Functional
- [ ] TC001: [Description]
- [ ] TC002: [Description]
### Integration
- [ ] TC101: [Description]
### E2E
- [ ] TC201: [Description]
## Test Data
[Required test data]
## Environment
[Test environment setup]
## Schedule
[Testing timeline]
## Exit Criteria
[Definition of done]Quality Metrics
Code Quality
- Test Coverage: > 80%
- Cyclomatic Complexity: < 10 per function
- Code Duplication: < 5%
- Technical Debt Ratio: < 5%
Defect Metrics
- Defect Density: < 1 defect per 1000 LOC
- Critical Defects: 0
- High Defects: 0
- Medium Defects: < 3
Test Metrics
- Test Pass Rate: > 95%
- Flaky Tests: 0
- Test Execution Time: < 10 minutes
Automation Strategy
Automate When
- Test is run frequently
- Test has deterministic results
- Test is stable
- ROI justifies automation cost
Don't Automate When
- Test requires human judgment
- Test is exploratory
- Test is one-time only
- Test changes frequently
Bug Report Template
## Bug Summary
[One-line summary]
## Severity
Critical / High / Medium / Low
## Steps to Reproduce
1.
2.
3.
## Expected Behavior
[What should happen]
## Actual Behavior
[What actually happens]
## Environment
- OS:
- Browser:
- Version:
## Attachments
[Screenshots, logs, etc.]Scripts
Generate test plan:
python scripts/generate_test_plan.py <feature>Analyze test coverage:
python scripts/coverage_analysis.pyReferences
references/strategy.md- Testing strategiesreferences/gates.md- Quality gate definitionsreferences/metrics.md- QA metrics and KPIs
QA Expert
A Claude Code skill for quality assurance strategy and quality gates.
Installation
This skill is part of the agent-playbook collection.
Usage
You: Create a QA plan
You: Set up quality gates
You: What tests should I write?Quality Gates
| Gate | Purpose |
|---|---|
| Lint | Code style and formatting |
| Type Check | Type safety |
| Unit Tests | Functionality correctness |
| Integration Tests | Component interaction |
| E2E Tests | User workflows |
Scripts
Generate test plan:
python scripts/generate_test_plan.py <feature>Resources
Quality Gates
Required Checks
- Lint passes
- Unit tests pass
- Coverage threshold met
- Security scan clean
Release Criteria
- No high severity defects
- Performance within target thresholds
QA Metrics
- Defect escape rate
- Test coverage by module
- Mean time to detect (MTTD)
- Mean time to resolve (MTTR)
QA Strategy
Objectives
- Validate critical user flows
- Detect regressions early
- Ensure performance and security baselines
Scope
- Unit tests
- Integration tests
- End-to-end tests
#!/usr/bin/env python3
# Template generator for coverage analysis.
from pathlib import Path
import argparse
import textwrap
def write_output(path: Path, content: str, force: bool) -> bool:
if path.exists() and not force:
print(f"{path} already exists (use --force to overwrite)")
return False
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(content, encoding="utf-8")
return True
def main() -> int:
parser = argparse.ArgumentParser(description="Generate a coverage analysis.")
parser.add_argument("--output", default="coverage-analysis.md", help="Output file path")
parser.add_argument("--name", default="example", help="Component or repo name")
parser.add_argument("--owner", default="team", help="Owning team")
parser.add_argument("--force", action="store_true", help="Overwrite existing file")
args = parser.parse_args()
content = textwrap.dedent(
f"""\
# Coverage Analysis
## Summary
Coverage summary for {args.name}.
## Ownership
- Owner: {args.owner}
## Coverage Gaps
- Missing unit tests
- Missing integration tests
## Risk Areas
- Critical paths with low coverage
- Recently changed modules
## Recommendations
- Add tests for gaps
- Improve data-driven coverage
## Next Steps
- Owners and deadlines
"""
).strip() + "\n"
output = Path(args.output)
if not write_output(output, content, args.force):
return 1
print(f"Wrote {output}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
#!/usr/bin/env python3
# Template generator for QA test plan.
from pathlib import Path
import argparse
import textwrap
def write_output(path: Path, content: str, force: bool) -> bool:
if path.exists() and not force:
print(f"{path} already exists (use --force to overwrite)")
return False
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(content, encoding="utf-8")
return True
def main() -> int:
parser = argparse.ArgumentParser(description="Generate a QA test plan.")
parser.add_argument("--output", default="docs/test-plan.md", help="Output file path")
parser.add_argument("--name", default="example", help="Feature or release name")
parser.add_argument("--owner", default="team", help="Owning team")
parser.add_argument("--force", action="store_true", help="Overwrite existing file")
args = parser.parse_args()
content = textwrap.dedent(
f"""\
# QA Test Plan
## Scope
{args.name}
## Ownership
- Owner: {args.owner}
- QA lead: TBD
## Risks
- High impact areas
- Known regressions
## Test Matrix
- Platforms
- Browsers
- Locales
## Environments
- Staging
- Production
## Test Data
- Seed data requirements
- Edge-case fixtures
## Exit Criteria
- Critical tests passing
- No unresolved P0/P1 issues
"""
).strip() + "\n"
output = Path(args.output)
if not write_output(output, content, args.force):
return 1
print(f"Wrote {output}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
Related skills
TddFollow test-driven development with a strict red-green-refactor loop when creating reliable features or fixing bugs.510k185k
Test Driven DevelopmentEnforce writing failing tests before any production implementation code.176k260kQaRun conversational QA sessions that turn user-reported bugs into well-written, domain-aware GitHub issues without manual ticket writing.164k185kMigrate To ShoehornAutomatically update TypeScript test files that rely on unsafe `as` type assertions by replacing them with type-safe partial objects from @total-typescript/shoehorn.151k185k
Webapp TestingVerify frontend behavior, debug UI issues, capture screenshots, and inspect logs of a running local web application using Playwright.121k164k
Playwright CliRun browser automation, generate element snapshots, inspect DOM attributes, and execute Playwright tests from the terminal.96.3k12.2kHow it compares
Pick this over test-generator skills when you need strategy and gates before any test files are written.
FAQ
What does qa-expert help plan before writing tests?
qa-expert helps plan risk-based testing priorities, testing pyramid balance across layers, and enforceable quality gates. The output is strategy and gates, not generated test code.
When should qa-expert activate in a coding agent?
qa-expert activates when a developer asks for QA strategy, quality gates, test coverage planning, or testing approach guidance before or during a ship cycle.
Is Qa Expert safe to install?
skills.sh reports 3 of 3 security scanners passed. Review the Security Audits panel on this page before installing in production.