/dex-improve

name: dex-improve
description: "Workshop one improvement idea into an implementation plan. Use when the user says 'let's flesh out idea-X', 'turn this into a plan', 'improve Dex's Y'. Not for ranking the whole backlog; use `dex-backlog`. Not for a PRD for the user's own product; use `product-brief`."

What This Command Does

**In plain English:** Your design partner for making Dex better. Three ways to use it:

1. **Workshop an idea** — Bring a fuzzy improvement idea, we'll shape it into a concrete plan 2. **Review what's new** — See recent Claude Code changes and how they could improve your system 3. **Full capability audit** — Find features you're not using that could help with your jobs-to-be-done

**When to use it:**

• "I have an idea but don't know how to implement it"
• "What new Claude Code features should I be using?"
• "Am I getting the most out of this system?"

**How to run it:**

/dex-improve                           # Shows menu of options
/dex-improve "your idea here"          # Jumps straight to workshopping

---

Entry Point

When invoked, offer these options:

How would you like to explore improvements?

1. **I have an idea** — Workshop a specific improvement
2. **What's new?** — Review Claude Code changes since [last check: DATE]
3. **Full audit** — Review all capabilities vs. your current usage

Or just describe your idea and I'll start workshopping.

If user provides $IDEA argument, skip to Mode 1 directly.

---

Mode 1: Workshop an Idea

**Arguments:** $IDEA — High-level description of what you want to improve

Phase 1: Understand

Parse the idea and frame it back:

1. Identify which Dex areas are involved:

• Workflows (daily, weekly routines)
• Automation (scripts, hooks, scheduled tasks)
• Relationships (people tracking, meetings)
• Task management (capture, flow, priorities)
• Projects (planning, tracking, health)
• Information retrieval (search, lookups)

2. State your understanding in 2-3 sentences 3. Note any ambiguity that needs clarification

Phase 2: Research + Capability Scan

Build context from multiple sources:

**Internal (always check):**

06-Resources/Learnings/                 # What you've learned so far
System/Skills/                       # Existing reusable behaviors
.claude/commands/                    # Existing commands that might overlap
System/pillars.yaml                  # Strategic priorities

**External (when needed):**

• Search web for latest Claude Code capabilities
• Check official docs at docs.anthropic.com

Check:

• Does similar functionality already exist?
• What existing patterns could we leverage?

Phase 3: Capability Match

Map requirements to optimal Claude Code features:

| Requirement Pattern | Suggested Feature | Why | |---------------------|-------------------|-----| | "Every time I edit X, do Y" | PostToolUse hook | Automatic trigger after tool completion | | "Before doing X, check Y" | PreToolUse hook | Validation/confirmation gate | | "At start of session, load Z" | SessionStart hook | Context injection | | "Fast search while I work" | Explore sub-agent | Haiku model, runs in parallel | | "Different perspective on X" | Custom sub-agent | Isolated context, specific focus | | "Multi-step structured workflow" | Skill | Reusable behavior, always available | | "Explicit invocation with steps" | Command | User-triggered workflow | | "Connect to external service" | MCP integration | Tool access to external systems |

Present the capability analysis to the user.

Phase 4: Expand

Suggest 2-3 adjacent improvements:

• Based on capability analysis, what else could we solve?
• Flag compound opportunities (build A, get B nearly free)
• Connect to existing gaps in the system
• Consider synergies with strategic pillars

Frame as: "While we're here, you might also consider..."

Phase 5: Refine

Drive toward concrete requirements through focused questions:

• Ask max 2-3 questions at a time
• Validate capability assumptions
• Confirm implementation approach preference
• Identify acceptance criteria

Loop between Research → Expand → Refine until requirements are solid.

Phase 6: Plan + Update

When requirements are firm:

1. Generate the plan document (see template below) 2. Save to `plans/dex-improvement-[slug].md` 3. Add any new patterns to `06-Resources/Learnings/` 4. Add viable future ideas to backlog

---

Mode 2: What's New?

Review recent Claude Code changes and suggest improvements.

Process

1. **Read state file:** `System/claude-code-state.json`

• If missing, this is first run — do a full scan instead

2. **Fetch current changelog:** Use WebSearch to find latest Claude Code changelog/releases

3. **Compare:** What's new since `last_check` date?

4. **For each new feature, evaluate:**

• Is this relevant to Dex use cases?
• What existing workflow could it improve?
• Does it unlock something previously impossible?

5. **Present findings:**

📢 Claude Code Updates (since [last check date])

=== NEW CAPABILITIES ===

1. [Feature Name]
   - What it does: [description]
   - How it could help: [specific Dex improvement]
   - Effort to implement: Low/Medium/High

2. [Feature Name]
   ...

=== SUGGESTED IMPROVEMENTS ===

Based on these new capabilities, here's what you could build:

1. [Improvement name]
   - What: [description]
   - Why: [connects to which pillar/job-to-be-done]
   - Uses: [which new capability]

Want to workshop any of these? (Enter number or describe your own idea)

6. **Update state file** with current date and capabilities seen

State File Format

Location: `System/claude-code-state.json`

{
  "last_check": "2026-01-22",
  "last_version_seen": "1.0.30",
  "features_seen": [
    "hooks",
    "sub-agents",
    "skills",
    "commands",
    "mcp"
  ],
  "features_noted": [
    {
      "version": "1.0.30",
      "feature": "Async hooks",
      "date_seen": "2026-01-22"
    }
  ]
}

---

Mode 3: