Agent skill

dex-improve

Workshop an improvement idea into implementation plan

Stars 163
Forks 31

Install this agent skill to your Project

npx add-skill https://github.com/majiayu000/claude-skill-registry/tree/main/skills/data/dex-improve

SKILL.md

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)
  1. Update state file with current date and capabilities seen

State File Format

Location: System/claude-code-state.json

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: Full Capability Audit

Review all known Claude Code capabilities against your current system.

Process

  1. Inventory current usage:

    • Scan .claude/ folder for hooks, commands, settings
    • Check System/Skills/ for skills
    • Check core/mcp/ for MCP integrations
    • Read 06-Resources/Learnings/ for known patterns
  2. Load capability reference:

    • Use the capability match table (from Mode 1, Phase 3)
    • Search web for comprehensive Claude Code feature list if needed
  3. Gap analysis:

=== CAPABILITY AUDIT ===

✅ Using Well:
- Commands (12 defined)
- Skills (person-lookup)

⚠️ Underutilized:
- Hooks — No hooks configured. Could automate:
  - Session start: Load context automatically
  - Post-edit: Update related files

❌ Not Using:
- Sub-agents — Could parallelize research tasks
- MCP beyond tasks — Calendar, email integrations possible

=== RECOMMENDATIONS ===

Ranked by impact vs. effort:

1. [High impact, low effort]
   - Add SessionStart hook to load daily context
   - Why: Saves 30 seconds every session
   - Connects to: [pillar]

2. [High impact, medium effort]
   ...
  1. Offer to workshop any recommendation the user wants to pursue

Plan Output Template

Create at: plans/dex-improvement-[slug].md

markdown
# Dex Improvement: [Title]

**Created:** [Date]
**Status:** Planning → In Progress → Complete
**Pillar:** [pillar name if configured]

## Overview

[2-3 sentence summary of what we're improving and why]

## Requirements

- [ ] Requirement 1
- [ ] Requirement 2
- [ ] Requirement 3

## Capability Analysis

| Requirement | Implementation | Feature Type | Rationale |
|-------------|----------------|--------------|-----------|
| [req] | [how] | Hook/Sub-agent/Skill/Command | [why this approach] |

## Recommended Approach

[Which Claude Code features to use and why. Include trade-offs considered.]

## Implementation Steps

### Phase 1: [Foundation]
1. [Step]
2. [Step]

### Phase 2: [Core]
1. [Step]
2. [Step]

## Files to Create/Modify

| File | Action | Purpose |
|------|--------|---------|
| `path/to/file` | Create/Modify | [what] |

## Compound Opportunities

[What else we could solve while building this]

- [ ] [Adjacent improvement 1]
- [ ] [Adjacent improvement 2]

## Acceptance Criteria

- [ ] [Testable outcome 1]
- [ ] [Testable outcome 2]

## Questions Resolved

- Q: [Question that came up]
- A: [How we decided]

Example Interactions

Mode 1: Workshop

/dex-improve "Better meeting action item capture"

> **Understanding:** You want to improve how action items flow from meetings 
> into your task system. This touches workflows (meeting processing) and 
> task management (capture and routing).
>
> **Current state** (from Learnings):
> - Meeting notes go to `00-Inbox/Meetings/`
> - Action items manually extracted during review
>
> **Capability scan:**
> - PostToolUse hook could auto-trigger processing after meeting note creation
> - Sub-agent could parallel process: action items, follow-ups, person updates
>
> **Questions:**
> 1. Where are items getting lost—during capture, or in follow-through?
> 2. Would auto-drafted follow-up emails be valuable?

Mode 2: What's New

/dex-improve
> [selects "What's new?"]

> 📢 Claude Code Updates (since 2026-01-15)
>
> === NEW CAPABILITIES ===
> 1. Async Hooks — Hooks can now run without blocking
>    - How it could help: Faster session startup
>    - Effort: Low
>
> === SUGGESTED IMPROVEMENTS ===
> 1. Non-blocking context loading
>    - What: Load learnings/preferences in background
>    - Why: Snappier session starts
>
> Want to workshop any of these?

Mode 3: Full Audit

/dex-improve
> [selects "Full audit"]

> === CAPABILITY AUDIT ===
>
> ✅ Using Well: Commands (12), Skills (1)
> ⚠️ Underutilized: Hooks (0 configured)
> ❌ Not Using: Sub-agents, Advanced MCP
>
> === TOP RECOMMENDATION ===
> Add SessionStart hook — saves context loading time every session
>
> Want me to workshop this improvement?

Behaviors

Always Do

  • Check internal patterns before suggesting new implementations
  • Tie suggestions to user's pillars/jobs-to-be-done when configured
  • Update state file after Mode 2 runs
  • Offer concrete capability recommendations, not just ideas

Never Do

  • Skip the research phase
  • Suggest capabilities without explaining why they fit
  • Output a plan before requirements are confirmed
  • Make changes without explicit approval

Philosophy

This isn't just requirements gathering—it's capability-aware design. The goal is to help you leverage Claude Code's full potential while building exactly what you need, nothing more.

Didn't find tool you were looking for?

Be as detailed as possible for better results