Skip to main content
skill CX Codex

holistic-testing-pact — Claude Code skill: setup and guide

holistic-testing-pact builds testing strategies around PACTS principles and holistic quadrants. It structures quality planning for classical, AI-assisted, and autonomous agent setups.

MIT 111 installs ★ 533 updated 2026-11-04

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

What holistic-testing-pact does

The skill applies the Holistic Testing Model combined with PACTS principles: Proactive, Autonomous, Collaborative, Targeted, and Structured. It divides test suites into four distinct quadrants, keeping developer-facing fast feedback loops separate from business acceptance testing. Specific tasks get routed to dedicated agents from the repository, including qe-test-architect and qe-requirements-validator.

The Structured principle reflects DORA research on AI delivery mechanisms. When autonomous agents handle quality engineering, the framework demands auditable decision traces and explicit guardrails. Running autonomous agents without established boundaries is treated as an anti-pattern, because adding agents to chaotic workflows merely automates the chaos.

What it helps with

  • map test suites across technical and business quadrants
  • run proactive risk analysis during refinement
  • audit autonomous agent decisions through confidence scores and traces
  • prune valueless checks to focus on high-risk workflows

Example prompts for the agent

  • Design a PACTS testing strategy for the checkout service
  • Run risk analysis on user story requirements using qe-requirements-validator
  • Establish governance guardrails and decision traces for test agents

How to install holistic-testing-pact

1Skills CLI (Vercel)

npx skills add proffesor-for-testing/agentic-qe --skill holistic-testing-pact -a claude-code

2Manually: put the files in place

~/.claude/skills/holistic-testing-pact/SKILL.md

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

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

Questions about holistic-testing-pact

How to install holistic-testing-pact in Claude Code?

Run npx skills add proffesor-for-testing/agentic-qe --skill holistic-testing-pact -a claude-code in your terminal. This writes the skill to ~/.claude/skills/holistic-testing-pact/SKILL.md.

What does holistic-testing-pact do?

It establishes a structured test strategy across holistic quadrants and PACTS principles. It coordinates testing tasks among agents like qe-fleet-commander and qe-test-architect.

Why does PACTS add the Structured principle?

Structured was introduced based on DORA research for agentic systems. It requires observability and guardrails so teams rely on verifiable confidence rather than unmeasured trust.

Source text

SKILL.md · MIT
---
name: holistic-testing-pact
description: "Apply the Holistic Testing Model evolved with PACTS (Proactive, Autonomous, Collaborative, Targeted, Structured) principles. Use when designing comprehensive test strategies for Classical, AI-assisted, Agent based, or Agentic Systems building quality into the team, or implementing whole-team quality practices."
category: testing-methodologies
priority: critical
tokenEstimate: 1100
agents: [qe-fleet-commander, qe-test-architect, qe-quality-gate, qe-requirements-validator]
implementation_status: optimized
optimization_version: 1.0
last_optimized: 2025-12-02
dependencies: []
quick_reference_card: true
tags: [holistic, pacts, quality, whole-team, proactive, autonomous, collaborative, targeted, structured]
trust_tier: 0
validation:
---

# Holistic Testing Model with PACTS Principles

<default_to_action>
When designing test strategies or building quality into teams:
1. APPLY PACTS principles: Proactive (test before bugs), Autonomous (teams own quality), Collaborative (whole-team responsibility), Targeted (risk-focused), Structured (governance, observability, and explainability of agent behavior)
2. IDENTIFY quadrant focus: Technology-facing (unit, integration, performance) or Business-facing (acceptance, exploratory, usability)
3. SELECT agents based on PACTS dimension and testing quadrant
4. IMPLEMENT feedback loops that catch issues in minutes, not days
5. MEASURE outcomes (bug escape rate, release confidence, agent confidence) not activities (test count)

