@dzhechkov/keysarium 1.4.0 → 1.5.0

package/templates/.claude/skills/feature-adr/modules/09-fleet-qe.md

@@ -0,0 +1,305 @@
+# Step 9: Fleet QE Assessment (Final Quality Gate)
+
+> Comprehensive quality fleet assessment — the final "did we miss something?" check before declaring the feature complete.
+> Each agent applies methodology from [agentic-qe](https://github.com/proffesor-for-testing/agentic-qe) skills.
+
+## When
+
+L/XL tiers only. For S/M tiers, Step 8 is the final step.
+
+This step implements the recursive quality loop: if gaps are found, the pipeline
+returns to the appropriate earlier step for remediation.
+
+## Model
+
+sonnet (analytical fleet coordination — multiple parallel agents)
+
+## Input
+
+- `{QE_RESULTS}` from Step 8
+- `{REQUIREMENTS}` from Step 1
+- `{ADR_DECISIONS}` from Step 3
+- `{IDEATION_VERDICT}` and `{QUALITY_RISKS}` from Step 3.5
+- `{CODE_CHANGES}` from Step 7
+- All feature artifacts in `features/<slug>/`
+
+## Protocol
+
+### 1. Fleet Assembly
+
+> Load agent protocols:
+> - Agent 1: `references/agentic-qe/qe-requirements-validation.md`
+> - Agent 2: `references/agentic-qe/risk-based-testing.md`
+> - Agent 3: `references/agentic-qe/enterprise-integration-testing.md`
+> - Agent 4: `references/agentic-qe/regression-testing.md`
+> - Shared: `references/agentic-qe/qe-coverage-analysis.md`
+
+Spawn a QE fleet of 4 parallel assessment agents:
+
+| Agent | Role | Agentic QE Skill | Model | Scope |
+|-------|------|-------------------|-------|-------|
+| Agent 1 | Requirements Traceability Auditor | qe-requirements-validation | sonnet | Every FR-N → test → code → ADR chain |
+| Agent 2 | Risk Mitigation Verifier | risk-based-testing | sonnet | Every QCSD risk → mitigation in code |
+| Agent 3 | Integration Integrity Checker | enterprise-integration-testing | sonnet | Cross-module interactions, API contracts |
+| Agent 4 | Regression Impact Analyzer | regression-testing | sonnet | Changes vs existing codebase, side effects |
+
+All 4 agents MUST be spawned in a SINGLE message.
+
+Each agent loads its corresponding agentic-qe skill protocol and applies
+the methodology within the feature-adr context.
+
+### 2. Traceability Matrix (Agent 1)
+
+> Protocol from: `qe-requirements-validation` (Tier 3)
+
+Apply the **qe-requirements-validation** traceability matrix protocol:
+
+1. **SMART Validation**: For each FR-N, verify acceptance criteria are Specific, Measurable, Achievable, Relevant, Testable
+2. **Forward Traceability**: Map requirements → ADR → tasks → code → tests
+3. **Backward Traceability**: Map tests → code → tasks → ADR → requirements
+4. **Orphan Detection**: Find tests not linked to any requirement, code not covered by tests
+
+Build the complete traceability chain:
+
+```
+FR-{N} → ADR-{M} → TASK-{K} → File:{path} → Test:{name} → Status: ✅|❌|⚠️
+```
+
+Coverage gate (from qe-requirements-validation):
+- Minimum coverage: 80% of FR-N chains complete
+- Maximum untested requirements: 2
+- Any broken chain on MUST requirement = GAP
+
+### 3. Risk Verification (Agent 2)
+
+> Protocol from: `risk-based-testing` (Tier 3)
+
+Apply the **risk-based-testing** Probability × Impact scoring:
+
+For each critical/high risk from Step 3.5, score using the 5×5 matrix:
+
+**Probability factors** (1-5): complexity, change rate, developer experience, technical debt
+**Impact factors** (1-5): users affected, revenue, safety, reputation
+
+```
+RISK-{N}: {description}
+  Risk Score: Probability({1-5}) × Impact({1-5}) = {score}
+  Priority Tier: Critical(≥20) | High(12-19) | Medium(6-11) | Low(≤5)
+  Mitigation in code: {file:line or "MISSING"}
+  Test covering mitigation: {test name or "MISSING"}
+  Status: MITIGATED | PARTIALLY_MITIGATED | UNMITIGATED
+```
+
+Test effort allocation (from risk-based-testing):
+- Critical risks: 60% of verification effort
+- High risks: 25%
+- Medium risks: 10%
+- Low risks: 5%
+
+Any UNMITIGATED critical risk (score ≥ 20) = GAP.
+
+### 4. Integration Check (Agent 3)
+
+> Protocol from: `enterprise-integration-testing` (Tier 3, condensed)
+
+Apply the **enterprise-integration-testing** hierarchical testing strategy:
+
+**Phase 1 — Contract validation:**
+- API contracts match between producer and consumer
+- Request/response schemas compatible
+- No breaking changes in shared interfaces
+
+**Phase 2 — Integration boundary testing:**
+- Data models consistent across modules
+- Event/message schemas compatible
+- Database access patterns don't conflict
+
+**Phase 3 — E2E flow validation:**
+- Complete user flows work end-to-end
+- Cross-module data consistency verified
+- Correlation IDs propagate through the chain
+
+**Phase 4 — Error recovery:**
+- No circular dependencies introduced
+- External service mocks are realistic
+- Failure scenarios have compensation/rollback
+
+Integration quality gates:
+- Cross-module data consistency: 100% for critical paths → BLOCK on failure
+- API contract compliance: 100% → BLOCK on failure
+- Error recovery: all compensation paths tested → WARN if partial
+
+### 5. Regression Analysis (Agent 4)
+
+> Protocol from: `regression-testing` (Tier 3)
+
+Apply the **regression-testing** change-based test selection and impact analysis:
+
+**Step 1 — Change-based analysis** (from regression-testing):
+- Map `{CODE_CHANGES}` via git diff to affected test suites
+- Classify tests: mustRun | shouldRun | canSkip
+- Expected reduction: 70-90% of full suite
+
+**Step 2 — Impact analysis:**
+- Which existing tests could break? (run mustRun + shouldRun)
+- Which existing features share modified files?
+- Are there implicit dependencies not in the task graph?
+- Does the feature change any public API?
+
+**Step 3 — Regression suite execution:**
+- Quick suite (per-commit critical tests): MUST pass
+- Extended suite (broader coverage): SHOULD pass
+- Full suite (complete regression): recommended for XL tier
+
+**Step 4 — Coverage delta** (from qe-coverage-analysis):
+- New code coverage: must hit 80%
+- Modified code: must maintain previous coverage
+- Critical paths: must hit 90%
+
+### 5.5. Shared Coverage Analysis
+
+> Protocol from: `qe-coverage-analysis`
+
+All 4 agents feed their findings into a shared coverage analysis:
+- Risk-weighted coverage scoring: complexity(0.3) + change frequency(0.25) + bug history(0.25) + criticality(0.2)
+- Differential coverage assessment for new vs modified code
+- Gap prioritization by risk weight
+
+### 6. Gap Synthesis and Decision
+
+After all agents complete, synthesize findings:
+
+```
+┌─────────────────────────────────────────────────────────┐
+│              FLEET QE ASSESSMENT RESULTS                 │
+├─────────────────────────────────────────────────────────┤
+│                                                          │
+│  Traceability: {N}/{M} chains complete ({%})             │
+│  Risk Mitigation: {N}/{M} risks mitigated ({%})          │
+│  Integration: {N} issues found                           │
+│  Regression: {N} potential impacts identified             │
+│                                                          │
+│  GAPS FOUND: {count}                                     │
+│  VERDICT: COMPLETE | NEEDS_REMEDIATION                   │
+│                                                          │
+└─────────────────────────────────────────────────────────┘
+```
+
+### 7. Remediation Loop
+
+If gaps are found (NEEDS_REMEDIATION):
+
+1. Classify each gap by origin step:
+   - Requirements gap → return to Step 1
+   - ADR gap → return to Step 3
+   - Implementation gap → return to Step 7
+   - Test gap → return to Step 8
+2. Present gaps to user with remediation recommendations
+3. After user confirms, execute remediation at the appropriate step
+4. Re-run Step 9 fleet assessment (max 2 iterations)
+5. If gaps remain after 2 iterations → flag for user decision
+
+If no gaps (COMPLETE):
+- Declare feature ready
+- Generate final README.md for `features/<slug>/`
+
+## Output
+
+Create `features/<slug>/09_fleet_qe_assessment.md` with:
+- Traceability matrix
+- Risk mitigation status
+- Integration check results
+- Regression analysis
+- Gap list (if any)
+- Remediation actions taken (if any)
+- Final verdict
+
+Set `{FLEET_QE_VERDICT}` variable (COMPLETE | NEEDS_REMEDIATION).
+
+## Checkpoint Format
+
+```
+═══════════════════════════════════════════════════════
+⏸️ STEP 9: Fleet QE Assessment Complete
+<promise>FEATURE_ADR_FLEET_VERIFIED</promise>
+Tier: {COMPLEXITY_TIER}
+
+Fleet: 4 agents | Traceability: {%} | Risks mitigated: {%}
+Gaps found: {N} | Verdict: {COMPLETE | NEEDS_REMEDIATION}
+
+{If NEEDS_REMEDIATION:}
+Gaps requiring attention:
+1. {gap description} → return to Step {N}
+2. {gap description} → return to Step {N}
+
+• "ок" — feature complete! (if COMPLETE)
+• "исправь" — remediate gaps (if NEEDS_REMEDIATION)
+• "пропусти [gap]" — accept risk for specific gap
+═══════════════════════════════════════════════════════
+```
+
+## Quality Gates
+
+- [ ] All 4 fleet agents spawned and completed
+- [ ] Traceability matrix covers all requirements
+- [ ] Critical QCSD risks verified as mitigated
+- [ ] No unresolved integration issues
+- [ ] Regression analysis completed
+- [ ] Remediation loop completed (if gaps found)
+- [ ] Fleet QE report created
+
+## Direct Mode (`--full-qe`)
+
+When `{AGENTIC_QE_MODE}` = `direct` (activated via `--full-qe` flag), Step 9
+uses full agentic-qe protocols for the same 4 core agents. No additional agents
+are added — the same fleet runs with deeper methodology from the full skill files.
+
+### What changes
+
+| Agent | Reference Mode | Direct Mode (`--full-qe`) |
+|-------|---------------|---------------------------|
+| Agent 1 | Condensed qe-requirements-validation | Full SMART + BDD + sprint coverage protocol |
+| Agent 2 | Condensed risk-based-testing | Full 5×5 matrix + ML-enhanced + dynamic reassessment |
+| Agent 3 | Condensed enterprise-integration | Full hierarchical fleet + QCSD flags |
+| Agent 4 | Condensed regression-testing | Full change-based + historical + time-budget strategies |
+
+## Direct Extended Mode (`--full-qe-extended`)
+
+When `{AGENTIC_QE_MODE}` = `direct-extended`, Step 9 gets everything from
+`--full-qe` PLUS additional conditional agents and production feedback loops.
+
+### Additional Conditional Agents
+
+| Agent | Skill | Condition | Scope |
+|-------|-------|-----------|-------|
+| Agent 5 | chaos-engineering-resilience | `HAS_INFRASTRUCTURE_CHANGE` | Fault injection, blast radius, steady state |
+| Agent 6 | security-testing | `HAS_AUTH` or `HAS_EXTERNAL_API` | OWASP Top 10, access control, injection |
+| Agent 7 | performance-testing | `HAS_PERFORMANCE_SLA` | Load/stress/spike testing, SLO verification |
+
+These agents are spawned alongside Agents 1-4 in the same message.
+
+### Post-Assessment: Production Feedback
+
+After Step 9 completes, if `--full-qe-extended` is active:
+1. Load `qcsd-production-swarm` feedback loop patterns
+2. Store Fleet QE findings in memory for future pipeline runs
+3. Flag production health risks for monitoring post-deploy
+4. Advisory: suggest post-deploy monitoring checklist
+
+### Extended Checkpoint (Direct Extended Mode)
+
+```
+Fleet: {4-7} agents | Mode: full-qe-extended | Traceability: {%} | Risks: {%}
+Extended: Security: {PASS|WARN|FAIL} | Performance: {PASS|WARN|FAIL} | Chaos: {PASS|WARN|N/A}
+```
+
+## Anti-Patterns
+
+| Anti-Pattern | Detection | Fix |
+|-------------|-----------|-----|
+| Skipping fleet QE "for speed" | No Step 9 for L/XL | BLOCK — mandatory for L/XL |
+| Fewer than 4 agents | Agent count < 4 | BLOCK — all 4 required |
+| Infinite remediation loop | > 2 iterations | Stop, flag for user |
+| Accepting unmitigated critical risks | UNMITIGATED status for critical | Require explicit user acknowledgment |
+| Using --full-qe-extended for S/M tier | Flag on simple features | WARN — overhead not justified |
+| --full-qe without agentic-qe installed | Flag present, tool missing | WARN and fall back to reference mode |

package/templates/.claude/skills/feature-adr/references/agentic-qe/README.md

@@ -0,0 +1,143 @@
+# Agentic QE Skills Integration
+
+Skills from [agentic-qe](https://github.com/proffesor-for-testing/agentic-qe) integrated into the feature-adr pipeline.
+
+## Installation (for Direct Mode)
+
+```bash
+# Install agentic-qe globally
+npm install -g agentic-qe
+
+# Initialize in your project (auto-detects tech stack, configures MCP)
+cd your-project && aqe init --auto
+```
+
+Then use with explicit flags:
+```
+/feature-adr --full-qe [описание фичи]            # Full protocols, same 9 core skills
+/feature-adr --full-qe-extended [описание фичи]    # Full protocols + 6 extra skills
+```
+
+Without installation, all core skills work in Reference Mode (no setup needed).
+
+## Skill Mapping to Feature-ADR Steps
+
+### Core Skills (always available, Reference Mode)
+
+| Feature-ADR Step | Agentic QE Skill | Purpose |
+|-----------------|------------------|---------|
+| Step 3 (ADR) → validation | shift-left-testing | Validate ADR testability (Level 4: Risk Analysis in Design) |
+| Step 3.5 | qcsd-ideation-swarm | Quality criteria swarm on refined ADR (HTSM, Risk Storming, testability) |
+| Step 6 (Impl Plan) | code-goal-planner | SPARC-GOAP milestone decomposition |
+| Step 8 (QE) → review | brutal-honesty-review | Linus/Ramsay/Bach modes for code + test review |
+| Step 8 → gap loop | requirements-validator (via shift-left) | Find gaps in implementation, iterate until fixed |
+| Step 9 → Agent 1 | qe-requirements-validation | Traceability matrix, SMART validation, orphan test detection |
+| Step 9 → Agent 2 | risk-based-testing | Probability×Impact 5×5 scoring, 4-tier test allocation |
+| Step 9 → Agent 3 | enterprise-integration-testing | Cross-module contract testing, E2E flow validation |
+| Step 9 → Agent 4 | regression-testing | Change-based test selection, impact analysis, regression pyramid |
+| Step 9 → shared | qe-coverage-analysis | Risk-weighted coverage scoring, differential coverage |
+
+### Extended Skills (Direct Extended Mode only, `--full-qe-extended`)
+
+| Feature-ADR Step | Agentic QE Skill | Purpose | Condition |
+|-----------------|------------------|---------|-----------|
+| Step 7 | tdd-london-chicago | TDD school selection (London mocks vs Chicago state) | Always in direct mode |
+| Step 8 | mutation-testing | Mutation score analysis, surviving mutant diagnosis | If test suite exists |
+| Step 8, 9 | security-testing | OWASP Top 10, access control, injection, crypto failures | `HAS_AUTH` or `HAS_EXTERNAL_API` |
+| Step 8, 9 | performance-testing | Load/stress/spike/endurance testing, SLO verification | `HAS_PERFORMANCE_SLA` |
+| Step 9 | chaos-engineering-resilience | Fault injection, blast radius progression, steady state | `HAS_INFRASTRUCTURE_CHANGE` |
+| Step 9+ | qcsd-production-swarm | 12-agent post-release health, DORA metrics, feedback loops | Advisory (post-deploy) |
+
+## Source Repository
+
+- Repository: https://github.com/proffesor-for-testing/agentic-qe
+- Skills path: `assets/skills/`
+- Agents path: `.claude/agents/goal/`
+- Total skills in repo: 77+
+- Skills integrated: 15 (9 core + 6 extended)
+
+### Trust Tiers
+
+| Skill | Tier |
+|-------|------|
+| shift-left-testing | 3 (Verified) |
+| qcsd-ideation-swarm | 3 (Verified) |
+| brutal-honesty-review | 2 (Validated) |
+| qe-requirements-validation | 3 (Verified) |
+| risk-based-testing | 3 (Verified) |
+| enterprise-integration-testing | 3 (Verified) |
+| regression-testing | 3 (Verified) |
+| qe-coverage-analysis | 3 (Verified) |
+| chaos-engineering-resilience | 3 (Verified) |
+| security-testing | 3 (Verified) |
+| performance-testing | 3 (Verified) |
+| mutation-testing | 3 (Verified) |
+| tdd-london-chicago | 3 (Verified) |
+| qcsd-production-swarm | 3 (Verified) |
+
+## Integration Modes
+
+### Reference Mode (default, no setup)
+
+Skills are stored as condensed copies in `references/agentic-qe/`.
+Feature-adr modules read the skill instructions and apply their methodology
+within the feature-adr checkpoint framework.
+
+- Works out of the box
+- 15 files, ~50KB total
+- Covers all core pipeline steps
+
+### Direct Mode (`--full-qe`, requires installation)
+
+When `--full-qe` flag is used and agentic-qe is installed:
+
+1. Step 0 detects agentic-qe installation (`which aqe`)
+2. Sets `{AGENTIC_QE_MODE}` = `direct`
+3. Modules load full skill files from agentic-qe package for the same 9 core skills
+4. Full QCSD swarm protocols with all agents + DDD mapping
+5. No additional skills — same agents, deeper protocols
+
+**When to use:**
+- L/XL tier features needing deeper QE methodology
+- Teams with established QE practices
+
+### Direct Extended Mode (`--full-qe-extended`, requires installation)
+
+Everything from `--full-qe` PLUS 6 additional skills:
+
+1. Sets `{AGENTIC_QE_MODE}` = `direct-extended`
+2. Step 7 gets TDD London/Chicago guidance
+3. Step 8 gets mutation testing + security + performance
+4. Step 9 gets up to 3 extra conditional agents (chaos, security, performance)
+5. Post-Step 9 gets production swarm feedback loops
+
+**When to use:**
+- XL tier features with security/compliance requirements
+- Banking domain (ФЗ-152), regulatory compliance
+- Maximum QE coverage needed
+
+**When Reference Mode is enough:**
+- S/M tier features
+- Quick iteration / prototyping
+- No special QE requirements
+
+## Files in this directory
+
+### Core (always loaded)
+- `shift-left-testing.md` — Full copy (Tier 3)
+- `qcsd-ideation-swarm.md` — Condensed from ~77KB (Tier 3)
+- `code-goal-planner.md` — Full copy (Agent)
+- `brutal-honesty-review.md` — Full copy (Tier 2)
+- `qe-requirements-validation.md` — Full copy, 254 lines (Tier 3)
+- `risk-based-testing.md` — Full copy, 212 lines (Tier 3)
+- `enterprise-integration-testing.md` — Condensed from 735 lines (Tier 3)
+- `regression-testing.md` — Full copy, 233 lines (Tier 3)
+- `qe-coverage-analysis.md` — Full copy, 193 lines (Tier 3)
+
+### Extended (loaded in Direct Mode)
+- `chaos-engineering-resilience.md` — Full copy, 164 lines (Tier 3)
+- `security-testing.md` — Full copy, 312 lines (Tier 3)
+- `performance-testing.md` — Full copy, 316 lines (Tier 3)
+- `mutation-testing.md` — Full copy, 237 lines (Tier 3)
+- `tdd-london-chicago.md` — Full copy, 250 lines (Tier 3)
+- `qcsd-production-swarm.md` — Condensed from 2781 lines (Tier 3)

package/templates/.claude/skills/feature-adr/references/agentic-qe/brutal-honesty-review.md

@@ -0,0 +1,240 @@
+---
+name: brutal-honesty-review
+description: "Unvarnished technical criticism combining Linus Torvalds' precision, Gordon Ramsay's standards, and James Bach's BS-detection. Use when code/tests need harsh reality checks, certification schemes smell fishy, or technical decisions lack rigor. No sugar-coating, just surgical truth about what's broken and why."
+category: quality-review
+priority: high
+tokenEstimate: 1200
+agents: [qe-code-reviewer, qe-quality-gate, qe-security-auditor]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-03
+dependencies: []
+quick_reference_card: true
+tags: [code-review, honesty, critical-thinking, technical-criticism, quality]
+trust_tier: 2
+validation:
+  schema_path: schemas/output.json
+  validator_path: scripts/validate-config.json
+
+---
+
+# Brutal Honesty Review
+
+<default_to_action>
+When brutal honesty is needed:
+1. CHOOSE MODE: Linus (technical), Ramsay (standards), Bach (BS detection)
+2. VERIFY CONTEXT: Senior engineer? Repeated mistake? Critical bug? Explicit request?
+3. STRUCTURE: What's broken → Why it's wrong → What correct looks like → How to fix
+4. ATTACK THE WORK, not the worker
+5. ALWAYS provide actionable path forward
+
+**Quick Mode Selection:**
+- **Linus**: Code is technically wrong, inefficient, misunderstands fundamentals
+- **Ramsay**: Quality is subpar compared to clear excellence model
+- **Bach**: Certifications, best practices, or vendor hype need reality check
+
+**Calibration:**
+- Level 1 (Direct): "This approach is fundamentally flawed because..."
+- Level 2 (Harsh): "We've discussed this three times. Why is it back?"
+- Level 3 (Brutal): "This is negligent. You're exposing user data because..."
+
+**DO NOT USE FOR:** Junior devs' first PRs, demoralized teams, public forums, low psychological safety
+</default_to_action>
+
+## Quick Reference Card
+
+### When to Use
+| Context | Appropriate? | Why |
+|---------|-------------|-----|
+| Senior engineer code review | ✅ Yes | Can handle directness, respects precision |
+| Repeated architectural mistakes | ✅ Yes | Gentle approaches failed |
+| Security vulnerabilities | ✅ Yes | Stakes too high for sugar-coating |
+| Evaluating vendor claims | ✅ Yes | BS detection prevents expensive mistakes |
+| Junior dev's first PR | ❌ No | Use constructive mentoring |
+| Demoralized team | ❌ No | Will break, not motivate |
+| Public forum | ❌ No | Public humiliation destroys trust |
+
+### Three Modes
+
+| Mode | When | Example Output |
+|------|------|----------------|
+| **Linus** | Code technically wrong | "You're holding the lock for the entire I/O. Did you test under load?" |
+| **Ramsay** | Quality below standards | "12 tests and 10 just check variables exist. Where's the business logic?" |
+| **Bach** | BS detection needed | "This cert tests memorization, not bug-finding. Who actually benefits?" |
+
+---
+
+## The Criticism Structure
+
+```markdown
+## What's Broken
+[Surgical description - specific, technical]
+
+## Why It's Wrong
+[Technical explanation, not opinion]
+
+## What Correct Looks Like
+[Clear model of excellence]
+
+## How to Fix It
+[Actionable steps, specific to context]
+
+## Why This Matters
+[Impact if not fixed]
+```
+
+---
+
+## Mode Examples
+
+### Linus Mode: Technical Precision
+
+```markdown
+**Problem**: Holding database connection during HTTP call
+
+"This is completely broken. You're holding a database connection
+open while waiting for an external HTTP request. Under load, you'll
+exhaust the connection pool in seconds.
+
+Did you even test this with more than one concurrent user?
+
+The correct approach is:
+1. Fetch data from DB
+2. Close connection
+3. Make HTTP call
+4. Open new connection if needed
+
+This is Connection Management 101. Why wasn't this caught in review?"
+```
+
+### Ramsay Mode: Standards-Driven Quality
+
+```markdown
+**Problem**: Tests only verify happy path
+
+"Look at this test suite. 15 tests, 14 happy path scenarios.
+Where's the validation testing? Edge cases? Failure modes?
+
+This is RAW. You're testing if code runs, not if it's correct.
+
+Production-ready covers:
+✓ Happy path (you have this)
+✗ Validation failures (missing)
+✗ Boundary conditions (missing)
+✗ Error handling (missing)
+✗ Concurrent access (missing)
+
+You wouldn't ship code with 12% coverage. Don't merge tests
+with 12% scenario coverage."
+```
+
+### Bach Mode: BS Detection
+
+```markdown
+**Problem**: ISTQB certification required for QE roles
+
+"ISTQB tests if you memorized terminology, not if you can test software.
+
+Real testing skills:
+- Finding bugs others miss
+- Designing effective strategies for context
+- Communicating risk to stakeholders
+
+ISTQB tests:
+- Definitions of 'alpha' vs 'beta' testing
+- Names of techniques you'll never use
+- V-model terminology
+
+If ISTQB helped testers, companies with certified teams would ship
+higher quality. They don't."
+```
+
+---
+
+## Assessment Rubrics
+
+### Code Quality (Linus Mode)
+
+| Criteria | Failing | Passing | Excellent |
+|----------|---------|---------|-----------|
+| Correctness | Wrong algorithm | Works in tested cases | Proven across edge cases |
+| Performance | Naive O(n²) | Acceptable complexity | Optimal + profiled |
+| Error Handling | Crashes on invalid | Returns error codes | Graceful degradation |
+| Testability | Impossible to test | Can mock | Self-testing design |
+
+### Test Quality (Ramsay Mode)
+
+| Criteria | Raw | Acceptable | Michelin Star |
+|----------|-----|------------|---------------|
+| Coverage | <50% branch | 80%+ branch | 95%+ mutation tested |
+| Edge Cases | Only happy path | Common failures | Boundary analysis complete |
+| Stability | Flaky (>1% failure) | Stable but slow | Deterministic + fast |
+
+### BS Detection (Bach Mode)
+
+| Red Flag | Evidence | Impact |
+|----------|----------|--------|
+| Cargo Cult Practice | "Best practice" with no context | Wasted effort |
+| Certification Theater | Required cert unrelated to skills | Filters out thinkers |
+| Vendor Lock-In | Tool solves problem it created | Expensive dependency |
+
+---
+
+## Agent Integration
+
+```typescript
+// Brutal honesty code review
+await Task("Code Review", {
+  code: pullRequestDiff,
+  mode: 'linus',  // or 'ramsay', 'bach'
+  calibration: 'direct',  // or 'harsh', 'brutal'
+  requireActionable: true
+}, "qe-code-reviewer");
+
+// BS detection for vendor claims
+await Task("Vendor Evaluation", {
+  claims: vendorMarketingClaims,
+  mode: 'bach',
+  requireEvidence: true
+}, "qe-quality-gate");
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/brutal-honesty/
+├── code-reviews/*     - Technical review findings
+├── bs-detection/*     - Vendor/cert evaluations
+└── calibration/*      - Context-appropriate levels
+```
+
+### Fleet Coordination
+```typescript
+const reviewFleet = await FleetManager.coordinate({
+  strategy: 'brutal-review',
+  agents: [
+    'qe-code-reviewer',    // Technical precision
+    'qe-security-auditor', // Security brutality
+    'qe-quality-gate'      // Standards enforcement
+  ],
+  topology: 'parallel'
+});
+```
+
+---
+
+## Related Skills
+- [code-review-quality](../code-review-quality/) - Diplomatic version
+- [context-driven-testing](../context-driven-testing/) - Foundation for Bach mode
+- [sherlock-review](../sherlock-review/) - Evidence-based investigation
+
+---
+
+## Remember
+
+**Brutal honesty eliminates ambiguity but has costs.** Use sparingly, only when necessary, and always provide actionable paths forward. Attack the work, never the worker.
+
+**The Brutal Honesty Contract**: Get explicit consent. "I'm going to give unfiltered technical feedback. This will be direct, possibly harsh. The goal is clarity, not cruelty."