Skip to main content
skill CX Codex

shift-left-testing · proffesor-for-testing — Claude Code skill: testing and installation

The shift-left-testing skill moves checks earlier in development: validate requirements, write tests before implementation, and run them in CI. Use it when introducing TDD or other early quality practices.

MIT 117 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 shift-left-testing -a claude-code
Open on GitHub

What shift-left-testing does

The skill lays out a workflow that checks whether requirements are testable before coding, puts tests ahead of implementation, and automates checks in CI. Its four levels cover unit tests in pull requests, TDD, BDD scenarios during refinement, and risk analysis during design.

It can coordinate agents for requirement checks, unit, integration, and end-to-end test generation, plus regression selection based on changed files. The CI example runs npm run test:unit and npm run test:integration, then checks coverage. Generating tests before understanding the requirements can encode the wrong behavior.

The skill is listed for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode. On Claude Code, install it with npx skills; its file is at ~/.claude/skills/shift-left-testing/SKILL.md.

What it helps with

  • check requirements for ambiguity before coding
  • write tests before implementing a feature
  • run unit and integration tests in CI
  • select regression tests from changed files
  • add a coverage check to a CI pipeline

Example prompts for the agent

  • Check these requirements for testability and ambiguity before coding.
  • Generate unit, integration, and end-to-end tests from these requirements.
  • Choose regression tests for the files changed in this pull request.

How to install shift-left-testing

1Skills CLI (Vercel)

npx skills add proffesor-for-testing/agentic-qe --skill shift-left-testing -a claude-code

2Manually: put the files in place

~/.claude/skills/shift-left-testing/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/shift-left-testing/

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

Questions about shift-left-testing

How do I install shift-left-testing in Claude Code?

Run npx skills add proffesor-for-testing/agentic-qe --skill shift-left-testing -a claude-code. The skill file is at ~/.claude/skills/shift-left-testing/SKILL.md.

What does shift-left-testing do?

It guides requirement checks before coding, test creation before implementation, and automated checks in CI. It also describes selecting regression tests based on changed files.

Which agents does shift-left-testing use?

It names qe-requirements-validator for requirement checks, qe-test-generator for test creation, and qe-regression-risk-analyzer for regression analysis.

Source text

SKILL.md · MIT
---
name: shift-left-testing
description: "Move testing activities earlier in the development lifecycle to catch defects when they're cheapest to fix. Use when implementing TDD, CI/CD, or early quality practices."
category: testing-methodologies
priority: high
tokenEstimate: 900
agents: [qe-test-generator, qe-requirements-validator, qe-regression-risk-analyzer]
implementation_status: optimized
optimization_version: 1.0
last_optimized: 2025-12-02
dependencies: []
quick_reference_card: true
tags: [shift-left, early-testing, tdd, bdd, ci-cd, prevention]
trust_tier: 3
validation:
  schema_path: schemas/output.json
  validator_path: scripts/validate-config.json
  eval_path: evals/shift-left-testing.yaml
---

# Shift-Left Testing

<default_to_action>
When implementing early testing practices:
1. VALIDATE requirements before coding (testability, BDD scenarios)
2. WRITE tests before implementation (TDD)
3. AUTOMATE in CI pipeline (every commit triggers tests)
4. FIX defects immediately - never let them accumulate

**Quick Shift-Left Levels:**
- Level 1: Unit tests with each PR (developer responsibility)
- Level 2: TDD practice (tests before code)
- Level 3: BDD/Example mapping in refinement (requirements testing)
- Level 4: Risk analysis in design (architecture testing)
</default_to_action>

## Quick Reference Card

### When to Use
- Reducing cost of defects
- Implementing CI/CD pipelines
- Starting TDD practice
- Improving requirements quality

### Shift-Left Levels
| Level | Practice | When |
|-------|----------|------|
| 1 | Unit tests in PR | Before merge |
| 2 | TDD | Before implementation |
| 3 | BDD/Example Mapping | During refinement |
| 4 | Risk Analysis | During design |

---

## Level 1: Tests in Every PR

```yaml
# CI pipeline - tests run on every commit
name: CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm run test:unit
      - run: npm run test:integration
      - run: npm run lint

  quality-gate:
    needs: test
    steps:
      - name: Coverage Check
        run: npx coverage-check --min 80
      - name: No New Warnings
        run: npm run lint -- --max-warnings 0
```

---

## Agent-Assisted Shift-Left

```typescript
// Validate requirements testability
await Task("Requirements Validation", {
  requirements: userStories,
  check: ['INVEST-criteria', 'testability', 'ambiguity'],
  generateBDD: true
}, "qe-requirements-validator");

// Generate tests from requirements
await Task("Generate Tests", {
  source: 'requirements',
  types: ['unit', 'integration', 'e2e'],
  coverage: 'comprehensive'
}, "qe-test-generator");

// Smart test selection for changes
await Task("Select Regression Tests", {
  changedFiles: prFiles,
  algorithm: 'risk-based',
  targetReduction: 0.7  // 70% time savings
}, "qe-regression-risk-analyzer");
```

