agentic-qe 2.0.0 → 2.1.1

package/.claude/skills/agentic-quality-engineering/SKILL.md

@@ -1,598 +1,245 @@
 ---
 name: agentic-quality-engineering
-description: Using AI agents as force multipliers in quality work. Use when designing autonomous testing systems, implementing PACT principles, or scaling quality engineering with intelligent agents. Core skill for all QE agents in the fleet.
+description: "AI agents as force multipliers for quality work. Core skill for all 18 QE agents using PACT principles."
+category: qe-core
+priority: critical
+tokenEstimate: 1400
+agents: [qe-test-generator, qe-test-executor, qe-coverage-analyzer, qe-quality-gate, qe-quality-analyzer, qe-performance-tester, qe-security-scanner, qe-requirements-validator, qe-production-intelligence, qe-fleet-commander, qe-deployment-readiness, qe-regression-risk-analyzer, qe-test-data-architect, qe-api-contract-validator, qe-flaky-test-hunter, qe-visual-tester, qe-chaos-engineer, qe-code-complexity]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-02
+dependencies: []
+quick_reference_card: true
+tags: [pact, agents, fleet, coordination, autonomous, foundational]
 ---
 
 # Agentic Quality Engineering
 
-## Overview
-
-Agentic Quality Engineering transforms traditional QE by deploying AI agents as force multipliers - amplifying human judgment through intelligent automation, adaptive testing, and autonomous quality analysis.
-
-**This is the foundational skill for all 17 QE Fleet agents.**
-
----
-
-## What Is Agentic Quality Engineering?
-
-### The Evolution of Quality Engineering
-
-**Traditional QE:** Human does everything manually
-- Manual test execution
-- Manual log analysis
-- Manual risk assessment
-- Human bottleneck at every stage
-
-**Automation QE:** Scripts handle repetitive tasks
-- Automated regression tests
-- Scripted checks
-- Fixed test scenarios
-- Still requires human orchestration
-
-**Agentic QE:** AI agents collaborate with humans
-- Agents analyze code changes and generate tests
-- Agents detect patterns and anomalies autonomously
-- Agents adapt strategies based on feedback
-- Humans focus on context, risk, and judgment
-
-### Core Premise
-
-**Agents amplify human expertise, not replace it.**
-
-The goal: More effective quality engineers who can:
-- Scale across 10x more code
-- Find patterns hidden in data volumes
-- Adapt testing strategy in real-time
-- Focus on high-value activities (exploratory testing, risk analysis, architecture review)
+<default_to_action>
+When implementing agentic QE or coordinating agents:
+1. SPAWN appropriate agent(s) for the task using `Task` tool with agent type
+2. CONFIGURE agent coordination (hierarchical/mesh/sequential)
+3. EXECUTE with PACT principles: Proactive analysis, Autonomous operation, Collaborative feedback, Targeted risk focus
+4. VALIDATE results through quality gates before deployment
+5. LEARN from outcomes - store patterns in `aqe/learning/*` namespace
+
+**Quick Agent Selection:**
+- Test generation needed → `qe-test-generator`
+- Coverage gaps → `qe-coverage-analyzer`
+- Quality decision → `qe-quality-gate`
+- Security scan → `qe-security-scanner`
+- Performance test → `qe-performance-tester`
+- Full pipeline → `qe-fleet-commander`
+
+**Critical Success Factors:**
+- Agents amplify human expertise, not replace it
+- Human-in-the-loop for critical decisions
+- Measure: bugs caught, time saved, coverage improved
+</default_to_action>
+
+## Quick Reference Card
+
+### When to Use
+- Designing autonomous testing systems
+- Scaling QE with intelligent agents
+- Implementing multi-agent coordination
+- Building CI/CD quality pipelines
+
+### PACT Principles
+| Principle | Agent Behavior | Human Role |
+|-----------|---------------|------------|
+| **P**roactive | Analyze pre-merge, predict risk | Set guardrails |
+| **A**utonomous | Execute tests, fix flaky tests | Review critical |
+| **C**ollaborative | Multi-agent coordination | Provide context |
+| **T**argeted | Risk-based prioritization | Define risk areas |
+
+### 18-Agent Fleet
+| Category | Agents | Primary Use |
+|----------|--------|-------------|
+| Core Testing (5) | test-generator, test-executor, coverage-analyzer, quality-gate, quality-analyzer | Daily testing |
+| Performance/Security (2) | performance-tester, security-scanner | Non-functional |
+| Strategic (3) | requirements-validator, production-intelligence, fleet-commander | Planning |
+| Advanced (4) | regression-risk-analyzer, test-data-architect, api-contract-validator, flaky-test-hunter | Specialized |
+| Visual/Chaos (2) | visual-tester, chaos-engineer | Edge cases |
+| Deployment (1) | deployment-readiness | Release |
+| Analysis (1) | code-complexity | Maintainability |
+
+### Coordination Patterns
+```
+Hierarchical: fleet-commander → [generators] → [executors] → quality-gate
+Mesh: test-gen ↔ coverage ↔ quality (peer decisions)
+Sequential: risk-analyzer → test-gen → executor → coverage → gate
+```
+
+### Success Criteria
+✅ 10x deployment frequency with same/better quality
+✅ Coverage gaps detected in real-time
+✅ Bugs caught pre-production
+❌ Agents acting without human oversight on critical decisions
+❌ Deploying all 18 agents at once (start with 1-2)
 
 ---
 
