Stop Wasting Hours on AI Prompt Engineering Turbo Does It For You

Stop Wasting Hours on AI Prompt Engineering—Turbo Does It For You

You're three hours into a Claude Code session. The agent seemed brilliant at first—churning out files, suggesting architectures, running tests. Then it happened. Again. It forgot the coding standards you painstakingly described in message #7. It skipped the edge cases you mentioned in message #23. It committed broken code because you forgot to remind it to run the test suite. Again.

Sound familiar? You're not alone. The dirty secret of agentic coding is that the "agent" part is still embarrassingly fragile. Without rigorous process, these tools become expensive autocomplete—brilliant one moment, catastrophically forgetful the next. The solution isn't better prompting. It's systematic process engineering.

Enter Turbo—a composable dev process for agentic coding harnesses, packaged as modular skills. Created by Tobias Hagemann and available at github.com/tobihagemann/turbo, this open-source project transforms Claude Code and Codex from wild improvisers into disciplined software engineers. With 60+ skills, a three-step shipping loop, and a self-improving architecture, Turbo might be the most important productivity multiplier you install this year.

What Is Turbo?

Turbo is a process framework disguised as a skill collection. At its core, it captures professional development workflows—planning, implementation, code review, testing, debugging, documentation—and packages them into composable, reusable skills that integrate directly with Claude Code and Codex.

The project maintains two sibling editions: a production-tested Claude Code edition and an experimental Codex edition. Both share identical skill sets but adapt invocation syntax and harness-specific behaviors to their respective platforms.

Why it's trending now: Agentic coding hit the mainstream in 2024-2025, but practitioners quickly hit a wall. Raw LLM interactions don't scale. Teams discovered that the difference between demo-quality output and production-grade code isn't model capability—it's process discipline. Turbo solves this at exactly the right moment, riding the wave of organizations desperately seeking structured approaches to AI-assisted development.

The philosophy is deceptively simple: the skill is the prompt. Instead of hand-crafting instructions for every task, you invoke pre-engineered skills like /turboplan, /finalize, or /investigate that encode best practices, failure modes, and recovery strategies. These skills compose like LEGO blocks—shallow ones for quick tasks, deeply nested pipelines for complex projects.

Critically, Turbo requires no framework, no custom runtime, no proprietary memory system. Skills are plain markdown^{↗ Smart Converter} files using standard tools: git, filesystem operations, and your harness's built-in capabilities. Remove one skill and the rest function normally. This isn't lock-in architecture—it's liberation architecture.

Key Features That Separate Turbo from Chaos

Standardized Process Capture

Turbo eliminates the "what should I ask the AI?" paralysis. Skills like /turboplan analyze complexity and auto-route to appropriate modes. /finalize executes your entire post-implementation QA in one command. /investigate follows structured root-cause analysis cycles. The cognitive load shifts from prompt engineering to goal articulation.

Layered Compositional Design

Skills nest to arbitrary depth. /review-code security runs a single-concern scan. Plain /review-code executes six parallel review types. /polish-code iterates format → lint → test → review → evaluate → apply → smoke test until stable. /finalize wraps everything with self-improvement and commit. /audit fans out all analysis skills in parallel, evaluates combined findings, and generates health reports.

The interface remains predictable at every layer. You never wonder "what will this do?"—the composition is transparent.

Swappable Puzzle Pieces

Every skill owns exactly one concern and communicates through standard interfaces: git staging area, PR state, and file conventions. Replace /commit-rules with your team's conventions. Swap /code-style for your organization's style guide. Substitute /consult-oracle with your preferred research tool. The pipeline adapts automatically—no cascading rewrites required.

Zero-Configuration Deployment

Install skills and the full workflow activates immediately. Dependencies are standard tooling most teams already use: GitHub CLI, your existing harness. The only "extra" is each edition's ADDITIONS.md—behavioral rules injected into your harness's instruction file during setup, primarily ensuring skills reload properly in nested pipelines.

