Claude Code on Steroids

The complete, production-grade Claude Code skill system — packaged, optimized, and update-proof.

Built on obra/superpowers by Jesse Vincent. Extended with 10 new skills, specific engineering improvements directed by GadaaLabs, and an override infrastructure that makes your skills survive plugin updates automatically.

curl -fsSL https://raw.githubusercontent.com/GadaaLabs/claude-code-on-steroids/main/install.sh | bash

Requires: Claude Code CLI · Node.js 20+

Karpathy Guidelines — Always-On Behavioral Layer

Derived from Andrej Karpathy's observations on LLM coding mistakes. A lightweight addition to your ~/.claude/CLAUDE.md that works alongside the skill stack — no invocation required.

Why this complements the skill stack: Skills need to be invoked. A CLAUDE.md is ambient — it fires on every session automatically. These two principles fill the gap when a skill wasn't invoked:

Principle	What it enforces	Covered by a skill?
Think Before Coding	Surface assumptions · present interpretations · ask before picking	Partial — `architect` covers design intent, not assumption surfacing
Goal-Driven Execution	Verifiable success criteria per step before writing code	Partial — `forge` + `sentinel` go deep, but only when invoked

Add to your global CLAUDE.md in one command:

curl -fsSL https://raw.githubusercontent.com/GadaaLabs/claude-code-on-steroids/main/examples/karpathy-guidelines.md >> ~/.claude/CLAUDE.md

Full annotated example → examples/karpathy-guidelines.md

How This Compares to the Original

	obra/superpowers	Claude Code on Steroids
Total skills	14	24
New skills not in obra	—	+10 (oracle, chronicle, vector, horizon, legion, pathfinder, gradient, nexus, ironcore, prism)
Domain expertise (ML/AI/EE/UI)	✗	✓
Intelligence layer (classifier, memory, router)	✗	✓
Multi-agent swarm templates	Concepts only	4 topology prompt templates
API pre-verification in TDD	✗	✓ (forge + blueprint)
Skill chain recipes	✗	6 end-to-end chains
Domain trigger system	✗	13 scenario → skill mappings
Override protection	✗	✓ 100% update survivability
One-command install	✗	✓
Token usage analytics	✗	✓ /tokenburn

Installation

New users (no superpowers installed)

Run one command. The installer handles everything — installs the superpowers plugin, copies all 24 skills, builds the tokenburn CLI, and wires up the SessionStart hook:

curl -fsSL https://raw.githubusercontent.com/GadaaLabs/claude-code-on-steroids/main/install.sh | bash

Then open any project:

cd your-project && claude
/oracle        # start here for every non-trivial task
/tokenburn     # see where your tokens are going

Requirements: Claude Code CLI (npm install -g @anthropic-ai/claude-code) and Node.js 20+.

Migrating from obra/superpowers (already installed)

No need to uninstall anything. The installer detects your existing superpowers installation and installs directly into it. Your plugin infrastructure, version, and settings remain intact — only the skill files are upgraded.

curl -fsSL https://raw.githubusercontent.com/GadaaLabs/claude-code-on-steroids/main/install.sh | bash

That's it. The next time you open Claude Code, the new skills are live.

What changes: 24 skill files are written into your existing superpowers skills directory. A SessionStart hook is added to ~/.claude/settings.json so your pinned overrides survive any future plugin update.

What stays the same: Your plugin version, all other plugin settings, Claude Code configuration, any custom CLAUDE.md files.

What the installer does

Detects whether superpowers is installed; installs it if not
Copies all 24 skill files into the superpowers skills directory
Builds the tokenburn CLI (npm install && npm run build && npm link) from the bundled TypeScript source
Installs the /tokenburn slash command
Adds a SessionStart hook that runs apply.sh on every Claude Code session open
apply.sh copies 9 pinned skill overrides into the live plugin directory so they survive plugin updates

The Token Burn Problem — Why This Exists

The biggest pain point in Claude Code is not missing workflows. It is token burn.

obra/superpowers gives you 14 structured workflows. It gives you zero memory, zero context management, and zero cost routing. Every session restart costs 5,000–15,000 tokens to re-establish context. Every repeated debugging problem costs 8,000–15,000 tokens to re-investigate from scratch. Every mechanical task routes through the LLM when it should hit a shell tool.

This is what was engineered closed:

Scenario	obra/superpowers	Claude Code on Steroids	Savings
Debug: 2nd encounter of same problem	8,000–15,000 tok (full re-investigation)	~50 tok (chronicle cache hit)	up to 99%
Context window limit hit	5,000–15,000 tok (crash + restart)	0 tok (horizon compresses)	100%
Mechanical task (rename, format, import)	500–2,000 tok (LLM call)	0 tok (vector Tier 0 → shell)	100%
New codebase exploration	30,000–60,000 tok (random reads)	8,000–12,000 tok (pathfinder 5-phase)	60–80%
Session bootstrap	1,023 tok	1,484 tok	–461 tok overhead
Debug: 1st encounter	1,955 tok	4,246 tok	–2,291 tok investment