-## The Agentic QE Architecture
-
-### Multi-Agent Fleet (17 Specialized Agents)
-
-**Core Testing Agents (5):**
-- `qe-test-generator` - AI-powered test generation with sublinear optimization
-- `qe-test-executor` - Multi-framework parallel test execution
-- `qe-coverage-analyzer` - Real-time gap detection with O(log n) algorithms
-- `qe-quality-gate` - Intelligent quality gate with risk assessment
-- `qe-quality-analyzer` - Comprehensive quality metrics analysis
-
-**Performance & Security (2):**
-- `qe-performance-tester` - Load testing with k6/JMeter/Gatling
-- `qe-security-scanner` - SAST/DAST multi-layer scanning
-
-**Strategic Planning (3):**
-- `qe-requirements-validator` - INVEST criteria + BDD generation
-- `qe-production-intelligence` - Production data to test scenarios
-- `qe-fleet-commander` - Hierarchical fleet coordination (50+ agents)
+## Core Concepts
 
-**Deployment (1):**
-- `qe-deployment-readiness` - Multi-factor risk assessment
+### QE Evolution
+| Stage | Approach | Limitation |
+|-------|----------|------------|
+| Traditional | Manual everything | Human bottleneck |
+| Automation | Scripts + fixed scenarios | Needs orchestration |
+| **Agentic** | AI agents + human judgment | Requires trust-building |
 
-**Advanced Testing (4):**
-- `qe-regression-risk-analyzer` - ML-driven test selection
-- `qe-test-data-architect` - High-speed realistic data (10k+ records/sec)
-- `qe-api-contract-validator` - Breaking change detection
-- `qe-flaky-test-hunter` - Statistical flakiness detection + auto-fix
+**Core Premise:** Agents amplify human expertise for 10x scale.
 
-**Specialized (2):**
-- `qe-visual-tester` - Visual regression with AI comparison
-- `qe-chaos-engineer` - Controlled fault injection
+### Key Capabilities
 
