Turbo

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:

1. Plan — Enter plan mode and describe what you want to build
2. Implement — Build it with Claude
3. Run /finalize — Tests, iterative code polishing, commit, and PR. One command.

Everything else in Turbo builds on this loop: a planning pipeline that produces better plans than raw plan mode, a project-wide audit for assessing codebase health, debugging tools for when things break, and self-improvement that makes each session teach the next. There are 60+ skills beyond /finalize. Read on for the full picture.

What Is This?

Turbo covers the full dev lifecycle: reviewing code, creating PRs, investigating bugs, self-improving from session learnings, and more.

Five ideas shape the design:

1. Standardized process. Skills capture dev workflows so you can run them directly instead of prompting from scratch. /finalize runs your entire post-implementation QA in one command. /investigate follows a structured root cause analysis cycle. The skill is the prompt.
2. Layered design. Skills compose other skills to any depth. /review-correctness analyzes code for bugs. /review-code runs six review skills in parallel. /polish-code loops format → lint → test → simplify → review → evaluate → apply → smoke test until stable. /finalize wraps the whole pipeline with self-improvement and commit. /audit fans out to all analysis skills in parallel, evaluates the combined findings, and produces a health report. They work together with a natural, predictable interface.
3. 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.
4. 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.
5. 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.

How Skills Connect

This diagram shows how /finalize composes its pipeline and how the key sub-skills compose. It covers the core workflow, not every skill in Turbo. See All Skills for the full list.

Works Best With

Turbo amplifies your existing process. It shines when your project has the right infrastructure in place:

