nw

Bug fix workflow: root cause analysis → user review → regression test + fix via TDD

Detects current wave progress for a feature and resumes at the next step. Scans docs/feature/ for artifacts.

Orchestrates the full DELIVER wave end-to-end (roadmap > execute-all > finalize). Use when all prior waves are complete and the feature is ready for implementation.

Designs system architecture with C4 diagrams and technology selection. Use when defining component boundaries, choosing tech stacks, or creating architecture documents.

Designs CI/CD pipelines, infrastructure, observability, and deployment strategy. Use when preparing platform readiness for a feature.

Generates C4 architecture diagrams (context, container, component) in Mermaid or PlantUML. Use when creating or updating architecture visualizations.

Conducts evidence-based product discovery through customer interviews and assumption testing. Use at project start to validate problem-solution fit.

Conducts Jobs-to-be-Done analysis, UX journey design, and requirements gathering through interactive discovery. Use when starting feature analysis, defining user stories, or creating acceptance criteria.

Creates E2E acceptance tests in Given-When-Then format from requirements and architecture. Use when preparing executable specifications before implementation.

Creates evidence-based documentation following DIVIO/Diataxis principles. Use when writing tutorials, how-to guides, reference docs, or explanations.

Dispatches a single roadmap step to a specialized agent for TDD execution. Use when implementing a specific step from a roadmap.json plan.

Fast-forwards through remaining waves end-to-end without stopping for review between waves.

Archives a completed feature to docs/evolution/, migrates lasting artifacts to permanent directories, and cleans up the temporary workspace. Use after all implementation steps pass and mutation testing completes.

Creates new specialized agents using the 5-phase workflow (ANALYZE > DESIGN > CREATE > VALIDATE > REFINE). Use when building a new AI agent or validating an existing agent specification.

Git change frequency hotspot analysis — find the most-changed files in your codebase

[EXPERIMENTAL] Complex refactoring roadmaps with visual tracking

Runs feature-scoped mutation testing to validate test suite quality. Use after implementation to verify tests catch real bugs (kill rate >= 80%).

Guided wizard to start a new feature. Asks what you want to build, recommends the right starting wave, and launches it.

Applies the Refactoring Priority Premise (RPP) levels L1-L6 for systematic code refactoring. Use when improving code quality through structured refactoring passes.

Gathers knowledge from web and files, cross-references across multiple sources, and produces cited research documents. Use when investigating technologies, patterns, or decisions that need evidence backing.

Dispatches an expert reviewer agent to critique workflow artifacts. Use when a roadmap, implementation, or step needs quality review before proceeding.

Selects a quality-vs-token-consumption profile (lean, standard, thorough, exhaustive, custom, inherit) and persists it globally (~/.nwave/global-config.json) or per-project (.nwave/des-config.json). Use when tuning how much rigor wave commands apply.

Creates a phased roadmap.json for a feature goal with acceptance criteria and TDD steps. Use when planning implementation steps before execution.

Root cause analysis and debugging

Use for review and critique tasks - Acceptance criteria and BDD review specialist. Runs on Haiku for cost efficiency.

Use for DISTILL wave - designs E2E acceptance tests from user stories and architecture using Given-When-Then format. Creates executable specifications that drive Outside-In TDD development.

Use for review and critique tasks - Agent design and quality review specialist. Runs on Haiku for cost efficiency.

Use when creating new AI agents, validating agent specifications, optimizing command definitions, or ensuring compliance with Claude Code best practices. Creates focused, research-validated agents (200-400 lines) with Skills for domain knowledge. Also optimizes bloated command files into lean declarative definitions.

Use for review and critique tasks - Data architecture and pipeline review specialist. Runs on Haiku for cost efficiency.

Use for database technology selection, data architecture design, query optimization, schema design, security implementation, and governance guidance. Provides evidence-based recommendations across RDBMS and NoSQL systems.

Use for reviewing documentarist assessments. Validates classification accuracy, validation completeness, collapse detection, and recommendation quality using Haiku model.

Use for documentation quality enforcement using DIVIO/Diataxis principles. Classifies documentation type, validates against type-specific criteria, detects collapse patterns, and provides actionable improvement guidance.

