Ik liet Claude Code een weekend draaien om een reactive UI library met Effect te bouwen

Afgelopen weekend besloot ik de grenzen van AI-assisted development op te zoeken. Gewapend met Claude Code, mijn TypeScript vibe coding meta en een licht geschift idee (wat als we een reactive UI library volledig bovenop Effect zouden bouwen?), verdween ik in een codeermarathon.
Wat er 48 uur later uit kwam was effect-ui: een volledig werkende reactive UI library die Effect niet zomaar gebruikt, hij is Effect, tot in de kern.
Waarom Effect zijn eigen reactive UI library verdient
Effect is stilletjes uitgegroeid tot een van de meest geavanceerde runtime-systemen van TypeScript. Het biedt streams, fibers, scopes, contexts, scheduling en error handling: eigenlijk alles wat je nodig hebt om complexe applicaties te bouwen. Toch behandelen de meeste UI libraries Effect als een bijzaak, iets wat je integreert via adapters en wrappers.
Maar wat als we dat omdraaien? Wat als we, in plaats van Effect om een UI library heen te wikkelen, de UI library vanuit de primitives van Effect bouwen?
// Traditional approach: UI library with Effect bolted onconst [state, setState] = useState(0);useEffect(() => { const subscription = effectStream.subscribe(setState); return () => subscription.unsubscribe();}, []);// Effect-UI approach: Streams are the UI primitivesconst Counter = () => ( <div>{Stream.iterate(0, n => n + 1).pipe( Stream.schedule(Schedule.spaced(1000)) )}</div>);
In traditionele UI libraries is reactiviteit de zorg van de library: je hebt hooks, signals of observables die de library beheert. De developer experience en coding patterns worden bepaald door precies die library die je gebruikt. In effect-ui komt reactiviteit uit het Stream-type van Effect, wat betekent dat je alle features en compositiekracht van Effect er gratis bij krijgt.
Cowboy coding is hier verboden
Op vrijdagavond opende ik Claude Code en begon ik te prompten.
Dit ging geen cowboy coding worden. Van mijn TypeScript vibe coding meta heb ik geleerd dat AI-assistenten structuur nodig hebben om kwaliteitscode te schrijven. Het eerste uur ging dus op aan het opstellen van regels:
## Project Rules1. Effect streams are first-class UI primitives2. Components execute once (ephemeral, like SolidJS)3. No virtual DOM, use direct DOM manipulation4. All async operations via Effect5. TypeScript strict mode, no any6. Every feature needs specs, mocks, and tests7. Run validation after every change
In plaats van meteen de implementatie in te duiken, besteedden Claude en ik de eerste drie uur aan het schrijven van specificaties:
// From dom.specs.mddeclare function mount( app: JSXNode, root: HTMLElement): Effect<MountHandle, RenderError>;declare interface MountHandle { unmount(): Effect<void>;}declare type JSXNode = | Primitive | Stream<JSXNode> | Effect<JSXNode> | JSXElement;
Door deze gedisciplineerde aanpak (eerst specs, dan implementatie) hadden we tegen bedtijd nog geen enkele regel runtime-code geschreven, maar wel een complete blauwdruk van het API-oppervlak van de library.
De superkrachten van Effect beginnen te schitteren
Hoe update je de DOM efficiënt wanneer streams nieuwe waardes emitten, zonder virtual DOM?
Traditionele reactive libraries diffen virtuele trees (React), gebruiken fine-grained reactivity met proxy traps (Vue, SolidJS) of compileren de reactiviteit weg (Svelte). Maar Effect-streams boden een unieke kans.
Zaterdagmiddag begon de echte magie. Omdat effect-ui op de primitives van Effect is gebouwd, werkten geavanceerde patronen gewoon out of the box:
// Scheduling is built-inconst clockStream = Stream.iterate(new Date(), () => new Date()).pipe( Stream.schedule(Schedule.spaced(1000)));// Error handling via Effect's error channelconst DataComponent = () => { const dataStream = Stream.fromEffect( Effect.tryPromise({ try: () => fetch('/api/data').then(r => r.json()), catch: (error) => new FetchError({ cause: error }) }) ); return <div>{dataStream}</div>;};// Cancellation via scopesconst mount = (app: JSXNode, root: HTMLElement) => Effect.gen(function*() { const scope = yield* Scope.make(); // All stream subscriptions are forked into this scope // ... return { unmount: () => Scope.close(scope, Exit.void) }; });
De integratie voelt natuurlijk omdat we simpelweg de primitives van Effect omarmen. Streams worden niet aangepast om met de UI te werken; de UI wordt uitgedrukt in streams.
Zondag: het componentmodel kristalliseert uit
Zondag bracht de laatste architectuurbeslissing: ephemeral components. Anders dan React, dat componentfuncties bij elke update opnieuw uitvoert, draaien effect-ui-components precies één keer:
const Timer = ({ initial }: { initial: number }) => { // This function executes ONCE console.log("Timer component executed"); // The stream handles all future updates return ( <div> Count: {Stream.iterate(initial, n => n + 1).pipe( Stream.schedule(Schedule.spaced(1000)) )} </div> );};// Even with changing props, the component doesn't re-execute// Only the streams update
Dit model, geleend van SolidJS, past perfect bij Effect-streams. De component zet de reactive graph één keer op, daarna handelen streams alle updates af. Geen re-rendering, geen reconciliation, alleen data die door het systeem stroomt.
Hoe mijn TypeScript vibe coding meta zichzelf bewees
Het hele weekend bleef de gedisciplineerde aanpak uit mijn vibe coding meta zich uitbetalen:
- Specs vóór code: elke feature begon als specificatie in
dom.specs.md. Dat gaf Claude duidelijke acceptatiecriteria. - Type-driven development: we schreven eerst de type signatures, met het
declare-keyword van TypeScript:declare function renderNode(node: JSXNode):Effect.Effect<RenderResult, RenderError, RenderContext>; - Test-driven validation: 27 acceptatiecriteria, elk met meerdere testcases. Na elke wijziging draaide de volledige test suite.
- Continue validatieloop:
# This ran hundreds of times over the weekendnpm test && npm run check && npm run lint
In 48 uur produceerde Claude ~500 regels documentatie, ~1000 regels code en ~1300 regels tests, met nul runtime errors in de uiteindelijke library.
Technische deep dive: streams als UI primitives
Laten we eens kijken wat effect-ui uniek maakt. In traditionele reactive UI libraries heb je meerdere concepten: state, effects, computeds, subscriptions. In effect-ui is alles een Stream:
// Static values become single-emission streams<div class="static">Hello</div>// Internally: Stream.make("static")// Dynamic values are already streams<div class={colorStream}>Content</div>// Effects become streams<div>{Stream.fromEffect(fetchUserData())}</div>// Even style properties can be streams<div style={{ width: Stream.iterate(100, n => n + 10).pipe( Stream.map(n => `${n}px`), Stream.take(20) ), backgroundColor: colorStream}}> Animated box</div>
Deze unificatie betekent dat je het complete ecosysteem aan stream operators van Effect kunt gebruiken:
const searchResults = Stream.fromEffect( Effect.succeed(searchInput)).pipe( Stream.debounce(300), Stream.flatMap(query => Stream.fromEffect(searchAPI(query)) ), Stream.retry(Schedule.exponential(100)), Stream.catchAll(() => Stream.make("Search failed")));return <div>{searchResults}</div>;
Lifecycle management op basis van scopes
Een van de gaafste features van Effect is het scope-systeem. In effect-ui creëert elke mount een supervision scope:
const mount = (app: JSXNode, root: HTMLElement) => Effect.gen(function*() { const runtime = ManagedRuntime.make(Layer.empty); const scope = yield* Scope.make(); const context = { runtime, scope, streamIdCounter: { current: 0 } }; // All stream subscriptions are forked into this scope yield* Effect.forkIn(renderNode(app), scope); let unmounted = false; return { unmount: () => Effect.gen(function*() { if (unmounted) return; unmounted = true; // This cancels ALL stream subscriptions at once yield* Scope.close(scope, Exit.void); yield* Effect.promise(() => runtime.dispose()); }) }; });
Dit is opvallend elegant. Elke stream subscription is een fiber die in de mount scope wordt geforkt. Zodra je unmount, annuleert het sluiten van de scope automatisch alle fibers, waardoor alle streams stoppen. Geen handmatige cleanup, geen memory leaks, gewoon het resource management van Effect.
De vergelijking met de gevestigde orde
Een van mijn kerndoelen was om mee te liften op Effect, zonder een compleet nieuwe reactivity-API te creëren. Met dat in gedachten: hoe verhoudt effect-ui zich tot het huidige landschap?
vs React:
- Geen virtual DOM-overhead
- Ingebouwde async primitives (geen useEffect-gedoe)
- Simpeler mentaal model (alleen streams, geen hooks)
vs SolidJS:
- Vergelijkbaar ephemeral componentmodel
- Geen proxy traps of reactive primitives nodig
vs Vue:
- Geen reactivity transform of compilermagie
- Streams zijn expliciet, niet verstopt achter proxies
Maar de echte vergelijking gaat niet over “beter” zijn; het gaat over het paradigma. Zoals ik beschrijf in mijn Redux in 2025-artikel: daar betoogde ik dat de waarde van Redux in zijn voorspelbaarheid en observeerbaarheid zit. Effect-ui bouwt daarop voort. Elke state change is een stream emission, elke async operatie is een Effect, elke cleanup wordt door een scope beheerd. Het hele systeem is observeerbaar, voorspelbaar en type-safe.
Het weekend zit erop: reflectie op AI-assisted development
Zondagavond. De test suite is groen, de playground heeft een paar werkende demo’s en effect-ui bestaat echt. Ik durf niet te beweren dat effect-ui production-ready is, maar in één weekend met Claude Code als mijn programmeur bouwden we iets waar normaal weken of maanden in gaan zitten.
Maar dit is het cruciale punt: dit was geen “prompt and pray”-development. Het succes kwam voort uit:
- Gedisciplineerde structuur: rules, specs, tests: de vibe coding meta in actie
- Domeinexpertise: begrip van de patterns van Effect en van UI library-architectuur
- Iteratieve verfijning: continue (zelf)validatie en bijsturing
- Duidelijke grenzen: AI schreef de code, ik leverde de architectuur en de richting
Ik kon me richten op architectuur en design terwijl Claude de implementatiedetails afhandelde. Als iets niet werkte, pasten we de regels aan en probeerden we het opnieuw.
Een paar take-aways van effect-ui
Dit weekend leerde ik drie dingen:
- Effect is klaar voor UI: de primitives zijn er (streams, fibers, scopes, contexts). We hoefden ze alleen nog goed in elkaar te zetten.
- AI kan complexe systemen bouwen: met de juiste structuur en discipline kunnen AI-assistenten geavanceerde projecten aan.
- Paradigmaverschuivingen zijn mogelijk: we hoeven niet te accepteren dat UI libraries op een bepaalde manier moeten werken. Door op andere primitives te bouwen (Effect in plaats van traditionele reactive systemen) ontstaan compleet nieuwe patterns.
Hoe nu verder
Is effect-ui production-ready? Nee. Tenzij je bereid bent om erom ontslagen te worden. Maar het is een proof of concept dat verrassend goed werkt.
Belangrijker nog: het laat zien dat de primitives van Effect krachtig genoeg zijn om hele categorieën libraries te bouwen die eerder niet bestonden.
Bij OWOW hebben de eerste stukjes Effect-code hun weg gevonden naar onze React-codebases. De patterns die Effect mogelijk maakt (streams als UI primitives, lifecycle management via scopes, ephemeral components met de runtime van Effect) gaan beïnvloeden hoe ik voortaan over UI-development nadenk.
Tot slot
In één weekend creëerden we, met gedisciplineerde AI-assistentie en de krachtige primitives van Effect, een reactive UI library waarin streams JSX zijn, effects promises zijn en alles gewoon… werkt. Of je nu helemaal om bent voor Effect, nieuwsgierig bent naar AI-assisted development of gewoon graag nieuwe benaderingen van oude problemen ziet: effect-ui bewijst dat er nog ruimte is voor innovatie in de ogenschijnlijk verzadigde wereld van JavaScript UI libraries.
De code staat op GitHub. Probeer het, breek het, verbeter het. En de volgende keer dat iemand je vertelt dat alle goede ideeën voor UI libraries al verkend zijn, laat ze dan zien wat er gebeurt als je de runtime van Effect combineert met een weekend en wat gedisciplineerde AI-samenwerking.
Let’s collaborate
You are now being called to action.Choose wisely
Pitch
To save us both time, we created a 30-second pitch on why we are the right digital partner for you
Tour
Proposals and pricing? Watch this for everything you need to make the next step
Discovery call
Ready to speak to a human? We have some of those. Book a No-Commitment discovery call!
-2834x1584.webp)