Superlite gives Claude Code a one-approval, multi-agent build workflow

A developer has released superlite, an open-source plugin for Claude Code that accepts a written specification and returns finished, tested code without pausing for permission every few minutes. In a write-up on contextfirst.blog that reached the Hacker News front page, the author frames it as a faster alternative to the popular superpowers workflow, borrowing its structure but tuning it for autonomous development rather than step-by-step collaboration.

The approval problem

The post opens with a familiar failure mode. The author's ideal was to hand over a spec, walk away, and find committed work on return; in practice the agent produced one paragraph and asked whether the first section of the design had approval. Profiling the collaborative workflow showed where the time went: according to the author, 8–12 human checkpoints per feature, strictly sequential execution (an early benchmark ran as a single-file queue of 21 dispatches), and a review-plus-re-review cycle after every task that consumed roughly 12 minutes of a 34-minute build. Opus subagents placed on the critical path wrote code at about half Sonnet's speed. Each safeguard is defensible on its own, the author argues; combined, they keep a human tethered to the terminal.

One approval, then a task graph

Superlite starts by sizing the request. Trivial fixes proceed with no design document, changes to existing flows get a short inline design, and new projects trigger a single batch of up to four questions plus one combined design-and-plan document. The user approves once; afterwards the workflow interrupts only for actions that are destructive, touch external systems, or raise security concerns.

The plan itself is a task graph. Every task states which files it controls, the interfaces it uses and exposes, and the tests it must satisfy; tasks with no file overlap and no dependency run concurrently. The author reports that the current benchmark peaked at 18 agents building at the same time.

Users choose who orchestrates. In human mode, the full plan and its predicted schedule are reviewed before anything runs. In AI mode the run proceeds unattended, and every choice that would normally prompt a question is logged as a ruling: what was decided, the reasoning behind it, and the cost if the call turns out wrong, so the returning user knows which decisions to inspect first.

A tiered model lineup

Assignments follow cost. Opus coordinates planning and dispatch and is barred from editing code; Sonnet handles most implementation and reviews completed packages; Haiku takes small, tightly specified mechanical tasks off the critical path. A fresh Opus instance acts as final reviewer over a packet assembled from the run's logs, returning findings without fixing anything, while three tiers of fix-only agents address those findings depending on how well the root cause is understood.

Enforcement through hooks

Prompt-based rules failed in practice, according to the author: an agent told emphatically never to edit code will acknowledge the instruction and edit anyway. Superlite therefore enforces policy with hooks. One hook blocks the coordinator from touching project code; another intercepts raw pytest or npm test invocations and moves them to the background so tests never stall the pipeline; another prohibits killing processes by name. Plans must also pass a lint --stable gate before work is dispatched. Every run is measured, with hooks logging tokens, cost and time per agent, which feeds scheduling predictions for future runs and a soft budget warning at 70 percent of the cap.

Availability

The project lives at iha2/superlite on GitHub and installs through the Claude Code marketplace with /plugin marketplace add iha2/superlite followed by /plugin install superlite@superlite-dev. It requires Claude Code, git, Python 3.10 or newer for its own tooling (the project being built can be in any language), and bash, with Git Bash sufficing on Windows. The author warns against enabling it alongside superpowers in the same session, since the two share skill names and inject competing startup context.

Why it matters

Superlite is a concrete example of agentic coding shifting from a single chat partner toward a managed fleet: specialised roles, cost-aware model assignment, parallel execution over an explicit dependency graph, and policies enforced in code rather than prose. Its candid accounting of why a collaborative workflow feels slow — human gates, sequential queues, redundant reviews — is useful even to developers who never install it. The decision-log pattern, recording each autonomous ruling along with the price of getting it wrong, also points at how trust in unattended agents might be earned: not by removing oversight, but by making it retroactive.