home / skills / questnova502 / claude-skills-sync / senior-qa

senior-qa skill

/skills/senior-qa

This skill helps you design and execute robust QA strategies for React, Next.js, and Node.js apps with automated test suite generation and coverage analysis.

npx playbooks add skill questnova502/claude-skills-sync --skill senior-qa

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

Files (7)
SKILL.md
4.4 KB
---
name: senior-qa
description: Comprehensive QA and testing skill for quality assurance, test automation, and testing strategies for ReactJS, NextJS, NodeJS applications. Includes test suite generation, coverage analysis, E2E testing setup, and quality metrics. Use when designing test strategies, writing test cases, implementing test automation, performing manual testing, or analyzing test coverage.
---

# Senior Qa

Complete toolkit for senior qa with modern tools and best practices.

## Quick Start

### Main Capabilities

This skill provides three core capabilities through automated scripts:

```bash
# Script 1: Test Suite Generator
python scripts/test_suite_generator.py [options]

# Script 2: Coverage Analyzer
python scripts/coverage_analyzer.py [options]

# Script 3: E2E Test Scaffolder
python scripts/e2e_test_scaffolder.py [options]
```

## Core Capabilities

### 1. Test Suite Generator

Automated tool for test suite generator tasks.

**Features:**
- Automated scaffolding
- Best practices built-in
- Configurable templates
- Quality checks

**Usage:**
```bash
python scripts/test_suite_generator.py <project-path> [options]
```

### 2. Coverage Analyzer

Comprehensive analysis and optimization tool.

**Features:**
- Deep analysis
- Performance metrics
- Recommendations
- Automated fixes

**Usage:**
```bash
python scripts/coverage_analyzer.py <target-path> [--verbose]
```

### 3. E2E Test Scaffolder

Advanced tooling for specialized tasks.

**Features:**
- Expert-level automation
- Custom configurations
- Integration ready
- Production-grade output

**Usage:**
```bash
python scripts/e2e_test_scaffolder.py [arguments] [options]
```

## Reference Documentation

### Testing Strategies

Comprehensive guide available in `references/testing_strategies.md`:

- Detailed patterns and practices
- Code examples
- Best practices
- Anti-patterns to avoid
- Real-world scenarios

### Test Automation Patterns

Complete workflow documentation in `references/test_automation_patterns.md`:

- Step-by-step processes
- Optimization strategies
- Tool integrations
- Performance tuning
- Troubleshooting guide

### Qa Best Practices

Technical reference guide in `references/qa_best_practices.md`:

- Technology stack details
- Configuration examples
- Integration patterns
- Security considerations
- Scalability guidelines

## Tech Stack

**Languages:** TypeScript, JavaScript, Python, Go, Swift, Kotlin
**Frontend:** React, Next.js, React Native, Flutter
**Backend:** Node.js, Express, GraphQL, REST APIs
**Database:** PostgreSQL, Prisma, NeonDB, Supabase
**DevOps:** Docker, Kubernetes, Terraform, GitHub Actions, CircleCI
**Cloud:** AWS, GCP, Azure

## Development Workflow

### 1. Setup and Configuration

```bash
# Install dependencies
npm install
# or
pip install -r requirements.txt

# Configure environment
cp .env.example .env
```

### 2. Run Quality Checks

```bash
# Use the analyzer script
python scripts/coverage_analyzer.py .

# Review recommendations
# Apply fixes
```

### 3. Implement Best Practices

Follow the patterns and practices documented in:
- `references/testing_strategies.md`
- `references/test_automation_patterns.md`
- `references/qa_best_practices.md`

## Best Practices Summary

### Code Quality
- Follow established patterns
- Write comprehensive tests
- Document decisions
- Review regularly

### Performance
- Measure before optimizing
- Use appropriate caching
- Optimize critical paths
- Monitor in production

### Security
- Validate all inputs
- Use parameterized queries
- Implement proper authentication
- Keep dependencies updated

### Maintainability
- Write clear code
- Use consistent naming
- Add helpful comments
- Keep it simple

## Common Commands

```bash
# Development
npm run dev
npm run build
npm run test
npm run lint

# Analysis
python scripts/coverage_analyzer.py .
python scripts/e2e_test_scaffolder.py --analyze

# Deployment
docker build -t app:latest .
docker-compose up -d
kubectl apply -f k8s/
```

## Troubleshooting

### Common Issues

Check the comprehensive troubleshooting section in `references/qa_best_practices.md`.

### Getting Help

- Review reference documentation
- Check script output messages
- Consult tech stack documentation
- Review error logs

## Resources

- Pattern Reference: `references/testing_strategies.md`
- Workflow Guide: `references/test_automation_patterns.md`
- Technical Guide: `references/qa_best_practices.md`
- Tool Scripts: `scripts/` directory

Overview

This skill is a comprehensive QA toolkit for senior engineers focused on test strategy, automation, and quality metrics for React, Next.js, and Node.js applications. It automates test suite generation, performs deep coverage analysis with recommendations, and scaffolds production-ready end-to-end tests. Use it to accelerate test implementation, baseline quality, and improve release confidence.

How this skill works

The skill inspects your codebase to identify components, routes, and API endpoints, then generates test templates following configurable best-practice patterns. It runs static and runtime coverage analysis to surface gaps, performance hotspots, and actionable remediation steps. For end-to-end workflows it scaffolds test projects and configuration that integrate with common runners and CI pipelines.

When to use it

  • Designing or validating a testing strategy for a React/Next.js or Node.js project
  • Quickly scaffolding unit, integration, and E2E test suites for an existing codebase
  • Analyzing test coverage to prioritize missing tests and flakiness sources
  • Preparing a codebase for CI integration and production-grade test automation
  • Reviewing quality metrics before a major release or refactor

Best practices

  • Start with high-value tests: critical user flows and public APIs before unit details
  • Keep generated tests deterministic and isolate external dependencies with mocks
  • Measure coverage but prioritize meaningful assertions over line counts
  • Integrate coverage analysis and E2E runs into CI to catch regressions early
  • Document test decisions and maintain templates to ensure consistency

Example use cases

  • Generate a baseline test suite for a Next.js app after initial feature delivery
  • Run a coverage audit on a Node.js API to identify untested endpoints and hot paths
  • Scaffold Playwright or Cypress E2E tests for key user journeys and CI integration
  • Automate remediation suggestions to reduce flaky tests and performance regressions
  • Create templates for component tests in a large React monorepo to onboard teams

FAQ

Which test frameworks and runners are supported?

The skill produces templates compatible with popular frameworks (Jest, Testing Library, Playwright, Cypress) and adapts to common runners used in React/Next and Node stacks.

Can it integrate with CI/CD pipelines?

Yes. Generated scaffolds and coverage reports are designed for easy integration with GitHub Actions, CircleCI, and similar CI systems.