Marcel van der Hoek

Notitie · 3 augustus 2026

2026-08-03T00:00:00.000Z

I would like to propose some formal definitions.

AI slop is software whose structure has degraded through repeated AI-assisted modifications until it exceeds the team’s ability to confidently understand, verify, or safely maintain it.

Vibe code is AI generated code accepted without sufficient human understanding or verification. Vibe coding is the behavior. AI slop is the potential, eventual outcome if we continue to vibe code the same app/source code.

— Tanya Janca (@shehackspurple), 23 juli 2026

Wat mij betreft zijn dit goede definities. Ze maken ook duidelijk waarom we niet alle code die met ondersteuning van AI geschreven wordt als vibe coding moeten bestempelen. Het onderscheid zit niet in het gebruik van AI op zich, maar in de manier waarop je ermee werkt. AI kan een ontwikkelaar wel degelijk versterken, zolang die de gegenereerde code begrijpt, kritisch beoordeelt en verifieert. Verantwoord gebruik van AI betekent dus dat de ontwikkelaar zelf zicht houdt op de werking en kwaliteit van de code, en er ook de verantwoordelijkheid voor blijft dragen. Dat laatste is misschien nog wel het belangrijkste, daar zit een artikel op zich in.

Citaat · Tommy Wieringa

2026-07-31T00:00:00.000Z

Overmoed is net zo belangrijk als talent: ik kan het niet maar ik doe het toch.

— Tommy Wieringa, Joe Speedboot

Notitie · 29 juli 2026

2026-07-29T00:00:00.000Z

Alles leek goed te gaan. In het café was Harrie de gebraden haan.

— Ik hou van mij, de biografie van Harrie Jekkers

Die uitdrukking kende ik niet. De gebraden haan uithangen betekent dat je iedereen wilt laten zien hoe rijk en belangrijk je bent. Waar het vandaan komt weten we niet zeker.

Notitie · 27 juli 2026

2026-07-27T00:00:00.000Z

There are certain situations where AI can do superhuman things, but so can forklifts.

— Hannah Fry, New Scientist

Zo snel code kloppen als AI kan geen mens. Maar bepalen welk probleem opgelost moet worden en welke afwegingen belangrijk zijn, is nog steeds mensenwerk. Dat zal nog wel een tijd zo blijven, al ben ik benieuwd wanneer die conclusie achterhaald blijkt.

Vandaag geleerd #2 · Als spaties in een stuk tekst toevallig onder…

2026-07-26T00:00:00.000Z

Als spaties in een stuk tekst toevallig onder elkaar vallen, ontstaan er verticale witrivieren door de alinea heen. Die rivieren van wit komen vooral voor bij uitgevulde tekst in smalle kolommen.

Vandaag geleerd #1 · Het woord mayday is niet geïnspireerd door een…

2026-07-25T00:00:00.000Z

Het woord mayday is niet geïnspireerd door een mooie dag in mei, maar een verbastering van het Franse m’aider (‘help mij’), verkort uit venez m’aider.

Citaat · Xavier Rudd

2026-07-25T00:00:00.000Z

The emptiness you’re feeling deep down inside
May never go away, at least it’s gonna take time
You gotta learn where to put it, it’s a part of life
Don’t let it wreak havoc on the rest of your time

— Xavier Rudd, Part of Life

Notitie · 21 juli 2026

2026-07-21T00:00:00.000Z

Alibaba kondigde zondag Qwen3.8 aan en gaat de gewichten vrijgeven. Het is straks dus open-weight en je kunt het model op je eigen hardware draaien. Open-weight is wat anders dan open source, want je krijgt niet te zien wat er in de trainingsdata zit en hoe het model precies getraind is. (Er bestaan trouwens wel open source modellen, zie bijvoorbeeld Olmo van Ai2.)

In de praktijk maakt het verschil tussen open-weight en open source weinig uit. Een model dat iedereen kan downloaden en hosten is vervangbaar, en vervangbaar betekent in theorie goedkoop. Zodra dit soort open-weight modellen (bijna) net zo goed worden als de gesloten modellen van bijvoorbeeld Anthropic en OpenAI komt de hele markt onder druk te staan. In Who’s Afraid of Chinese Models? gaat Ben Thompson hier verder op in.

