Een Python backend bouwen zonder ooit Python te hebben gebruikt

Vandaag heb ik een Python backend opgezet voor playitsmart.nl. Drie uur werk, fundament staat, hij kan praten met de database. En als ik eerlijk ben: ik snap er weinig van.

Ik heb in mijn leven nagenoeg nooit met Python gewerkt. Vandaag ook niet, eigenlijk. Wel zat ik drie uur achter mijn terminal commando's te plakken, terwijl Claude ze één voor één aanleverde. En na elk commando vroeg ik: wat doe je nu eigenlijk? Wat is het effect? Loop ik risico als dit fout gaat?

Dat is een vreemde manier van werken. Eerlijk gezegd ook een beetje eng.

Wat ik wel weet

Voor we vandaag begonnen, hadden Claude en ik samen een architectuurdocument uitgewerkt. Daar staat in welke onderdelen het systeem heeft, hoe ze met elkaar praten, en waarom we voor bepaalde keuzes gaan. Welke database (Supabase). Welke taal (Python). Welke broker (Interactive Brokers). Welke datafeed (Financial Modeling Prep). Welke regels het systeem volgt om aandelen te beoordelen. Welke fasering we aanhouden tot we live gaan.

Dat document begrijp ik. Iedere keuze erin is bewust. Voor- en nadelen afgewogen, opties tegen elkaar gezet, en gekozen wat past. Dat is mijn werk: structuur, fasering, beslissingen nemen op basis van wat we willen bereiken.

Wat ik niet weet

Maar dan komt vandaag. We gaan die structuur omzetten in echte code. Een werkende achterkant die met de database kan praten. Een eerste stap richting het automatische handelssysteem dat ik wil bouwen.

En dáár begint het stuk waar ik niks van begrijp. Welke libraries je nodig hebt, hoe je een virtual environment opzet, waarom Python in dit project een andere versie moet hebben dan op de rest van mijn Mac, wat een service role key doet, en waarom de database mij eerst niet wilde laten lezen terwijl alles correct leek te staan.

Dit is geen valse bescheidenheid. Ik weet niet wat ik doe.

Hoe het toch werkte

De aanpak was simpel maar streng: stap, check, stap, check. Eén commando per keer. Na elk commando een verificatie of het ook echt was wat we wilden. Bij twijfel doorvragen.

Claude gaf me telkens drie stukjes informatie:

Eerst: wat het commando doet. Niet diepgaand, wel begrijpelijk.

Tweede: hoe lang het duurt. "Dit duurt vijf tot tien minuten op je Mac, ga rustig zitten." Of: "Dit is een halve seconde." Dat is verrassend belangrijk. Een terminal die niets doet ziet er hetzelfde uit als een terminal die iets stuk maakt. Weten dat het normaal is dat je een paar minuten wacht, scheelt enorm.

Derde: welke errors je kunt verwachten, en wat dan de volgende stap is.

En het ging mis. Drie keer vandaag stond er ineens een error op mijn scherm waar ik niks van snapte. Drie keer pakte Claude het rustig op, stelde een diagnose, gaf één commando om het te fixen, en gingen we door.

Op één moment moest ik een soort beveiligingstoken laten ontleden om te checken of het wel de juiste was. Ik heb echt geen idee wat ik daar deed. Maar het werkte.

Het risico waar ik wel mee zit

Aan het einde van de dag staat er een werkende backend. Hij praat met de database, leest data, geeft het juiste antwoord terug. Ik heb dat zelf opgebouwd, met Claude erbij.

En ik begrijp het in essentie niet.

Dat is best link. Want straks moet dit systeem mijn echte geld gaan beleggen. Tienduizend euro start, mogelijk meer later. Als er straks iets fout gaat in productie, kan ik niet zelf de logfiles induiken om de oorzaak te vinden. Ik ben afhankelijk van Claude om mij te helpen begrijpen wat er aan de hand is.

Daar is geen makkelijk antwoord op. Wat ik wel doe: tijdens het bouwen zoveel mogelijk vragen stellen, zodat ik op zijn minst de structuur achter elk stuk snap. Niet de code zelf, maar wel waarom hij doet wat hij doet. Dat verschil is belangrijk. Als ik in een live situatie weet welke stap het systeem op welk moment moet doen, kan ik in elk geval signaleren wanneer iets afwijkt van het plan, ook al kan ik de code niet zelf lezen.

Maar het werkt

Ondanks dat ik niet alles begrijp, heb ik vandaag iets neergezet wat zonder Claude in geen drie maanden zou bestaan. Misschien helemaal niet.

Dat is wat me fascineert aan deze tijd. Ik kan dingen bouwen waar ik in essentie niet de kennis voor heb, mits ik de structuur erachter wel begrijp, en mits ik discipline heb om stap voor stap te werken en niet vooruit te lopen.

Het architectuurdocument is mijn houvast. De stap-voor-stap werkwijze is mijn discipline. Claude is mijn co-pilot. Samen bouwen we iets dat geen van ons twee alleen had kunnen maken.

Morgen gaan we de eerste call doen naar Financial Modeling Prep om echte data binnen te halen. Ook daar weet ik niet hoe het in Python werkt. Ook daar gaan we het stap voor stap doen.

En over een paar weken, als alles staat, draait er een systeem dat zelf koopt en verkoopt op de beurs. Helemaal zonder dat ik ooit een regel Python heb geschreven.