-### Agent Coordination Patterns
-
-**Hierarchical:**
-```
-qe-fleet-commander
-├── qe-test-generator → qe-test-executor → qe-coverage-analyzer
-├── qe-security-scanner + qe-performance-tester (parallel)
-└── qe-quality-gate (final validation)
-```
-
-**Mesh (Peer-to-Peer):**
-```
-qe-test-generator ↔ qe-coverage-analyzer ↔ qe-quality-analyzer
-           ↕                     ↕                    ↕
-qe-requirements-validator ↔ qe-test-executor ↔ qe-quality-gate
-```
-
-**Sequential (Pipeline):**
-```
-Code Change → qe-regression-risk-analyzer → qe-test-generator →
-qe-test-executor → qe-coverage-analyzer → qe-quality-gate → Deploy
-```
-
----
-
-## Key Capabilities
-
-### 1. Intelligent Test Generation
-
-**What agents do:**
-- Analyze code changes (git diff)
-- Identify changed functions and dependencies
-- Generate relevant test scenarios
-- Prioritize based on risk and coverage gaps
-
-**Example:**
+**1. Intelligent Test Generation**
 ```typescript
-// Agent detects new payment method
-async function processStripePayment(amount: number, token: string) {
-  // New code
-}
-
-// Agent generates:
-// ✓ Happy path test
-// ✓ Invalid token test
-// ✓ Zero/negative amount test
-// ✓ Network timeout test
-// ✓ Idempotency test
-```
-
-**Human role:** Review generated tests, add domain-specific edge cases, validate test quality
-
-### 2. Pattern Detection in Logs
-
-**What agents do:**
-- Scan thousands of log lines in seconds
-- Identify anomaly patterns
-- Correlate errors across services
-- Detect performance degradation trends
-
-**Example:**
-```
-Agent finds pattern:
-2025-10-20T10:15:32 [ERROR] Payment timeout (customer_123)
-2025-10-20T10:16:01 [ERROR] Payment timeout (customer_456)
-2025-10-20T10:16:18 [ERROR] Payment timeout (customer_789)
-
-Agent analysis:
-→ 15 payment timeouts in 5 minutes
-→ All timeouts to Stripe gateway
-→ Started after deploy at 10:14:00
-→ Recommendation: Rollback deployment
+// Agent analyzes code change, generates targeted tests
+const tests = await qeTestGenerator.generate(prDiff);
+// → Happy path, edge cases, error handling tests
 ```
 
-**Human role:** Validate analysis, make rollback decision, fix root cause
+**2. Pattern Detection** - Scan logs, find anomalies, correlate errors
 
-### 3. Adaptive Test Strategy
+**3. Adaptive Strategy** - Adjust test focus based on risk signals
 
-**What agents do:**
-- Monitor test results and production incidents
-- Adjust test focus based on risk signals
-- Re-prioritize test execution
-- Recommend new test coverage
+**4. Root Cause Analysis** - Link failures to code changes, suggest fixes
 
-**Example:**
-```
-Agent detects:
-- 5 production incidents in checkout (last 7 days)
-- Current test coverage: 60%
-- Flaky test rate: 8%
-
-Agent adapts:
-→ Increase checkout test coverage to 90%
-→ Add chaos testing for payment gateway
-→ Fix/quarantine flaky tests
-→ Run checkout tests on every commit
-```
-
-**Human role:** Approve strategy changes, validate risk assessment, set guardrails
-
-### 4. Root Cause Analysis
+---
 
-**What agents do:**
-- Correlate test failures across test suites
-- Link failures to code changes
-- Identify affected components
-- Suggest likely root causes
+## Agent Coordination
 
