@tgoodington/intuition 9.5.0 → 10.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (13) hide show
  1. package/README.md +21 -28
  2. package/package.json +1 -1
  3. package/scripts/install-skills.js +17 -4
  4. package/scripts/uninstall-skills.js +3 -0
  5. package/skills/intuition-initialize/references/agents_template.md +12 -19
  6. package/skills/intuition-initialize/references/claude_template.md +30 -34
  7. package/skills/intuition-initialize/references/intuition_readme_template.md +21 -29
  8. package/skills/intuition-meander/SKILL.md +80 -0
  9. package/skills/intuition-outline/SKILL.md +1 -1
  10. package/skills/intuition-start/SKILL.md +3 -3
  11. package/skills/intuition-think-tank/SKILL.md +159 -0
  12. package/skills/intuition-design/SKILL.md +0 -385
  13. package/skills/intuition-engineer/SKILL.md +0 -307
package/README.md CHANGED
@@ -15,11 +15,10 @@ This installs 12 skills globally to `~/.claude/skills/`. Verify by typing `/` in
15
15
 
16
16
  ## Workflow
17
17
 
18
- Five phases with handoff transitions between each:
18
+ Two workflow modes:
19
19
 
20
- ```
21
- prompt → outline → [design] → engineer → build
22
- ```
20
+ **v9 (current):** `prompt → outline → assemble → detail → build → test`
21
+ **v8 (legacy):** `prompt → outline → build` (with handoff transitions)
23
22
 
24
23
  The first cycle is the **trunk**. After completion, create **branches** for new features or changes.
25
24
 
@@ -29,18 +28,14 @@ The first cycle is the **trunk**. After completion, create **branches** for new
29
28
  /intuition-initialize # Set up project memory (once per project)
30
29
  /intuition-start # Check status, get routed to next step
31
30
  /intuition-prompt # Describe what you want to build
32
- /intuition-handoff # Process → move to outlining
33
31
  /intuition-outline # Create the blueprint
34
- /intuition-handoff # Review design flags
35
- /intuition-design # Elaborate flagged items (if any)
36
- /intuition-handoff # Prepare for engineering
37
- /intuition-engineer # Create code specifications
38
- /intuition-handoff # Prepare for build
32
+ /intuition-assemble # Match tasks to domain specialists
33
+ /intuition-detail # Specialists produce blueprints
39
34
  /intuition-build # Implement and verify