**Quick PACTS Application:**
- Proactive → Design testability into architecture, risk analysis during refinement
- Autonomous → Devs run tests locally, CI gates automated wherever risk and regulation allow
- Collaborative → Three Amigos, QE pairs with dev, shared test ownership
- Targeted → Risk-based planning, focus on critical flows, kill valueless tests
- Structured → Governance, observability, and explainability of agent behavior; measure confidence, not trust

**Critical Success Factors:**
- Quality is a whole-team responsibility, not a QA phase
- QA as enablers (build infrastructure, coach), not gatekeepers
- Fast feedback during development, not after
</default_to_action>

## Quick Reference Card

### When to Use
- Designing comprehensive test strategies
- Building quality culture in teams
- Choosing testing approach for new projects
- Evolving from sequential QA to concurrent quality

### PACTS Principles
| Principle | Focus | Anti-Pattern |
|-----------|-------|--------------|
| **Proactive** | Test before code, design testability | Waiting for bugs to find you |
| **Autonomous** | Teams deploy when ready | QA as manual gatekeepers |
| **Collaborative** | Whole-team quality thinking | QA works in isolation |
| **Targeted** | Risk-based, high-value tests | Exhaustive checkbox testing |
| **Structured** | Governance, observability, explainability of agent behavior | Bolting agentic AI onto chaos |

### Holistic Testing Quadrants
| Quadrant | Purpose | Examples |
|----------|---------|----------|
| Tech + Support | Fast feedback | Unit, component, integration tests |
| Tech + Critique | Find limits | Performance, security, chaos |
| Business + Support | Shared understanding | BDD, acceptance tests |
| Business + Critique | Discover unknowns | Exploratory, usability, A/B |

### Agent Selection by PACTS + Quadrant
| PACTS Dimension | Agents |
|----------------|--------|
| Proactive + Tech | qe-test-architect, qe-requirements-validator |
| Autonomous + Tech | qe-parallel-executor, qe-coverage-specialist |
| Collaborative | qe-fleet-commander (orchestration) |
| Targeted | qe-regression-analyzer, qe-quality-gate |
| Structured | qe-fleet-commander, qe-quality-gate (governance, observability, explainability) |

---

## PACTS in Practice

### Proactive: Test Before Bugs
```javascript
// During API design, ask: "How will we know if this times out under load?"
// Build observability from start
await Task("Risk Analysis", {
  phase: 'refinement',
  question: 'What could go wrong and how will we know?'
}, "qe-requirements-validator");
```

### Autonomous: Teams Own Quality
- Developers run full test suite locally
- CI fails fast with clear diagnostics
- Deployment approvals automated where the risk allows; where regulation or risk requires a human sign-off, make it fast and evidence-based rather than a queue
- Self-service test environments

### Collaborative: Whole-Team Thinking
- QE attends planning and refinement
- Three Amigos for every user story
- Shared ownership of test code
- Ensemble testing for complex scenarios

### Targeted: Test What Matters
```javascript
// E-commerce checkout? Test thoroughly.
// Admin panel used twice a month? Lighter touch.
await Task("Risk-Based Planning", {
  critical: ['checkout', 'payment'],
  light: ['admin-panel', 'settings']
}, "qe-regression-analyzer");
```

### Structured: Governance, Observability, Explainability
The 5th principle for agentic systems. As agents take on quality work, you need
governance (boundaries and guardrails), observability (what agents did and why),
and explainability (decisions you can audit). Especially important in regulated
industries.

- We measure **CONFIDENCE, not trust** — trust is a human feeling; confidence can
  be mathematically explained.
- Ships with a playbook + readiness-assessment guide.
- Anti-pattern: bolting agentic AI onto chaos. Structure first, then automate.

```javascript
// Make agent behavior auditable and explainable, not a black box
await Task("Agent Governance Review", {
  guardrails: ['scope-boundaries', 'approval-gates'],
  observability: ['decision-traces', 'confidence-scores'],
  explainability: 'every-decision-auditable'
}, "qe-fleet-commander");
```

---

## From PACT to PACTS

