Type /next-move. Get a parallelized execution plan. Accept, modify, or reject.
/next-move: Your AI Already Knows What's Next
We built a slash command that reads your project's git state, conversation context, and skill catalog — then predicts the highest-impact sequence of agents to run. Zero API cost. One command.
You're deep in a session. You've been refactoring auth, writing tests, fixing edge cases. You pause. What should I do next?
Vanilla Claude gives you a wall of text. Maybe a bulleted list. No structure, no parallelism, no skill matching, no risk analysis. Just vibes.
/next-move gives you this:
That's a predicted DAG: 7 nodes across 3 waves, each matched to a specific skill from a 143+ library, with commitment levels, time estimates, cost estimates, and a pre-mortem risk analysis. One command. Zero API cost — the agent IS the LLM.
How It Works — 5-agent meta-DAG
Skill Specificity — 7 nodes, 7 experts
Output Format — commitment levels
Triple Storage — learning loop
The Problem With "What's Next?"
Every AI coding assistant can answer "what should I do next?" But the answers are always flat. A bulleted list doesn't encode:
- Dependencies: Which tasks block which other tasks?
- Parallelism: Which tasks can run simultaneously?
- Skill specificity: Which expert agent should handle each task?
- Risk: What could go wrong before you commit?
- Commitment levels: Which tasks are certain vs. exploratory?
A DAG encodes all of this. /next-move produces one.
How It Works
Under the hood, /next-move simulates a 5-agent meta-DAG pipeline in a single pass. Each agent produces structured output that feeds the next:
The Pipeline
Wave 0 — Sensemaker: Reads your git status, branch, recent commits, CLAUDE.md, and conversation context. Classifies the problem as well-structured, ill-structured, or wicked. If confidence drops below 0.6, the halt gate fires — it asks you instead of guessing.
Wave 1 — Decomposer: Breaks the inferred problem into 3-8 concrete subtasks. Each must be testable and achievable by a single agent. Groups independent tasks into parallel waves.
Wave 2a — Skill Selector: For each subtask, runs a three-step selection cascade — narrow 143+ skills to 5-10 candidates by semantic similarity, reason about fit (checking "NOT for" exclusions, scope alignment, downstream needs), then note the runner-up for future Thompson sampling. A code review task gets code-review-checklist, not generic Claude. An API design gets api-architect. A blog post gets claude-ecosystem-promoter.
Wave 2b — PreMortem (parallel with Skill Selector): Scans for structural risks (single points of failure, missing subtasks), skill risks (mismatches, overlaps), and context risks (uncommitted work, stale branches).
Wave 3 — Synthesizer: Assembles the complete PredictedDAG with timing, cost estimates, and the risk summary. Presents it with commitment levels and asks: Accept, Modify, or Reject?
Why Skill Specificity Matters
This is the core WinDAGs advantage. Vanilla Claude uses one approach for everything. A single /next-move invocation references 6+ specific skills via the selection cascade. Every predicted DAG node gets matched to a purpose-built skill from the library.
Consider a typical prediction with 7 nodes:
| Node | Generic Claude | With Skills |
|---|---|---|
| Commit cleanup | git add -A && git commit |
commit skill: conventional commits, staged-only, hook-aware |
| Fix dead refs | Find and replace | refactoring-surgeon: AST-aware, cross-file, import tracking |
| Package skill | Copy files | skill-creator: frontmatter validation, activation triggers, anti-patterns |
| Write tutorial | Markdown dump | technical-writer: progressive disclosure, code examples, installation steps |
| Record demo | Screenshot | webapp-testing: VHS/asciinema, terminal recording, GIF optimization |
| Blog post | Long paragraph | claude-ecosystem-promoter: SEO, embedded media, architecture diagrams |
| Update metadata | Edit JSON | windags-librarian: catalog consistency, cross-reference validation |
The more skills you have, the more specific the matches. The more you use /next-move, the sharper the selections become — every accept/modify/reject decision feeds back into skill sharpening.
The Output Format
FEELING IT OUT — flexible
SCOUTING — exploratory
Below 0.5 = halt gate fires
/next-move presents predictions with light-hearted commitment levels:
- LOCKED IN — This is happening. High confidence, well-defined task.
- FEELING IT OUT — Probably, but flexible. Approach may change based on earlier results.
- SCOUTING — Might not be needed. Depends on what we learn.
The tone is a colleague showing you a plan, not a system generating a report. Because that's what it is — a skilled agent reasoning about your project with genuine context.
Triple Storage
Every prediction gets stored as a triple: { context, prediction, feedback }. The feedback starts as null and gets filled when you accept, modify, or reject.
{
"context": {
"git_branch": "main",
"modified_files_count": 62,
"recent_commits": ["feat: /next-move two invocation paths"]
},
"prediction": {
"title": "Ship next-move to the World",
"confidence": 0.88,
"waves": 3,
"nodes": 7
},
"feedback": null
}
Triples are local and private. They accumulate across sessions and feed the learning loop — which skills get swapped out, which subtasks were missing, whether the decomposition granularity was right. This is the data that makes skill selection sharper over time.
Install These Skills
Drop them into ~/.claude/skills/ and they activate automatically. Works with Claude Code, Codex, Gemini CLI, Cursor, and 40+ agents.
Predict your next DAG. Zero API cost.
$ npx skills add curiositech/windags-skills --skill next-move$ git clone https://github.com/curiositech/windags-skills.git && cp -r windags-skills/skills/next-move ~/.claude/skills/Design, create, and audit agent skills.
$ npx skills add curiositech/windags-skills --skill skill-architect$ git clone https://github.com/curiositech/windags-skills.git && cp -r windags-skills/skills/skill-architect ~/.claude/skills/Guides creation of high-quality skills with scoring.
$ npx skills add curiositech/windags-skills --skill skill-coach$ git clone https://github.com/curiositech/windags-skills.git && cp -r windags-skills/skills/skill-coach ~/.claude/skills/Try It
/next-move
No arguments needed. It reads your project context automatically — git state, conversation history, available skills — and produces a predicted DAG in seconds.
Your call: Accept / Modify / Reject.