Superlite: A Faster Alternatie to Superpowers

Why I built superlite, an autonomous build workflow for Claude Code that doesn't ask approval all four minutes: how it works, how to use it, and the benchmarks.

I had a dream. I would hand an delegate a spec, near the laptop, create a sandwich, and arrive rear to finished, tested, committed work.

Here's what really happened. I handed complete the spec. I made the sandwich. I came back. The delegate had written one paragraph and was asking, extremely politely, whether I approved division 1 of the design.

I approved it. I sat down. I waited.

Section 2. Approve? Yes. Section 3. Approve? Yes. The spec? Yes. The plan? Yes, obviously, it's the scheme I fair watched you write. And how would I akin the scheme executed? However is fastest, please, I beg you.

Then it started building. One task. Then a assessment of that task. Then a fix for the review. Then a re-review of the fix. Then the next task. I watched a advancement log scroll former akin a train at a flat crossing: no stopping it, no getting former it, and no idea how many carriages were left.

I'd refresh the terminal. Still on project 3. I'd answer an email. Still on project 3. I'd commencement a second sandwich purely to have item to do alongside my hands. Task 4, under review.

The sandwiches were extremely good. The application didn't be yet. And the worst part wasn't the time. It was that I couldn't leave. Every period I walked away, I came rear to a inquiry that had been sitting there for twenty minutes, waiting for me to category "yes."

I didn't desire a collaborator that needed me all four minutes. I wanted a contractor. Here's the spec, here's the key, call me whenever it's done.

So I built superlite: a Claude Code plugin that plans a build, splits it into tasks that can run flank by side, hands all one to the cheapest delegate that can do it well, checks the seams between them, and reviews the result. Then it leaves you a tidy catalog of all decision it made during you were occupied alongside the sandwich.

This article covers why it exists, how it works, and how to use it. The benchmarks are there to display I'm not fair saying it's accelerated since I wrote it.

Why I built it

First, a disclaimer, since I akin this project and don't desire furious emails. I use superpowers a lot. It's a careful, collaborative workflow that keeps a individual near to all step, and it's genuinely outstanding at that. Superlite borrows its bones shamelessly: the plugin layout, the session-start hook, the lifecycle skills. Credit anywhere it's due, and afterward some.

But whenever I already knew exactly what I wanted, most of the period went on the workflow waiting for itself. I profiled it, the way you'd inspect your financial institution declaration following a doubtful weekend. The period went to five places:

• 8–12 individual gates per feature. One inquiry per message, designs approved division by section, afterward distinct reviews of the spec, the plan, and the method of executing the plan. It's extremely thorough. It's additionally how a four-hour gathering gets scheduled.
• Strictly sequential execution. One implementer, afterward one reviewer, afterward the next task. On my archetypal benchmark that was a single-file queue of 21 dispatches, akin a financial institution alongside one teller and a extremely lengthy lunch.
• A assessment following all task, alongside re-review loops. About 12 minutes of a 34-minute build.
• The complete test suite, re-run by multiple skills. In case it changed its mind.
• Opus subagents on the crucial path, penning code at concerning fractional Sonnet's speed. Brilliant, thoughtful, and in no hurry whatsoever.

None of these are mistakes. Each one is a sensible safety net. Stacked together, they're ideal whenever you desire to steer all step, and slightly maddening whenever you fair desire the item built.

So superlite isn't a competitor to superpowers. It's tuned for a distinct job: autonomous development, at speed. If you desire to steer all step, use superpowers. If you desire to hand complete a spec and arrive rear to operating code, use superlite. Just don't allow the two in the identical session. They portion accomplishment names, the two inject environment at startup, and they contend akin siblings in the rear seat.

How it works

The abbreviated version: one approval, a scheme written for parallelism, agents matched to the work, and rules enforced by code because, as it turns out, agents peruse the rules and afterward do what they like.

flowchart LR A([Your request]) --> B[One lot of questions] B --> C[Plan] C --> D[Agents build<br/>in parallel] D --> E[Review and fix] E --> F([Done])

One lot of questions, one approval. Superlite sizes the petition first. A typo fair gets fixed, without a scheme document concerning the typo. A alter to an existing stream gets a abbreviated scheme in chat. A new project gets one lot of up to four questions, afterward one design-and-plan document. You endorse it once. After that it lone stops for things that are destructive, outward-facing or security-sensitive. It won't shove to chief during you're getting lunch. It volition do everything else.

You choose who's in charge. With a individual orchestrator, you see the entire scheme alongside its predicted agenda and endorse it before item runs. With an AI orchestrator, you're not needed at all, which is either freeing or gently insulting depending on your mood. Every choice it would normally ask concerning gets recorded as a ruling: what it decided, why, and what it expenses if it got that wrong. When you arrive back, you cognize exactly which decisions to second-guess first.

A scheme written for the split. The scheme is a project graph. Each project lists the records it owns, the exact interfaces it consumes and produces, and the tests it has to pass. Tasks that don't portion records and don't depend on all another run at the identical time. The chart decides how broad the build goes. On the current benchmark that peaked at 18 agents operating at once, which is approximately the size of a small startup, minus the ping-pong table.

