Superlite: geef een agent een specificatie en kom terug bij getest werk

Door Iheatu Chris Wogu — 18 oktober 2026

Eén voor één versus alles tegelijk

Ik had een droom: ik zou een agent een specificatie geven, mijn laptop dichtklappen, een broodje maken en terugkomen bij afgerond, getest en gecommit werk.

Dit is wat er in werkelijkheid gebeurde. Ik leverde de specificatie aan. Ik maakte het broodje. Ik kwam terug. De agent had één alinea geschreven en vroeg nu heel beleefd of ik sectie 1 van het ontwerp goedkeurde.

Ik keurde het goed. Ik ging zitten. Ik wachtde.

Sectie 2. Goedkeuren? Ja. Sectie 3. Goedkeuren? Ja. De specificatie? Ja. Het plan? Ja, natuurlijk, het is het plan dat ik net heb zien schrijven. En hoe het plan uitgevoerd moest worden? Op de snelste manier, alsjeblieft, ik smeek je.

Toen begon het bouwen. Eén taak. Dan een review van die taak. Dan een correctie voor de review. Dan een her-review van de correctie. Dan de volgende taak. Ik keek naar een voortgangslog die voorbij scrollde als een trein bij een spoorovergang: er was geen stopknop, ik kon er niet langs en ik had geen idee hoeveel wagons er nog over waren.

Ik ververste de terminal. Nog steeds bij taak 3. Ik beantwoordde een e-mail. Nog steeds bij taak 3. Ik begon aan een tweede broodje, puur om iets met mijn handen te doen. Taak 4, in review.

De broodjes waren erg lekker. De software bestond nog niet. En het ergste was niet de tijd, maar het feit dat ik niet weg kon. Elke keer als ik wegliep, kwam ik terug bij een vraag die er al twintig minuten stond te wachten tot ik "ja" zou typen.

Ik wilde geen collaborator die me elke vier minuten nodig had. Ik wilde een aannemer. Hier is de specificatie, hier is de sleutel, bel me als het klaar is.

Daarom heb ik superlite gebouwd: een Claude Code-plugin die een build plant, deze opsplitst in taken die naast elkaar kunnen draaien, elke taak toewijst aan de goedkoopste agent die het goed kan uitvoeren, de aansluitingen tussen de taken controleert en het resultaat reviewt. Daarna krijg je een nette lijst van elke beslissing die is genomen terwijl jij bezig was met je broodje.

Dit artikel behandelt waarom superlite bestaat, hoe het werkt en hoe je het gebruikt. De benchmarks tonen aan dat het niet alleen snel is omdat ik het geschreven heb.

Waarom ik het heb gebouwd

Eerst een disclaimer: ik gebruik superpowers veel. Het is een zorgvuldige, collaboratieve workflow die een mens dicht bij elke stap houdt, en het is oprecht uitstekend in dat proces. Superlite leent brutaal de basis van superpowers: de plugin-layout, de session-start hook en de lifecycle skills.

Maar wanneer ik al precies wist wat ik wilde, ging de meeste tijd verloren omdat de workflow op zichzelf wachtte. Ik analyseerde de tijd waarin het proces vertraagde en vond vijf hoofdoorzaken:

  1. Menselijke controlepunten: 8 tot 12 menselijke tussenstappen per feature. Eén vraag per bericht, ontwerpen die sectie voor sectie worden goedgekeurd, gevolgd door aparte reviews van de specificatie, het plan en de uitvoeringsmethode. Zeer grondig, maar het is precies hoe een vergadering van vier uur wordt ingepland.
  2. Strikt sequentiële uitvoering: Eén implementeerder, dan één reviewer, dan de volgende taak. In mijn eerste benchmark was dit een wachtrij van 21 opeenvolgende acties.
  3. Review-loops: Een review na elke taak, met loops voor herstel. Ongeveer 12 minuten van een build van 34 minuten gingen hiernaartoe.
  4. Herhaalde testsuites: De volledige testsuite werd meerdere keren opnieuw uitgevoerd door verschillende skills, voor het geval de agent van gedachten was veranderd.
  5. Opus-subagents op het kritieke pad: Deze schreven code met ongeveer de helft van de snelheid van Sonnet. Briljant en bedachtzaam, maar totaal niet gehaast.

