icon
en

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

Een visualisatie van streams, bij het artikel van Stef van Wijchen over hoe hij Claude Code een weekend liet draaien om een reactive UI-library met Effect te bouwen. Gemaakt met MidJourney.

Geschreven door

Stef van Wijchen

Geplaatst op

Deel artikel

LinkedIn

Facebook

X

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 on
const [state, setState] = useState(0);
useEffect(() => {
const subscription = effectStream.subscribe(setState);
return () => subscription.unsubscribe();
}, []);

// Effect-UI approach: Streams are the UI primitives
const 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 Rules

1. Effect streams are first-class UI primitives
2. Components execute once (ephemeral, like SolidJS)
3. No virtual DOM, use direct DOM manipulation
4. All async operations via Effect
5. TypeScript strict mode, no any
6. Every feature needs specs, mocks, and tests
7. 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.md
declare 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-in
const clockStream = Stream.iterate(new Date(), () => new Date()).pipe(
Stream.schedule(Schedule.spaced(1000))
);

// Error handling via Effect's error channel
const 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 scopes
const 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:

  1. Specs vóór code: elke feature begon als specificatie in dom.specs.md. Dat gaf Claude duidelijke acceptatiecriteria.
  2. 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>;
  3. Test-driven validation: 27 acceptatiecriteria, elk met meerdere testcases. Na elke wijziging draaide de volledige test suite.
  4. Continue validatieloop:# This ran hundreds of times over the weekend
    npm 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:

  1. Gedisciplineerde structuur: rules, specs, tests: de vibe coding meta in actie
  2. Domeinexpertise: begrip van de patterns van Effect en van UI library-architectuur
  3. Iteratieve verfijning: continue (zelf)validatie en bijsturing
  4. 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:

  1. Effect is klaar voor UI: de primitives zijn er (streams, fibers, scopes, contexts). We hoefden ze alleen nog goed in elkaar te zetten.
  2. AI kan complexe systemen bouwen: met de juiste structuur en discipline kunnen AI-assistenten geavanceerde projecten aan.
  3. 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

30sec

Pitch

To save us both time, we created a 30-second pitch on why we are the right digital partner for you

Watch pitchicon
10min

Tour

Proposals and pricing? Watch this for everything you need to make the next step

View presentationicon
30min

Discovery call

Ready to speak to a human? We have some of those. Book a No-Commitment discovery call!

Book a callicon