Hoe een taalmodel werkt: van token tot agent

2026-07-24T00:00:00.000Z

Eerlijk, ik dacht dat dit een lange intro zou worden, met verschillende visies op AI erin, misschien een paar gevatte opmerkingen. Maar de zinnen komen niet. Dus ik sla de intro lekker over en ga meteen naar de vraag die ik wilde beantwoorden: hoe werkt een taalmodel nou eigenlijk? Niet tot in de wiskundige details, maar uitgebreid genoeg om het echt te begrijpen.

Steeds het volgende token

In de kern doet een taalmodel, een LLM, maar één ding. Het krijgt tekst en berekent voor elk mogelijk vervolg een kans. Niet voor hele zinnen, maar steeds alleen voor het eerstvolgende stukje: een token. Er wordt één token gekozen, dat wordt geplakt achter de tekst die er al stond, en de hele lap tekst gaat direct weer terug het model in voor de volgende ronde. Het model schrijft dus geen antwoord, maar kiest steeds één token, en dan nog één, etc. Je zou denken dat het model altijd het token met de hoogste kans pakt, maar je raadt het al: dat is niet per definitie zo. Het model trekt er één, gewogen naar de kansen, zodat waarschijnlijke tokens vaker vallen dan onwaarschijnlijke. De favoriet wint alsnog meestal, maar niet altijd.

Het model krijgt niet alleen jouw tekst, maar een heel samengesteld pakket: systeemprompt, eerdere berichten, opgehaalde documenten, beschrijvingen van beschikbare tools, en helemaal achteraan jouw nieuwe vraag. Het ziet niet alleen je laatste invoer, maar de hele context, en voorspelt daarmee het volgende token.

Achter die ene keuze gaan weliswaar miljarden berekeningen schuil (daar kom ik onder Gokken en bijstellen op terug), maar de lus zelf is niet ingewikkelder dan: kans berekenen, kiezen, plakken, opnieuw.

Logische vraag is nu: wanneer stopt die lus dan? Het model kent niet alleen woorden maar ook een aantal speciale tokens, en één daarvan betekent: hier eindigt het antwoord. Dat eindtoken is in de lus steeds een van de kandidaten, met een eigen kans. Wordt het eindtoken gekozen, dan stopt de lus.Er is ook een maximale lengte van het antwoord. Als die lengte wordt bereikt, dan stopt de generatie. Ook als het model nog geen eindtoken heeft gekozen.

De keuze van het volgende token is dus een soort loterij. Het token dat 97% kans heeft, krijgt 97 lootjes, en over de resterende tokens worden de overige 3 lootjes verdeeld.

De temperatuurknop

De temperatuur van een taalmodel bepaalt hoeveel willekeur er in het antwoord zit, door de kansverdeling voor het volgende token scherper of vlakker te maken. In onze loterij betekent dat: bij een lage temperatuur krijgt de favoriet relatief meer lootjes, en bij een hoge temperatuur worden de kansen gelijkmatiger verdeeld. De temperatuur verandert dus niet welke tokens bovenaan staan, maar wel hoe groot de verschillen ertussen zijn.

Zet je de temperatuur op 0.00, dan kiest het model altijd het token met de hoogste kans.Dat heet greedy decoding. In theorie gedraagt het model zich dan volledig deterministisch: bij exact dezelfde invoer krijg je altijd hetzelfde vervolg. In de praktijk zorgen kleine reken- en afrondingsverschillen op de duizenden parallelle chips ervoor dat er soms tóch een ander token uitrolt, maar alle creativiteit is er dan wel uit (voor zover je hier kan spreken over creativiteit, maar dat is weer een ander verhaal). Handig als je voorspelbaarheid wilt, maar de tekst wordt er vlak en repetitief van. Daarom staat een model meestal niet op nul.

Nergens in de lus wordt gecontroleerd of het gekozen vervolg klopt, en hallucinaties ontstaan niet simpelweg doordat het model loot. Ook bij een temperatuur van nul kan er nog onzin uitrollen, maar dan is het telkens dezelfde onzin. De temperatuur heeft dus alleen invloed op de variatie en niet op het waarheidsgehalte.

