Superlite, the Claude Code plugin that builds a spec with parallel agents, was between 1.4x and 1.85x faster than Superpowers in our tests, not 3.9x. We measured it twice with the author’s own benchmark: it was always faster and cheaper, but on the large project it turned out less robust.
yoDEV Tested · October 19, 2026
We ran the author’s own benchmark (bench/harness.py) on a Mac with Apple M5 Pro, using Claude Code 2.1.303, Superlite at commiteea16ee0and Superpowers 7.0.0: two runs per plugin on the 89-test task and one per plugin on the 177-test task, always one at a time. The results we report as ours come from that test.
Iheatu Chris Wogu announced Superlite on October 18, 2026. It’s MIT licensed and explicitly builds on ideas from obra/superpowers: the plugin structure, the login hook, and the lifecycle skills. Its author says it’s not a rival to Superpowers, but a version tuned for different work: autonomous and rapid development. Since the whole proposal rests on speed, we installed both plugins and timed them ourselves.
What is Superlite?
Superlite is an autonomous build workflow for Claude Code. You describe what you want (a paragraph or a spec file), choose who orchestrates, and the plugin plans, divides, builds, verifies, and reviews the project on its own.
The center of the design is how it distributes work among models:
- Opus coordinates. It plans and dispatches tasks, and hooks prevent it from editing project code.
- Sonnet builds most tasks and reviews each package.
- Haiku builds only “mechanical” tasks: small, fully specified, and off the critical path.
- A final Opus reviewer, fresh in each run, reads an assembled package with logs and returns findings. It never fixes anything itself.
- Agents that only fix, in three tiers, handle those findings.
The plan is a task graph. Each task declares the files it owns, the interfaces it consumes and produces, and the tests it must pass. Tasks that don’t share files run at the same time as subagents (the usual claude code subagents), and according to the README up to 18 agents can work in parallel.
You also choose who orchestrates. With a human orchestrator, you approve a plan of about two pages before anything runs. With the AI orchestrator, it never stops: each decision it would have asked you about is logged as a “resolution” in .superlite/progress.md.
What is Superpowers for Claude?
Superpowers is the skills framework from obra (Jesse Vincent and Prime Radiant) that imposes a complete methodology on your agent before it writes code. It goes through brainstorming, design validated by sections, a detailed plan, development guided by subagents with strict TDD, and code review between tasks. It installs from Claude’s official plugin marketplace with /plugin install superpowers@claude-plugins-official. We covered its version 5.1.0 in this note.
Superlite takes that foundation and changes a single priority: instead of keeping a person close to each step, it aims to finish the build without them.
How is Superlite different from Superpowers?
The difference lies in how much the workflow waits, either for you or on its own. Superpowers keeps a person close to each step. In its announcement, Superlite’s author measured between 8 and 12 human approvals per feature: design is approved section by section, execution is sequential, and there’s a review after each task. Superlite reduces all that to a batch of questions, one approval, and parallel waves.
| Superpowers | Superlite | |
|---|---|---|
| Human approvals | Several per feature (design sections, spec, plan, execution method) | One batch of questions and one approval, or none with the AI orchestrator |
| Execution | Sequential: implement, review, fix, next task | Task graph; independent ones run in parallel |
| Models | Opus subagents on the critical path | Opus coordinates, Sonnet builds, Haiku for mechanical tasks |
| Rules | Applied via prompts and skills | Key ones applied with hooks (coordinator can’t edit code, tests run in the background) |
| Best for | Directing each step yourself | Delivering a spec and getting back working code |
The author sums it up this way: use Superpowers if you want to direct each step, and Superlite if you want to delegate the whole job. Don’t activate both in the same session. They share skill names and both inject context on startup, so they conflict.
How do you install Superlite in Claude Code?
Inside Claude Code, it’s two commands:
/plugin marketplace add iha2/superlite
/plugin install superlite@superlite-dev
If you want to try it in a single session from a local clone, use claude --plugin-dir <path-to-superlite>.
According to the README, you need Claude Code, git, Python 3.10 or higher (for Superlite’s tools; the project you build can be in any language), and bash (Git Bash on Windows). To verify the installation, open a new session and send Let's make a react todo list. If it’s properly installed, it starts with brainstorming before writing code.
If you already use Superpowers, disable it before activating Superlite.
The repository also includes installation instructions for Cursor, Gemini CLI, GitHub Copilot CLI, OpenCode, Qwen Code, Devin CLI, Factory Droid, Kimi Code, Pi, Hermes Agent, Muse, and Antigravity. At the time of publishing this note, the README marks the Codex and Grok routes as untested.
Is Superlite really 3.9x faster than Superpowers?
In our tests, no. We got 1.85x on the same task the 3.9x comes from, and close to 1.4x on the larger task, where the author reports 2.1x.
The 3.9x figure comes from a single run per plugin with Superlite 0.1.0, and the author’s own report acknowledges that the two runs overlapped in time and shared usage limits. The most recent headline in the README compares 16.1 minutes against an average of 33.6 minutes for Superpowers on that larger task, which amounts to 52 percent less time. The author also asks to treat those differences as hints, not proof.
How did we do the test?
We used the author’s own harness (bench/harness.py) and two of their tasks. Each task builds a project from a spec and evaluates the result against hidden tests the agents never see. We made one change: we ran the tests strictly one at a time, never in parallel.
Environment: macOS on an Apple M5 Pro, Claude Code 2.1.303, Max plan, Superlite at commit eea16ee0 and Superpowers 7.0.0. Both ran headless on Opus, without stopping to ask for human intervention.
What happened on the 89-test task?
This is the 3.9x task: sitegen, a Python static site generator with 9 modules, evaluated with 89 hidden tests. We did two runs per plugin, alternating the order.
| Run | Total time | Cost (API equivalent) | Hidden tests | Own tests | Max simultaneous agents | Dispatches |
|---|---|---|---|---|---|---|
| Superpowers, run 1 | 36.2 min* | $8.81 | 89/89 | 365 | 4 | 19 |
| Superlite, run 1 | 22.9 min | $4.41 | 89/89 | 203 | 9 | 16 |
| Superlite, run 2 | 18.6 min | $3.66 | 89/89 | 170 | 9 | 14 |
| Superpowers, run 2 | 40.4 min | $7.50 | 89/89 | 296 | 2 | 20 |
*Includes about one minute with the team suspended; adjusted, it’s about 35.3 min.
| Author (1 run, overlapped) | yoDEV (average of 2, sequential) | |
|---|---|---|
| Superpowers | 34.4 min, $8.15 | 38.3 min, $8.16 |
| Superlite | 8.8 min, $3.28 | 20.7 min, $4.04 |
| Speed ratio | 3.9x | 1.85x |
| Cost savings | 60% | 51% |
Our Superpowers numbers match the author’s almost exactly, so on this task the difference is almost entirely on the Superlite side, which took more than twice as long on our hardware. All runs passed the 89 hidden tests. Superlite always wrote fewer of its own tests (between 170 and 203, versus 296 to 365 for Superpowers), in line with the author’s report, which talks about 30 percent less.
And on a larger project, with 177 tests?
On the large task, Superlite finished the work about 15 minutes earlier and cost a third less, but failed 2 of the 7 robustness probes that Superpowers passed completely. It’s the task in the current README headline: a site generator plus a spreadsheet engine (formula evaluator, HTTP API, and web interface), evaluated with 177 hidden tests and 7 robustness probes that go beyond the spec. We did one run per plugin.
| Superpowers | Superlite | |
|---|---|---|
| Time to finish work | 53.9 min | 38.9 min* |
| Total time recorded by harness | 53.9 min | 55.5 min |
| Cost (API equivalent) | $13.32 | $9.05 |
| Hidden tests | 177/177 | 177/177 |
| Robustness probes | 7/7 | 5/7 |
| Own tests | 600 | 349 |
| Max simultaneous agents | 3 | 8 |
| Dispatches | 10 | 18 |
*Superlite finished the work at 38.9 minutes, with tests passing and the work tree clean. But it had previously scheduled a periodic check and stayed waiting about 16.5 minutes until that timer fired, to respond that nothing was left to coordinate. The harness counts that wait, and that’s why the raw total time leaves it just behind Superpowers. We checked the other runs and it’s the only case. In a headless session, it’s a real cost of those scheduled checks: the work is done, but the session stays open.
The two probes Superlite failed (test_huge_literal_is_not_infinite and test_huge_argument_does_not_crash) test what happens with a huge numeric literal like =1e400. Superpowers’ final review detected that same issue and fixed it. Superlite had twice as many agents in parallel, but wrote just over half as many own tests.
Against the author’s numbers (33.6 min for Superpowers and 16.1 for Superlite, 2.1x), both plugins were about 20 minutes slower on our hardware. Our ratio, with the time to finish work, was 1.4x.
A practical note: there was no throttling, but our Max plan’s five-hour usage window hit 94 percent. If you want to repeat the comparison, reserve your quota.
Why are our numbers lower than the author’s?
We don’t know for sure, and we didn’t isolate any single cause. These are the differences between our environment and the author’s:
- Sequential runs versus overlapped. Ours ran one at a time; the 3.9x runs ran at the same time.
- Superpowers version. We used 7.0.0; the author used 6.4.1 in their initial report.
- Environment. Our setups loaded the plugins, MCP servers, and the global
CLAUDE.mdwe use daily. On the 89-test task, our Superlite coordinator worked with a much larger context: a median of between 110,000 and 122,000 tokens, versus the author’s 70,000. Since the author’s report flags coordinator context as the main cost lever, a more loaded environment is a reasonable suspect. - Machine and timing. On the large task, both plugins were slower than in the author’s runs, not just Superlite. That points to differences in hardware or service load, affecting both equally.
- Variance. Superlite alone ranged from 18.6 to 22.9 minutes across our two runs of the small task, and on the large one we have only one run per plugin.
The practical lesson: if you want to evaluate it, a clean Claude Code profile probably gets closer to the author’s numbers than your full daily setup.
Does Superlite save time outside a benchmark?
Probably more than our numbers show, but we didn’t measure it. In the benchmark both plugins run headless with approvals already granted, so neither stops for a person. That means our ratios reflect only parallelism and review structure. In interactive use, Superpowers asks for approval several times per feature and Superlite once (or never). That difference depends on how fast you respond, and no benchmark can capture it.
What should you keep in mind before using Superlite?
- It’s less robust on edge cases. On the large task it failed 2 of 7 robustness probes that Superpowers passed completely, in line with what the README itself admits (4 of 7, versus about 5.7 of 7). It writes fewer of its own tests and its final review didn’t detect the issue that Superpowers’ did.
- It might cost more. The README warns about that, though in our three comparisons it always cost less.
- Hidden tests measure spec compliance, not code quality. Both plugins hit the ceiling on both tasks. A tie at 177/177 doesn’t say which code is easier to maintain.
- It’s at an early stage. As of October 19, 2026, there’s no tagged release. The benchmark refers to version 0.1.0 and the README lists a 0.3 redesign in progress, so the architecture will probably change fast.
- It never pushes or merges without you. Destructive actions, ones visible to the outside, or security-sensitive ones still ask for confirmation, even with the AI orchestrator.
Superlite or Superpowers: which to use?
Use Superlite when the spec is clear and you want to let it work alone: an MVP, a well-defined feature, or a refactor with tests already written. Based on our runs, expect between a quarter and half less time, and between a third and half less cost. Don’t expect a quarter of the time.
Use Superpowers when the design is still being defined and you want to approve it in pieces, or when edge cases matter more than speed: in our large test, its final review was what caught the bug.
Whichever you use, keep only one of the two active per session.
What about you? How much do you let your agent decide before you review the code?
- I approve each step (Superpowers style)
- One approval and it builds alone (Superlite style)
- It depends on the project
- I prefer another option (tell us which)
Comment below or, if this article reached you by email, reply directly to the email: your reply will be published here.