Geen van deze punten is een fout; elk is een verstandig veiligheidsnet. Gestapeld op elkaar zijn ze perfect wanneer je elke stap wilt sturen, maar lichtelijk frustrerend wanneer je gewoon wilt dat het product gebouwd wordt.

Superlite is dus geen rivaal van superpowers, maar is afgestemd op een andere taak: autonome ontwikkeling op snelheid. Als je elke stap wilt sturen, gebruik je superpowers. Als je een specificatie wilt overhandigen en terug wilt komen bij werkende code, gebruik je superlite. Schakel ze niet beide tegelijk in; ze delen skill-namen en injecteren allebei context bij de opstart, waardoor ze gaan ruzien als broertjes en zusjes op de achterbank.

Hoe het werkt

In het kort: één goedkeuring, een plan geschreven voor parallellisatie, agents die worden gekoppeld aan het werk, en regels die door code worden afgedwongen (omdat agents, zoals blijkt, regels lezen en vervolgens doen waar ze zin in hebben).

Het procesoverzicht

Uw verzoek → Eén batch vragen → Plan → Agents bouwen parallel → Review en fix → Klaar

Eén batch vragen, één goedkeuring. Superlite schat eerst de omvang van het verzoek in. Een typfout wordt direct hersteld zonder ontwerpdocument. Een wijziging in een bestaande flow krijgt een kort ontwerp in de chat. Een nieuw project krijgt één batch van maximaal vier vragen, gevolgd door één ontwerp- en plandocument. Je keurt dit één keer goed. Daarna stopt het proces alleen voor zaken die destructief zijn, extern zichtbaar zijn of betrekking hebben op beveiliging. Het zal niet naar main pushen terwijl je luncht, maar doet al het andere.

Keuze van de orchestrator. Je kunt kiezen wie de leiding heeft:

  • Menselijke orchestrator: Je ziet het volledige plan met de voorspelde planning en keurt dit goed voordat er iets wordt uitgevoerd.
  • AI-orchestrator: Je bent helemaal niet nodig. Elke keuze die normaal gesproken een vraag zou triggeren, wordt geregistreerd als een "besluit" (ruling): wat is besloten, waarom, en wat zijn de kosten als het fout is gegaan. Bij terugkomst weet je precies welke beslissingen je als eerste moet controleren.

Een plan voor splitsing. Het plan is een taakgrafiek (task graph). Elke taak bevat de bestanden die het beheert, de exacte interfaces die het consumeert en produceert, en de tests die het moet passeren. Taken die geen bestanden delen en niet van elkaar afhankelijk zijn, draaien gelijktijdig. In benchmarks piekte dit op 18 agents die tegelijk werkten.

Agent-rollen (De organisatiestructuur):

  • Opus: Coördineert. Plant en verdeelt taken, maar mag de code niet aanraken (het management).
  • Sonnet: Bouwt de meeste taken en voert de reviews van de pakketten uit.
  • Haiku: Bouwt alleen kleine, volledig gespecificeerde "mechanische" taken die niet op het kritieke pad liggen (de stagiair).
  • Opus (Finale Reviewer): Een frisse Opus-agent leest een review-pakket gebouwd uit de logs en geeft alleen bevindingen terug. Deze agent mag nooit zelf iets repareren, alleen aanwijzen.
  • Fix-only agents: Deze zijn verdeeld over drie niveaus en nemen de bevindingen over, afhankelijk van hoe goed de oorzaak van de fout begrepen wordt.

Afgedwongen door code, niet door prompts. Ik heb geleerd dat je "de coördinator bewerkt nooit code" in dikgedrukte hoofdletters in een prompt kunt zetten, maar dat de coördinator dat toch zal doen. Daarom worden hooks gebruikt:

  • Een hook blokkeert de coördinator van het bewerken van projectcode.
  • Een andere hook vangt pytest of npm test op en zet deze om in een achtergrondproces, zodat tests de coördinator niet blokkeren.
  • Een plan moet eerst lint --stable passeren voordat het werk begint.

Elke run wordt gemeten. Hooks registreren tokens, kosten en tijd per agent, wat wordt gebruikt voor voorspellingen in volgende runs en een budgetwaarschuwing bij 70% van het maximum.

Hoe je het gebruikt