Hierboven heb ik voor het gemak de eerste stap in de lus, het berekenen van een kans, als één ding behandeld. Maar in die ene stap zit het meeste werk: van tekst naar tokens, van tokens naar getallen, laag na laag, tot er een kansverdeling uitkomt.

Geen letters, maar tokens

Ergens halverwege 2024 was het opeens hip om aan taalmodellen te vragen hoeveel r’en er in het woord strawberry zitten. Inmiddels is het grapje niet meer actueel, maar het is wel een goed voorbeeld om nog wat beter te illustreren hoe dat tokenverhaal werkt.

Bijna goed.

Het model ziet dus helemaal geen letters of woorden. Voordat tekst het model ingaat, wordt die in stukken geknipt: tokens met elk een eigen nummer. Een veelvoorkomend woord is vaak één token, een zeldzamer woord valt uiteen in twee of meer blokjes. In dit geval herkent het dus geen tien losse letters, maar een paar genummerde tokens. Losse letters tellen kan zo’n model dus niet zonder omweg. Huidige modellen kunnen al beter tellen doordat ze het woord in een redeneerstap letter voor letter uitspellen, of het antwoord uit de trainingsdata kennen. Soms gebruiken ze een stukje code dat het telwerk overneemt.

Tokens zijn de rekeneenheid van een taalmodel, en van de factuur die je krijgt voor het gebruik ervan. Alles wat het model in één keer kan overzien, het contextvenster, wordt gemeten in tokens. En je rekent af per token, voor alles wat erin gaat en alles wat eruit komt: je vraag, instructies, documenten eromheen, en het antwoord.

Van tokens naar betekenis

Nu wordt het eigenlijk pas interessant, want tokens verklaren op zichzelf niet waarom modellen samenhang lijken te snappen. Daarvoor moet je weten wat er met die genummerde blokjes gebeurt. Hierboven zie je dat elk token een ID heeft, maar dat is niks meer dan een label. “berry” is toevallig nummer 19772. Dat getal zegt verder niks: een verwant woord kan een heel ander ID hebben. De betekenis zit ergens anders. Bij elk token zoekt het model een rij van duizenden getallen op. Die rij vormt een soort coördinaat in een ruimte met evenzoveel richtingen.Die getallenrijen heten embeddings. Eén rij is een embeddingvector, opgezocht in een grote tabel die de embeddinglaag heet. Afstand is in die ruimte verwantschap. Koning ligt dicht bij koningin, Amsterdam dicht bij Nederland.

Belangrijker nog: die startplek ligt wel vast, maar de betekenis niet. Neem het woord “python”. In de zin “De python loert op zijn prooi” stuurt de context het woord richting reptielen en biologie. Maar in “Ik schrijf een script in python” trekken de omringende woorden het direct naar software en code. Hetzelfde woord, exact dezelfde startplek, maar de context duwt het punt een compleet andere hoek van die ruimte in.Hoe heette dat ook alweer… O ja, een homoniem. Het model zoekt die betekenis niet op in een statische database. Er is geen mapje python-de-programmeertaal dat wordt klaargezet. Het model berekent die verschuiving live, laag na laag, op basis van de relatie met de andere tokens. In elke laag kijkt elk token naar de tokens eromheen en schuift het zijn eigen positie een stukje op, op grond van wat relevant is.Dit mechanisme heet attention: elk token weegt hoe belangrijk de tokens eromheen zijn voor zijn eigen betekenis. Eén laag doet dat subtiel, maar na tientallen lagen draagt het laatste token zoveel van de hele zin in zich dat het model er rechtstreeks een kans voor elk mogelijk vervolg uit afleest. Daar zit het meeste rekenwerk, en daar komt de kansverdeling van het begin vandaan.

Dit is waarom een model samenhang lijkt te begrijpen: niet door een vaste betekenis op te zoeken, maar door elk token een positie te geven die meebeweegt met de rest van de zin. Of dat “begrijpen” mag heten, is een vraag waar ik nog op terugkom.

Gokken en bijstellen

Die posities en kansen van daarnet zijn niet geprogrammeerd. Het taalmodel vormt ze zelf. De vraag is hoe, en het antwoord is verrassend simpel: gokken en bijstellen, en dat heel vaak achter elkaar.

