Claude Skill

turboplan

Analyze task complexity and route to a mode by artifact: direct fix for clear-scope changes, or a plan file when the approach needs to be written down. Use when the user asks to "turboplan", "run turboplan", "plan this task", "turbo plan mode", "plan and implement", or "use turbo

LLM Mart · 0 points · 22 views 0 listing impressions 0 install-command copies
Virus-scanned Reviewed automatically before listing.

Full trust report

Download tobihagemann-turbo-claude_skills_turboplan-733e983.zip · 2 KB
Part of tobihagemann/turbo — 147 skills

Install

skills CLI npx skills add https://github.com/tobihagemann/turbo/tree/main/claude/skills/turboplan
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install tobihagemann-turbo@llmmart
Git git clone https://github.com/tobihagemann/turbo.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole tobihagemann/turbo collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Turboplan

Analyze task complexity to recommend an execution mode, then let the user set the final route.

Categorize the user-supplied task along these dimensions using subjective judgment. This analysis makes the recommendation informed:

  • Scope: single feature / single subsystem vs multi-feature / multi-subsystem
  • Stakes: one-off change vs long-lived project with architectural implications
  • Unknowns: clear approach vs needs exploration and product decisions

Modes are named by what they produce: no plan, or a plan file.

Mode Criteria Route
Direct Clear scope, with any remaining decisions small enough to settle in conversation rather than write down. Aligns on the shape, then implements. Read references/direct-mode.md and follow its steps.
Plan The approach warrants writing down before implementing — to survey patterns, settle architectural decisions, or survive a fresh session. Produces a plan file, however large the work turns out to be. Read references/plan-mode.md and follow its steps.

Recommend and Confirm the Route

Form a recommended route from the dimensions and criteria above. Output the recommendation as text: the recommended mode and a line or two on why it fits over its neighbor.

Then use AskUserQuestion to have the user set the final route. Offer the recommended mode first, marked "(Recommended)", alongside the other mode; the auto-appended "Other" lets the user describe a different path.

Add a third Get a second opinion option whenever committing to the wrong mode would cost a session of rework, and whenever the recommended mode does not earn "(Recommended)" with conviction. It runs the /consult-codex skill for the soundest route given the task's scope, stakes, and unknowns. Then resolve the route with that answer in hand, re-asking when the choice stays the user's.

Carry the confirmed route into its reference file from the table above and follow its steps.

Rules

  • Diff size, perceived task simplicity, and context window concerns are not reasons to skip the chosen mode's phases.
