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
Install
npx skills add https://github.com/tobihagemann/turbo/tree/main/codex/skills/turboplan
claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install tobihagemann-turbo@llmmart
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 request_user_input 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-claude 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.
Workflow state lives at .turbo/workflows/<slug>.md — slug from the task summary (lowercased, non-alphanumerics to hyphens, truncated to 40 characters at a word boundary). It pairs one-to-one with the thread's goal. When this run's create_goal attempt succeeds, write the file fresh: Status: active plus the confirmed route's step list from its reference file as a checkbox list. When an unfinished goal already exists, mirror into the workflow file its objective names; when it names none, continue without workflow state. Mirror every update_plan call into the file; it holds the pipeline's remaining steps and their statuses. When this run created the goal, run the terminal step in order: mark the final entry completed and mirror it, set Status: closed, mark the goal complete with update_goal, then emit any halt message.
Attempt create_goal with the objective: "Carry the task '
Carry the confirmed route into its reference file from the table above and follow its steps. If this run created the goal, resolve it inside the route's own flow rather than after it: mark it complete with update_goal when the route's final step is reached, before emitting any designed halt message.
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 578 B
# Turboplan: Direct Mode Run `$discuss-change`. Direct mode aligns on the shape and implements it; `.turbo/plans/` stays untouched. ## Task Tracking Use `update_plan` to track each phase, restating any remaining steps of a parent workflow alongside them: 1. Run `$discuss-change` skill ## Phase 1: Run `$discuss-change` Skill Run the `$discuss-change` skill. Then call `update_plan` to mark this step completed and continue with the next step of the active workflow. ## Rules - Direct mode applies the change via `$discuss-change` and leaves `.turbo/plans/` untouched. -
plan-mode.md 2.3 KB
# Turboplan: Plan Mode Draft → refine → self-improve → mark ready → halt to produce a plan file the user implements after an optional `/compact`. ## Task Tracking Use `update_plan` to track each phase, restating any remaining steps of a parent workflow alongside them: 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, call `update_plan` to add an entry right after Phase 2 for running `$refine-plan` on the gated plan's path, restating any remaining steps of a parent workflow. ## 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>`. > > This is a good point to `/compact` before implementing. Then run `$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` after an optional `/compact`.
-
-
SKILL.md 4.2 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 `request_user_input` 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-claude` 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. Workflow state lives at `.turbo/workflows/<slug>.md` — slug from the task summary (lowercased, non-alphanumerics to hyphens, truncated to 40 characters at a word boundary). It pairs one-to-one with the thread's goal. When this run's `create_goal` attempt succeeds, write the file fresh: `Status: active` plus the confirmed route's step list from its reference file as a checkbox list. When an unfinished goal already exists, mirror into the workflow file its objective names; when it names none, continue without workflow state. Mirror every `update_plan` call into the file; it holds the pipeline's remaining steps and their statuses. When this run created the goal, run the terminal step in order: mark the final entry completed and mirror it, set `Status: closed`, mark the goal complete with `update_goal`, then emit any halt message. Attempt `create_goal` with the objective: "Carry the task '<task summary>' through the confirmed <route> route's final step; for the plan route that is the route's designed summarize-and-halt, and if the confirmed route changes, the new route's final step applies. Workflow state: `.turbo/workflows/<slug>.md`; mirror every `update_plan` call into it. Loop state lives under `.turbo/loops/`. After any context compaction, re-read the workflow file and any active ledger, and continue from the first unfinished entry. Mark this goal complete at the route's final step, before any designed halt message." If an unfinished goal already exists, an outer workflow owns it; continue without creating one. Carry the confirmed route into its reference file from the table above and follow its steps. If this run created the goal, resolve it inside the route's own flow rather than after it: mark it complete with `update_goal` when the route's final step is reached, before emitting any designed halt message. ## 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.
Reviews (0)
No reviews yet.
No comments yet.