Turbo

A composable dev process for agentic coding harnesses, packaged as modular skills. Turbo has sibling editions for Claude Code and Codex.

The Claude Code edition is production-tested. The Codex edition is currently experimental: the skill set has reached parity, but it has seen less real-world use.

TL;DR — Three steps to ship:

1. Plan — Run /turboplan (or enter raw plan mode) and describe what you want to build
2. Implement — Run /implement-plan on the plan, or /implement for ad-hoc changes
3. Finalize — /finalize runs 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 70+ 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.

Quick Start

Prerequisites

Pick your edition: claude/SETUP.md for Claude Code, codex/SETUP.md for Codex. Both editions work best with their respective Max-tier plans (pipeline workflows are context-heavy). Additional tools are installed during setup.

External services: The Claude edition benefits from ChatGPT Plus or higher for Codex peer review. The Codex edition benefits from Claude Code access for Claude peer review. ChatGPT Pro or Business is useful for /consult-oracle, where Pro models are the only ones that reliably solve very hard problems. /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)

In Claude Code or Codex, prompt:

Walk me through the Turbo setup. Read SETUP.md from the tobihagemann/turbo repo and follow the guide for your edition.

The agent reads the root SETUP.md, picks the file that matches its harness (claude/SETUP.md or codex/SETUP.md), clones the repo, installs skills, configures the environment, and walks you through each step interactively.

Updating

Run /update-turbo (Claude Code) or $update-turbo (Codex) to update all skills. It fetches the latest update instructions from GitHub, builds a changelog, handles conflict detection for customized skills, and manages exclusions.

Editions

claude/   # Claude Code edition
codex/    # Codex edition

Each edition is a self-contained tree with its own SETUP.md, UPDATE.md, MIGRATION.md, ADDITIONS.md, SKILL-CONVENTIONS.md, and skills/. The root-level files are short routers that point at the per-edition versions.

What Is This?

Turbo covers the full dev lifecycle. Five ideas shape its design:

1. Standardized process. Skills capture dev workflows so you can run them directly instead of prompting from scratch. /turboplan analyzes complexity and routes to the right mode. /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-code security runs a single-concern scan. /review-code with no argument runs all six types in parallel. /polish-code loops stage → format → lint → test → 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. Each pipeline composes with a natural, predictable interface. See The Turboplan Pipeline and The Finalize Pipeline for worked examples.
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 the harness's native primitives (git, filesystem, built-in tools). Remove an independent skill and the rest still work.

The one thing beyond skills is each edition's ADDITIONS.md (e.g. claude/ADDITIONS.md), a small set of behavioral rules added to your harness's instruction file during setup. The most important one is Skill Loading: without it, the agent 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 claude/docs/skill-loading-reasoning.md for the full rationale (Claude-specific failure modes and mitigations; the Codex edition adapts the same rules in codex/ADDITIONS.md).

The other core piece is /self-improve, which makes the whole system compound: it routes each session's lessons back into your project's instructions, memory, and skills. See Self-Improvement below.

Works Best With

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

• Tests — The /polish-code loop inside /finalize runs your test suite and reviews coverage gaps. Without tests, there's no safety net. If your project has none, /smoke-test can fill the gap by launching your app and verifying changes manually in the same loop, but real tests are always better. See Browser and UI Testing for the tools behind that verification.
• Linters and formatters — The /polish-code loop runs your formatter and linter before code review. If you don't have one, style issues slip through.
• Pre-commit hooks — When /finalize commits, it triggers any pre-commit hooks you have configured and fixes hook failures before retrying. If your project uses tools like husky, lint-staged, or pre-commit, Turbo works with them automatically.
• Existing analysis tools — Skills like /find-dead-code and /assess-technical-debt lean on integrated tools (knip, vulture, periphery, lizard, jscpd) when your project already has them.
• Dependencies — GitHub CLI powers PR operations. The Claude edition uses Codex for peer review; the Codex edition uses Claude for peer review. Everything works without peer review, but the full pipeline is better with it. See the edition setup guides for details.

Who It's For

Turbo is for 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.

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.

The Turboplan Pipeline

Claude Code's built-in plan mode tends to produce plans that miss existing patterns, skip edge cases, or propose approaches that don't hold up under scrutiny, and it can feel too restrictive for iterative planning. Turbo