Een vers model is niks meer dan een enorme hoeveelheid getallen: de gewichten.Gewichten en parameters zijn hetzelfde. Lees je een nieuwsbericht over een model met tig miljard parameters, dan betekent dat: tig miljard afgestelde gewichten. Verwar ze niet met parameters in gewone software, want die stelt een mens in, en gewichten worden getraind. Die gewichten staan bij de start op willekeurige waarden. Als je zo’n model iets zou vragen, rolt er pure onzin uit. Het heeft nog nergens een patroon in gezien. Trainen is het proces dat die willekeurige berg omvormt tot iets dat zinnig klinkende tekst produceert.

Dat trainen gebeurt in een lus. Neem een stuk echte tekst, laat het model het volgende token voorspellen, en vergelijk die gok met wat er in werkelijkheid stond. Als het model ernaast zit, dan krijgen alle gewichten een zetje in de goeie richting, zodat de volgende gok een fractie dichterbij komt.Welk zetje precies, dat bepaalt het model met backpropagation. De stapjes bergafwaarts naar minder fouten heten gradient descent. Als je dit één keer doet, verandert er natuurlijk weinig aan de samenhang. Zodra je dit over een gigantische hoeveelheid tekst miljarden keren herhaalt, ontstaat er een model dat grammatica, feiten en schrijfstijl in de gewichten heeft zitten.

Alles wat het model “weet” zit dus in de gewichten. Er is geen opgeslagen tekst, en er is geen database met feiten.Al kunnen stukken trainingstekst wel degelijk vrijwel letterlijk uit de gewichten rollen. Er zijn alleen afgestelde gewichten en de manier waarop ze samen een kansverdeling opleveren. Dit is ook meteen de reden waarom trainen zo duur is. Je kan je voorstellen dat zoveel getallen afstellen op enorme bergen tekst heel veel rekenkracht kost.

Dit deel van de training levert een model dat vloeiend tekst aanvult, maar nog niet per se een behulpzame chatbot. Daarvoor is nog een afwerkfase nodig, de posttraining, en daar kom ik onder Twee levens op terug.

Stampen of snappen?

Met wat we nu weten zou je kunnen concluderen dat een taalmodel de antwoorden gewoon uit zijn hoofd leert, op basis van die reusachtige set aan data waarop het model is getraind. Dat is ook deels waar, maar daar blijft het niet bij. Dat is aangetoond met een simpel experiment waarin een model leerde optellen op een analoge klok. Hierbij is 10 + 5 niet 15 maar 3, want op een klok begin je na de 12 weer bij 1 (modulair rekenen). Dit is hier ideaal omdat er maar twee mogelijke oplossingen zijn: alle uitkomsten uit het hoofd leren, of de methode snappen. Je kan dus zien welke van de twee het model koos.

Eerst leerde het model de voorbeelden: sommen uit de trainingsdata gingen goed, nieuwe sommen gingen fout. Maar na lang doortrainen sloeg het model om, en gingen ook nieuwe sommen goed. Het model was dus overgestapt op de echte methode. Dat wordt grokking genoemd.Power e.a., 2022. De term grokking komt van grok, een woord uit Heinleins sciencefictionroman Stranger in a Strange Land (1961). Het betekent iets zo volledig begrijpen dat het deel van je wordt, precies wat hier gebeurt.

Een ander team ging nog wat verder en ontleedde zo’n grokkend model. Dit model bleek een soort klok te gebruiken: het had geleerd de getallen als punten op een cirkel te zien en draaide eromheen om op te tellen.Nanda e.a., 2023. Geen tabel met antwoorden, maar een uitgevonden procedure.

Of iets vergelijkbaars ook gebeurt tussen de miljarden gewichten van een echt taalmodel is lastiger na te gaan. Men begrijpt de architectuur van die modellen tot in detail, maar teruglezen welke methodes een getraind model daarin heeft gevormd, is een ander verhaal. Recentere berichten wijzen wel die kant op: onderzoekers van Anthropic zagen een groot model een vraag als “de hoofdstad van de staat waar Dallas ligt” intern in stappen oplossen, eerst van Dallas naar Texas, dan van Texas naar Austin.Anthropic, “Tracing the thoughts of a large language model”, 2025.

