Agent skill
dex-improve
Workshop an improvement idea into implementation plan
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:
- Workshop an idea — Bring a fuzzy improvement idea, we'll shape it into a concrete plan
- Review what's new — See recent Claude Code changes and how they could improve your system
- 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:
-
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)
-
State your understanding in 2-3 sentences
-
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:
- Generate the plan document (see template below)
- Save to
plans/dex-improvement-[slug].md - Add any new patterns to
06-Resources/Learnings/ - Add viable future ideas to backlog
Mode 2: What's New?
Review recent Claude Code changes and suggest improvements.
Process
-
Read state file:
System/claude-code-state.json- If missing, this is first run — do a full scan instead
-
Fetch current changelog: Use WebSearch to find latest Claude Code changelog/releases
-
Compare: What's new since
last_checkdate? -
For each new feature, evaluate:
- Is this relevant to Dex use cases?
- What existing workflow could it improve?
- Does it unlock something previously impossible?
-
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)
- 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: Full Capability Audit
Review all known Claude Code capabilities against your current system.
Process
-
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
- Scan
-
Load capability reference:
- Use the capability match table (from Mode 1, Phase 3)
- Search web for comprehensive Claude Code feature list if needed
-
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]
...
- Offer to workshop any recommendation the user wants to pursue
Plan Output Template
Create at: plans/dex-improvement-[slug].md
# 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.
Recommended Agent Skills
Expand your agent's capabilities with these related and highly-rated skills.
agent-ops-spec
Manage specification documents in .agent/specs/. Use when user provides requirements, acceptance criteria, or feature descriptions that need to be tracked and validated against implementation.
agent-ops-state
Maintain .agent state files. Use at session start, after meaningful steps, and before concluding: read/update constitution/memory/focus/issues/baseline consistently.
agent-ops-spec
Manage specification documents in .agent/specs/. Use when user provides requirements, acceptance criteria, or feature descriptions that need to be tracked and validated against implementation.
agent-ops-testing
Test strategy, execution, and coverage analysis. Use when designing tests, running test suites, or analyzing test results beyond baseline checks.
agent-ops-testing
Test strategy, execution, and coverage analysis. Use when designing tests, running test suites, or analyzing test results beyond baseline checks.
agent-ops-state
Maintain .agent state files. Use at session start, after meaningful steps, and before concluding: read/update constitution/memory/focus/issues/baseline consistently.
Didn't find tool you were looking for?