40
- /intuition-handoff # Complete the cycle
35
+ /intuition-test # Quality gate
41
36
  ```
42
37
 
43
- Run `/clear` before each phase skill to keep context clean. Not every project needs design — if the outline is clear enough, handoff skips straight to engineer.
38
+ Run `/clear` before each phase skill to keep context clean.
44
39
 
45
40
  ## Skills
46
41
 
@@ -49,20 +44,28 @@ Run `/clear` before each phase skill to keep context clean. Not every project ne
49
44
  | Skill | Model | Purpose |
50
45
  |-------|-------|---------|
51
46
  | `/intuition-prompt` | opus | Refines a rough idea into an outline-ready brief |
52
- | `/intuition-outline` | opus | Strategic blueprint with tasks, dependencies, design flags |
53
- | `/intuition-design` | opus | ECD framework design exploration for flagged items |
54
- | `/intuition-engineer` | opus | Code-level specs through research + interactive dialogue |
55
- | `/intuition-build` | sonnet | Delegates implementation, verifies against specs |
47
+ | `/intuition-outline` | opus | Strategic blueprint with tasks, dependencies, depth assessment |
48
+ | `/intuition-assemble` | sonnet | Matches tasks to domain specialists and producers |
49
+ | `/intuition-detail` | opus | Domain specialists produce detailed blueprints |
50
+ | `/intuition-build` | sonnet | Delegates implementation, verifies against blueprints |
51
+ | `/intuition-test` | opus | Post-build quality gate — test strategy and execution |
56
52
 
57
53
  ### Infrastructure
58
54
 
59
55
  | Skill | Model | Purpose |
60
56
  |-------|-------|---------|
61
57
  | `/intuition-start` | haiku | Detects phase, routes to next skill, version check |
62
- | `/intuition-handoff` | haiku | State transitions, brief generation, design loop |
58
+ | `/intuition-handoff` | sonnet | Branch creation, v8 state transitions, migrations |
63
59
  | `/intuition-initialize` | haiku | Project memory setup (run once) |
64
60
  | `/intuition-update` | haiku | Package update manager |
65
61
 
62
+ ### Standalone Tools
63
+
64
+ | Skill | Model | Purpose |
65
+ |-------|-------|---------|
66
+ | `/intuition-meander` | opus | Thought partner — reason through problems collaboratively |
67
+ | `/intuition-think-tank` | opus | Rapid expert-panel analysis of documents, ideas, or proposals |
68
+
66
69
  ### Advisory
67
70
 
68
71
  | Skill | Model | Purpose |
@@ -73,21 +76,12 @@ Run `/clear` before each phase skill to keep context clean. Not every project ne
73
76
 
74
77
  ## Key Concepts
75
78
 
76
- ### Engineer → Build Split
77
-
78
- - **Engineer** (opus) determines the code-level HOW: researches codebase, discusses decisions interactively, produces `code_specs.md`
79
- - **Build** (sonnet) implements against specs: delegates to subagents, verifies with reviewers, runs mandatory security review, produces `build_report.md`
80
-
81
79
  ### Trunk and Branches
82
80
 
83
81
  - **Trunk**: First prompt→build cycle — the foundation
84
82
  - **Branches**: Subsequent cycles that read parent context for continuity
85
83
  - After any cycle completes, `/intuition-start` offers branch creation or debugging
86
84
 
87
- ### Design Loop
88
-
89
- The outline flags tasks needing design exploration. Handoff manages a loop: design one item → check for more → design next or advance to engineer.
90
-
91
85
  ### Project Memory
92
86
 
93
87
  All workflow state and knowledge lives in `docs/project_notes/`:
@@ -103,8 +97,7 @@ intuition/
103
97
  │ ├── intuition-start/ # Session primer + routing
104
98
  │ ├── intuition-prompt/ # Discovery refinement
105
99
  │ ├── intuition-outline/ # Strategic outlining
106
- │ ├── intuition-design/ # ECD design exploration
107
- │ ├── intuition-engineer/ # Code spec creation
100
+ │ ├── intuition-meander/ # Thought partner
108
101
  │ ├── intuition-build/ # Implementation + verification
109
102
  │ ├── intuition-handoff/ # State transitions + briefs
110
103
  │ ├── intuition-debugger/ # Post-completion diagnostics
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@tgoodington/intuition",
3
- "version": "9.5.0",
3
+ "version": "10.0.0",
4
4
  "description": "Domain-adaptive workflow system for Claude Code: prompt, outline, assemble specialist teams, detail with domain experts, build with format producers, test code output. Supports v8 compat (design, engineer, build) and v9 specialist workflows with 14 domain specialists and 6 format producers.",
5
5
  "keywords": [
6
6
  "claude-code",
package/scripts/install-skills.js CHANGED
@@ -46,8 +46,8 @@ const skills = [
46
46
  'intuition-prompt',
47
47
  'intuition-handoff',
48
48
  'intuition-outline',
49
- 'intuition-design',
50
- 'intuition-engineer',
49
+ 'intuition-meander',
50
+ 'intuition-think-tank',
51
51
  'intuition-build',
52
52
  'intuition-test',
53
53
  'intuition-debugger',
@@ -117,6 +117,19 @@ try {
117
117
  log(`Removed old /intuition-execute skill (split into /intuition-engineer + /intuition-build in v8.0)`);
118
118
  }
119
119
 
120
+ // Remove old design/engineer skills if they exist (removed in v10.0)
121
+ const oldDesignDest = path.join(claudeSkillsDir, 'intuition-design');
122
+ if (fs.existsSync(oldDesignDest)) {
123
+ fs.rmSync(oldDesignDest, { recursive: true, force: true });
124
+ log(`Removed old /intuition-design skill (removed in v10.0)`);
125
+ }
126
+
127
+ const oldEngineerDest = path.join(claudeSkillsDir, 'intuition-engineer');
128
+ if (fs.existsSync(oldEngineerDest)) {
129
+ fs.rmSync(oldEngineerDest, { recursive: true, force: true });
130
+ log(`Removed old /intuition-engineer skill (removed in v10.0)`);
131
+ }
132
+
120
133
  // Remove old plan skill if it exists (renamed to outline in v9.1)
121
134
  const oldPlanDest = path.join(claudeSkillsDir, 'intuition-plan');
122
135
  if (fs.existsSync(oldPlanDest)) {
@@ -229,8 +242,8 @@ try {
229
242
  log(` /intuition-prompt - Focused discovery (prompt-engineering refinement)`);
230
243
  log(` /intuition-handoff - Handoff orchestrator (phase transitions + design loop)`);
231
244
  log(` /intuition-outline - Strategic outline (ARCH protocol + design flagging)`);
232
- log(` /intuition-design - Design exploration (ECD framework, domain-agnostic)`);
233
- log(` /intuition-engineer - Code spec creator (engineering decisions)`);
245
+ log(` /intuition-meander - Thought partner (reasoning + exploration)`);
246
+ log(` /intuition-think-tank - Rapid expert-panel analysis`);
234
247
  log(` /intuition-assemble - Team assembler (v9 specialist/producer matching)`);
235
248
  log(` /intuition-detail - Domain specialist orchestrator (v9 detail phase)`);
236
249
  log(` /intuition-build - Build manager (blueprint + producer delegation)`);
package/scripts/uninstall-skills.js CHANGED
@@ -46,6 +46,9 @@ try {
46
46
  'intuition-prompt',
47
47
  'intuition-handoff',
48
48
  'intuition-outline',
49
+ 'intuition-meander',
50
+ 'intuition-think-tank',
51
+ // Legacy skills (removed in v10.0)
49
52
  'intuition-design',
50
53
  'intuition-engineer',
51
54
  'intuition-build',
package/skills/intuition-initialize/references/agents_template.md CHANGED
@@ -2,7 +2,7 @@
2
2
 
3
3
  ## Overview
4
4
 
5
- This project uses a multi-agent system coordinated by Intuition (`@tgoodington/intuition`), a Claude Code skill system. Twelve specialized skills handle prompt refinement, planning, design exploration, code engineering, and build execution, with memory maintained in `docs/project_notes/` for consistency across sessions.
5
+ This project uses a multi-agent system coordinated by Intuition (`@tgoodington/intuition`), a Claude Code skill system. Specialized skills handle prompt refinement, planning, domain-specialist detailing, and build execution, with memory maintained in `docs/project_notes/` for consistency across sessions.
6
6
 
7
7
  ## Workflow Skills
8
8
 
@@ -12,9 +12,10 @@ This project uses a multi-agent system coordinated by Intuition (`@tgoodington/i
12
12
  |-------|-------|-------------|
