A composable dev process for Claude Code, packaged as modular skills. Each skill encodes a dev workflow so you can run it instead of prompting from scratch. Battle-tested with the Opus model.
TL;DR — Three steps to ship:
- Plan — Run
/turboplan(or enter raw plan mode) and describe what you want to build - Implement — Run
/implement-planon the plan, or/implementfor ad-hoc changes - Finalize —
/finalizeruns tests, code polishing, commit, and PR. It kicks in automatically after any/implement*skill; run it yourself if you built by hand.
This loop is the core. Two more pipelines run alongside it for work that does not fit the loop: /audit for project-wide health checks and /onboard for ramping up on new projects. Beyond the four pipelines, Turbo ships 60+ skills for debugging, reviewing, dependency upgrades, and self-improvement that makes each session teach the next. See the prompt examples for how they look in practice, or read on for the full picture.
Turbo covers the full dev lifecycle: reviewing code, creating PRs, investigating bugs, self-improving from session learnings, and more.
Five ideas shape the design:
- Standardized process. Skills capture dev workflows so you can run them directly instead of prompting from scratch.
/turboplananalyzes complexity and routes to the right mode./finalizeruns your entire post-implementation QA in one command./investigatefollows a structured root cause analysis cycle. The skill is the prompt. - Layered design. Skills compose other skills to any depth.
/review-code securityruns a single-concern scan./review-codewith no argument runs all six types in parallel./polish-codeloops format → lint → test → review → evaluate → apply → smoke test until stable./finalizewraps the whole pipeline with self-improvement and commit./auditfans out to all analysis skills in parallel, evaluates the combined findings, and produces a health report. Each pipeline composes with a natural, predictable interface. See The Turboplan Pipeline and The Finalize Pipeline for worked examples. - Swappable by design. Every skill owns one concern and communicates through standard interfaces. Replace any piece with your own and the pipeline adapts. See The Puzzle Piece Philosophy for details.
- Works out of the box. Install the skills and the full workflow is ready. Dependencies are standard dev tooling (GitHub CLI, Codex) that most teams already have.
- Just skills. No framework, no custom runtime, no new memory system. Skills are plain markdown that use Claude Code's native primitives (git, filesystem, built-in tools). Remove an independent skill and the rest still work.
The one thing beyond skills is CLAUDE-ADDITIONS.md, a small set of behavioral rules added to ~/.claude/CLAUDE.md during setup. The most important one is Skill Loading: without it, Claude tends to skip reloading skills it has already seen in a session, which causes it to silently drop steps in nested pipelines like /finalize. The additions are kept in sync by /update-turbo. See docs/skill-loading-reasoning.md for the full rationale.
The other core piece is /self-improve, which makes the whole system compound. After each session, it extracts lessons from the conversation and routes them to the right place: project CLAUDE.md, auto memory, or existing/new skills. Every session teaches Claude something, and future sessions benefit.
Turbo amplifies your existing process. It shines when your project has the right infrastructure in place:
- Tests —
/finalizeruns your test suite and reviews test coverage gaps. Without tests, there's no safety net. If your project doesn't have automated tests,/smoke-testcan fill the gap by launching your app and verifying changes manually (it's part of the/polish-codeloop), but real tests are always better. See Browser and UI Testing for the tools that power browser and native app verification. - Linters and formatters —
/finalizeruns your formatter and linter before code review. If you don't have one, style issues slip through. - Pre-commit hooks —
/finalizecommits your changes, which triggers any pre-commit hooks you have configured. Claude Code respects hook failures and fixes issues before retrying. If your project uses tools likehusky,lint-staged, orpre-commit, Turbo works with them automatically. - Dead code analysis —
/find-dead-code(standalone skill, not part of/finalize) identifies unused code via parallel analysis, but it's even better when your project already has tools likeknip,vulture, orperipheryintegrated. - Dependencies — GitHub CLI and Codex CLI power PR operations and peer review. Everything works without them, but the full pipeline is better with them. See the manual setup guide for details.
The target audience is experienced developers who want to move faster without sacrificing quality. That said, beginners are welcome too. Turbo is a great way to learn how a professional dev workflow looks. Just don't blindly trust outputs. Review what Claude produces, understand why it made those choices, and build your own judgment alongside it.
If your plan is vague, your architecture is unclear, and you skip every review finding, Turbo won't save you. Garbage in, garbage out.
Every skill is a self-contained piece. Pipeline skills like /finalize and /audit compose them into workflows, but each piece works independently too.
Want to swap a piece? For example:
- Replace
/consult-oraclewith your own setup (it's macOS-only and has a cookies workaround) - Replace
/commit-rulesor/changelog-ruleswith your team's conventions. The pipeline adapts. - Replace
/code-stylewith your team's style guide. The built-in one teaches general principles rather than opinionated rules, so it's a natural swap point.
Skills communicate through standard interfaces: git staging area, PR state, and file conventions.
If Turbo has helped you ship faster and you're so inclined, I'd greatly appreciate it if you'd consider sponsoring my open source work.
Turbo requires Claude Code. Works best with Claude Code Max 5x, Max 20x, or Team plan with Premium seats (pipeline workflows are context-heavy). Additional tools are installed during setup.
External services: ChatGPT Plus or higher (for codex peer review), and ChatGPT Pro or Business (for /consult-oracle, where Pro models are the only ones that reliably solve very hard problems). That said, /peer-review and /consult-oracle are designed as swappable puzzle pieces, so if you don't have access, replace them with alternatives that work for you.
Open Claude Code and prompt:
Walk me through the Turbo setup. Read SETUP.md from the tobihagemann/turbo repo and guide me through each step.
Claude will clone the repo, copy the skills, configure your environment, and walk you through each step interactively.
Run /update-turbo in Claude Code to update all skills. It fetches the latest update instructions from GitHub, builds a changelog, handles conflict detection for customized skills, and manages exclusions.
See the manual setup guide for step-by-step instructions.
Claude Code's built-in plan mode is a starting point, but it tends to produce plans that miss existing patterns, skip edge cases, or propose approaches that don't hold up under scrutiny. It can also feel too restrictive for iterative planning. Turbo replaces raw plan mode with /turboplan as a universal entry point. You always start with /turboplan — whether your task is a single-session change or a multi-subsystem project. /turboplan analyzes the task, routes it through the right pipeline, and produces plans that survive contact with reality. /turboplan does not require plan mode to be active. Trivial edits chain straight through /implement to /finalize; small tasks halt once for a fresh /implement-plan session, and complex tasks halt again after /pick-next-shell before implementation.
/turboplan has three modes, selected automatically by its complexity analysis:
- Trivial mode — True one-line edit (typo, single rename, single config tweak). Hands off to
/implement, which loads/code-style, applies the fix, and runs/finalize. No plan file is written. - Small-task mode — Single-session change. Runs
/draft-plan(survey + consult skills/docs + escalate + discuss + draft) →/refine-plan→/self-improve. Halts after self-improve; you run/implement-planin a fresh session. - Complex-project mode — Multi-subsystem project with architectural decisions. Routes to
/draft-specfor a guided spec discussion, then/refine-planto iteratively review and revise the spec, then/draft-shellsto decompose the spec into shells with YAML frontmatter, then/refine-planto review and revise the shells, then/self-improveto compound planning learnings before context is cleared. Halts after self-improve; you run/pick-next-shellin fresh sessions to plan each shell, then/implement-planto implement it.
Every sub-skill works standalone too. Run /draft-plan directly if you want to draft a plan without the rest of the pipeline. Run /refine-plan on a plan you wrote yourself. Run /implement-plan in a fresh session on any plan file. Run /draft-spec to write a spec without committing to the full pipeline.
For complex projects, /draft-shells decomposes the spec into shells: structured decomposition artifacts that capture the wiring invariants (Produces, Consumes, Covers spec requirements) and high-level Implementation Steps. Shells lock in the decomposition — what each session builds, what it depends on, what spec requirements it covers — without committing to concrete file paths. /refine-plan reviews and tightens the shells until stable.
You then drive implementation one shell at a time. /pick-next-shell picks the next shell whose dependencies are satisfied and chains into /expand-shell, which adds a fresh pattern survey and concrete references against the current codebase, then refine → self-improve → halt. You run /implement-plan in a fresh session. Each implementation session gets fresh pattern surveys, so decisions from earlier sessions naturally inform later ones.
/finalize is the QA and commit side of the loop. Run it when you're done implementing, or let /implement / /implement-plan chain into it automatically. One command runs tests, iterative code polishing, changelog updates, self-improvement, and commit.
/finalize runs through these phases automatically:
- Polish Code — Iterative loop: stage → format → lint → test → review → evaluate → apply → smoke test → re-run until stable
- Update Changelog — Add entries to the Unreleased section of CHANGELOG.md (skipped if no changelog exists)
- Self-Improve — Extract learnings, route to CLAUDE.md / memory / skills
- Ship It — Branch if needed, commit, push, create or update PR
/self-improve is a core skill that makes each session teach the next. Run it anytime before ending your session (it's also part of /finalize Phase 3). It scans the conversation for corrections, repeated guidance, failure modes, and preferences, then routes each lesson to the right place: project CLAUDE.md, auto memory, or existing/new skills. Over time, Turbo gets better at your specific project.
/note-improvement captures improvement opportunities that come up during work but are out of scope: code review findings you chose to skip, refactoring ideas, missing tests. These get tracked in .turbo/improvements.md so they don't get lost. Since .turbo/ is gitignored, it doesn't clutter the repo. Each entry is tagged with a type — trivial, investigate, or standard — so it can be routed correctly later. When you're ready to act on them, /implement-improvements validates each entry against the current codebase, filters stale items, and runs one lane per session: trivial entries go through /implement for a direct fix, investigate entries run /investigate with /consult-codex and then /implement, and standard entries go through /turboplan.
Two pipelines run alongside the main loop instead of inside it. They are not part of plan-implement-finalize, but they share the same composition style.
/audit fans out to all analysis skills in parallel (correctness, security, API usage, consistency, simplicity, test coverage, dependencies, tooling, dead code), evaluates the combined findings, and produces a health report at .turbo/audit.md with a dashboard and an interactive HTML version. Run it to assess codebase health before a major release, after onboarding to a new project, or on a regular cadence.
/audit is analysis-only: it produces the report and stops there. When you're ready to act on findings, use /apply-findings or address them manually.
/onboard generates a comprehensive onboarding guide for new developers joining a project. It composes /map-codebase (architecture), /review-tooling (development workflow), and /review-agentic-setup (AI coding infrastructure) with inline agents for prerequisites, troubleshooting, and next steps (top GitHub issues). The result is .turbo/onboarding.md with an interactive HTML version.
The guide covers both traditional onboarding (setup, build commands, tooling) and agentic onboarding (what CLAUDE.md/AGENTS.md cover, installed skills, MCP servers, Claude Code vs Codex CLI compatibility). If a threat model exists, security considerations are included too.
/map-codebase also works standalone when you just need the architecture report without the full onboarding guide.
/smoke-test and /exploratory-test automate manual testing — the kind of hands-on verification you'd normally do yourself. These tools determine how Claude interacts with your app:
/agent-browserskill — Browser automation with the most control for web app testing.claude-in-chromeMCP — Built-in Claude Code browser automation using your real Chrome browser. Falls back to this when/agent-browseris not installed.computer-useMCP — Built-in Claude Code screen control for native app and UI testing on macOS.
These are prompts you can type directly into Claude Code. Skill names work as natural words in your sentences.
# Planning a change (single entry — /turboplan routes based on complexity)
/turboplan add a caching layer to the image pipeline ← small task → draft → refine → halt; run /implement-plan after
/turboplan build a notification system with backend, API, and UI ← complex → spec → shells → halt
/survey-patterns ← pattern-ground an approach without drafting a plan
/implement-plan ← execute the latest plan in .turbo/plans/ in a fresh session
# Continuing a complex project
/pick-next-shell ← pick next shell → expand → refine → halt; run /implement-plan after
# Investigating bugs
tests are failing in the auth module, can you please /investigate?
/investigate the app crashes when i click "save" after editing a profile
# Reviewing code
/review-code
/review-pr for PR #42
# Auditing project health
/audit
read @.turbo/audit.md and /apply-findings ← follow-up session
# Onboarding to a new project
/onboard
/map-codebase ← architecture report only
# Resolving PR feedback
/resolve-pr-comments
# Updating dependencies
/update-dependencies
# Working through the improvements backlog
the error messages in this module are inconsistent, /note-improvement
/implement-improvements ← dedicated session
# Testing manually
/smoke-test
/exploratory-test
# Picking the next issue to work on
/pick-next-issue
# Extracting session learnings
/self-improve
# Creating a new skill
/create-skill for a skill that <description>
| Skill | What it does | Uses |
|---|---|---|
/turboplan |
Universal planning entry: analyzes complexity and routes to trivial, small-task, or complex-project mode | /implement, /draft-plan, /refine-plan, /self-improve, /implement-plan, /draft-spec, /draft-shells |
/finalize |
Post-implementation QA: polish, changelog, self-improve, commit, PR | /polish-code, /update-changelog, /self-improve, /ship, /split-and-ship |
/audit |
Project-wide health audit: all analysis skills, evaluation, markdown and HTML report | /review-code, /peer-review, /review-dependencies, /review-tooling, /review-agentic-setup, /find-dead-code, /create-threat-model, /evaluate-findings, /frontend-design |
/onboard |
Developer onboarding guide: architecture, tooling, agentic setup, prerequisites, troubleshooting, next steps | /map-codebase, /review-tooling, /review-agentic-setup, /frontend-design |
| Skill | What it does | Uses |
|---|---|---|
/draft-plan |
Produces a plan at .turbo/plans/<slug>.md: guided discussion then draft |
/survey-patterns |
/draft-spec |
Guided discussion that produces a spec at .turbo/specs/<slug>.md |
|
/draft-shells |
Decompose a spec into shells with YAML frontmatter and structured wiring invariants (Produces, Consumes, Covers) | |
/expand-shell |
Expand a shell with fresh pattern survey, concrete references, and verification | /survey-patterns |
/refine-plan |
Iterative review loop over a planning artifact (plan, shells, or spec) until stable: review → evaluate → apply → re-run | /review-plan, /evaluate-findings, /apply-findings |
/review-plan |
Review planning artifacts (plan, shells, or spec): internal review and peer review in parallel | /peer-review |
/implement-plan |
Execute a plan file: pre-implementation prep, load task-specific skills, hand off to /implement |
/implement |
/pick-next-shell |
Pick the next shell and carry it through planning: expand, refine, self-improve, halt | /expand-shell, /refine-plan, /self-improve |
/pick-next-issue |
Pick the most popular open GitHub issue and plan it | /turboplan |
/survey-patterns |
Survey the codebase for analogous features, reusable utilities, and convention anchors |
| Skill | What it does | Uses |
|---|---|---|
/map-codebase |
Deep architecture report: parallel inspections across structure, stack, APIs, patterns, data flow, dependencies, testing | /frontend-design |
/create-threat-model |
Analyze a codebase and produce a threat model at .turbo/threat-model.md |
|
/review-code |
Review code for bugs, security, API usage, consistency, simplicity, or test coverage: internal review(s) and peer review in parallel | /peer-review |
/find-dead-code |
Identify unused code via parallel analysis | /evaluate-findings, /investigate |
/polish-code |
Iterative quality loop: stage → format → lint → test → review → evaluate → apply → smoke test → re-run until stable | /stage, /review-code, /evaluate-findings, /apply-findings, /smoke-test, /investigate |
/simplify-code |
Review code quality and fix issues | |
/implement |
Standard implementation flow: load code-style rules, make the change, run /finalize |
/code-style, /finalize |
/investigate |
Systematic root cause analysis for bugs and failures | /consult-codex, /evaluate-findings, /consult-oracle |
| Skill | What it does | Uses |
|---|---|---|
/create-test-plan |
Generate a structured test plan at .turbo/test-plan.md with four escalating levels |
|
/smoke-test |
Launch the app and verify changes manually | /agent-browser, /investigate |
/exploratory-test |
Multi-level exploratory testing: basic, complex, adversarial, and cross-cutting scenarios | /create-test-plan, /agent-browser, /investigate |
| Skill | What it does | Uses |
|---|---|---|
/review-dependencies |
Detect outdated or vulnerable dependencies | |
/update-dependencies |
Smart dependency upgrades with breaking change research | /review-dependencies |
/review-tooling |
Detect dev tooling gaps across linters, formatters, hooks, test runners, and CI/CD | |
/review-agentic-setup |
Detect agentic coding infrastructure: CLAUDE.md, AGENTS.md, skills, MCP, hooks, cross-tool compatibility |
| Skill | What it does | Uses |
|---|---|---|
/interpret-feedback |
Parallel internal + codex interpretation of third-party feedback | /peer-review |
/evaluate-findings |
Triage review feedback with adversarial verification | |
/apply-findings |
Apply findings from evaluations or reviews | /note-improvement |
/resolve-findings |
Choose implementation path (trivial or standard) for evaluated findings and dispatch | /code-style, /apply-findings, /finalize, /turboplan |
| Skill | What it does | Uses |
|---|---|---|
/stage |
Stage implementation changes with precise file selection | |
/stage-commit |
Stage files and commit in one step | /stage, /commit-staged |
/stage-commit-push |
Stage, commit, and push in one step | /stage-commit |
/commit-staged |
Commit already-staged files with good message | /commit-rules |
/commit-staged-push |
Commit already-staged files and push | /commit-staged |
/ship |
Commit, push, and optionally create or update a PR | /commit-staged-push, /create-pr, /update-pr |
/split-and-ship |
Ship split plan as separate branches, commits, and PRs | /commit-staged-push, /create-pr, /update-pr |
/review-pr |
PR review: fetch comments, detect base branch, run code review, evaluate findings, dispatch to implementation | /fetch-pr-comments, /review-code, /evaluate-findings, /resolve-findings |
/create-pr |
Draft and create a GitHub PR | /github-voice |
/update-pr |
Update existing PR title and description | /github-voice |
/fetch-pr-comments |
Read-only summary of unresolved PR comments | |
/resolve-pr-comments |
Evaluate, fix, answer, and reply to PR comments (including reviewer questions) | /interpret-feedback, /evaluate-findings, /resolve-findings, /answer-reviewer-questions, /reply-to-pr-threads, /reply-to-pr-conversation |
/answer-reviewer-questions |
Recall implementation reasoning and compose raw answers to reviewer questions | /recall-reasoning |
/reply-to-pr-threads |
Draft, confirm, and post PR thread replies; re-fetches resolution state to skip auto-resolved threads | /github-voice |
/reply-to-pr-conversation |
Draft, confirm, and post a single conversational reply to PR issue comments, addressing tracked items as natural prose | /github-voice |
| Skill | What it does | Uses |
|---|---|---|
/peer-review |
Independent peer review via codex (code, plans, specs, shells, feedback) | /codex-exec |
/codex-review |
Code review via codex CLI | Codex CLI |
/consult-codex |
Multi-turn consultation with codex CLI | Codex CLI |
/consult-oracle |
Consult ChatGPT Pro when completely stuck (requires setup) | ChatGPT Pro |
/codex-exec |
Autonomous task execution via codex CLI | Codex CLI |
| Skill | What it does | Uses |
|---|---|---|
/code-style |
Enforce mirror, reuse, and symmetry principles | |
/frontend-design |
Design guidelines for distinctive, production-grade frontend interfaces | |
/github-voice |
Shared writing style rules for GitHub-facing output (PR comments, descriptions, titles) | |
/commit-rules |
Shared commit message rules and technical constraints | |
/changelog-rules |
Shared changelog conventions and formatting rules |
| Skill | What it does | Uses |
|---|---|---|
/self-improve |
Extract session learnings to CLAUDE.md, memory, or skills | |
/note-improvement |
Capture out-of-scope improvement ideas to .turbo/improvements.md |
|
/implement-improvements |
Validate improvements and run one lane per session (trivial, investigate, or standard) | /implement, /investigate, /turboplan |
/recall-reasoning |
Recall implementation reasoning from past Claude Code transcripts for a commit or file location | |
/explain-this |
Explain whatever the user is pointing at in plain language: a pending question, code, an error, output, or an artifact | |
/create-skill |
Create or update a skill with proper structure | /evaluate-findings, /apply-findings |
/create-project-skills |
Scan the codebase and generate project-specific skills that capture inferred conventions | /create-skill |
/update-turbo |
Update Turbo skills with always-latest instructions fetched from GitHub | |
/contribute-turbo |
Submit turbo skill improvements back to upstream | /commit-rules, /github-voice |
/create-changelog |
Create a CHANGELOG.md with version history backfilled from GitHub releases or git tags | /changelog-rules |
/update-changelog |
Update the Unreleased section of CHANGELOG.md based on current changes (no-op if no changelog) | /changelog-rules |
Distributed under the MIT License. See the LICENSE file for details.