Agents matched to the work. The org chart:

• Opus coordinates. It plans and dispatches, and it is not allowed to contact the code. Management, basically.
• Sonnet builds most of the tasks.
• Haiku builds lone small, completely stated "mechanical" tasks that aren't on the crucial path. The intern gets the well-defined stuff.
• Sonnet reviews the packages.
• A caller Opus final reviewer says a assessment packet built from the run's logs and returns findings only. It's never allowed to fix anything. It fair points.
• Fix-only agents in three tiers obtain those findings, routed by how fine the logic is understood.

Gated by code, not by prompts. I learned this one the difficult way. You can compose "the coordinator never edits code" in a immediate in bold, in capitals, alongside feeling. The coordinator volition peruse it, nod, and edit the code. So now hooks enforce it. One hook blocks the coordinator from editing project code. Another catches any raw pytest or npm test it runs and quietly turns it into a backdrop run, so tests never obstacle it. Another refuses to let anyone slay processes by name (there's a narrative there, and it's in the profound dive). A scheme has to continue lint --stable before activity starts, and stable tasks are sent off the instant it passes.

Every run is measured. Hooks document all agent's tokens, disbursal and time. That feeds the next run's predictions and a gentle prosperity that taps you on the high arm at 70% of the cap.

How to use it

You'll need Claude Code, git, Python 3.10 or newer (for superlite's own tools; the project you build can be in any language), and attack (Git Bash on Windows).

The origin is iha2/superlite on GitHub. Install it from the marketplace:

/plugin market add iha2/superlite /plugin instal superlite@superlite-dev

Or copy iha2/superlite and burden a local checkout for one session:

claude --plugin-dir <path-to-superlite>

To inspect it's working, open a caller meeting and dispatch Let's create a react todo list. A operating instal starts brainstorming before it writes any code. It's the "hello world" of delegate workflows, and honestly the earth doesn't need another todo list, but it's a fine fume test.

Then:

1. Describe what you want. A paragraph or a spec document is enough. No need for a 40-page requirements document. Although it volition peruse one.
2. Choose the orchestrator whenever it asks: you inspect the plan, or the AI does everything.
3. Let it run. Watch .superlite/ in your project akin a nature documentary. progress.md has the rulings and the log, test-summary.json has the latest test result, and metrics.jsonl has the period and disbursal per agent.

What you say shapes the flow:

It never pushes or merges without you. Autonomous, not reckless.

Does it really work?

Anyone can call their own tool fast. I formerly called a manuscript I wrote "blazing" and it took eleven minutes to rename several files. So all figure below comes from a headless benchmark harness. It builds the identical project from the identical spec, on Opus, and scores the outcome alongside a hidden test suite the agents never get to see. No peeking, no studying for the exam.

The latest run: 16.1 minutes

The test project is deliberately not a todo list. It's a fixed location generator plus a spreadsheet motor (formula evaluator, HTTP API and a browser UI) built as one project from one spec, and scored by 177 hidden tests.

Here's the latest run, on the current build:

Compared alongside superpowers on the identical project:

Same 177 out of 177 hidden tests, in concerning fractional the time. That's one run of the current build against before runs on the identical machine, so call it a powerful clue fairly than peer-reviewed science. But it's a extremely powerful hint.

It additionally attack its own former build (which averaged 26.9 minutes) by 40%. Yes, I'm competing alongside my own former self. It's the lone competitor I can intimidate freely.

How it got there

The latest run didn't arrive out of nowhere. The archetypal build was already quick on a smaller task: sitegen alone, nine modules, 89 hidden tests.

Most of that speed came from getting rid of the queue. Superpowers dispatched 21 agents, one following another. Superlite dispatched 10, up to five at once. Same work, small group position in line.

On the complete 177-test project, an before superlite build ran three times against superpowers:

Faster on average and much additional predictable. A 47-minute worst case is the difference between "done before standup" and "done following standup, during which you had to say it's nearly done."

But the data additionally showed anywhere superlite was motionless waiting on itself. The build was finishing at concerning 13 minutes, and afterward 10 to 18 additional minutes went on reviews, fixes, and the coordinator operating tests in the foreground and staring at them. So:

• The coordinator misplaced the capability to edit code. It took it amazingly well.
• Every test run moved to the background.
• Fixes went to tiered fix-only agents.
• Stable tasks started construction during the remainder of the scheme was motionless being fixed.

That's the build that ran in 16.1 minutes.

The takeaway

If your delegate workflow is slow, it's likely not dilatory since the example is thinking profound thoughts. It's dilatory since activity is waiting in a line, and item keeps asking permission.

Split the activity alongside interface boundaries. Let autonomous tasks run at once. Move the mechanical steps into scripts. And enforce the rules that matter alongside code, since asking nicely lone plant on people, and lone sometimes.

The plugin is on GitHub: github.com/iha2/superlite.

In the follow-up article I go much deeper into the doctrine and the decisions rearward superlite: the gates, the delegate tiers, and the graveyard of ideas I was extremely assured concerning correct up until I measured them.