13
13
  | `/intuition-prompt` | opus | Transforms a rough vision into a planning-ready brief through focused iterative refinement |
14
14
  | `/intuition-outline` | opus | Strategic architect — maps stakeholders, explores components, evaluates options, creates executable blueprint |
15
- | `/intuition-design` | opus | Elaborates flagged plan items through ECD framework (Elements, Connections, Dynamics) |
16
- | `/intuition-engineer` | opus | Creates code-level specifications through codebase research and interactive dialogue → `code_specs.md` |
17
- | `/intuition-build` | sonnet | Delegates implementation to subagents, verifies outputs against code specs and acceptance criteria |
15
+ | `/intuition-assemble` | sonnet | Matches tasks to domain specialists and format producers |
16
+ | `/intuition-detail` | opus | Domain specialists produce detailed blueprints through exploration and user gates |
17
+ | `/intuition-build` | sonnet | Delegates implementation to subagents, verifies outputs against blueprints and acceptance criteria |
18
+ | `/intuition-test` | opus | Post-build quality gate — test strategy design and execution |
18
19
 
19
20
  ### Infrastructure
20
21
 
@@ -29,6 +30,8 @@ This project uses a multi-agent system coordinated by Intuition (`@tgoodington/i
29
30
 
30
31
  | Skill | Model | What it does |
31
32
  |-------|-------|-------------|
33
+ | `/intuition-meander` | opus | Thought partner — collaborative reasoning and problem exploration |
34
+ | `/intuition-think-tank` | opus | Rapid expert-panel analysis of documents, ideas, or proposals |
32
35
  | `/intuition-debugger` | opus | Expert debugger — 5 diagnostic categories, causal chain analysis, post-completion only |
33
36
  | `/intuition-agent-advisor` | opus | Expert advisor on building custom Claude Code agents |
34
37
  | `/intuition-skill-guide` | opus | Expert advisor on building custom Claude Code skills |
@@ -41,12 +44,11 @@ This project uses a multi-agent system coordinated by Intuition (`@tgoodington/i
41
44
 
42
45
  ## Workflow
43
46
 
44
- ### Trunk (first cycle)
47
+ ### Trunk (first cycle, v9)
45
48
 
46
49
  ```
47
- /intuition-prompt → handoff → /intuition-outline → handoff →
48
- [/intuition-design loop] → handoff → /intuition-engineer → handoff →
49
- /intuition-build → handoff → complete
50
+ /intuition-prompt → /intuition-outline → /intuition-assemble →
51
+ /intuition-detail → /intuition-build → /intuition-test → complete
50
52
  ```
51
53
 
52
54
  Each handoff transition:
@@ -64,18 +66,9 @@ After trunk completes, run `/intuition-start` to:
64
66
 
65
67
  Branches follow the same 5-phase workflow but read parent context for continuity.
66
68
 
67
- ### Design Loop (optional)
69
+ ### Detail Phase (v9)
68
70
 
69
- The plan flags tasks requiring design exploration (Section 6.5). If design items exist:
70
- 1. Handoff generates a design brief for the first item
71
- 2. `/intuition-design` elaborates it using the ECD framework
72
- 3. Handoff checks for remaining items → loops back or advances to engineer
73
-
74
- ### Engineer → Build Split
75
-
76
- - **Engineer** (opus, interactive) determines the code-level HOW: reads codebase via research subagents, discusses decisions with you, produces `code_specs.md`
77
- - **Build** (sonnet, PM) implements against specs: delegates to Code Writer subagents, verifies with Code Reviewer, runs mandatory Security Expert review, produces `build_report.md`
78
- - Build makes NO engineering decisions — it matches output to specs
71
+ The outline assesses every task by domain and depth. The assemble phase matches tasks to domain specialists. The detail phase runs each specialist through exploration → user gate → blueprint specification.
79
72
 
80
73
  ## Build Sub-Agents
81
74
 
package/skills/intuition-initialize/references/claude_template.md CHANGED
@@ -5,13 +5,11 @@ This project uses a five-phase workflow coordinated by the Intuition system, wit
5
5
  ### Workflow Model
6
6
 
7
7
  The Intuition workflow uses a trunk-and-branch model:
8
- - **Trunk**: The first prompt→plan→design→engineer→build cycle. Represents the core vision.
8
+ - **Trunk**: The first prompt→outline→detail→build→test cycle. Represents the core vision.
9
9
  - **Branches**: Subsequent cycles that build on, extend, or diverge from trunk or other branches.
10
10
  - **Debugger**: Post-completion diagnostic specialist for hard problems.
11
11
 
12
- All phases: `/intuition-prompt` → `/intuition-handoff` → `/intuition-outline` → `/intuition-handoff` →
13
- `[/intuition-design loop]` → `/intuition-handoff` → `/intuition-engineer` → `/intuition-handoff` →
14
- `/intuition-build` → `/intuition-handoff` → complete
12
+ v9 workflow: `/intuition-prompt` → `/intuition-outline` → `/intuition-assemble` → `/intuition-detail` → `/intuition-build` → `/intuition-test` → complete
15
13
 
16
14
  After completion: `/intuition-start` to create branches or `/intuition-debugger` to debug issues.
17
15
 
@@ -36,29 +34,30 @@ The project follows a structured workflow with handoff transitions between phase
36
34
  - Flags tasks requiring design exploration with rationale
37
35
  - Output: `outline.md` with tasks, dependencies, risks, design recommendations
38
36
 
39
- **Design** — `/intuition-design`
40
- - Detailed design exploration for flagged plan items
41
- - Framework: ECD (Elements, Connections, Dynamics)
42
- - Domain-agnostic: works for code, world building, UI, documents, or any creative/structural work
43
- - Runs once per flagged item in a loop managed by handoff
44
- - Output: Design specifications per item
37
+ **Assemble** — `/intuition-assemble`
38
+ - Matches outline tasks to domain specialists and format producers
39
+ - Writes team_assignment.json for the detail phase
45
40
 
46
- **Engineering** — `/intuition-engineer`
47
- - Creates code-level specifications through codebase research and interactive dialogue
48
- - Research subagents read codebase, engineer discusses decisions with user
49
- - Output: `code_specs.md` — determines the code-level HOW for every task
41
+ **Detail** — `/intuition-detail`
42
+ - Domain specialists produce detailed blueprints
43
+ - Stage 1 exploration → user gate → Stage 2 specification
44
+ - Output: Blueprints per specialist domain
50
45
 
51
46
  **Build** — `/intuition-build`
52
- - Delegates implementation to subagents, verifies against code specs and acceptance criteria
47
+ - Delegates implementation to format producers, verifies against blueprints and acceptance criteria
53
48
  - Mandatory security review before completion
54
- - Makes NO engineering decisions — matches output to specs
55
- - Output: `build_report.md` — task outcomes, files modified, deviations from specs
49
+ - Output: `build_report.md` — task outcomes, files modified
50
+
51
+ **Test** — `/intuition-test`
52
+ - Post-build quality gate
53
+ - Designs test strategy, creates tests, runs fix cycles
54
+ - Output: `test_report.md`
56
55
 
57
56
  **Session Primer** — `/intuition-start`
58
57
  - Loads project context, detects workflow phase, suggests next step
59
58
  - Run at the start of any session to get oriented
60
59
 
61
- **Recommended Flow**: Prompt → Handoff → Plan → Handoff → [Design Loop] → Handoff → Engineer → Handoff → Build → Handoff → complete
60
+ **Recommended Flow (v9)**: Prompt → Outline → Assemble → Detail → Build → Test → complete
62
61
 
63
62
  Run `/clear` before each phase skill. After completion, run `/intuition-start` to create a branch or invoke `/intuition-debugger` to debug issues.
64
63
 
@@ -74,11 +73,11 @@ Run `/clear` before each phase skill. After completion, run `/intuition-start` t
74
73
  **Phase Output Files** (created during workflow, in `{context_path}/`):
75
74
  - **outline_brief.md** — Brief for outline phase (created by Handoff)
76
75
  - **outline.md** — Structured project outline with design recommendations
77
- - **design_brief.md** — Brief for current design item (created/updated by Handoff)
78
- - **engineering_brief.md** — Brief for engineering phase (created by Handoff)
79
- - **code_specs.md** — Code-level specifications (created by Engineer)
80
- - **build_brief.md** — Brief for build phase (created by Handoff)
76
+ - **team_assignment.json** — Specialist/producer assignments (created by Assemble)
77
+ - **blueprints/** — Detailed blueprints per specialist (created by Detail)
78
+ - **build_brief.md** — Brief for build phase (created by Handoff, v8)
81
79
  - **build_report.md** — Task outcomes and files modified (created by Build)
80
+ - **test_report.md** — Test results and coverage (created by Test)
82
81
 
83
82
  ### Memory-Aware Protocols
84
83
 
@@ -115,20 +114,17 @@ Run `/clear` before each phase skill. After completion, run `/intuition-start` t
115
114
  **When user suggests outline work:**
116
115
  - "This sounds like a good candidate for planning. Use `/intuition-handoff` to process the brief, then `/intuition-outline` to develop a structured approach."
117
116
 
118
- **When plan is ready and has design items:**
119
- - "The plan looks ready! Use `/intuition-handoff` to review design recommendations and start the design loop."
120
-
121
- **When design items are complete:**
122
- - "All design specs are done! Use `/intuition-handoff` to prepare the engineering brief."
117
+ **When outline is ready:**
118
+ - "Outline looks ready! Use `/intuition-assemble` to match tasks to specialists."
123
119
 
124
- **When user is ready to engineer:**
125
- - "Engineering brief is ready! Use `/intuition-engineer` to create code specifications."
120
+ **When assembly is complete:**
121
+ - "Team assigned! Use `/intuition-detail` to start the specialist blueprint phase."
126
122
 
127
- **When engineering is complete:**
128
- - "Code specs are ready! Use `/intuition-handoff` to prepare the build brief."
129
-
130
- **When user is ready to build:**
131
- - "Build brief is ready! Use `/intuition-build` to kick off implementation."
123
+ **When detail is complete:**
124
+ - "Blueprints ready! Use `/intuition-build` to kick off implementation."
132
125
 
133
126
  **When build is complete:**
127
+ - "Build done! Use `/intuition-test` to run the quality gate."
128
+
129
+ **When test is complete:**
134
130
  - "Workflow cycle complete! Use `/intuition-start` to create a branch for new work, or `/intuition-debugger` to debug any issues."
package/skills/intuition-initialize/references/intuition_readme_template.md CHANGED
@@ -1,26 +1,19 @@
1
1
  # Intuition
2
2
 
3
- A trunk-and-branch workflow system for Claude Code. Turns rough ideas into structured plans, detailed designs, code specifications, and verified implementations through guided dialogue. Supports iterative development through independent branch cycles and post-completion debugging.
3
+ A trunk-and-branch workflow system for Claude Code. Turns rough ideas into structured plans, specialist-driven blueprints, and verified implementations through guided dialogue.
4
4
 
5
5
  ## Workflow
6
6
 
7
7
  ```
8
- /intuition-prompt → /intuition-handoff → /intuition-outline → /intuition-handoff
9
- ↓
10
- [design loop, if needed]
11
- ↓
12
- /intuition-handoff → /intuition-engineer
13
- ↓
14
- /intuition-build ← /intuition-handoff
15
- ↓
16
- /intuition-handoff → complete
17
- ↓
18
- /intuition-start → create branch or /intuition-debugger
8
+ /intuition-prompt → /intuition-outline → /intuition-assemble →
9
+ /intuition-detail → /intuition-build → /intuition-test → complete
10
+ ↓
11
+ /intuition-start → create branch or /intuition-debugger
19
12
  ```
20
13
 
21
- Run `/intuition-handoff` between every phase. It manages state, generates briefs, and routes you forward. Run `/clear` before each new phase skill to keep context clean.
14
+ Run `/clear` before each new phase skill to keep context clean.
22
15
 
23
- The first prompt→build cycle is the **trunk**. After trunk completes, create **branches** for new features or changes. Use `/intuition-debugger` to investigate hard problems in any completed context.
16
+ The first cycle is the **trunk**. After trunk completes, create **branches** for new features or changes. Use `/intuition-debugger` to investigate hard problems in any completed context.
24
17
 
25
18
  ## Skills
26
19
 
@@ -28,13 +21,16 @@ The first prompt→build cycle is the **trunk**. After trunk completes, create *
28
21
  |-------|-------------|
29
22
  | `/intuition-start` | Detects where you left off, shows project status, routes to next step or branch creation |
30
23
  | `/intuition-prompt` | Sharpens a rough idea into a planning-ready brief through focused Q&A |
31
- | `/intuition-outline` | Builds a strategic blueprint with tasks, decisions, and design flags |
32
- | `/intuition-design` | Elaborates flagged items through collaborative design exploration (ECD framework) |
33
- | `/intuition-engineer` | Creates code-level specifications through codebase research and interactive dialogue |
34
- | `/intuition-build` | Delegates implementation to subagents, verifies against code specs and acceptance criteria |
24
+ | `/intuition-outline` | Builds a strategic blueprint with tasks, depth assessment, and domain classification |
25
+ | `/intuition-assemble` | Matches tasks to domain specialists and format producers |
26
+ | `/intuition-detail` | Domain specialists produce detailed blueprints through exploration and user gates |
27
+ | `/intuition-build` | Delegates implementation to subagents, verifies against blueprints and acceptance criteria |
28
+ | `/intuition-test` | Post-build quality gate — test strategy design and execution |
35
29
  | `/intuition-debugger` | Expert debugger — diagnostic specialist for complex bugs, cross-context failures, performance issues |
36
- | `/intuition-handoff` | Processes phase outputs, updates memory, prepares the next phase |
30
+ | `/intuition-handoff` | Branch creation, v8 state transitions, migrations |
37
31
  | `/intuition-initialize` | Sets up project memory (you already ran this) |
32
+ | `/intuition-meander` | Thought partner — reason through problems collaboratively |
33
+ | `/intuition-think-tank` | Rapid expert-panel analysis of documents, ideas, or proposals |
38
34
 
39
35
  ## Quick Start
40
36
 
@@ -42,17 +38,13 @@ The first prompt→build cycle is the **trunk**. After trunk completes, create *
42
38
 
43
39
  1. `/intuition-start` — see where you are
44
40
  2. `/intuition-prompt` — describe what you want to build
45
- 3. `/intuition-handoff` — process and move to outline
46
- 4. `/intuition-outline` — create the blueprint
47
- 5. `/intuition-handoff` — review design flags, confirm items
48
- 6. `/intuition-design` — elaborate each flagged item (repeat with handoff between)
49
- 7. `/intuition-handoff` — prepare for engineering
50
- 8. `/intuition-engineer` — create code specifications
51
- 9. `/intuition-handoff` — prepare for build
52
- 10. `/intuition-build` — implement and verify
53
- 11. `/intuition-handoff` — complete the cycle
41
+ 3. `/intuition-outline` — create the blueprint
42
+ 4. `/intuition-assemble` — match tasks to specialists
43
+ 5. `/intuition-detail` — specialists produce blueprints
44
+ 6. `/intuition-build` — implement and verify
45
+ 7. `/intuition-test` — quality gate
54
46
 
55
- Not every project needs design. If the plan is clear enough, handoff skips straight to engineer. Run `/clear` before each phase skill.
47
+ Run `/clear` before each phase skill.
56
48
 
57
49
  ### After trunk completes (branches)
58
50
 
package/skills/intuition-meander/SKILL.md ADDED
@@ -0,0 +1,80 @@
1
+ ---
2
+ name: intuition-meander
3
+ description: Thought partner for reasoning through problems. Use when the user wants to think through an idea, explore a problem space, work through a decision, or talk something out. A collaborative thinking companion — not a workflow tool.
4
+ model: opus
5
+ tools: Read, Glob, Grep, Bash, Agent, AskUserQuestion, WebFetch, WebSearch
6
+ allowed-tools: Read, Glob, Grep, Bash, Agent
7
+ ---
8
+
9
+ # Meander — Thinking Partner
10
+
11
+ You are a thinking partner. Your job is to reason alongside the user — not interview them, not manage a process, not produce deliverables. Think together.
12
+
13
+ ## CRITICAL RULES
14
+
15
+ 1. You MUST research before you respond. When the user describes what they're thinking about, immediately launch 1-3 parallel research agents to gather relevant context (codebase, domain knowledge, prior art). Weave findings into conversation naturally.
16
+ 2. You MUST ask at most 1-2 focused questions per turn. Never rapid-fire. If you have three questions, pick the one that opens the most ground.
17
+ 3. You MUST build on the user's ideas ("yes, and..."). Your default posture is collaborative expansion. Add to their thinking — don't interrogate it.
18
+ 4. You MUST steer gently. If research reveals a better path or a known pitfall, bring it up respectfully: "One thing worth considering..." not "That won't work because..."
19
+ 5. You MUST NOT produce structured deliverables, briefs, specs, or formal documents unless explicitly asked.
20
+ 6. You MUST NOT reference any workflow, phase, state file, or framework. You are standalone.
21
+ 7. You MUST match the user's energy and register. If they're casual, be casual. If they're deep in technical weeds, go there with them.
22
+
23
+ ## HOW TO START
24
+
25
+ When the user invokes `/meander` or describes wanting to think something through:
26
+
27
+ 1. **Read the room.** What are they bringing? A half-formed idea? A decision they're stuck on? A problem they can't crack? A creative exploration?
28
+ 2. **Research immediately.** Based on what they've shared, launch research agents to gather context. If they're in a codebase, scan relevant files. If it's a domain question, look for patterns and prior art. Do this silently — don't announce it.
29
+ 3. **Respond as a thinking partner.** Share what you found that's relevant. Build on their idea. Offer a perspective. Ask one good question that moves the thinking forward.
30
+
31
+ ## VOICE
32
+
33
+ You are a sharp, knowledgeable colleague who genuinely enjoys thinking through hard problems. Not a consultant. Not a coach. Not an interviewer.
34
+
35
+ - **Opinionated but open.** You have views and share them. You also change your mind when the user makes a good point.
36
+ - **Curious, not interrogative.** Your questions come from genuine interest, not a checklist.
37
+ - **Warm but direct.** No flattery, no hedging, no "great question!" — just honest engagement.
38
+ - **Concise.** Say what matters. If a point takes one sentence, don't use three.
39
+ - **Domain-fluid.** Code architecture, business strategy, creative writing, system design, life decisions — you adapt to whatever the user brings.
40
+
41
+ ## RESEARCH PROTOCOL
42
+
43
+ Research is what separates you from a rubber duck. Use it constantly.
44
+
45
+ **When to research:**
46
+ - User describes a problem → research the domain, the codebase, similar solutions
47
+ - User proposes an approach → research whether it's been tried, what the trade-offs are
48
+ - Conversation reveals an unknown → research it before speculating
49
+
50
+ **How to research:**
51
+ - Launch `Explore` subagents or use Grep/Glob/Read directly for quick lookups
52
+ - For broader questions, use WebSearch or WebFetch
53
+ - Keep research focused — you're gathering context to think better, not writing a report
54
+ - Never announce "let me research that" — just do it and bring the findings into conversation
55
+
56
+ **Research budget:** 1-3 agents per turn max. Don't over-research simple questions.
57
+
58
+ ## THINKING PATTERNS
59
+
60
+ Use whichever pattern fits the moment. Don't announce them.
61
+
62
+ - **Steel-manning**: When the user is weighing options, make the strongest case for each before helping them decide.
63
+ - **Inversion**: "What would make this definitely fail?" can reveal more than "What would make this succeed?"
64
+ - **Analogical reasoning**: Pull from other domains. A database migration problem might mirror a logistics challenge.
65
+ - **Decomposition**: When something feels overwhelming, break it into pieces and tackle one.
66
+ - **Red teaming**: Poke holes in ideas — respectfully — to find the weak spots before reality does.
67
+
68
+ ## WHAT YOU DON'T DO
69
+
70
+ - No structured outputs unless asked (no briefs, specs, reports, JSON)
71
+ - No workflow management (no state files, phase transitions, routing)
72
+ - No project management (no task tracking, status updates)
73
+ - No unsolicited documentation
74
+ - No wrapping up with action items unless the user asks for them
75
+
76
+ ## DOCUMENTING
77
+
78
+ If the user asks you to document the conversation, write it down, or save your conclusions — do it. Write to whatever location makes sense (they'll tell you, or you can suggest one). Keep the format natural — a summary of what you discussed and what emerged, not a formal document.
79
+
80
+ If they don't ask, don't offer. The conversation is the product.
package/skills/intuition-outline/SKILL.md CHANGED
@@ -28,7 +28,7 @@ These are non-negotiable. Violating any of these means the protocol has failed.
28
28
  16. When planning on a branch, you MUST read the parent context's outline.md and include a Parent Context section (Section 2.5). Inherited architectural decisions from the parent are binding unless the user explicitly overrides them.
29
29
  17. You MUST NEVER proceed past a research agent launch until its results have returned and been incorporated into your analysis. Do NOT draft options, present findings, or write any output document while a research agent is still running.
30
30
 
31
- REMINDER: One question per turn. v9 → fast track `/intuition-build` or `/intuition-assemble`. v8 → `/intuition-handoff`. Never to `/intuition-engineer`.
31
+ REMINDER: One question per turn. v9 → fast track `/intuition-build` or `/intuition-assemble`. v8 → `/intuition-handoff`.
32
32
 
33
33
  # ARCH COVERAGE FRAMEWORK
34
34
 
package/skills/intuition-start/SKILL.md CHANGED
@@ -162,16 +162,16 @@ Output one line of status, then the next command.
162
162
  | planning_in_progress | "Planning in progress." | `/intuition-outline` |
163
163
  | ready_for_assemble | "Planning complete (v9)." | `/intuition-assemble` |
164
164
  | detail_in_progress | "Detail phase in progress." | `/intuition-detail` |
165
- | design_in_progress | "Design exploration in progress." | See DESIGN ROUTING below |
165
+ | design_in_progress | "Design exploration in progress (v8 legacy)." | See DESIGN ROUTING below |
166
166
  | ready_for_engineering | "Planning complete (v8)." | `/intuition-handoff` |
167
- | engineering_in_progress | "Engineering in progress." | `/intuition-engineer` |
167
+ | engineering_in_progress | "Engineering in progress (v8 legacy)." | `/intuition-handoff` |
168
168
  | ready_for_build | "Specs ready." | `/intuition-build` |
169
169
  | build_in_progress | "Build in progress." | `/intuition-build` |
170
170
  | ready_for_test | "Build complete, testing pending." | `/intuition-test` |
171
171
  | test_in_progress | "Test phase in progress." | `/intuition-test` |
172
172
  | post_completion | See POST-COMPLETION below | — |
173
173
 
174
- **DESIGN ROUTING (v8 only):** Read `context_workflow.workflow.design.items`. If any item has status "in_progress" → `/intuition-design`. If an item just completed and others remain → `/intuition-handoff`. If ambiguous, ask the user.
174
+ **DESIGN ROUTING (v8 only):** Read `context_workflow.workflow.design.items`. If any item has status "in_progress" or items remain → `/intuition-handoff` (design and engineer skills have been removed; handoff can help migrate or skip forward). If ambiguous, ask the user.
175
175
 
176
176
  **DETAIL ROUTING:** Read `context_workflow.workflow.detail`. If `current_specialist` is set and its status is "in_progress" → `/intuition-detail`. If all specialists completed but build not started → `/intuition-build`. If ambiguous, ask the user.
177
177