The first two scenarios cost more upfront. Every subsequent encounter pays the investment back. By day 2 of any engineering sprint, the cumulative burn has already crossed over in your favor.

Token Analytics — /tokenburn

Every install includes a built-in cost dashboard. Run it any time inside Claude Code:

/tokenburn          # this week's usage (default)
/tokenburn today    # today only
/tokenburn week     # last 7 days
/tokenburn 30d      # last 30 days
/tokenburn month    # this calendar month

It reads your local ~/.claude/projects/**/*.jsonl session logs — no external calls, no accounts, no telemetry — and renders a full breakdown directly in your terminal:

╔══════════════════════════════════════════════════════════════════════════════════════════════════════════════════╗
║                                        TokenBurn — Claude Code Analytics                                         ║
║                                              Period: week                                                         ║
╚══════════════════════════════════════════════════════════════════════════════════════════════════════════════════╝

  [ today ]  [ week ]  [ 30days ]  [ month ]

┌─────────────────────────────────────────────────┐  ┌─────────────────────────────────────────────────┐
│ Daily Activity                                  │  │ By Project                                      │
│                                                 │  │                                                 │
│ Apr 10  ████████████████████████░░░░  $2.14     │  │ /myapp          ████████████████████░░░░  $4.82 │
│ Apr 11  ██████████████░░░░░░░░░░░░░░  $1.23     │  │ /api-service    ████████████░░░░░░░░░░░░  $2.91 │
│ Apr 12  ██████████████████░░░░░░░░░░  $1.67     │  │ /ml-pipeline    ████████░░░░░░░░░░░░░░░░  $1.94 │
│ Apr 13  ████████░░░░░░░░░░░░░░░░░░░░  $0.73     │  │ /infra          ████░░░░░░░░░░░░░░░░░░░░  $0.97 │
│ Apr 14  ████████████████████████████  $2.61     │  │                                                 │
│                                                 │  │ Total: $10.64                                   │
│ Total: $8.38    Messages: 247                   │  │                                                 │
└─────────────────────────────────────────────────┘  └─────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────┐  ┌─────────────────────────────────────────────────┐
│ By Activity                                     │  │ By Model                                        │
│                                                 │  │                                                 │
│ Coding       ████████████████████░░░░  47%      │  │ claude-sonnet  ████████████████████████  $7.12  │
│ Debugging    ████████████░░░░░░░░░░░░  29%      │  │ claude-haiku   ████████░░░░░░░░░░░░░░░░  $2.43  │
│ Exploration  ██████░░░░░░░░░░░░░░░░░░  14%      │  │ claude-opus    ████░░░░░░░░░░░░░░░░░░░░  $1.09  │
│ Testing      ████░░░░░░░░░░░░░░░░░░░░   8%      │  │                                                 │
│ Conversation ██░░░░░░░░░░░░░░░░░░░░░░   2%      │  │ 847 input / 312 output (K tokens)               │
└─────────────────────────────────────────────────┘  └─────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────┐  ┌─────────────────────────────────────────────────┐
│ Core Tools                                      │  │ Shell Commands + MCP Servers                    │
│                                                 │  │                                                 │
│ Bash    ████████████████████████████  412 calls │  │ git      ████████████████████████████  187 runs │
│ Read    ████████████████░░░░░░░░░░░░  284 calls │  │ npm      ████████████████░░░░░░░░░░░░  143 runs │
│ Edit    ████████████░░░░░░░░░░░░░░░░  198 calls │  │ grep     ████████████░░░░░░░░░░░░░░░░  112 runs │
│ Write   █████░░░░░░░░░░░░░░░░░░░░░░░   87 calls │  │ cat      ████████░░░░░░░░░░░░░░░░░░░░   76 runs │
│ Grep    ████░░░░░░░░░░░░░░░░░░░░░░░░   74 calls │  │ python   ████░░░░░░░░░░░░░░░░░░░░░░░░   43 runs │
│ Glob    ███░░░░░░░░░░░░░░░░░░░░░░░░░   61 calls │  │                                                 │
└─────────────────────────────────────────────────┘  └─────────────────────────────────────────────────┘

Section	What it shows
Daily Activity	Cost + message count per day
By Project	Cost ranked by working directory
By Activity	Coding / Debugging / Delegation / Testing / Build / Exploration / Conversation
By Model	Cost + call count — Sonnet, Haiku, Opus (uses real per-model pricing)
Core Tools	How many times each Claude tool was called (Bash, Read, Edit, Write…)
Shell Commands	Top bash commands by frequency (git, npm, grep…)
MCP Servers	Any MCP tool usage

How it works: tokenburn is a TypeScript/React-ink CLI that parses your local JSONL session logs. It never phones home. Pricing is baked in at current Anthropic rates (Sonnet 4.6: $3/$15 per MTok input/output, Haiku 4.5: $0.80/$4, Opus 4.6: $15/$75).

Why this matters: Most engineers have no idea which projects, sessions, or habits are burning the most money. Five minutes with /tokenburn usually reveals one or two high-cost patterns that are immediately fixable.

The Override Infrastructure

Both obra and the official plugin distribution share the same gap: plugin updates overwrite any customizations.