DELIVER wave - Outside-In TDD with functional paradigm. Pure functions, pipeline composition, types as documentation, property-based testing. Use when the project follows a functional-first approach (F#, Haskell, Scala, Clojure, Elixir, or FP-heavy TypeScript/Python/Kotlin).

Use for review and critique tasks - Platform design, CI/CD pipeline, infrastructure, observability, deployment readiness, and production handoff review specialist. Runs on Haiku for cost efficiency.

Use for DESIGN wave (infrastructure design) and DEVOPS wave (deployment execution, production readiness, stakeholder sign-off). Transforms architecture into deployable infrastructure, then coordinates production delivery and outcome measurement.

Use as peer reviewer for product-discoverer outputs -- validates evidence quality, sample sizes, decision gate compliance, bias detection, and discovery anti-patterns. Runs on Haiku for cost efficiency.

Conducts evidence-based product discovery through customer interviews, assumption testing, and opportunity validation. Use when validating problems exist, prioritizing opportunities, or confirming market viability before writing requirements.

Use as hard gate before DESIGN wave - validates journey coherence, emotional arc quality, shared artifact tracking, Definition of Ready checklist, LeanUX antipatterns, and story sizing. Blocks handoff if any critical issue or DoR item fails. Runs on Haiku for cost efficiency.

Conducts UX journey design and requirements gathering with BDD acceptance criteria. Use when defining user stories, emotional arcs, or enforcing Definition of Ready.

Use for review and critique tasks - Research quality and evidence review specialist. Runs on Haiku for cost efficiency.

Use for evidence-driven research with source verification. Gathers knowledge from web and files, cross-references across multiple sources, and produces cited research documents.

Use for review and critique tasks - Code quality and implementation review specialist. Runs on Haiku for cost efficiency.

DELIVER wave - Outside-In TDD and progressive refactoring. Research-optimized core (~375L) with Skills for deep knowledge. Includes Mikado Method for complex refactoring.

Architecture design and patterns review specialist - Optimized for cost-efficient review operations using Haiku model.

Use for DESIGN wave - collaborates with user to define system architecture, component boundaries, technology selection, and creates architecture documents with business value focus. Hands off to acceptance-designer.

Use for review and critique tasks - Risk analysis and failure mode review specialist. Runs on Haiku for cost efficiency.

Use for investigating system failures, recurring issues, unexpected behaviors, or complex bugs requiring systematic root cause analysis with evidence-based investigation.

Review dimensions for validating agent quality - template compliance, safety, testing, and priority validation

Review dimensions for validating agent quality - template compliance, safety, testing, and priority validation

Review dimensions for acceptance test quality - happy path bias, GWT compliance, business language purity, coverage completeness, walking skeleton user-centricity, priority validation, observable behavior assertions, traceability coverage, and walking skeleton boundary proof

Detailed 5-phase workflow for creating agents - from requirements analysis through validation and iterative refinement

5-layer testing approach for agent validation including adversarial testing, security validation, and prompt injection resistance

Architectural style selection decision matrices, trade-off analysis, structural enforcement rules, and combination patterns. Load when choosing or evaluating architecture styles.

Comprehensive architecture patterns, methodologies, quality frameworks, and evaluation methods for solution architects. Load when designing system architecture or selecting patterns.

Domain-specific authoritative source databases, search strategies by topic category, and source freshness rules

BDD patterns for acceptance test design - Given-When-Then structure, scenario writing rules, pytest-bdd implementation, anti-patterns, and living documentation

BDD requirements discovery methodology - Example Mapping, Three Amigos, conversational patterns, Given-When-Then translation, and collaborative specification

Canary skill for auto-injection detection

CI/CD pipeline design methodology, deployment strategies, GitHub Actions patterns, and branch/release strategies. Load when designing pipelines or deployment workflows.

Cross-agent collaboration protocols, workflow handoff patterns, and commit message formats for TDD/Mikado/refactoring workflows

Documentation collapse anti-patterns - detection rules, bad examples, and remediation strategies for type-mixing violations

Best practices for command definition files - size targets, declarative template, anti-patterns, and canonical examples based on research evidence

Step-by-step workflow for converting bloated command files to lean declarative definitions

Data architecture patterns (warehouse, lake, lakehouse, mesh), ETL/ELT pipelines, streaming architectures, scaling strategies, and schema design patterns

Database comparison catalogs, RDBMS vs NoSQL selection criteria, CAP/ACID/BASE theory, OLTP vs OLAP, and technology-specific characteristics

DELIVER wave orchestration workflow -- 9 phases from baseline to finalization. Load when user invokes *deliver command. Covers state tracking, smart skip logic, retry, resume, and quality gate enforcement.

Rollback procedures, risk assessment, pre/post-deployment validation, and contingency planning. Load when orchestrating deployment or preparing rollback plans. For deployment strategy details (canary, blue-green, rolling), see `cicd-and-deployment` skill.

Evaluation criteria and scoring for data engineering artifact reviews

Apple LeanUX++ design workflow, journey schema, emotional arc patterns, and CLI UX patterns. Load when transitioning from discovery to visualization or when designing journey artifacts.

7 agentic design patterns with decision tree for choosing the right pattern for each agent type

Question-first approach to understanding user journeys. Load when starting a new journey design or when the discovery phase needs deepening.

4-phase discovery workflow with decision gates, phase transitions, success metrics, and state tracking

DIVIO/Diataxis four-quadrant documentation framework - type definitions, classification decision tree, and signal catalog

Strategic and tactical DDD patterns, bounded context discovery, context mapping, aggregate design rules, and decision frameworks for when to apply DDD

Definition of Ready checklist criteria, antipattern detection patterns, UAT quality rules, and domain language enforcement for product owner review

Critique dimensions, severity framework, verdict decision matrix, and review output format for documentation assessment reviews

Toyota 5 Whys methodology with multi-causal branching, evidence requirements, and validation techniques

TLA+ and PlusCal for specifying distributed system invariants. Decision heuristics for when formal verification adds value, key patterns, state explosion management, and alternatives comparison.

Algebra-driven API design with monoids, semigroups, and interpreters via algebraic equations

Clojure language-specific patterns, data-first modeling, REPL-driven development, and spec

Domain modeling with algebraic data types, smart constructors, and type-level error handling

F# language-specific patterns, Railway-Oriented Programming, and Computation Expressions

Haskell language-specific patterns, GADTs, type classes, and effect systems

Hexagonal architecture patterns with pure core and side-effect shell for functional codebases

Kotlin language-specific patterns with Arrow, Raise DSL, and coroutine-based effects

Core functional programming thinking patterns and type system foundations, language-agnostic

Scala 3 language-specific patterns with ZIO, Cats Effect, and opaque types

Naming conventions, API ergonomics, and usability patterns for functional code

5-layer agent output validation, I/O contract specification, vertical slice development, and test doubles policy with per-layer examples

Infrastructure as Code patterns (Terraform, Kubernetes), observability design (SLOs, metrics, alerting, dashboards), and pipeline security stages. Load when designing infrastructure, observability, or security scanning.

Mom Test questioning toolkit, JTBD analysis, interview conduct, assumption testing framework, and hypothesis design

Evidence collection methods, problem categorization, analysis techniques, and solution design patterns

Translating JTBD analysis to BDD scenarios - job story to Given-When-Then patterns, forces-based test discovery, job-map-based test discovery, and property-shaped criteria

Core JTBD theory and job story format - job dimensions, job story template, job stories vs user stories, 8-step universal job map, outcome statements, and forces of progress

JTBD discovery techniques adapted for AI product owner context. Four Forces extraction, job dimension probing, question banks, and anti-patterns for interactive feature discovery conversations.

JTBD opportunity scoring and prioritization - outcome statement format, opportunity algorithm, scoring interpretation, feature prioritization, and opportunity matrix template

JTBD workflow classification and routing - ODI two-phase framework, five job types with workflow sequences, baseline type selection, workflow anti-patterns, and common recipes

LeanUX backlog management methodology - user story template, story sizing, story states, task types, Definition of Ready/Done, anti-pattern detection and remediation

DDD-guided legacy refactoring patterns -- strangler fig, bubble context, ACL migration, 14 tactical/strategic/infrastructure patterns, and incremental monolith-to-microservices methodology

Enhanced Mikado Method for complex architectural refactoring - systematic dependency discovery, tree-based planning, and bottom-up execution

Tool safety protocols, adversarial output validation, error recovery patterns, and I/O contracts for research operations

Opportunity Solution Trees, opportunity scoring, Lean Canvas, JTBD job mapping, and technique selection guide

Outcome KPI definition methodology - synthesizes Who Does What By How Much (Gothelf/Seiden), Running Lean (Maurya), and Measure What Matters (Doerr) into a practical framework for measurable outcome KPIs

Platform design review critique dimensions and severity levels. Load when reviewing CI/CD pipelines, infrastructure, deployment strategies, observability, or security designs.

Quality dimensions and review checklist for devop reviews

.NET property-based testing with FsCheck, CsCheck, and fsharp-hedgehog frameworks

Erlang/Elixir property-based testing with PropEr, PropCheck, and StreamData frameworks

Property-based testing core concepts, property taxonomy, and strategy selection (language-agnostic)

Go property-based testing with rapid and gopter frameworks

Haskell property-based testing with QuickCheck and Hedgehog frameworks

JVM property-based testing with jqwik, ScalaCheck, and ZIO Test frameworks

Python property-based testing with Hypothesis framework, strategies, and pytest integration

Rust property-based testing with proptest, quickcheck, and bolero frameworks

Stateful property-based testing patterns, model-based testing, and anti-patterns

TypeScript/JavaScript property-based testing with fast-check framework and arbitraries

Evidence quality validation and decision gate criteria for product discovery reviews

Structured persona creation and JTBD analysis methodology - persona templates, ODI job step tables, pain point mapping, success metric quantification, and multi-persona segmentation

Foundational platform engineering knowledge from key references -- Continuous Delivery, SRE, Accelerate, Team Topologies, Chaos Engineering, and Secure Delivery. Load when contextual grounding in platform engineering theory is needed.

Requirements quality critique dimensions for peer review - confirmation bias detection, completeness validation, clarity checks, testability assessment, and priority validation

Review dimensions and bug patterns for journey artifact reviews

Blameless post-mortem structure, incident timeline reconstruction, response evaluation, and organizational learning

Monitoring, observability, operational procedures, CI/CD lessons learned, and quality gate definitions. Load when assessing production readiness or validating operational excellence.

Agent safety boundaries - input validation, output filtering, scope constraints, and document creation policy

Progressive L1-L6 refactoring hierarchy, 22 code smell taxonomy, atomic transformations, test code smells, and Fowler refactoring catalog

Property-based testing strategies, mutation testing, shrinking, and combined PBT+mutation workflow for test quality validation

Quality gates - 11 commit readiness gates, build/test protocol, validation checkpoints, and quality metrics

Type-specific validation checklists, six quality characteristics, and quality gate thresholds for documentation assessment

SQL and NoSQL query optimization techniques, indexing strategies, execution plan analysis, JOIN algorithms, cardinality estimation, and database-specific query patterns

Research output templates, distillation workflow, and quality standards for evidence-driven research

YAML output format and approval criteria for platform design reviews. Load when generating review feedback.

Detailed review process, v2 validation checklist, and scoring methodology for agent definition reviews

Roadmap-specific validation checks for architecture reviews. Load when reviewing roadmaps for implementation readiness.

Critique dimensions and scoring for research document reviews

Architecture quality critique dimensions for peer review. Load when invoking solution-architect-reviewer or performing self-review of architecture documents.

Architecture quality critique dimensions for peer review. Load when performing architecture document reviews.

Reviewer critique dimensions for peer review - implementation bias detection, test quality validation, completeness checks, and priority validation

Database security (encryption, access control, injection prevention), data governance (lineage, quality, MDM), and compliance frameworks (GDPR, CCPA, HIPAA)

Security design principles, STRIDE threat modeling, OWASP Top 10 architectural mitigations, and secure patterns. Load when designing systems or reviewing architecture for security.

Shared artifact registry, common artifact patterns, and integration validation. Load when tracking data that flows across journey steps or validating horizontal coherence.

Source reputation tiers, cross-referencing methodology, bias detection, and citation format requirements

Demonstration preparation, audience-tailored presentations, feedback collection, and business outcome measurement. Load when preparing demos or measuring business value delivery.

Advanced architecture stress analysis methodology for designing systems that survive unknown stresses. Load when --residuality flag is used or when designing high-uncertainty, mission-critical systems.

Deep knowledge for Outside-In TDD - double-loop architecture, ATDD integration, port-to-port testing, walking skeletons, and test doubles policy

Test design mandate enforcement, test budget validation, 5-phase TDD validation, and external validity checks for the software crafter reviewer

Four design mandates for acceptance tests - hexagonal boundary enforcement, business language abstraction, user journey completeness, walking skeleton strategy, and pure function extraction

Test directory structure patterns by architecture style, language conventions, naming rules, and fixture placement. Decision tree for selecting test organization strategy.

Detailed refactoring mechanics with step-by-step procedures, and test code smell catalog with detection patterns and before/after examples

TLA+ formal verification for design correctness and PBT pipeline integration

Review dimensions and scoring for root cause analysis quality assessment

User story mapping for backlog management and outcome-based prioritization. Load during Phase 2.5 (User Story Mapping) to produce story-map.md and prioritization.md.

Desktop application UI patterns for product owners. Load when designing native or cross-platform desktop applications, writing desktop-specific acceptance criteria, or evaluating panel layouts and keyboard workflows.

Emotional design and delight patterns for product owners. Load when designing onboarding flows, empty states, first-run experiences, or evaluating the emotional quality of an interface.

Core UX principles for product owners. Load when evaluating interface designs, writing acceptance criteria with UX requirements, or reviewing wireframes and mockups.

Terminal UI and CLI design patterns for product owners. Load when designing command-line tools, interactive terminal applications, or writing CLI-specific acceptance criteria.

Web UI design patterns for product owners. Load when designing web application interfaces, writing web-specific acceptance criteria, or evaluating responsive designs.

9 hooks across 5 events