-**Example:**
+### Memory Namespaces
 ```
-Test failure: "API returns 500 on POST /orders"
-
-Agent analysis:
-→ 12 tests failing (all order-related)
-→ Started after commit abc123
-→ Changed file: order-service.ts
-→ Root cause: Missing null check on line 45
-→ Confidence: 95%
-```
-
-**Human role:** Verify root cause, implement fix, validate solution
-
-### 5. Documentation Generation
-
-**What agents do:**
-- Generate test reports
-- Create API documentation from code
-- Build quality dashboards
-- Write test summaries
-
-**Example:**
-```markdown
-# Sprint 42 Quality Report (Agent-Generated)
-
-## Test Coverage
-- Unit: 85% (↑ 3% from last sprint)
-- Integration: 72% (↑ 5%)
-- E2E: Critical paths at 100%
-
-## Bugs Found
-- Critical: 2 (fixed)
-- High: 5 (4 fixed, 1 in progress)
-- Medium: 12 (triaged)
-
-## Risk Assessment
-🔴 Payment gateway timeout (production incident)
-🟡 Checkout flow performance degrading
-🟢 Authentication stable
+aqe/test-plan/*     - Test planning decisions
+aqe/coverage/*      - Coverage analysis results
+aqe/quality/*       - Quality metrics and gates
+aqe/learning/*      - Patterns and Q-values
+aqe/coordination/*  - Cross-agent state
 ```
 
-**Human role:** Review report, add context, present to stakeholders
-
----
-
-## PACT Principles for Agentic QE
-
-### Proactive
-**Agents act before problems occur:**
-- Analyze code changes pre-merge
-- Predict high-risk areas
-- Generate tests for new code
-- Monitor trends in real-time
-
-**Example:** Agent detects increasing error rate and generates alerts before customer impact
-
-### Autonomous
-**Agents work independently:**
-- Execute tests without human trigger
-- Prioritize test execution
-- Generate test data
-- Fix flaky tests automatically
-
-**Example:** Agent detects flaky test, identifies root cause (timing issue), applies fix, creates PR
-
-### Collaborative
-**Agents work with humans and other agents:**
-- Multi-agent coordination (test-gen → test-exec → coverage)
-- Human-in-the-loop for critical decisions
-- Share insights across team
-- Learn from human feedback
-
-**Example:** Agent generates tests, human reviews and adds domain knowledge, agent learns patterns
-
-### Targeted
-**Agents focus on high-value work:**
-- Risk-based test prioritization
-- Coverage of critical paths
-- Ignore low-risk areas
-- Optimize for impact
-
-**Example:** Agent focuses 80% of testing on payment and auth (high risk) vs 20% on admin panel (low risk)
-
----
-
-## Using with QE Agents
-
-### Agent Assignment by Skill
-
-Each of the 17 QE agents uses this foundational skill plus specialized skills:
+### Blackboard Events
+| Event | Trigger | Subscribers |
+|-------|---------|-------------|
+| `test:generated` | New tests created | executor, coverage |
+| `coverage:gap` | Gap detected | test-generator |
+| `quality:decision` | Gate evaluated | fleet-commander |
+| `security:finding` | Vulnerability found | quality-gate |
 
-**qe-test-generator:**
-- `agentic-quality-engineering` (core)
-- `api-testing-patterns`
-- `tdd-london-chicago`
-- `test-automation-strategy`
-
-**qe-coverage-analyzer:**
-- `agentic-quality-engineering` (core)
-- `quality-metrics`
-- `risk-based-testing`
-
-**qe-flaky-test-hunter:**
-- `agentic-quality-engineering` (core)
-- `exploratory-testing-advanced`
-- `risk-based-testing`
-
-**qe-security-scanner:**
-- `agentic-quality-engineering` (core)
-- `security-testing`
-- `risk-based-testing`
-
-*See `.claude/agents/` for complete agent definitions and skill mappings.*
-
-### Agent Coordination Examples
-
-**Example 1: PR Quality Gate**
+### Example: PR Quality Pipeline
 ```typescript
-// 1. qe-regression-risk-analyzer scans PR
-const riskAreas = await agent.analyzeRisk(prDiff);
-
-// 2. qe-test-generator creates targeted tests
-const newTests = await agent.generateTests(riskAreas);
+// 1. Risk analysis
+const risks = await Task("Analyze PR", prDiff, "qe-regression-risk-analyzer");
 
-// 3. qe-test-executor runs test suite
-const results = await agent.executeTests(newTests);
+// 2. Generate tests for risks
+const tests = await Task("Generate tests", risks, "qe-test-generator");
 
-// 4. qe-coverage-analyzer checks gaps
-const gaps = await agent.analyzeCoverage(results);
+// 3. Execute + analyze
+const results = await Task("Run tests", tests, "qe-test-executor");
+const coverage = await Task("Check coverage", results, "qe-coverage-analyzer");
 
-// 5. qe-quality-gate makes decision
-const decision = await agent.evaluateQuality(results, gaps);
-// → PASS: All critical tests passed, coverage > 85%
-```
-
-**Example 2: Production Intelligence Loop**
-```typescript
-// 1. qe-production-intelligence monitors production
-const incidents = await agent.monitorProduction();
-
-// 2. Agent converts incident to test scenario
-const testScenario = await agent.incidentToTest(incidents[0]);
-
-// 3. qe-test-generator implements test
-const test = await agent.generateTest(testScenario);
-
-// 4. qe-test-executor validates fix
-const result = await agent.executeTest(test);
-// → Test now prevents regression
+// 4. Quality decision
+const decision = await Task("Evaluate", {results, coverage}, "qe-quality-gate");
+// → GO/NO-GO with rationale
 ```
 
 ---
 
