Skip to main content
skill CX Codex

qe-test-execution — Claude Code skill: what it does, how to install

qe-test-execution orchestrates Jest, Vitest, and Playwright suites using the aqe CLI with parallel workers, affected-test selection, and flaky test retries.

MIT 122 installs ★ 533 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add proffesor-for-testing/agentic-qe --skill qe-test-execution -a claude-code
Open on GitHub

What qe-test-execution does

The skill orchestrates test suite runs across Jest, Vitest, and Playwright via the aqe CLI tool. It organizes parallel execution with worker processes, selects tests based on git diffs, and reruns flaky tests with configurable delays.

Work is divided across subagents. The qe-test-executor handles test execution alongside JUnit reporting, qe-test-selector finds impacted code from HEAD~1, and qe-flaky-detector quarantines tests that fail repeatedly. Outputs compile into a single result object with timing metrics and logs.

Parallel execution can hide flaky failures. For diagnosis, switch back to --workers=1. Full test runs inside containers also risk out-of-memory crashes, so intermediate outputs should be written directly to disk rather than stored in session memory.

What it helps with

  • run test suites across multiple parallel workers or CI shards
  • execute only tests affected by recent git changes
  • quarantine and retry flaky tests automatically
  • export aggregated execution results to JUnit and JSON reports

Example prompts for the agent

  • Run only affected tests against HEAD~1 using 4 parallel workers
  • Execute the full test suite with 3 retries for flaky failures and generate a JUnit report
  • Configure test execution with sharding for our CI matrix pipeline

How to install qe-test-execution

1Skills CLI (Vercel)

npx skills add proffesor-for-testing/agentic-qe --skill qe-test-execution -a claude-code

2Manually: put the files in place

~/.claude/skills/qe-test-execution/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/qe-test-execution/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about qe-test-execution

How to install qe-test-execution in Claude Code?

Run npx skills add proffesor-for-testing/agentic-qe --skill qe-test-execution -a claude-code. The skill file will be placed at ~/.claude/skills/qe-test-execution/SKILL.md.

What does qe-test-execution do?

It directs test orchestration for Jest, Vitest, and Playwright via aqe test run. It manages parallel sharding, filters suites by git changes, and handles flaky retries.

How does it diagnose flaky tests?

Parallel execution can hide intermittent failures, so the author advises switching to --workers=1 when debugging flakiness. The system also supports quarantine thresholds and automated retry loops.

Source text

SKILL.md · MIT
---
name: "qe-test-execution"
description: "Orchestrates test suite execution with parallel sharding, intelligent retry, and real-time reporting across Jest, Vitest, and Playwright. Use when running test suites, optimizing execution time, handling flaky tests, configuring CI test pipelines, or analyzing test run results."
trust_tier: 3
validation:
  schema_path: schemas/output.json
  validator_path: scripts/validate-config.json
  eval_path: evals/qe-test-execution.yaml
---

# QE Test Execution

## Purpose

Guide the use of v3's test execution capabilities including parallel orchestration, smart test selection, flaky test handling, and distributed execution across multiple environments.

## Activation

- When running test suites
- When optimizing test execution time
- When handling flaky tests
- When setting up CI/CD test pipelines
- When executing tests across environments

## Quick Start

```bash
# Run all tests with parallelization
aqe test run --parallel --workers 4

# Run affected tests only
aqe test run --affected --since HEAD~1

# Run with retry for flaky tests
aqe test run --retry 3 --retry-delay 1000

# Run specific test types
aqe test run --type unit,integration --exclude e2e
```

## Agent Workflow

```typescript
// Orchestrate test execution
Task("Execute test suite", `
  Run the full test suite with:
  - 4 parallel workers
  - Retry flaky tests up to 3 times
  - Generate JUnit report
  - Fail fast on critical tests
  Report results and any failures.
`, "qe-test-executor")

// Smart test selection
Task("Run affected tests", `
  Analyze changes in PR #123 and:
  - Identify affected test files
  - Run only relevant tests
  - Include integration tests for changed modules
  - Report coverage delta
`, "qe-test-selector")
```

## Execution Strategies

### 1. Parallel Execution

```typescript
await testExecutor.runParallel({
  suites: ['unit', 'integration'],
  workers: 4,
  distribution: 'by-file',  // or 'by-test', 'by-duration'
  isolation: 'process',
  sharding: {
    enabled: true,
    total: 4,
    index: process.env.SHARD_INDEX
  }
});
```