Our installer adds apply.sh + a SessionStart hook to ~/.claude/settings.json:

Session opens
  → SessionStart hook fires
  → apply.sh reads installed plugin path from installed_plugins.json
  → Copies 9 pinned skill files over the plugin files
  → Session begins with your locked versions in place

Plugin updates to any future version? Next session, your pinned versions win automatically. Zero maintenance.

Skills pinned: ascend blueprint chronicle commander forge legion pathfinder phantom vector

The Skills — All 24

Evolved from obra originals (12 skills)

Skill	obra original	What was improved
forge	test-driven-development	+ Mandatory API pre-verification step before writing any test. Prevents phantom-API test failures.
blueprint	writing-plans	+ Phase 0 Documentation Discovery — verifies every API in the spec exists before a plan is written
ascend	using-superpowers	+ 6 workflow chains, 13-entry domain trigger table, oracle-first intake rule
commander	dispatching-parallel-agents	+ COMMANDER vs PHANTOM decision table — eliminates the most common dispatch mistake
hunter	systematic-debugging	+ Root-cause bisect protocol, defense-in-depth patterns
sentinel	verification-before-completion	+ Confidence scoring gate (HIGH / MEDIUM / LOW) with evidence requirements
architect	brainstorming	+ Spec document reviewer, visual companion
arbiter	receiving-code-review	+ Technical verification protocol before implementing any suggestion
tribunal	requesting-code-review	+ Domain-aware criteria: ML / AI / Embedded / Frontend / Security
vault	using-git-worktrees	+ Worktree lifecycle management, safety verification
seal	finishing-a-development-branch	+ Four structured completion options with verification
sculptor	writing-skills	+ TDD applied to skill creation — Iron Law for process documentation

Brand new — not in obra (10 skills)

Skill	What it does
oracle	Classifies task complexity, selects skill chain, assigns model tier. Run before every non-trivial task.
chronicle	Self-learning memory. Stores solved patterns in a ReasoningBank. 3-layer token-efficient retrieval before each task.
pathfinder	5-phase codebase exploration protocol. Maps entry points, architecture, and traps before writing code.
vector	Model cost routing. Tier 0 ($0, no LLM) for mechanical tasks. Tier 3 (Opus) only when complexity demands it.
horizon	Context window budget management. Tracks token usage, compresses when needed, hands off cleanly.
legion	Multi-agent swarm coordination. Hierarchical / mesh / ring / star topologies with ready-to-use prompt templates.
gradient	ML domain expertise: data pipelines, model training, serving infrastructure, MLOps, drift detection.
nexus	AI engineering: RAG architectures, agent patterns, prompt engineering, LLM evaluation frameworks.
ironcore	Embedded systems: ISRs, RTOS task design, state machines, hardware abstraction, timing analysis.
prism	UI/UX engineering: 67 design styles, 25 chart types, WCAG 2.1 AA accessibility, Core Web Vitals targets.

Restructured from obra (2 → 3 skills)

obra's executing-plans and subagent-driven-development were split into:

Skill	What it does
phantom	In-session parallel plan execution with 2-stage review (spec compliance → code quality)
exodus	Plan execution in a completely fresh isolated session — zero context pollution

The 6 Workflow Chains (in ascend)

DEBUG     →  chronicle → hunter → forge → sentinel → oracle → chronicle(store)

FEATURE   →  oracle → chronicle → [domain] → architect → blueprint
             → horizon → vector + legion → phantom → sentinel → tribunal
             → oracle → chronicle(store)

ARCH      →  oracle → chronicle → architect → blueprint → tribunal
             → oracle → chronicle(store)

REFACTOR  →  oracle → forge → blueprint → horizon → sentinel
             → oracle → chronicle(store)

ML/AI/EE/UI → oracle → [gradient|nexus|ironcore|prism]
              → feature-chain or debug-chain

LONG SESSION → horizon → continue or fresh handoff

Quick Start After Install

cd your-project && claude

/oracle        # Start every non-trivial task here
/tokenburn     # See where your tokens are actually going
/gradient      # ML work
/nexus         # RAG / agent work
/hunter        # Hard debugging
/pathfinder    # Unfamiliar codebase
/forge         # Writing tests — TDD first, always

Credits

Jesse Vincent (@obra) — original 14-skill Superpowers foundation
claude-plugins-official team — expanded distribution and codename system
AgentSeal/codeburn — React-ink TUI engine that powers tokenburn
GadaaLabs — engineering improvements (API verification, domain trigger system, decision tables, skill chains), override infrastructure, tokenburn integration, packaging, and community distribution

Support This Work

If this closed a gap in your workflow, reduced your API costs, or helped you ship something — a coffee keeps this maintained and expanded.

Other ways to help:

Star the repo — helps others find it
Submit a PR — DevOps, security, and mobile skills are the priority gaps
Share your results — post what changed, tag what you built

Contributing

PRs welcome. Priority gaps: DevOps/Kubernetes skill, security engineering skill, mobile engineering skill.

License

MIT — use freely, modify freely, share freely.

claude-code-on-steroids

About claude-code-on-steroids

Platforms

Languages

Links

README.md