Vereisten

  • Claude Code
  • git
  • Python 3.10 of nieuwer (voor de tools van superlite; het project dat je bouwt kan in elke taal zijn)
  • bash (Git Bash op Windows)

Installatie

De broncode staat op GitHub onder iha2/superlite. Installeren via de marketplace: /plugin marketplace add iha2/superlite /plugin install superlite@superlite-dev

Of clone iha2/superlite en laad een lokale checkout voor één sessie: claude --plugin-dir <pad-naar-superlite>

Om te controleren of het werkt, open een nieuwe sessie en stuur: "Let's make a react todo list." Een werkende installatie begint met brainstormen voordat er code wordt geschreven.

Workflow

  1. Beschrijf wat je wilt. Een alinea of een specificatiedocument is voldoende.
  2. Kies de orchestrator wanneer daarom wordt gevraagd (mens of AI).
  3. Laat het draaien. Houd de map .superlite/ in je project in de gaten:
  • progress.md: bevat de besluiten (rulings) en de log.
  • test-summary.json: de laatste testresultaten.
  • metrics.jsonl: tijd en kosten per agent.

Voorbeelden van prompts

SituatieVoorbeeld prompt
Nieuw project"Bouw me een static site generator op basis van deze spec"
Feature in bestaande code"Voeg CSV-export met kolombreedtes toe aan de bestaande app"
Debugging"Deze test faalt op schrikkeldagen: vind de bronoorzaak en fix het"
Kleine wijziging"Hernoem 'build' naar 'render' overal in het project"
Volledig autonoom"Bouw X. Ik ben weg, beslis zelf"
Afronden"We zijn klaar: voltooi de branch"

Let op: superlite pusht of merget nooit zonder jouw tussenkomst.

Werkt het echt?

Alle onderstaande cijfers komen uit een headless benchmark-harness. Het bouwt hetzelfde project vanuit dezelfde specificatie op Opus, en scoort het resultaat met een verborgen testsuite die de agents nooit te zien krijgen.

Het testproject: Een static site generator plus een spreadsheet-engine (formule-evaluator, HTTP API en browser UI), gescoord door 177 verborgen tests.

Resultaten laatste run

  • Reële tijd (van spec naar build): 16,1 min
  • Verborgen tests: 177 / 177
  • Agents: 21 in totaal (maximaal 18 gelijktijdig)
  • Start van bouw: na ongeveer 3 minuten
  • Finale review: 30 seconden
  • Menselijke tussenkomst: 0

Vergelijking met superpowers (op hetzelfde project)

ConfiguratieReële tijd (gemiddelde van 3 runs)
superpowers, stock33,6 min
superpowers, orchestrated23,5 min
superlite, laatste run16,1 min

Dit is 52% minder tijd dan de stock-versie en 31% minder dan de orchestrated-versie, met hetzelfde resultaat (177/177 tests).

Hoe we hier zijn gekomen

De snelheidswinst kwam voort uit een iteratief proces:

  1. Wachtrijen verwijderen: In vroege versies verstuurde superpowers 21 agents één na de andere. Superlite verstuurde er 10, waarvan er tot vijf tegelijk konden werken.
  2. Voorspelbaarheid: Superlite bleek niet alleen gemiddeld sneller, maar ook consistenter (minder spreiding tussen de snelste en langzaamste run).
  3. Optimalisatie van de laatste fase: De build was vaak na 13 minuten klaar, maar daarna volgden nog 10 tot 18 minuten aan reviews en tests in de foreground. Dit werd opgelost door:
  • De coördinator de mogelijkheid om code te bewerken te ontnemen.
  • Elke testrun naar de achtergrond te verplaatsen.
  • Fixes toe te wijzen aan specifieke fix-only agents.
  • Stabiele taken direct te laten bouwen terwijl de rest van het plan nog werd gecorrigeerd.

Conclusie

Als je agent-workflow traag is, komt dat waarschijnlijk niet omdat het model "diep nadenkt". Het is traag omdat werk in de rij staat te wachten en er constant om toestemming wordt gevraagd.

Splits het werk langs interface-grenzen. Laat onafhankelijke taken gelijktijdig draaien. Verplaats mechanische stappen naar scripts. En dwing de belangrijkste regels af met code, want vriendelijk vragen werkt alleen bij mensen, en zelfs dan slechts soms.

De plugin is beschikbaar op GitHub: github.com/iha2/superlite.