---

## Agent Coordination Hints

### Memory Namespace
```
aqe/shift-left/
├── requirements/*       - Validated requirements
├── generated-tests/*    - Auto-generated tests
├── coverage-targets/*   - Coverage goals by component
└── pipeline-results/*   - CI/CD test history
```

### Fleet Coordination
```typescript
const shiftLeftFleet = await FleetManager.coordinate({
  strategy: 'shift-left',
  agents: [
    'qe-requirements-validator',     // Level 3-4
    'qe-test-generator',             // Level 2
    'qe-regression-risk-analyzer'    // Smart selection
  ],
  topology: 'sequential'
});
```

---

## Related Skills
- [tdd-london-chicago](../tdd-london-chicago/) - TDD practices
- [holistic-testing-pact](../holistic-testing-pact/) - Proactive testing
- [cicd-pipeline-qe-orchestrator](../cicd-pipeline-qe-orchestrator/) - Pipeline integration
- [shift-right-testing](../shift-right-testing/) - Production feedback

---

## Remember

**With Agents:** Agents validate requirements testability, generate tests from specs, and select optimal regression suites. Use agents to implement shift-left practices consistently.

## Skill Composition

- **TDD practice** → Use `/tdd-london-chicago` for specific TDD guidance
- **Generate tests** → Use `/qe-test-generation` for AI-powered test generation
- **CI/CD quality** → Use `/cicd-pipeline-qe-orchestrator` for pipeline setup

## Gotchas

- "Shift left" doesn't mean "only test left" — production monitoring (shift right) is still needed
- Agent generates tests before understanding requirements — tests for wrong behavior are worse than no tests
- CI pipeline tests that take >10 minutes kill the feedback loop — keep commit-stage tests under 5 minutes
- TDD discipline degrades when agent writes test+code simultaneously — enforce Red phase separation
- Shifting left without lightweight environments just shifts the bottleneck — fix environments first

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

Similar skills

All skills for Testing and QA →

shift-left-testing by other authors comes first.

shift-left-testing kindlmann shift-left-testing brings quality validation into refinement, design, and code review. It helps engineering teams run Three Amigos sessions, adopt TDD, and enforce testability before code hits staging. CX Codex +1 1,300installs testing-expert PCL Team testing-expert — a skill that gives the agent rules for writing tests: AAA structure, isolated cases, doubles and edge cases. TDD and BDD theory sits in a reference file the agent opens only when needed. CX Codex +1 206installs bats-testing-patterns Ryan Snodgrass The bats-testing-patterns skill helps write and run shell-script tests with Bats. Use it for TDD, CI/CD checks, and error-case coverage across bash, sh, and dash. CX Codex +1 11,000installs godot-testing-patterns thedivergentai godot-testing-patterns provides testing decision trees and GdUnit4 templates for Godot. Guides developers through unit tests, headless CI runs, frame stepping, and network mocks. CX Codex +1 680installs Pytest Testing pluginagentmarketplace Pytest Testing — a skill for writing pytest tests: fixtures, mocks, coverage and CI runs. Useful when a Python project's tests need structure. CX Codex +1 555installs methodology-advisor FlorianBruniaux The methodology-advisor command for Claude Code and Codex reads the codebase and asks three questions to recommend an AI-development methodology stack. Run it at the start of a project, before choosing a workflow. CX Codex +1 ★ 6,529repo stars behavior-driven-development FradSer behavior-driven-development — a BDD skill for feature work, bug fixes, and executable tests. It turns behavior examples into failing tests before implementation. CX Codex +1 151installs

From the same set73

The whole set →
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 iterative-loop iterative-loop runs continuous build-test-fix loops until pass criteria are met. Useful for test-driven feature development, bug fixing, and metric optimization. CX Codex +1 118installs test-environment-management test-environment-management is a Claude Code skill for setting up test infrastructure and matching it to production. It covers environment setup, parity checks, and test infrastructure costs. CX Codex +1 117installs debug-loop debug-loop — a skill for step-by-step debugging of errors through real commands, not simulations. Forms hypotheses, validates them against live data, identifies root cause, and only then fixes the code. CX Codex +1 117installs shift-right-testing shift-right-testing guides agents through production testing using feature flags, canary rollouts, and chaos experiments. Useful when setting up progressive delivery or tracking SLOs. CX Codex +1 115installs qe-contract-testing qe-contract-testing — a skill for verifying REST, GraphQL, and event-driven API contracts with schema validation. Detects incompatible changes and ensures APIs won't break downstream clients. CX Codex +1 115installs

Project sponsors

Companies that keep this analytics open