Daarmee is het te simpel om te beweren dat een model alleen heel veel feiten in zijn geheugen stampt en daartussen verbanden legt. Een model stampt niet alleen, maar het vormt ook methodes. Iets wat alleen maar tekst herkauwt, zou nooit een som kunnen oplossen die het nog nooit heeft gezien.

Of je dat “begrijpen” kan noemen, weet ik niet. Dat is sowieso een definitiekwestie, en aan die discussie ga ik in dit verhaal mijn vingers niet branden.

Twee levens

Een taalmodel leidt twee levens. Het eerste is het trainen: gokken en bijstellen tot de gewichten kloppen. Het tweede begint zodra het trainen afgelopen is en je het model gebruikt. Na de training ligt het model vast. De gewichten bevriezen, en praten met een model verandert daar niks meer aan. Het leert niet van jouw gesprek.Dat wil niet zeggen dat je gesprekken nooit gebruikt worden om een nieuwe versie te trainen. Of dat gebeurt, verschilt per aanbieder. Zakelijke abonnementen zijn er meestal van uitgezonderd.

Het trainen heeft twee stappen. De eerste stap is het ruwe trainen van hierboven: de pretraining. Daarna kan het model vloeiend tekst aanvullen, maar net zo goed jouw vraag met een wedervraag beantwoorden of blijven doorratelen. Het is immers simpelweg tekst uit de trainingsdata aan het imiteren.

In de tweede stap van de training wordt het model bijgeschaafd met menselijke feedback. Mensen beoordelen antwoorden, en het model leert daarvan welke toon en vorm de bedoeling zijn. Het bekendste onderdeel van deze posttraining is precies dat bijsturen. Dat is ook waar een model zijn omgangsvormen en grenzen leert. Deze stap verandert vooral hóé het model antwoordt, en voegt daarnaast vaardigheden en soms wat kennis toe.

Bij elk gesprek komt er nog een laatste laag bovenop: de systeemprompt. Dat is een reeks instructies die je niet ziet, maar die vooraan de context staat en definieert hoe het model zich moet gedragen.

Het wordt wel een lang verhaal zo, nog even volhouden. Dan heb je een aardig overzicht van hoe modellen in elkaar zitten. We weten nu dat een model min of meer drie soorten “geheugen” heeft:

De gewichten. Alles wat tijdens het trainen is opgepikt. De gewichten staan stil. Na de training komt er niks meer bij.
De context. Alles in het lopende gesprek, van de systeemprompt tot jouw laatste zin. Eigenlijk is dit het vluchtige werkgeheugen, want bij een nieuwe sessie begin je weer alsof er nooit iets gezegd is.Sommige chatproducten zoals ChatGPT en Claude omzeilen dit met een geheugenfunctie. Informatie uit eerdere gesprekken wordt dan bij een nieuw gesprek in de context geplakt. Dat is dan dus onderdeel van het externe geheugen van het volgende punt.
Extern geheugen. Wat het model erbij haalt. Dat kan een document zijn, een zoekopdracht of een tool. Opgehaald op het moment zelf, en in de context geplakt.

Dat verklaart ook waar een hoop verwarring vandaan komt. Geef je een model tijdens een gesprek een paar voorbeelden, dan lijkt het een patroon op te pikken. Maar dat gebeurt dus alleen in de huidige context, niet in de gewichten, en bij een volgend gesprek is het weer weg.Als je echt interessant wilt doen: in-context learning.

Omdat de gewichten na de training bevriezen, heeft elk model een kennisgrens. Het weet niks van wat er daarna gebeurt, tenzij je dat in de context stopt of via een tool toevoegt. Daarom zoeken recente modellen het web af en kunnen ze documenten lezen. Ze kennen het nieuws niet, maar halen het op en lezen het ter plekke.

Waarom een taalmodel hallucineert

Een taalmodel verkondigt soms heel stellig dingen die niet kloppen: niet-bestaand beleid, een verzonnen boektitel, een citaat dat nooit is uitgesproken. Zulke verzinsels heten hallucinaties, en ze komen direct voort uit hoe een model werkt. Een model voorspelt een waarschijnlijk vervolg, niet per se de waarheid. Er zit nergens in de lus een controlestap. Als het model iets niet “weet”, dan valt het niet stil, maar vult het in wat plausibel is.

