s-do

name	s-do
description	Freeform router - accepts natural language and routes to the appropriate skill(s)

/s:do - Freeform Router

Accepts natural language instructions and routes to the correct skill(s). The universal entry point.

Usage: /s:do {natural language instruction}

Step 1: Parse Intent

Read the user's natural language instruction. Analyze it to determine:

1. Action type: create, fix, review, ship, explore, document, test, debug, plan
2. Scope: single file, module, feature, project-wide
3. Urgency: quick fix vs. planned work
4. Dependencies: does this require other skills first?

Step 2: Intent-to-Skill Mapping

Map the detected intent to one or more skills:

Single-Skill Routes

Intent Pattern	Routes To	Reason
"fix {bug/error/issue}"	/s:debug	Systematic debugging required
"review {code/PR/changes}"	/s:review	Multi-perspective code review
"ship it / push / deploy / PR"	/s:ship	Ship workflow
"what's the status / where are we"	/s:status	Project state overview
"continue / resume / pick up"	/s:resume	Context reconstruction
"pause / stop / save state"	/s:pause	State preservation
"test the UI / check the page"	/s:qa	Browser-based QA
"document / write docs"	/s:docs	Documentation update
"note: {something}"	/s:note	Quick note capture
"help / what can you do"	/s:help	Skill listing
"map the codebase / show architecture"	/s:map	Codebase documentation
"brainstorm / explore / think about"	/s:brainstorm	Creative exploration
"plan {feature/work}"	/s:plan	Implementation planning
"verify / check / confirm done"	/s:verify	Evidence-based verification
"retro / retrospective / what went well"	/s:retro	Retrospective
"save learnings / compound"	/s:compound	Knowledge persistence
"start new project"	/s:new	Project initialization
"requirements / discuss / what should we build"	/s:discuss	Requirements gathering
"open {url} / browse {url}"	/s:browse	Headless browser
"setup cookies / login"	/s:cookies	Cookie import

Multi-Skill Chains

Intent Pattern	Routes To	Reason
"add a new feature for X"	/s:brainstorm > /s:plan > /s:build	Full feature workflow
"fix the bug and ship it"	/s:debug > /s:verify > /s:ship	Fix + verify + ship
"review and ship"	/s:review > /s:verify > /s:ship	Review gate before ship
"build and test X"	/s:build > /s:verify	Implementation + verification
"start fresh on X"	/s:new > /s:discuss	New project kickoff
"plan and build X"	/s:plan > /s:build	Plan then implement
"quick fix for X"	/s:quick "{X}"	Compressed workflow
"do everything automatically"	/s:auto	Full autonomous loop
"review from CEO perspective"	/s:ceo-review	Product perspective
"technical review"	/s:eng-review	Engineering perspective
"full review"	/s:ceo-review > /s:eng-review > /s:review	All perspectives

Step 3: Display Routing Decision

Always show the routing decision before executing:

[DO] Understood: "{user_instruction}"
[DO] Routing to: /s:{skill} because {reason}

For multi-skill chains:

[DO] Understood: "{user_instruction}"
[DO] Routing chain:
  1. /s:{skill_1} - {reason_1}
  2. /s:{skill_2} - {reason_2}
  3. /s:{skill_3} - {reason_3}

Step 4: Ambiguity Resolution

If the intent is ambiguous (maps to multiple possible skills equally):

[DO] I'm not sure which workflow fits best for: "{user_instruction}"

Options:
  A) /s:{skill_a} - {when this makes sense}
  B) /s:{skill_b} - {when this makes sense}
  C) /s:{skill_c} - {when this makes sense}

Which one? (A/B/C or describe more)

NEVER guess when ambiguous. Ask.

Step 5: Confirmation Gate

For single-skill routes with HIGH confidence: execute immediately, no confirmation needed.

For multi-skill chains: ask for confirmation before starting:

[DO] This will run {N} skills in sequence. Proceed? (yes/no/modify)

For destructive-sounding actions (delete, reset, remove): ALWAYS confirm:

[DO] This sounds like a destructive action. Routing to: /s:{skill}
[DO] Are you sure? (yes/no)

Step 6: Execute

Once routing is confirmed:

1. Run the first skill with its full instructions
2. For chains, pass context from one skill to the next
3. Show progress: [DO] Completed /s:{skill_1}, starting /s:{skill_2}...
4. If any skill fails, stop and report (don't blindly continue the chain)

Step 7: Handle Unknown Intents

If no skill matches the instruction:

[DO] I don't have a specific skill for that, but here's what I can do:

Core:     /s:new  /s:discuss  /s:plan  /s:build  /s:status  /s:resume  /s:pause  /s:note
Quality:  /s:brainstorm  /s:review  /s:verify  /s:debug  /s:ceo-review  /s:eng-review
Ship:     /s:ship  /s:compound  /s:retro  /s:docs
Browser:  /s:qa  /s:qa-only  /s:browse  /s:cookies
Auto:     /s:auto  /s:quick  /s:do  /s:map  /s:help

Can you rephrase, or pick a skill directly?

Step 8: Context Awareness

Before routing, check current project state:

• If .planning/STATE.md doesn't exist and the request needs it → suggest /s:new first
• If there's an active phase in STATE.md → factor that into routing decisions
• If the request conflicts with current state (e.g., "ship" but no tests pass) → warn

[DO] Warning: You asked to ship, but STATE.md shows verification hasn't passed yet.
[DO] Recommended chain: /s:verify > /s:ship
[DO] Proceed with recommended chain? (yes/no/force ship anyway)

Compound Requests

Handle instructions with "and", "then", "after that":

• "fix the bug and then ship it" → /s:debug > /s:verify > /s:ship
• "brainstorm, plan, and build the auth feature" → /s:brainstorm > /s:plan > /s:build
• "review, fix issues, and ship" → /s:review > (fix issues inline) > /s:verify > /s:ship

Parse conjunctions and sequence words to build the skill chain.

Notes

• /s:do is a ROUTER, not a skill executor - it delegates to real skills
• Every routed skill runs with its full instructions and protocols
• TDD, verification, and other rules still apply through the routed skills
• /s:do respects circuit breaker state if /s:auto set one
• If the user just wants to talk/ask a question (no action), respond normally without routing