-## Practical Implementation Guide
+## Implementation Phases
 
-### Phase 1: Experiment (Weeks 1-4)
+| Phase | Duration | Goal | Agent(s) |
+|-------|----------|------|----------|
+| Experiment | Weeks 1-4 | Validate one use case | 1 agent |
+| Integrate | Months 2-3 | CI/CD pipeline | 3-4 agents |
+| Scale | Months 4-6 | Multiple use cases | 8+ agents |
+| Evolve | Ongoing | Continuous learning | Full fleet |
 
-**Goal:** Validate value with one use case
-
-**Pick one agent + one use case:**
-- `qe-test-generator` for PR test generation
-- `qe-coverage-analyzer` for gap detection
-- `qe-quality-gate` for automated quality checks
-
-**Measure:**
-- Tests generated per PR
-- Coverage improvements
-- Bugs caught before production
-- Time saved
-
-**Example:**
+### Phase 1 Example
 ```bash
-# Week 1: Deploy qe-test-generator
+# Week 1: Deploy single agent
 aqe agent spawn qe-test-generator
 
-# Week 2-3: Generate tests for 10 PRs
-# Track: How many bugs found, test quality, human review time
+# Weeks 2-3: Generate tests for 10 PRs
+# Track: bugs found, test quality, review time
 
 # Week 4: Measure impact
 aqe agent metrics qe-test-generator
-# Result: 150 tests generated, 12 bugs found, 8 hours saved
-```
-
-### Phase 2: Integrate (Months 2-3)
-
-**Goal:** Build into CI/CD pipeline
-
-**Add agents to workflow:**
-```yaml
-# .github/workflows/quality-gate.yml
-name: Agentic Quality Gate
-
-on: [pull_request]
-
-jobs:
-  quality-check:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Analyze Risk
-        run: aqe agent run qe-regression-risk-analyzer
-
-      - name: Generate Tests
-        run: aqe agent run qe-test-generator
-
-      - name: Execute Tests
-        run: aqe agent run qe-test-executor
-
-      - name: Check Coverage
-        run: aqe agent run qe-coverage-analyzer
-
-      - name: Quality Gate
-        run: aqe agent run qe-quality-gate
-```
-
-**Create feedback loops:**
-- Agents learn from which tests find bugs
-- Humans label false positives
-- System adapts over time
-
-### Phase 3: Scale (Months 4-6)
-
-**Goal:** Expand to multiple use cases
-
-**Add more agents:**
-- Performance testing (`qe-performance-tester`)
-- Security scanning (`qe-security-scanner`)
-- Flaky test detection (`qe-flaky-test-hunter`)
-
-**Coordinate agents:**
-```typescript
-// Fleet coordination
-const fleet = await FleetManager.init({
-  topology: 'hierarchical',
-  agents: [
-    'qe-fleet-commander',
-    'qe-test-generator',
-    'qe-test-executor',
-    'qe-coverage-analyzer',
-    'qe-security-scanner',
-    'qe-quality-gate'
-  ]
-});
-
-// Commander orchestrates all agents
-await fleet.commander.orchestrate(pullRequest);
-```
-
-### Phase 4: Evolve (Ongoing)
-
-**Goal:** Continuous improvement through learning
-
-**Agent learning:**
-- Track success rates
-- Learn from human corrections
-- Adapt to codebase patterns
-- Improve over time
-
-**Metrics:**
-```bash
-aqe learn status --agent test-generator
-# Shows: Learning progress, pattern recognition, success rate
+# → Tests: 150, Bugs: 12, Time saved: 8h
 ```
 
 ---
 