Compounding Self-Improvement

Here's where Turbo transcends mere automation. /self-improve extracts lessons from every session—corrections you gave, patterns that failed, preferences you expressed—and routes them to project CLAUDE.md/AGENTS.md, auto memory, or new skills. Every session teaches the system. Future sessions benefit automatically.

Real-World Use Cases Where Turbo Dominates

1. Shipping Features Without the QA Cliff

The classic agentic coding failure: brilliant implementation, catastrophic delivery. The agent writes 500 lines of elegant code, forgets to test the error path, commits with a vague message, and opens a PR with no description. Turbo's /finalize pipeline eliminates this entirely—running iterative polish, changelog updates, and structured commits automatically.

2. Onboarding to Foreign Codebases

Joining a new project? /onboard generates comprehensive guides combining architecture mapping (/map-codebase), tooling review (/review-tooling), and agentic setup analysis (/review-agentic-setup). The output: .turbo/onboarding.md with interactive HTML. What normally takes days of archaeology becomes a 30-minute conversation.

3. Systematic Technical Debt Elimination

That nagging feeling about inconsistent error messages? /note-improvement captures it without derailing current work. Later, /implement-improvements validates each entry against current code, filters stale items, and routes them correctly: direct fixes through /implement, complex issues through /investigate, architectural concerns through /turboplan.

4. Pre-Release Confidence Building

Major release looming? /audit executes nine parallel analysis dimensions—correctness, security, API usage, consistency, simplicity, test coverage, dependencies, tooling, dead code—and produces a dashboard with prioritized findings. No more "hope we didn't break anything." Know before you ship.

5. Debugging Without the Guesswork

"Tests are failing in the auth module"—instead of random exploration, /investigate follows structured root-cause analysis: reproduce, isolate, hypothesize, verify, document. The skill encodes debugging discipline that junior and senior developers alike can leverage.

Step-by-Step Installation & Setup Guide

Prerequisites

Choose your edition based on your harness:

• Claude Code edition: Requires Claude Code with Max-tier plan (pipeline workflows are context-heavy)
• Codex edition: Requires Codex CLI with Max-tier plan

External services (optional but enhanced):

• Claude Code edition benefits from ChatGPT Plus/Business for Codex peer review via /peer-review
• Codex edition benefits from Claude Code access for Claude peer review
• ChatGPT Pro/Business recommended for /consult-oracle (hard problem solving)

Both editions require GitHub CLI (gh) for PR operations.

Automatic Setup (Recommended)

The fastest path: let your agent handle everything.

# In Claude Code or Codex, simply prompt:
Walk me through the Turbo setup. Read SETUP.md from the tobihagemann/turbo repo and follow the guide for your edition.

Your agent will:

1. Read root SETUP.md and route to edition-specific guide (claude/SETUP.md or codex/SETUP.md)
2. Clone the tobihagemann/turbo repository
3. Install all skills into your harness's skill directory
4. Configure environment with ADDITIONS.md behavioral rules
5. Walk through each step interactively

Manual Setup (If You Prefer Control)

# Clone the repository
git clone https://github.com/tobihagemann/turbo.git
cd turbo

# Navigate to your edition
ls claude/  # or codex/

# Follow edition-specific instructions
cat claude/SETUP.md  # Detailed manual steps

Post-Setup Verification

# Test core skills are recognized
/turboplan --help  # Claude Code
$turboplan --help  # Codex

# Verify self-improvement pipeline
/self-improve  # Should analyze session and suggest improvements

Keeping Updated

# Update all skills with conflict detection
/update-turbo        # Claude Code
$update-turbo        # Codex

This fetches latest instructions, builds changelogs, detects conflicts with your customizations, and manages exclusions.

REAL Code Examples from Turbo's Repository

Example 1: The Three-Step Shipping Loop

Turbo's entire philosophy distills to this workflow. Here's how the README presents it:

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