Toch zit hier wel een rem op. Onderzoekers van Anthropic ontdekten hoe dit intern werkt. In een bijgeschaafd model zit een soort ingebouwde handrem, die het bij twijfel naar “ik weet het niet” laat neigen. Zodra er een naam of term voorbijkomt die bekend klinkt, gaat de handrem eraf. Soms gebeurt dat onterecht, en dan zit er geen echte kennis achter de herkenning. Het model begint dan met volle overtuiging te fantaseren.De onderzoekers bewezen dit door de handrem er handmatig af te halen, waarna het model meteen de grootste onzin produceerde. Zie: Anthropic, “Tracing the thoughts of a large language model”, 2025.

Het model maakt dus geen betrouwbaar onderscheid tussen een feit dat vastligt en een gat dat het opvult. Juist bij namen, datums, cijfers en citaten is de kans op overtuigende onzin het grootst. De remedie is om het niet op zijn woord te geloven, het een bron te geven en te controleren wat eruit komt.

De voorspeller in een lus

Tot nu toe hebben we het eigenlijk maar over één ding gehad: een taalmodel dat tekst voorspelt. Zo’n model kan niet betrouwbaar rekenen, niet in je agenda kijken, en niks opzoeken op internet. Als je naar het weer van morgen vraagt, dan krijg je een nutteloos antwoord.

De oplossing is het aanreiken van een stukje software dat het model mag gebruiken, een tool (je zag de term eerder al een paar keer voorbijkomen). Dat kan een rekenmachine zijn, een zoektool of zelfs een omgeving waarin code kan worden uitgevoerd. In de context staat welke tools beschikbaar zijn, en hoe ze aangeroepen kunnen worden. Het model kiest die aanroep zoals het elk ander token kiest: als het waarschijnlijkste vervolg. Met andere woorden: het model voorspelt de aanroep. Om die aanroep ook daadwerkelijk uit te voeren, zit er om het model een laag gewone software heen: het harnas dat de tekstvoorspeller handen en voeten geeft.Engelse term: harness. Harnas is misschien niet de allerbeste letterlijke vertaling, maar in deze context vind ik hem wel mooi passen. Het harnas ziet de aanroep, voert de tool uit, en plakt het resultaat terug in de context. Daarna voorspelt het model weer verder, met het resultaat uit de tool erbij.

Zet die stap in een lus en je hebt een agent. Het model doet iets, ziet het resultaat, en kiest de volgende stap. Het kan verder met het genereren van tekst, nog een tool aanroepen, of stoppen als het doel bereikt is. Het bepaalt zelf wanneer het klaar is. Dit is nog steeds dezelfde lus waar we het heel de tijd al over hebben, maar nu met echte acties ertussen.

Zo simpel is het

Dat was het wel zo’n beetje. Nog even terug naar de vraag waarmee ik begon: hoe werkt een taalmodel nou eigenlijk?

Het antwoord past nu in een paar zinnen. Een model berekent voor elk mogelijk vervolg de kans, en trekt uit die opties een token. Die voorspellingen zijn aangeleerd door tijdens het trainen miljarden keren te gokken en bij te stellen, tot alle kennis in de gewichten zat. Met een lus en wat tools erbij wordt die tekstvoorspeller opeens een agent die echte taken uit kan voeren. Een model heeft geen begrip zoals een mens, en er is geen database met vaststaande gegevens die wordt geraadpleegd.

How Docker Works Under the Hood

2026-07-11T00:00:00.000Z

Honderden containers opgestart, en toch nooit helemaal begrepen hoe Docker nu eigenlijk werkt. Dit stuk legt het helder uit, en de nieuwsbrief van ByteByteGo is sowieso een aanrader.

Bron: blog.bytebytego.com · permalink

Citaat · T.H. White

2026-07-11T00:00:00.000Z

“The best thing for being sad,” replied Merlin, beginning to puff and blow, “is to learn something. That’s the only thing that never fails. You may grow old and trembling in your anatomies, you may lie awake at night listening to the disorder of your veins, you may miss your only love, you may see the world about you devastated by evil lunatics, or know your honour trampled in the sewers of baser minds. There is only one thing for it then — to learn. Learn why the world wags and what wags it. That is the only thing which the mind can never exhaust, never alienate, never be tortured by, never fear or distrust, and never dream of regretting. Learning is the only thing for you. Look what a lot of things there are to learn.”