-## Challenges and Limitations
-
-### What Agents Can't Do (Yet)
-
-**Business Context:**
-- Agents don't understand "why" features exist
-- Can't prioritize based on business value without guidance
-- Need humans to explain domain constraints
-
-**Ethical Judgment:**
-- Agents can't make ethical decisions
-- Can't balance competing priorities (speed vs quality)
-- Need human oversight for critical decisions
+## Limitations & Strengths
 
-**Creative Exploration:**
-- Agents follow patterns, humans explore unknown unknowns
-- Humans excel at "what if" scenarios
-- Agents need structured problems
+### Agents Excel At
+- **Volume**: Scan thousands of logs in seconds
+- **Patterns**: Find correlations humans miss
+- **Tireless**: 24/7 testing and monitoring
+- **Speed**: Instant code change analysis
 
-**Domain Expertise:**
-- Agents lack deep domain knowledge (healthcare, finance, legal)
-- Can't replace subject matter experts
-- Need human context for specialized systems
-
-### What Agents Excel At
-
-**Data Volume:**
-- Scan thousands of log lines in seconds
-- Analyze entire codebases
-- Process metrics from hundreds of services
-
-**Pattern Detection:**
-- Find correlations humans would miss
-- Detect subtle anomalies
-- Identify trends over time
-
-**Tireless Repetition:**
-- Run tests 24/7
-- Monitor systems continuously
-- Never get bored or tired
-
-**Rapid Feedback:**
-- Instant analysis of code changes
-- Real-time test generation
-- Immediate coverage feedback
+### Agents Need Humans For
+- Business context and priorities
+- Ethical judgment and trade-offs
+- Creative exploration ("what if" scenarios)
+- Domain expertise (healthcare, finance, legal)
 
 ---
 
 ## Best Practices
 
-### 1. Start Small
-```
-✅ Deploy one agent for one use case
-❌ Deploy all 17 agents at once
-
-✅ Measure impact before scaling
-❌ Assume agents will work perfectly
+| Do | Don't |
+|----|-------|
+| Start with one agent, one use case | Deploy all 18 at once |
+| Build feedback loops early | Deploy and forget |
+| Human reviews agent output | Auto-merge without review |
+| Measure bugs caught, time saved | Track vanity metrics (test count) |
+| Build trust gradually | Give full autonomy immediately |
 
-✅ Build feedback loops early
-❌ Deploy and forget
+### Trust Progression
 ```
-
-### 2. Human-Agent Collaboration
+Month 1: Agent suggests → Human decides
+Month 2: Agent acts → Human reviews after
+Month 3: Agent autonomous on low-risk
+Month 4: Agent handles critical with oversight
 ```
-✅ Agent generates tests → Human reviews → Agent learns
-❌ Agent generates tests → Auto-merge without review
 
-✅ Agent flags risk → Human investigates → Agent refines
-❌ Agent decides to block deployment autonomously
+---
 
-✅ Agent detects anomaly → Human confirms → Agent adapts
-❌ Agent takes action without human validation
-```
+## Agent Coordination Hints
 
