Stop Met Tutorials Kijken — Leer Sneller Programmeren
Ik verspilde zes maanden van mijn leven aan het kijken naar tutorials.
Geen overdrijving. Zes volledige maanden. Ik had een Udemy-bibliotheek die kon wedijveren met de curriculum van een kleine universiteit, een YouTube-kijkgeschiedenis gevuld met "Bouw een Full Stack App in 2 Uur"-video's, en een bladwijzermap zo opgeblazen dat hij mijn browser twee keer liet crashen. Ik kon over React hooks praten, het verschil tussen SQL en NoSQL uitleggen, en Docker-commando's uit mijn hoofd opdreunen.
Maar ik kon niets bouwen.
Niet één functionerend project dat geen copy-paste-klus was van iemands anders scherm. En het ergste? Ik geloofde echt dat ik aan het leren was. Elke voltooide tutorial voelde als vooruitgang. Ik liep op een loopband, zweette hard, ging absoluut nergens naartoe — en ik besefte het niet eens totdat een vriend me vroeg om een eenvoudige CRUD-app vanaf nul te bouwen en ik bevroor.
Dat moment brak iets in me. Maar het repareerde ook iets. Want de paniek die ik voelde terwijl ik naar een leeg VS Code-venster staarde, dwong me een waarheid onder ogen te zien die ik had ontlopen: Ik wist niet hoe ik moest coderen. Ik wist hoe ik instructies moest volgen.
De Echte Reden Waarom Je Niet Beter Wordt
Het probleem is bijna altijd je leeraanpak.
Ik heb dit honderden keren zien spelen. Een gemotiveerde persoon besluit Python, JavaScript of welke taal ook te leren. Ze vinden een hoog gewaardeerde cursus. Ze volgen mee, typen precies wat de instructeur typt. Ze voelen zich goed wanneer de code werkt. Ze gaan naar de volgende les.
Dan proberen ze iets alleen te bouwen. En het valt allemaal uit elkaar.
Deze cyclus heeft een naam in de developercommunity: tutorial-hell. En het is niet zomaar een grapje — het is een echte psychologische val die motivatie sneller opraakt dan welke syntaxisfout ook.
Het kernprobleem? Tutorials leren je hoe je iets doet voordat ze uitleggen waarom het werkt. Je imiteert zonder te begrijpen.
Stap 1: Geef Toe Dat De Aanpak Kapot Is (Niet Jij)
Dit klinkt voor de hand liggend, maar het is de stap die de meeste mensen overslaan.
Hier is een erkenning die ik persoonlijk moest doen. Ik zat in mijn appartement in 2012, starend naar dat lege VS Code-venster (Sublime Text destijds), en ik nam een beslissing. Ik sloot elk tutorial-tabblad. Alle 47.
Toen opende ik een enkel leeg bestand en typte één regel:
# Bouw een to-do app. Geen tutorial. Kom er zelf achter.
Die opmerking bleef drie dagen bovenaan mijn bestand terwijl ik me door documentatie, Stack Overflow-threads en een werkelijk beschamend aantal print("waarom werkt dit niet")-debug-statements worstelde.
Maar aan het eind van die drie dagen had ik een werkende to-do app. Lelijk als de nacht. Waarschijnlijk elke best practice in het boek schendend. Maar het werkte. En ik begreep elke regel omdat ik voor elke regel had gevochten.
Stap 2: Ontsnap Aan Tutorial-Hell Door Lelijke Dingen te Bouwen
Ik moet eerlijk zijn over iets dat misschien controversieel is: de meeste coderingstutorials zijn ontworpen om je te laten blijven kijken, niet om je competent te maken.
Het doorbreken ervan vereist één ding: projecten bouwen voordat je je klaar voelt.
Ik geef elke nieuwe developer wat ik de "lelijke project-uitdaging" noem:
- Kies iets dat je daadwerkelijk wilt laten bestaan (een persoonlijke budgettracker, een workoutlogger, een receptenorganisator — alles wat je echt zou gebruiken)
- Bouw het met wat je nu weet
- Wanneer je vastloopt, Google het specifieke probleem — niet een tutorial over het algemene onderwerp
- Accepteer dat versie één er verschrikkelijk uit zal zien en slecht zal werken
- Publiceer het toch
De magie zit niet in het eindproduct. De magie zit in het vastlopen en het uitzoeken gedeelte.
Stap 3: Maak AI Je Studiepartner, Niet Je Vervanger
Wanneer ChatGPT eind 2022 explodeerde, zag ik de developercommunity zich splitsen in twee kampen. Kamp één zei "AI vervangt alle programmeurs binnen vijf jaar." Kamp twee zei "AI is overhyped onzin die geen echte code kan schrijven."
Beide kampen hadden het mis.
AI is een versterker, geen vervanger. Als je de fundamentals begrijpt, maakt AI je 3-5x sneller. Als je de fundamentals niet begrijpt, maakt AI je 3-5x sneller in het produceren van kapotte code die je niet kunt debuggen.
Hier is hoe ik AI werkelijk gebruik als leermiddel:
Wanneer ik vastloop op een bug:
# Slechte prompt:
"Repareer deze code: [code plakken]"
# Betere prompt:
"Deze code gooit een TypeError op regel 14.
Kun je uitleggen wat er op conceptueel niveau
gebeurt en welk JavaScript-principe ik niet begrijp?"
Wanneer ik een nieuw concept leer: Ik bouw er eerst iets kleins mee (stap twee), loop vast, dan vraag ik AI om de specifieke leemte in mijn begrip uit te leggen.
Wanneer ik bestaande code wil verbeteren: Na het bouwen van iets dat werkt, vraag ik AI het te beoordelen. "Wat zijn de prestatieproblemen met deze aanpak?"
De 3C-Regel: Een Framework Dat Werkelijk Werkt
C1: Verduidelijken
Voordat je een regel code schrijft, zorg ervoor dat je het concept dat je gaat gebruiken werkelijk begrijpt. Niet "ik heb een video erover bekeken" begrip.
Mijn lakmoestest: als je niet kunt uitleggen waarom iets werkt, begrijp je het nog niet.
Ik houd een conceptenjournaal bij — een gewoon markdown-bestand. Mijn bestand telt nu meer dan 200 inzendingen lang, en ik raadpleeg het vaker dan Stack Overflow.
C2: Creëren
Onmiddellijk — en ik bedoel onmiddellijk — bouw iets met het concept dat je net hebt verduidelijkt. Niet morgen. Niet na de volgende les. Nu.
De kloof tussen leren en doen is waar de meeste kennis sterft.
Mijn regel: elk concept krijgt een miniproject binnen 24 uur. Zelfs als het maar 20 regels code zijn.
C3: Controleren
Dit is waar AI echt krachtig wordt. Nadat je iets hebt gebouwd, beoordeel het kritisch.
Stel vragen zoals:
- "Wat zou kapot gaan als ik dit naar 1.000 gebruikers schaalde?"
- "Wat is de meest voorkomende fout die developers maken met dit patroon?"
- "Hoe zou je dit refactoren om SOLID-principes te volgen?"
Stap 4: Één Onderwerp Per Week (De Anti-Overweldigingsstrategie)
Nieuwe developers proberen alles tegelijk te leren. React en Node en databases en Docker en testen en CI/CD en TypeScript en —
Stop. Gewoon stoppen.
De fix is bijna belachelijk eenvoudig: focus op één specifiek onderwerp per week.
Elke week volgt de 3C-cyclus. Verduidelijk het onderwerp diep. Maak een klein project ermee. Controleer je werk.
Dit voelt pijnlijk langzaam. Maar hier is wat er na 12 weken van deze aanpak gebeurt: je hebt 12 concepten die je werkelijk begrijpt. Ondertussen heeft de persoon die die 12 weken doorsprongen heeft tussen 30 verschillende onderwerpen oppervlakkige kennis van allemaal en meesterschap van niets.
Stap 5: Bouw Consistentie (En Stop Met Coderen Als Een Sprinter)
Ik had ooit een student die 14 uur aaneengesloten op een zaterdag codeerde en daarna tien dagen de code niet aanraakte.
De sweet spot die ik heb gevonden — voor mezelf en elke developer die ik heb gementord — is één gefocust uur per dag, zes dagen per week.
Hier is hoe mijn dagelijkse uur eruit zag toen ik mijn vaardigheden opbouwde:
0:00 - 0:05 Beoordeel de code en notities van gisteren
0:05 - 0:10 Verduidelijk het microdoel van vandaag
0:10 - 0:50 Code. Bouw. Debug. Worstel.
0:50 - 0:55 Vraag AI om wat ik schreef te beoordelen, noteer de feedback
0:55 - 1:00 Schrijf een 3-zinssamenvatting van wat ik leerde
Dat laatste deel — de driezinsamenvatting — is iets dat ik van een natuurkundeprofessor heb gestolen en het is crimineel effectief.
Ik volg mijn coderingsstreak. Mijn huidige (op het moment van schrijven) is 847 dagen.
Wat Er Werkelijk Verandert Wanneer Je Deze Vijf Stappen Volgt
Ik wil je echte cijfers geven. Ik volgde 23 mentees die deze vijfstapsmethode gedurende zes maanden volgden:
- 17 van de 23 bouwden en publiceerden een persoonlijk project waar ze trots op waren
- 9 kregen hun eerste developerbaan of freelance klant
- Alle 23 rapporteerden meer vertrouwen bij technische interviews
- Gemiddelde dagelijkse coderingsconsistentie steeg van 2,3 dagen/week naar 5,1 dagen/week
Wat Ik Jarenlang Verkeerd Had (En Wat Alles Veranderde)
Ik wil teruggaan naar die versie van mij, in een Dhaka-appartement in 2012, starend naar een lege editor. Er is een deel van dit verhaal dat ik je nog niet heb verteld.
Na het bouwen van die lelijke to-do-app, voelde ik me geweldig voor ongeveer een week. Toen zag ik de code van een senior developer op GitHub en voelde ik me onmiddellijk als een bedrieger.
Wat ik niet besefte was: de kloof tussen "werkt" en "elegant" is precies wat je maakt tot een echte developer. Je sluit die kloof niet door elegante code te bestuderen. Je sluit het door lelijke code te schrijven, te begrijpen waarom het lelijk is, en het geleidelijk minder lelijk te maken.
Dat is de 3C-Regel in één zin.
Sluit dit tabblad. Open je code-editor. Start een leeg bestand. Bouw iets kleins, lalijks en van jou.
Laten We Samenwerken
Wil je AI-systemen bouwen, workflows automatiseren of je technische infrastructuur opschalen? Ik help je graag.
- Fiverr (custom builds & integraties): fiverr.com/s/EgxYmWD
- Portfolio: mejba.me
- Ramlit Limited (enterprise-oplossingen): ramlit.com
- ColorPark (design & branding): colorpark.io
- xCyberSecurity (beveiligingsdiensten): xcybersecurity.io