What's happening here? This isn't pseudocode—it's the actual user interface. The slashes invoke markdown-based skills that orchestrate complex sub-pipelines. /turboplan isn't a single prompt; it's a complexity router that analyzes your request and dispatches to direct mode (immediate implementation), plan mode (draft → refine → halt), or spec mode (full architectural decomposition). The beauty is in the progressive disclosure: simple tasks stay simple, complex tasks get structure without manual process design.

Example 2: Edition Structure

claude/   # Claude Code edition
codex/    # Codex edition

Each edition contains:

SETUP.md           # Installation guide
UPDATE.md          # Update procedures
MIGRATION.md       # Version migration
ADDITIONS.md       # Behavioral rules injected into harness
SKILL-CONVENTIONS.md  # How to write/modify skills
skills/            # All modular skills

Why this matters: The root-level files are routers, not duplicates. They detect your harness and point to the right edition. This design enables seamless multi-harness teams—same repository, different entry points. The ADDITIONS.md is particularly critical: without its Skill Loading rule, Claude Code silently skips reloading skills it's "already seen," causing catastrophic step drops in nested pipelines like /finalize. This is the kind of failure mode discovered through painful production experience, now encoded as automatic prevention.

Example 3: Prompt Examples for Daily Workflow

From the repository's prompt examples section, here are concrete invocations:

# Planning a change (single entry — /turboplan routes based on complexity)
/turboplan add a caching layer to the image pipeline
  ← plan mode → draft → refine → halt; run /implement-plan after

/turboplan build a notification system with backend, API, and UI
  ← spec mode → spec → shells → halt

# Continuing a spec-mode 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?

# Reviewing code
/review-code
/review-pr for PR #42

# Auditing project health
/audit
read @.turbo/audit.md and /apply-findings

# Working through the improvements backlog
the error messages in this module are inconsistent, /note-improvement
/implement-improvements  ← dedicated session

The genius here: Natural language and skill invocations interleave seamlessly. You don't switch modes or contexts. "can you please /investigate?" reads like human conversation but triggers rigorous structured analysis. The arrows (←) in documentation show the actual pipeline executed—transparency that builds trust and teaches users the underlying process.

Example 4: The Finalize Pipeline Internals

`/finalize` runs through these phases automatically:

1. **Polish Code** — Iterative loop: stage → format → lint → test → 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 / AGENTS.md / memory / skills
4. **Ship It** — Branch if needed, commit, push, create or update PR

This is where Turbo earns its keep. The "Polish Code" phase alone encodes enormous operational wisdom: many developers run formatters once and hope, or skip smoke tests when "everything passed." Turbo's loop converges on stability—if applying a review suggestion breaks tests, it re-runs. If formatting introduces lint errors, it re-lints. This isn't just automation; it's automation with feedback loops that match senior engineering judgment.

Example 5: Self-Improvement Routing Logic

`/self-improve` scans the conversation for corrections, repeated guidance, failure modes, and preferences, then routes each lesson to the right place: project `CLAUDE.md`/`AGENTS.md`, auto memory, or existing/new skills.