Files (turbo)
  • references
    • direct-mode.md 476 B
      # Turboplan: Direct Mode
      
      Run `/discuss-change`. Direct mode aligns on the shape and implements it; `.turbo/plans/` stays untouched.
      
      ## Task Tracking
      
      Use `TaskCreate` to create a task for each phase:
      
      1. Run `/discuss-change` skill
      
      ## Phase 1: Run `/discuss-change` Skill
      
      Run the `/discuss-change` skill.
      
      Then use the TaskList tool and proceed to any remaining task.
      
      ## Rules
      
      - Direct mode applies the change via `/discuss-change` and leaves `.turbo/plans/` untouched.
      
    • plan-mode.md 2.2 KB
      # Turboplan: Plan Mode
      
      Draft → refine → self-improve → mark ready → halt to produce a plan file the user implements in a fresh session.
      
      ## Task Tracking
      
      Use `TaskCreate` to create a task for each phase:
      
      1. Run `/draft-plan` skill
      2. Run `/refine-plan` skill
      3. Run `/self-improve` skill
      4. Mark plan ready
      5. Summarize and halt
      
      ## Phase 1: Run `/draft-plan` Skill
      
      Run the `/draft-plan` skill with the input. The input may be a freeform task description, an explicit slug, or a path to a background document. Capture the resolved plan path from `/draft-plan`'s output for the next phases, and the path of any gated plan it also wrote. When it wrote one, use `TaskUpdate` to name both paths in the Phase 2 task's description.
      
      ## Phase 2: Run `/refine-plan` Skill
      
      Run the `/refine-plan` skill with `<path>` from Phase 1. When Phase 1 captured a gated plan, run the `/refine-plan` skill again with that path once the first run finishes.
      
      ## Phase 3: Run `/self-improve` Skill
      
      Run the `/self-improve` skill to compound planning learnings.
      
      ## Phase 4: Mark Plan Ready
      
      Update the YAML frontmatter of each plan from Phase 1 to `status: ready`.
      
      ## Phase 5: Summarize and Halt
      
      Present a brief summary of the finished plan: the essence of what it builds and the key decisions behind it, short enough to read at a glance so the user does not have to open the full plan file. When the plan delivers value to a user, developer, or operator, also present a short list of stories capturing what that person gains, in the form "As a <persona>, I want <capability> so that <outcome>". Skip the stories only when no beneficiary or outcome can be named, such as a purely mechanical refactor. Fit both to the plan rather than a fixed template.
      
      Then halt with this message:
      
      > Plan ready at `<plan path>`.
      >
      > Planning context is likely full, and the plan is comprehensive enough to continue fresh. Run `/clear`, then `/implement-plan <slug>` to implement.
      
      When Phase 1 captured a gated plan, add a line to that message naming its path and the gate that must pass before running `/implement-plan` on it.
      
      ## Rules
      
      - Route revisions through `/refine-plan` or `/draft-plan`.
      - Hand implementation to the user via the Phase 5 halt; the user runs `/implement-plan` in a fresh session.
      
  • SKILL.md 2.5 KB
    ---
    name: turboplan
    description: "Analyze task complexity and route to a mode by artifact: direct fix for clear-scope changes, or a plan file when the approach needs to be written down. Use when the user asks to \"turboplan\", \"run turboplan\", \"plan this task\", \"turbo plan mode\", \"plan and implement\", or \"use turboplan instead of plan mode\"."
    ---
    
    # Turboplan
    
    Analyze task complexity to recommend an execution mode, then let the user set the final route.
    
    Categorize the user-supplied task along these dimensions using subjective judgment. This analysis makes the recommendation informed:
    
    - **Scope**: single feature / single subsystem vs multi-feature / multi-subsystem
    - **Stakes**: one-off change vs long-lived project with architectural implications
    - **Unknowns**: clear approach vs needs exploration and product decisions
    
    Modes are named by what they produce: no plan, or a plan file.
    
    | Mode | Criteria | Route |
    |---|---|---|
    | **Direct** | Clear scope, with any remaining decisions small enough to settle in conversation rather than write down. Aligns on the shape, then implements. | Read [references/direct-mode.md](references/direct-mode.md) and follow its steps. |
    | **Plan** | The approach warrants writing down before implementing — to survey patterns, settle architectural decisions, or survive a fresh session. Produces a plan file, however large the work turns out to be. | Read [references/plan-mode.md](references/plan-mode.md) and follow its steps. |
    
    ## Recommend and Confirm the Route
    
    Form a recommended route from the dimensions and criteria above. Output the recommendation as text: the recommended mode and a line or two on why it fits over its neighbor.
    
    Then use `AskUserQuestion` to have the user set the final route. Offer the recommended mode first, marked "(Recommended)", alongside the other mode; the auto-appended "Other" lets the user describe a different path.
    
    Add a third **Get a second opinion** option whenever committing to the wrong mode would cost a session of rework, and whenever the recommended mode does not earn "(Recommended)" with conviction. It runs the `/consult-codex` skill for the soundest route given the task's scope, stakes, and unknowns. Then resolve the route with that answer in hand, re-asking when the choice stays the user's.
    
    Carry the confirmed route into its reference file from the table above and follow its steps.
    
    ## Rules
    
    - Diff size, perceived task simplicity, and context window concerns are not reasons to skip the chosen mode's phases.
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.

Related