Given - Rank Skills by ROI for a Given Goal

Input: $ARGUMENTS

Core Principles

1. ROI is contextual, not intrinsic. A skill doesn’t have a fixed ROI — it depends on the goal, the current state, what’s already been done, and what resources are available. /gu is high-ROI when the goal is vague, negative-ROI when the goal is already crystal clear.

2. Timing dominates. A skill can be high ROI later but low ROI now. /pv (procedure validation) is worthless before you have a procedure, essential after. Score for NOW, but flag future timing.

3. Skills interact. Running /gu first might make /foht much more valuable — it clarifies what “how” means. Score skills both independently AND in combination with likely predecessors.

4. Negative ROI is real and important. Some skills are tempting but actively harmful at the wrong time. /iterate on a first draft wastes effort. /ma when you need focus causes sprawl. Flagging these is as valuable as recommending positive-ROI skills.

5. RUN_NOW must be short. The user needs 2-4 immediate actions, not a ranked list of 20. The full ranking exists for reference; the execution slice exists for action.

Phase 1: Goal Parse

[G1] GOAL: [restated in one sentence]
[G2] GOAL_TYPE: [achievement | exploration | prevention | restoration | maintenance]
[G3] CONSTRAINTS: [time, resources, dependencies, blockers]
[G4] URGENCY: [exploring | planning | ready-to-act | deadline-driven | crisis]
[G5] CURRENT_STATE: [what's been done, what exists, what's known]
[G6] GOAL_CLARITY: [clear | somewhat clear | vague | contradictory]

If GOAL_CLARITY is vague or contradictory:

[G7] CLARITY_ISSUE: [what's unclear]
[G8] RESOLUTION: Consider running /gu first — ROI ranking on a vague goal produces vague rankings

Phase 2: Candidate Selection

From the full skill library, select skills plausibly relevant to the goal. Exclude obviously irrelevant skills.

For each candidate:

[G-N] CANDIDATE: /skill-id — RELEVANCE: [how it connects to the goal]

Selection Lenses

Phase 3: ROI Scoring

For each candidate, score on four dimensions:

ROI Classification

[G-N] SCORE: /skill-id
  UPSIDE: [level] — [why]
  COST: [level] — [why]
  RISK: [level] — [why]
  TIMING_FIT: [level] — [why]
  ROI_CLASS: HIGH | MEDIUM | LOW | NEGATIVE
  ROI_REASONING: [one sentence explaining the ROI]

Classification rules:

• HIGH: Upside ≥ High, Cost ≤ Medium, Risk ≤ Low, Timing = Right time or Urgent
• MEDIUM: Upside ≥ Medium, no dimension is prohibitive/certain
• LOW: Upside is Low, or Cost/Risk outweigh upside
• NEGATIVE: Running this skill now would actively hurt — wrong timing, causes sprawl, wastes effort on premature optimization

Interaction Effects

Check whether any high-scoring skill’s ROI changes based on running another skill first:

[G-N] INTERACTION: /skill-a ROI becomes [higher/lower] if /skill-b runs first — [why]

Phase 4: Ranking and Execution Slice

Sort all scored candidates highest to lowest ROI. Then extract the RUN_NOW subset.

RUN_NOW rules:

• Maximum 4 skills
• Must include the highest-ROI skill
• Must respect dependencies (if A needs B’s output, B comes first)
• Should cover different needs (not 3 analytical skills and no action skills)

Phase 5: Output

GOAL: [restated]
CURRENT_STATE: [summary]
GOAL_CLARITY: [level]

RUN_NOW (immediate execution slice):
1. /skill-id — ROI: HIGH — WHY: [one sentence]
2. /skill-id — ROI: HIGH — WHY: [one sentence]
3. /skill-id — ROI: MEDIUM — WHY: [one sentence]

FULL_RANKING:
1. /skill-id — ROI: HIGH
   UPSIDE: [level] — COST: [level] — RISK: [level] — TIMING: [level]
   WHY: [one sentence]
2. /skill-id — ROI: MEDIUM
   UPSIDE: [level] — COST: [level] — RISK: [level] — TIMING: [level]
   WHY: [one sentence]
...

NEGATIVE_ROI (tempting but harmful now):
- /skill-id — WHY_NEGATIVE_NOW: [reason] — WHEN_IT_BECOMES_POSITIVE: [condition]
- /skill-id — WHY_NEGATIVE_NOW: [reason] — WHEN_IT_BECOMES_POSITIVE: [condition]

INTERACTION_EFFECTS:
- /skill-a + /skill-b: [how they interact]

Failure Modes

Depth Scaling

Default: 2x. These are floors.

Pre-Completion Checklist

• Goal restated clearly with type and constraints
• Goal clarity assessed (if vague, flagged before ranking)
• Candidates selected from multiple lenses (not just direct)
• Each candidate scored on all four ROI dimensions with reasoning
• Interaction effects checked between top candidates
• Negative ROI skills identified (not left empty)
• RUN_NOW is ≤4 skills with dependency order respected
• TIMING_FIT factored into ROI class (not just UPSIDE)

Integration

• Use from: /meta, /want (after goal is clear, to decide what to run)
• Differs from /wsib: wsib picks one best skill by intent fit; given ranks many by ROI
• Differs from /extract: extract maps skills by sub-need coverage; given ranks by value
• Differs from /fonss: fonss sequences skills; given ranks them by ROI
• Routes to: whatever skills are in the RUN_NOW slice