— T.H. White, The Once and Future King

Zuurdesembrood

2025-08-29T00:00:00.000Z

Ik heb inmiddels een brood of vijftig gebakken met zuurdesem. Dat maakt me zeker geen meesterbakker, maar ik begin wel wat gevoel te krijgen voor het proces. Mijn basisrecept komt van Rutger Bakt, inclusief de methode om een starter te maken. Voordat ik bij zijn methode belandde heb ik meerdere andere varianten geprobeerd, die voornamelijk platte pannenkoeken opleverden.

Voor het voeren van de desemstarter gebruik ik T65 bloem. Het bakken van het brood doe ik met een mengsel van Amerikaans patentbloem (60%) en T65 bloem (40%).

Opbrengst: 1 brood · voorbereiding 1 uur · bereiding 1 uur · wachttijd 1 dag · totaal 1 dag 2 uur

Keukengerei

banneton (rijsmandje)
gietijzeren pan met deksel
keukenmachine met deeghaak

Ingrediënten

Starter

100 gram actieve starter
100 gram bloem
100 milliliter water

Brood

390 gram bloem
225 milliliter water
165 gram actieve starter
9 gram zout

Bereiding

Meng alle ingrediënten in de mengkom van de keukenmachine. Laat vervolgens 25 minuten rusten.
Kneed in de machine 6 minuten op stand 1 en 6 minuten op stand 2, of met de hand ongeveer 15 minuten tot soepel.
Vouw het deeg een aantal keer dubbel en bol het vervolgens op. Dit brengt lucht in en versterkt het glutennetwerk. Herhaal dit elke 45 minuten, 3 tot 4 keer.
Vorm het deeg en laat 12–24 uur in een bebloemd rijsmandje in de koelkast staan.
Verwarm oven en gietijzeren pan voor op 230 °C.
Deeg insnijden, 2 ijsblokjes in de pan gooien, brood snel in de pan en in totaal 46 minuten laten bakken. Na 25 minuten het deksel van de pan af, en oven terug naar 210 °C voor de laatste 21 minuten.
Laat het brood op een rooster afkoelen voordat je het aansnijdt.

Notities

Van de 300 gram actieve starter gebruik je 165 gram voor het brood. De rest blijft in de pot voor de volgende keer.

Chutney van cherrytomaten

2025-08-26T00:00:00.000Z

De tomaten voor deze chutney kwamen uit onze eigen tuin. Mijn zoon en ik plantten een paar struikjes voor de leuk, en de oogst pakte veel groter uit dan we verwachtten. Pastasaus lag te veel voor de hand, dus het werd een chutney.

Opbrengst: 1 potje van 370 ml · voorbereiding 15 min · bereiding 1 uur 30 min · totaal 1 uur 45 min

Keukengerei

steelpannetje
glazen potje van 370 g, met deksel

Ingrediënten

500 gram cherrytomaten
2 teentjes knoflook
180 gram kristalsuiker
2 eetlepels appelciderazijn
1 eetlepel balsamicoazijn
1½ theelepel Old Mother Crispy chili in oil
1 theelepel zout
½ theelepel komijnzaad, fijn
¼ theelepel cayennepeper

Bereiding

Halveer de cherrytomaten en pers de knoflook.
Doe alle ingrediënten in het steelpannetje, roer goed door elkaar en breng het geheel aan de kook.
Laat zachtjes sudderen tot het een stevige, bijna stroperige dikte heeft gekregen. Bij mij duurde dit ongeveer anderhalf uur.
Schep de hete prut in het schone potje, vul tot 5 mm onder de rand, sluit af en zet het potje 5 minuten op z'n kop. Draai daarna om en laat langzaam afkoelen.

Notities

De eerste versie van dit recept maakte ik met geleisuiker. Met kristalsuiker gaat het ook goed, de verdikking komt bij chutney door het inkoken.
De gebruikte tomaten hebben we opgekweekt uit zaadjes en waren van het ras Sweet Million F1. Een aanrader!