agentic-qe 1.0.5 → 1.2.0

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

@@ -0,0 +1,225 @@
+---
+name: holistic-testing-with-pact-principles
+description: Apply the Holistic Testing Model evolved with PACT (Proactive, Autonomous, Collaborative, Targeted) 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.
+version: 1.0.0
+category: quality-engineering
+tags: [pact-principles, holistic-testing, test-strategy, whole-team-quality, agile-testing, quality-culture]
+difficulty: intermediate
+estimated_time: 2-3 hours
+author: user
+---
+
+# Holistic Testing Model with PACT Principles
+
+## Philosophy
+
+Quality is a whole-team responsibility. Testing is an activity, not a phase. The Holistic Testing Model views testing through multiple dimensions, now evolved with PACT principles for the agentic era.
+
+## PACT Principles
+
+### Proactive
+**Stop waiting for bugs to find you.**
+
+- Test before code exists (risk analysis during refinement)
+- Design testability into architecture
+- Identify failure modes during design reviews
+- Create feedback loops that catch issues in minutes, not days
+
+**Example:** During API design, ask: "How will we know if this endpoint times out under load?" Build observability in from the start.
+
+### Autonomous
+**Empower the team to own quality.**
+
+- Developers run tests locally before pushing
+- Automated checks in CI pipeline (no manual gates)
+- Self-service test environments
+- Teams deploy when ready, not when QA says so
+
+**Anti-pattern:** QA as gatekeepers who manually test every change. That's a bottleneck, not quality.
+
+**Better:** QA as enablers who build test infrastructure, coach teams, and explore what automation misses.
+
+### Collaborative
+**Quality work requires whole-team thinking.**
+
+- QE pairs with dev during feature work
+- Product owner clarifies acceptance criteria with QE input
+- Ensemble testing sessions for complex scenarios
+- Shared ownership of test code
+
+**Practical:** Three Amigos meetings aren't theater. They're where you discover the edge cases, clarify assumptions, and design better solutions.
+
+### Targeted
+**Test what matters, skip what doesn't.**
+
+- Risk-based test planning (not exhaustive checkbox testing)
+- Focus on business-critical flows and recent changes
+- Adjust depth based on risk profile
+- Kill tests that don't provide value
+
+**Example:** E-commerce checkout? Test thoroughly. Admin panel used twice a month? Lighter touch.
+
+## The Holistic Testing Dimensions
+
+### 1. Technology-Facing Tests
+
+**Supporting the Team (Building Quality In)**
+- Unit tests (TDD both schools)
+- Component tests
+- Integration tests
+- API contract tests
+
+**Goal:** Fast feedback during development. Developers can refactor fearlessly.
+
+**Critique the Team (Finding Issues)**
+- Performance testing
+- Security testing
+- Load/stress testing
+- Chaos engineering
+
+**Goal:** Validate non-functional requirements. Find limits before customers do.
+
+### 2. Business-Facing Tests
+
+**Supporting the Team (Defining Expected Behavior)**
+- Acceptance tests (BDD/Specification by Example)
+- Prototypes and simulations
+- Example-driven development
+
+**Goal:** Shared understanding of what we're building and why.
+
+**Critique the Product (Discovering What We Don't Know)**
+- Exploratory testing
+- Usability testing
+- User acceptance testing
+- A/B testing in production
+
+**Goal:** Uncover issues automation can't find. Validate actual user value.
+
+## Applying PACT to Each Dimension
+
+### Technology + Proactive
+- Write failing tests before code
+- Design APIs for testability
+- Build observability into architecture
+
+### Technology + Autonomous
+- Developers run full test suite locally
+- CI fails fast with clear diagnostics
+- No manual deployment approvals
+
+### Technology + Collaborative
+- Pair on complex test scenarios
+- Shared test code ownership
+- Mob on test infrastructure
+
+### Technology + Targeted
+- Test pyramid (many unit, some integration, few E2E)
+- Skip tests for deprecated features
+- Focus on changed areas
+
+### Business + Proactive
+- Risk workshops before sprint starts
+- Example mapping in refinement
+- Test ideas in prototypes
+
+### Business + Autonomous  
+- Product owners write acceptance criteria
+- Designers validate UX before dev
+- Teams decide when to release
+
+### Business + Collaborative
+- QE attends planning and refinement
+- Three Amigos for every user story
+- Cross-functional test design
+
+### Business + Targeted
+- Deep exploration of critical paths
+- Quick smoke test of low-risk changes
+- Focus where bugs hurt most
+
+## Implementation Patterns
+
+### Start Small
+Pick one quadrant and one PACT principle. 
+
+Example: "Let's add unit tests (technology-supporting) and have devs run them locally before pushing (autonomous)."
+
+### Measure What Matters
+- Time from code complete to production
+- Bug escape rate to production
+- Mean time to detect/resolve issues
+- Team confidence in releases
+
+**Don't measure:** Test count, code coverage percentage, number of test cases executed. Those are vanity metrics.
+
+### Common Challenges
+
+**"We don't have time for testing."**
+You're already testing - manually, in production, with real users. Shift that effort left.
+
+**"Our code isn't testable."**
+Then you have a design problem, not a testing problem. Refactor for testability.
+
+**"QA is too slow."**
+QA shouldn't be on the critical path. If they are, you're doing it wrong.
+
+**"100% automation is the goal."**
+No. Automation supports testing, it doesn't replace human judgment. Keep exploring.
+
+## Evolution from Traditional Models
+
+### Old Way (Sequential)
+1. Dev writes code
+2. QA tests code
+3. QA finds bugs
+4. Dev fixes bugs
+5. Repeat until "done"
+
+**Problem:** Slow feedback, finger-pointing, quality as gatekeeping.
+
+### Holistic + PACT Way (Concurrent)
+1. Team discusses what to build and how to test it
+2. Write tests that define success
+3. Build with tests running continuously
+4. Deploy with confidence
+5. Monitor and learn
+
+**Benefit:** Fast feedback, shared ownership, quality as enabler.
+
+## Tools Support the Model, Not Define It
+
+The model is tool-agnostic. Whether you use:
+- Jest or JUnit
+- Playwright or Cypress  
+- Postman or REST-assured
+- Cucumber or plain code
+
+...doesn't matter. What matters is applying holistic thinking and PACT principles.
+
+## Questions to Ask
+
+**Proactive:** "What could go wrong, and how will we know?"
+**Autonomous:** "Can the team move forward without waiting for someone else?"
+**Collaborative:** "Who else needs to be part of this conversation?"
+**Targeted:** "What's the highest risk here, and are we testing it?"
+
+## Success Signals
+
+- Features deploy multiple times per day
+- Bug escape rate trending down
+- Team discusses quality naturally, not just in "QA time"
+- Developers write tests without being told
+- Retrospectives focus on system improvements, not blame
+- Releases are boring (in a good way)
+
+## Further Reading
+
+- **Agile Testing** by Lisa Crispin and Janet Gregory (origin of quadrants)
+- **Explore It!** by Elisabeth Hendrickson (exploratory testing)
+- **Growing Object-Oriented Software Guided by Tests** by Freeman & Pryce (TDD collaboration)
+- Your own retrospectives - what actually worked in your context?
+
+## Remember
+
+Context drives decisions. These principles guide thinking, they don't dictate process. Adapt them to your team's reality.