nw-mikado

[EXPERIMENTAL] Complex refactoring roadmaps with visual tracking

322 stars

Best use case

nw-mikado is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

[EXPERIMENTAL] Complex refactoring roadmaps with visual tracking

Teams using nw-mikado should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/nw-mikado/SKILL.md --create-dirs "https://raw.githubusercontent.com/nWave-ai/nWave/main/nWave/skills/nw-mikado/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/nw-mikado/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How nw-mikado Compares

Feature / Agentnw-mikadoStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

[EXPERIMENTAL] Complex refactoring roadmaps with visual tracking

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# NW-MIKADO: Complex Refactoring with Mikado Method

> **EXPERIMENTAL**: Under active development. Behavior and output format may change between versions.

**Wave**: CROSS_WAVE
**Agent**: Crafty (nw-software-crafter)
**Command**: `*mikado`

## Overview

Plan and execute complex refactoring using the Mikado Method. Builds dependency {visualization} through iterative exploration|tracks discoveries via commits|executes leaf-to-goal bottom-up. For architectural changes spanning multiple classes where simple refactoring is insufficient.

## Context Files Required

- src/\* - Codebase to refactor
- docs/product/architecture/brief.md - Target architecture (if available)

## Agent Invocation

@nw-software-crafter

Execute \*mikado for {refactoring-goal}.

**Context Files:**
- src/\*
- docs/product/architecture/brief.md

**Configuration:**
- refactoring_goal: "{goal description with business value}"
- complexity: complex # simple/moderate/complex
- visualization: {tree|graph} # tree = indented markdown checklist, graph = Mermaid dependency diagram

## Success Criteria

- [ ] Mikado {visualization} persisted at docs/mikado/{goal-name}.mikado.md
- [ ] Discovery commits capture each exploration attempt
- [ ] All leaf nodes implemented bottom-up
- [ ] Goal node achieved with all tests passing
- [ ] {visualization_label} stable (no new dependencies emerging)

**Visualization labels**: tree → "Tree", graph → "Graph". Use the selected visualization type in all output messages (e.g., "Wrote the Mikado tree" or "Wrote the Mikado graph").

## Next Wave

**Handoff To**: {invoking-agent-returns-to-workflow}
**Deliverables**: Refactored codebase + Mikado {visualization} documentation

## Examples

### Example 1: Extract shared domain model
```
/nw-mikado "Extract shared domain model from monolithic service layer"
```
Crafty builds Mikado dependency {visualization} through iterative exploration, discovers 12 leaf nodes across 4 modules, executes bottom-up from leaves to goal with discovery commits at each step.

## Expected Outputs

```
docs/mikado/{goal-name}.mikado.md
src/*                                (refactored implementation)
Discovery-tracking commits in git log
```

Related Skills

nw-mikado-method

322
from nWave-ai/nWave

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

nw-ux-web-patterns

322
from nWave-ai/nWave

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

nw-ux-tui-patterns

322
from nWave-ai/nWave

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

nw-ux-principles

322
from nWave-ai/nWave

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

nw-ux-emotional-design

322
from nWave-ai/nWave

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.

nw-ux-desktop-patterns

322
from nWave-ai/nWave

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.

nw-user-story-mapping

322
from nWave-ai/nWave

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.

nw-tr-review-criteria

322
from nWave-ai/nWave

Review dimensions and scoring for root cause analysis quality assessment

nw-tlaplus-verification

322
from nWave-ai/nWave

TLA+ formal verification for design correctness and PBT pipeline integration

nw-test-refactoring-catalog

322
from nWave-ai/nWave

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

nw-test-organization-conventions

322
from nWave-ai/nWave

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

nw-test-design-mandates

322
from nWave-ai/nWave

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