-### 3. Measure Value
-```
-Track:
-- Time saved (manual testing → agent testing)
-- Bugs caught (pre-production vs production)
-- Coverage improvement (before vs after)
-- Developer confidence (survey)
-
-Don't track:
-- Number of tests generated (vanity metric)
-- Agent uptime (not meaningful)
-- Lines of code analyzed (doesn't show value)
-```
+```yaml
+coordination:
+  topology: hierarchical
+  commander: qe-fleet-commander
+  memory_namespace: aqe/coordination
+  blackboard_topic: qe-fleet
 
-### 4. Build Trust Gradually
-```
-Month 1: Agent suggests, human decides
-Month 2: Agent acts, human reviews after
-Month 3: Agent acts autonomously on low-risk tasks
-Month 4: Agent handles critical tasks with human oversight
+preload_skills:
+  - agentic-quality-engineering  # Always (this skill)
+  - risk-based-testing           # For prioritization
+  - quality-metrics              # For measurement
+
+agent_assignments:
+  qe-test-generator: [api-testing-patterns, tdd-london-chicago]
+  qe-coverage-analyzer: [quality-metrics, risk-based-testing]
+  qe-security-scanner: [security-testing, risk-based-testing]
+  qe-performance-tester: [performance-testing]
 ```
 
 ---
 
 ## Related Skills
-
-**Core Quality Practices:**
-- [holistic-testing-pact](../holistic-testing-pact/) - PACT principles for agentic systems
-- [context-driven-testing](../context-driven-testing/) - Adapt testing to context
-- [risk-based-testing](../risk-based-testing/) - Focus agents on high-risk areas
-
-**Testing Specializations:**
-- [api-testing-patterns](../api-testing-patterns/) - API testing with agents
-- [performance-testing](../performance-testing/) - Load testing automation
-- [security-testing](../security-testing/) - Security scanning agents
-- [test-automation-strategy](../test-automation-strategy/) - Automation best practices
-
-**Development Practices:**
-- [tdd-london-chicago](../tdd-london-chicago/) - TDD with agent assistance
-- [xp-practices](../xp-practices/) - Pair programming with agents
-
-**Communication:**
-- [technical-writing](../technical-writing/) - Agent-generated documentation
-- [quality-metrics](../quality-metrics/) - Metrics for agent effectiveness
-
----
+- `holistic-testing-pact` - PACT principles deep dive
+- `risk-based-testing` - Prioritize agent focus
+- `quality-metrics` - Measure agent effectiveness
+- `api-testing-patterns`, `security-testing`, `performance-testing` - Specialized testing
 
 ## Resources
-
-**Documentation:**
-- [AQE Fleet Original Requirements](../../../docs/Agentic-QE-Framework.md)
-- [Agent Definitions](../../../.claude/agents/)
-- [CLI Reference](../../../src/cli/)
-
-**Learning:**
-- Start with `qe-test-generator` for immediate value
-- Use `aqe agent --help` for CLI commands
-- Read agent-specific docs in `.claude/agents/`
-
-**Community:**
-- [GitHub Discussions](https://github.com/proffesor-for-testing/agentic-qe-cf/discussions)
-- [Issue Tracker](https://github.com/proffesor-for-testing/agentic-qe-cf/issues)
+- Agent definitions: `.claude/agents/`
+- CLI: `aqe agent --help`
+- Fleet status: `aqe fleet status`
 
 ---
 
-**Remember:** Agentic QE amplifies human expertise, it doesn't replace it. The goal is more effective quality engineers who can scale their impact 10x through intelligent agent collaboration.
-
-**Success Metric:** Can your QE team confidently deploy 10x more frequently with the same or better quality? If yes, agentic QE is working.
+**Success Metric:** Deploy 10x more frequently with same or better quality through intelligent agent collaboration.