### 2. Smart Test Selection

```typescript
await testExecutor.runAffected({
  changes: gitChanges,
  selection: {
    direct: true,      // Tests for changed files
    transitive: true,  // Tests for dependents
    integration: true  // Integration tests touching changed code
  },
  fallback: 'full-suite'  // If analysis fails
});
```

### 3. Flaky Test Handling

```typescript
await testExecutor.handleFlaky({
  detection: {
    enabled: true,
    threshold: 0.1,  // 10% flake rate
    window: 100      // Last 100 runs
  },
  strategy: {
    retry: 3,
    quarantine: true,
    notify: ['#flaky-tests']
  }
});
```

## Execution Configuration

```yaml
execution:
  parallel:
    workers: auto  # CPU cores - 1
    timeout: 30000
    bail: false

  retry:
    count: 2
    delay: 1000
    only_failed: true

  reporting:
    formats: [junit, json, html]
    include_timing: true
    include_logs: true

  environments:
    - name: node-18
      image: node:18-alpine
    - name: node-20
      image: node:20-alpine
```

## CI/CD Integration

```yaml
# GitHub Actions example
test:
  runs-on: ubuntu-latest
  strategy:
    matrix:
      shard: [1, 2, 3, 4]
  steps:
    - uses: actions/checkout@v4
    - name: Run tests
      run: |
        aqe test run \
          --shard ${{ matrix.shard }}/4 \
          --parallel \
          --report junit
    - name: Upload results
      uses: actions/upload-artifact@v4
      with:
        name: test-results-${{ matrix.shard }}
        path: reports/
```

## Result Aggregation

```typescript
interface ExecutionResults {
  summary: {
    total: number;
    passed: number;
    failed: number;
    skipped: number;
    flaky: number;
    duration: number;
  };
  shards: ShardResult[];
  failures: TestFailure[];
  flakyTests: FlakyTest[];
  coverage: CoverageReport;
  timing: TimingAnalysis;
}
```

## Gotchas

- Full test suites may OOM in containers — the rule "don't run full suite" was violated 20x despite being in CLAUDE.md. Fix: make suite lightweight, don't just add more rules
- Fewer focused agents (3-4) outperform many vague ones (6-8) — always include verification command in each agent prompt
- New model releases can shift agent behavior mid-sprint — rules followed yesterday may be ignored today after model update
- Running all tests in parallel can mask flaky tests — use `--workers=1` for initial diagnosis
- Session crashes lose all context — save intermediate results to disk, not just memory

## Coordination

**Primary Agents**: qe-test-executor, qe-test-selector, qe-flaky-detector
**Coordinator**: qe-test-execution-coordinator
**Related Skills**: qe-test-generation, qe-coverage-analysis

© proffesor-for-testing · MIT · proffesor-for-testing/agentic-qe

Similar skills

All skills for Testing and QA →

From the same set73

The whole set →
qe-chaos-resilience qe-chaos-resilience — a skill for Claude Code, Codex, Cursor and other agents that injects controlled faults into distributed systems and checks recovery behavior. Runs during circuit breaker, failover, and retry logic validation. CX Codex +1 123installs consultancy-practices consultancy-practices is a Claude Code skill that applies software quality consulting practices: it identifies client pain, prioritizes work by impact and effort, and transfers knowledge. CX Codex +1 122installs mutation-testing Skill runs mutation testing: mutates code (operators, boundaries, logic), runs tests, and counts surviving mutants — weak spots in your test suite. CX Codex +1 122installs qe-code-intelligence qe-code-intelligence builds a semantic code index, dependency graphs and knowledge graphs. Helps understand unfamiliar codebases, trace call chains, and find code by meaning rather than keywords. CX Codex +1 122installs qe-learning-optimization qe-learning-optimization optimizes QE agents through transfer learning across test frameworks, Bayesian hyperparameter tuning, and A/B experiments. CX Codex +1 121installs qe-security-compliance qe-security-compliance runs code security audits, dependency vulnerability scans, secret detection, and compliance checks for OWASP and SOC2. CX Codex +1 120installs testability-scoring testability-scoring scores web application testability against 10 principles and produces a report. Use it to check test readiness and find areas that make testing harder. CX Codex +1 119installs test-data-management The test-data-management skill creates test datasets, anonymizes PII, and keeps test records isolated. Use it for unit, integration, performance, and boundary testing. CX Codex +1 118installs

Project sponsors

Companies that keep this analytics open