• Tests — /finalize runs your test suite and reviews test coverage gaps. Without tests, there's no safety net. If your project doesn't have automated tests, /smoke-test can fill the gap by launching your app and verifying changes manually (it's part of the /polish-code loop), but real tests are always better. See Browser and UI Testing for the tools that power browser and native app verification.
• Linters and formatters — /finalize runs your formatter and linter before code review. If you don't have one, style issues slip through.
• Pre-commit hooks — /finalize commits 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 like husky, lint-staged, or pre-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 like knip, vulture, or periphery integrated.
• 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.

Who It's For

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.

The Puzzle Piece Philosophy

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-oracle with your own setup (it's macOS-only and has a cookies workaround)
• Replace /commit-rules or /changelog-rules with your team's conventions. The pipeline adapts.
• Replace /code-style with your team's style guide. The built-in one teaches general principles rather than opinionated rules, so it's a natural swap point.

This is also why analysis skills and workflow skills both exist. /review-correctness analyzes code and returns structured findings. /review-code composes /review-test-coverage, /review-correctness, /review-security, /review-quality, /review-api-usage, and /peer-review-code into one aggregated review. Run the analysis skill when you want a single-concern scan. Run the workflow when you want the combined results.

Skills communicate through standard interfaces: git staging area, PR state, and file conventions.

Sponsorship

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.

Quick Start

Prerequisites

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 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-code and /consult-oracle are designed as swappable puzzle pieces, so if you don't have access, replace them with alternatives that work for you.

Automatic Setup (Recommended)

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.

Updating

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.

Manual Setup

See the manual setup guide for step-by-step instructions.

The Main Workflow

The recommended way to use Turbo:

1. Enter plan mode and plan the implementation
2. Approve the plan
3. Run /finalize when you're done implementing

Planning is up to you. You can use Turbo's planning pipeline, your own process, or skip planning entirely and jump straight to implementation. Turbo's core focus is making sure the implementation is as clean as possible for the commit.

/finalize runs through these phases automatically:

1. Polish Code — Iterative loop: stage → format → lint → test → simplify → review → evaluate → apply → smoke test → re-run until stable
2. Update Changelog — Add entries to the Unreleased section of CHANGELOG.md (skipped if no changelog exists)
3. Self-Improve — Extract learnings, route to CLAUDE.md / memory / skills
4. Commit and PR — Branch if needed, commit, push, create or update PR

Self-Improvement

/self-improve is another core skill. Run it anytime before ending your session (it's also part of /finalize Phase 2). 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. It routes lessons through Claude Code's built-in knowledge layers and, over time, makes Claude 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. When you're ready to act on them, /implement-improvements validates each entry against the current codebase (filtering out stale items), then plans and implements the remaining ones.

Project-Wide Audit

/audit is Turbo's other pipeline. It fans out to all analysis skills in parallel (correctness, security, API usage, quality, 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.

The Planning Pipeline

Claude Code's built-in plan mode is a starting point, but on its own it tends to produce plans that miss existing patterns, skip edge cases, or propose approaches that don't hold up under scrutiny. Turbo's planning pipeline adds structure around plan mode: pattern surveys that ground the approach in your codebase, peer reviews via codex, and spec reviews that catch gaps before they cascade into implementation. The result is plans that survive contact with reality.

You don't have to use Turbo's pipeline. Any structured planning process that goes beyond raw plan mode will improve your results. /plan-style is a swappable piece, like /code-style. Replace it with your own conventions if you have a planning process that works for you.

For larger projects, the full spec-to-implementation pipeline:

1. Run /create-spec — Guided discussion that produces a spec at .turbo/spec.md
2. Run /create-prompt-plan — Breaks the spec into context-sized prompts at .turbo/prompts.md
3. For each prompt, open a new session: enter plan mode and run /pick-next-prompt, then approve the plan

/pick-next-prompt uses /plan-style, which includes implementation and /finalize in the plan.

Each session handles one prompt to keep context focused.

Browser and UI Testing

/smoke-test and /comprehensive-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-browser — Companion skill for browser automation. Provides the most control for web app testing.
• claude-in-chrome MCP — Built-in Claude Code browser automation using your real Chrome browser. Falls back to this when agent-browser is not installed.
• computer-use MCP — Built-in Claude Code screen control for native app and UI testing on macOS.

All Skills

Pipelines

Skill	What it does	Uses
/finalize	Post-implementation QA: polish, changelog, commit, PR	/polish-code, /update-changelog, /self-improve, /commit-staged, /create-pr, /update-pr
/audit	Project-wide health audit: all analysis skills, evaluation, markdown and HTML report	/review-correctness, /review-security, /review-api-usage, /peer-review-code, /review-quality, /review-test-coverage, /review-dependencies, /review-tooling, /find-dead-code, /create-threat-model, /evaluate-findings, /frontend-design

Workflows

Skill	What it does	Uses
/polish-code	Iterative quality loop: stage → format → lint → test → simplify → review → evaluate → apply → smoke test → re-run until stable	/stage, /simplify-code, /review-code, /evaluate-findings, /apply-findings, /smoke-test, /investigate
/review-code	AI code review: 6 parallel reviewers	/review-test-coverage, /review-correctness, /review-security, /review-quality, /review-api-usage, /peer-review-code
/review-plan	AI plan review: internal review and codex peer review in parallel	/peer-review-plan
/review-spec	AI spec review: internal review and codex peer review in parallel	/peer-review-spec
/review-prompt-plan	AI prompt plan review: internal review and codex peer review in parallel	/peer-review-prompt-plan
/review-pr	PR review: fetch comments, detect base branch, run code review, evaluate findings	/fetch-pr-comments, /review-code, /evaluate-findings
/simplify-code	Review code quality and fix issues
/apply-findings	Apply findings from evaluations or reviews	/note-improvement
/update-dependencies	Smart dependency upgrades with breaking change research	/review-dependencies

Analysis

Skill	What it does	Uses
/review-correctness	Analyze code for bugs, logic errors, and correctness problems
/review-security	Security-focused code review with threat model integration
/review-api-usage	Check API/library usage against official documentation
/review-quality	Cross-file quality analysis: duplication, architectural consistency, abstraction opportunities
/review-test-coverage	Analyze code for test coverage gaps and missing edge cases
/review-dependencies	Detect outdated or vulnerable dependencies
/review-tooling	Detect dev tooling gaps across linters, formatters, hooks, test runners, and CI/CD
/peer-review-code	AI code review via codex	/codex-review
/peer-review-plan	AI plan review via codex	/codex-exec
/peer-review-spec	AI spec review via codex	/codex-exec
/peer-review-prompt-plan	AI prompt plan review via codex	/codex-exec
/evaluate-findings	Confidence-based triage of review feedback
/find-dead-code	Identify unused code via parallel analysis	/evaluate-findings, /investigate
/investigate	Systematic root cause analysis for bugs and failures	/consult-codex, /evaluate-findings, /consult-oracle
/smoke-test	Launch the app and verify changes manually	/agent-browser, /investigate
/comprehensive-test	Multi-level testing: basic, complex, adversarial, and cross-cutting scenarios	/create-test-plan, /agent-browser, /investigate
/codex-review	AI code review via codex CLI	Codex CLI
/codex-exec	Autonomous task execution 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)	/evaluate-findings, /apply-findings, ChatGPT Pro

Planning

Skill	What it does	Uses
/create-spec	Guided discussion that produces a spec at .turbo/spec.md	/review-spec, /evaluate-findings, /apply-findings
/create-test-plan	Generate a structured test plan at .turbo/test-plan.md with four escalating levels
/create-prompt-plan	Break a spec into context-sized implementation prompts	/review-prompt-plan, /evaluate-findings, /apply-findings
/pick-next-prompt	Pick the next prompt from .turbo/prompts.md and plan it	/plan-style
/pick-next-issue	Pick the most popular open GitHub issue and plan it	/plan-style
/plan-style	Planning conventions for task tracking, skill loading, and finalization	/review-plan, /evaluate-findings, /apply-findings
/capture-context	Capture session knowledge into the plan file before clearing context
/code-style	Enforce mirror, reuse, and symmetry principles
/frontend-design	Design guidelines for distinctive, production-grade frontend interfaces

Git & GitHub

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
/commit-rules	Shared commit message rules and technical constraints
/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, and reply to PR comments	/evaluate-findings, /apply-findings, /finalize, /github-voice

Knowledge & Maintenance

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 and implement improvements from the backlog	/plan-style
/create-skill	Create or update a skill with proper structure	/evaluate-findings, /apply-findings
/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
/changelog-rules	Shared changelog conventions and formatting rules
/create-threat-model	Analyze a codebase and produce a threat model at .turbo/threat-model.md
/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

License

Distributed under the MIT License. See the LICENSE file for details.