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: planning pipelines for large projects, debugging tools for when things break, and self-improvement that makes each session teach the next. There are 40+ 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 chains four review skills with evaluation. /polish-code loops write tests → simplify → review → test → lint until stable. /finalize wraps the whole pipeline with self-improvement and commit. 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 writes missing tests. Without tests, there's no safety net. If your project doesn't have automated tests, /smoke-test (standalone skill, not part of /finalize) can fill the gap by launching your app and verifying changes manually, but real tests are always better.
• Linters and formatters — /finalize runs your linter after code review fixes. If you don't have one, style issues slip through.
• 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 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 with your team's commit convention. 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-correctness, /peer-review, /review-security, and /review-api-usage into a full pipeline with evaluation. Run the analysis skill when you want a single-concern scan. Run the workflow when you want the whole review.

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 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

/finalize runs through these phases automatically:

1. Polish Code — Iterative loop: stage → write tests → simplify → review + fix → test → lint → re-run until stable
2. Self-Improve — Extract learnings, route to CLAUDE.md / memory / skills
3. 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.

The Planning Pipeline (Optional)

For larger projects, Turbo offers a full spec-to-implementation pipeline. You can skip this entirely and jump straight to implementation + /finalize.

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.

All Skills

Pipelines

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

Workflows

Skill	What it does	Uses
/polish-code	Iterative quality loop: stage → write tests → simplify → review + fix → test → lint → re-run until stable	/stage, /write-tests, /simplify-code, /review-code, /investigate
/review-code	AI code review: 4 parallel reviewers + evaluation	/review-correctness, /peer-review, /review-security, /review-api-usage, /evaluate-findings
/review-pr	PR review: fetch comments, detect base branch, run code review	/fetch-pr-comments, /review-code
/simplify-code	Review code quality and fix issues	/review-quality
/write-tests	Analyze coverage gaps and write missing tests	/review-test-coverage, /investigate
/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	Multi-agent review for reuse, quality, efficiency, clarity
/review-test-coverage	Analyze code for test coverage gaps and missing edge cases
/review-dependencies	Detect outdated or vulnerable dependencies
/peer-review	AI code review via codex	/codex-review
/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	/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)	ChatGPT Pro

Planning

Skill	What it does	Uses
/create-spec	Guided discussion that produces a spec at .turbo/spec.md
/create-prompt-plan	Break a spec into context-sized implementation prompts	/evaluate-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
/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, /self-improve, /stage-commit-push, /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
/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.