PACT originated with Reuven Cohen (Agentics Foundation) and was adapted to quality
engineering by Dragan Spiridonov. PACTS adds a fifth principle — **Structured** —
inspired by DORA's research on AI-assisted delivery and platform-engineering
quality measurement. The addition reflects that autonomous, agentic quality work
needs governance, observability, and explainability to earn confidence at scale.

---

## Evolution from Traditional

| Old Way (Sequential) | Holistic + PACTS (Concurrent) |
|---------------------|------------------------------|
| Dev writes → QA tests → bugs found → fixes | Team discusses what to build and how to test |
| Slow feedback, finger-pointing | Fast feedback, shared ownership |
| Quality as gatekeeping | Quality as enabler |
| QA on critical path | QA builds infrastructure, coaches |

---

## Success Signals

- Deployments happen as often as the business and its risk profile need, without fear (a medical device and a consumer web app have different right answers)
- Bug escape rate trending down
- Team discusses quality naturally
- Developers write tests without being told
- Releases are boring (in a good way)

---

## Agent Coordination Hints

### Memory Namespace
```
aqe/holistic-testing/
├── pacts-assessment/*    - PACTS maturity analysis
├── quadrant-coverage/*   - Coverage per quadrant
├── team-metrics/*        - Quality ownership metrics
└── feedback-loops/*      - Cycle time data
```

### Fleet Coordination
```typescript
const holisticFleet = await FleetManager.coordinate({
  strategy: 'holistic-testing',
  pacts: { proactive: true, autonomous: true, collaborative: true, targeted: true, structured: true },
  agents: [
    'qe-fleet-commander',       // Orchestration
    'qe-test-architect',        // Tech quadrant
    'qe-requirements-validator', // Business quadrant
    'qe-quality-gate'           // Quality decisions
  ],
  topology: 'mesh'
});
```

---

## Related Skills
- [agentic-quality-engineering](../agentic-quality-engineering/) - Agent coordination
- [context-driven-testing](../context-driven-testing/) - Adapt to context
- [shift-left-testing](../shift-left-testing/) - Proactive testing
- [risk-based-testing](../risk-based-testing/) - Targeted testing

---

## Remember

**PACTS = Proactive + Autonomous + Collaborative + Targeted + Structured**

Quality is built in, not tested in. Teams own quality. QA enables, doesn't gate. Test what matters, skip what doesn't. Govern agent behavior with observability and explainability — measure confidence, not trust. Measure outcomes, not activities.

**With Agents:** Agents analyze PACTS maturity, recommend quadrant coverage, and coordinate whole-team quality. Use agents to scale holistic thinking while maintaining human judgment.

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

Similar skills

All skills for Testing and QA →

From the same set73

The whole set →
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 security-visual-testing security-visual-testing validates URLs, masks sensitive data on screenshots, and runs multi-viewport visual regression tests with WCAG accessibility audits. CX Codex +1 115installs enterprise-integration-testing Enterprise integration testing skill for SAP, middleware, and WMS setups. It coordinates cross-system checks across RFC, IDoc, OData, and ESB flows. CX Codex +1 113installs observability-testing-patterns observability-testing-patterns is a Claude Code skill with patterns for checking dashboards, alert thresholds, log aggregation, and APM tracing during monitoring tests. CX Codex +1 109installs sfdipot-product-factors The sfdipot-product-factors skill turns requirements into ranked test ideas using seven SFDIPOT dimensions. Use it to assess epics, user stories, or a test strategy. CX Codex +1 108installs qcsd-ideation-swarm qcsd-ideation-swarm runs Quality Criteria sessions during PI or sprint planning using HTSM v6.3 and Risk Storming. Delivers a GO, CONDITIONAL, or NO-GO verdict before development begins. CX Codex +1 107installs middleware-testing-patterns The middleware-testing-patterns skill helps design checks for message routing, transformations, DLQs, and error handling in ESBs and brokers. Use it when testing integration flows. CX Codex +1 107installs

Project sponsors

Companies that keep this analytics open