`/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.

The compounding effect cannot be overstated. Without this, every session starts from zero. With it, your agent accumulates organizational knowledge—your specific conventions, your recurring pitfalls, your architectural preferences. The .turbo/ directory is gitignored, keeping operational state separate from source control while maintaining project-local context.

Advanced Usage & Best Practices

Optimize Your Infrastructure First

Turbo amplifies existing quality infrastructure. Before heavy adoption, ensure:

• Test coverage exists — /finalize runs tests but can't create meaningful suites from scratch. Without tests, use /smoke-test for manual verification fallback.
• Linters/formatters configured — Style issues slip through without automated enforcement.
• Pre-commit hooks active — Tools like husky, lint-staged, or pre-commit integrate seamlessly; /finalize respects hook failures and auto-fixes.
• Dead code detection — Integrate knip, vulture, or periphery for /find-dead-code to leverage.

Master the Three Turboplan Modes

Pro tip: Start conservative. Use plan mode until you're confident the agent understands your codebase's patterns. Escalate to spec mode only when direct mode produces plans that "miss existing patterns, skip edge cases, or propose approaches that don't hold up under scrutiny."

Customize Through Replacement, Not Modification

Follow the Puzzle Piece Philosophy: replace entire skills rather than editing internals. This preserves update compatibility. Create claude/skills/my-commit-rules/SKILL.md with your team's conventions, then reference it in custom pipeline compositions.

Monitor the Improvements Backlog

Regularly run /implement-improvements to prevent .turbo/improvements.md from becoming a graveyard. The tagging system (direct, investigate, plan) ensures correct routing—don't ignore it.

Comparison with Alternatives

The verdict: Raw harness use is fine for experimentation. Custom prompt libraries work for individuals with time to maintain them. Turbo is the only option that scales from personal productivity to team standardization without architectural lock-in.

FAQ: What Developers Ask About Turbo

Q: Does Turbo work with my existing Claude Code or Codex setup? A: Yes. Turbo installs as skills within your existing harness. No migration, no new accounts, no workflow disruption. The automatic setup reads your current configuration and extends it.

Q: Can I use Turbo without Max-tier plans? A: Technically yes, but pipeline workflows are context-heavy. Lower tiers may hit limits during complex operations like /audit or spec-mode planning. The skills still function; performance degrades.

Q: How do I customize skills for my team's conventions? A: Replace individual skills following the Puzzle Piece Philosophy. Standard interfaces (git staging, PR state, file conventions) ensure your replacements compose with existing pipelines. Use /update-turbo with exclusions to preserve customizations during updates.

Q: What happens if a skill fails mid-pipeline? A: Skills are designed with failure modes in mind. /finalize's polish loop retries until stable. /turboplan escalates complexity when initial analysis proves insufficient. The ADDITIONS.md Skill Loading rule prevents silent skips. You're always informed, never abandoned.

Q: Is the Codex edition production-ready? A: The skill set has reached parity with Claude Code, but it has seen less real-world use. The Claude Code edition is battle-tested. Start with Claude Code for critical projects; experiment with Codex for parallel workflows.

Q: How does self-improvement handle sensitive information? A: Learnings route to project-local files (CLAUDE.md, AGENTS.md, .turbo/improvements.md) or your harness's auto memory. Nothing leaves your environment. Review /self-improve outputs before accepting if you have specific compliance requirements.

Q: Can I contribute skills back to the project? A: Turbo is MIT-licensed and welcomes contributions. Follow SKILL-CONVENTIONS.md for your edition. The modular architecture makes community extensions natural.

Conclusion: Process Is the Product

After weeks of using Turbo, I'm convinced of something that felt impossible: agentic coding can be reliable. Not because the models got smarter (though they did), but because the process around them got rigorous.

Turbo doesn't ask you to trust Claude Code or Codex. It asks you to trust systematic workflow engineering—the same discipline that makes human teams successful, now encoded for artificial teammates. The three-step loop (plan → implement → finalize), the compounding self-improvement, the swappable puzzle pieces—these aren't features. They're fundamental architectural decisions that treat agentic coding as software engineering, not magic.

The production-tested Claude Code edition is ready for your most critical projects. The experimental Codex edition offers a glimpse of multi-harness futures. Both share the same DNA: skills as process, process as product.

Stop hand-crafting prompts for every task. Stop discovering that your agent forgot critical steps three hours into a session. Stop treating agentic coding as an art and start treating it as engineering.

Install Turbo today. Your future self—reviewing clean commits, reading comprehensive changelogs, watching tests pass automatically—will thank you.

👉 Get Turbo on GitHub: github.com/tobihagemann/turbo

If Turbo accelerates your shipping as much as it has mine, consider sponsoring Tobias Hagemann's open source work. Great process tooling deserves sustainable maintenance.