Vibecoding in de praktijk

De bouwstenen van vibecoding

Van HTML tot Git: negen begrippen om te snappen wat de AI voor je bouwt

Waar we beginnen

Wat is vibecoding?

1. Jij beschrijft

In gewone taal wat je wilt: ‘Maak een to-do app waarin ik taken kan opslaan.’

2. De AI bouwt

Er verschijnen bestanden vol code: HTML, CSS, JavaScript, Python, een database, een repository.

3. Jij stuurt en controleert

Dat lukt alleen als je herkent wát de AI gemaakt heeft, en waar het thuishoort.

De opbouw

Zo zit een webapp in elkaar

Vier onderdelen, elk met eigen bouwstenen. De gebruiker ziet alleen de frontend.

Frontend

In de browser

Wat de gebruiker ziet en bedient: de pagina, de knoppen, de tekst.

HTMLCSSJavaScript

Backend

Op de server

Waar de logica draait: controleren, berekenen, verzoeken afhandelen.

PythonFlask

Opslag

De database

Waar alle gegevens bewaard blijven, ook als de app uit staat.

SQLDatabase

Versiebeheer

Naast de app

Elke wijziging in de code vastgelegd, met de mogelijkheid terug te gaan.

Git
JSON

Het formaat waarin frontend en backend gegevens uitwisselen. Geen onderdeel, maar een afspraak over de vorm.

Vier vragen bij elke bouwsteen

Eerst een kaart van het geheel, dan steeds dezelfde vier vragen.

1

Wat is het?

Eén zin, zonder jargon.

2

Wat doet het?

Welke rol speelt het in de app?

3

Hoe ziet het eruit?

Een paar regels echte code, zoals de AI ze schrijft.

4

Hoe herken je het?

Bestandsnaam, typische woorden, de plek in het project.

Bouwsteen 1 van 9

HTML

Bepaalt wat er op de pagina staat: koppen, tekst, knoppen, afbeeldingen.

Wat is het?

HyperText Markup Language: de taal die beschrijft wat er op een pagina staat. Koppen, tekst, lijsten, knoppen, afbeeldingen.

Wat doet het?

Geeft de pagina structuur. Zonder HTML is er niets te zien en niets om op te klikken. De browser leest het en tekent de pagina.

Zo ziet het eruit

<h1>Mijn taken</h1>
<ul>
  <li>Melk kopen</li>
</ul>
<button>Taak toevoegen</button>

Zo herken je het

eindigt op .html<tags> tussen haakjesindex.html = de startpagina

De tags die je in bijna elke pagina tegenkomt

tagwat het isvoorbeeld
<h1> … <h3>koppen, van groot naar klein<h1>Mijn taken</h1>
<p>een alinea tekst<p>Nog 3 taken open.</p>
<a>een link; href zegt waarheen<a href="/taken">Alle taken</a>
<img>een afbeelding; src = bestand, alt = beschrijving<img src="logo.png" alt="Logo">
<ul> <ol> <li>een lijst (zonder of met nummers) met items<ul><li>Melk</li></ul>
<div> <section>een vak om dingen te groeperen<section id="open">…</section>
<button>een knop<button>Opslaan</button>
<form> <input>invoer van de gebruikervolgende slide

Een formulier om een taak toe te voegen

<form id="nieuw">
  <label for="taak">Taak</label>
  <input id="taak" name="taak" type="text" placeholder="Melk kopen" required>
  <input name="prioriteit" type="number" min="1" max="3" value="2">
  <label><input name="klaar" type="checkbox"> Al klaar</label>
  <button type="submit">Opslaan</button>
</form>

type bepaalt het veld

text tekst, number getal, email, date, password, checkbox aan/uit. De browser controleert zelf of een e-mailadres klopt; required maakt een veld verplicht.

name is de sleutel

Onder die naam gaat de waarde naar de server: taak=Melk kopen. Een label hoort bij een veld via for en id. De knop met type="submit" verstuurt het formulier.

Alles zit in iets anders

<section>
  <h2>Open taken</h2>
  <ul>
    <li><a href="/taak/1">Melk kopen</a></li>
    <li><a href="/taak/2">Offerte sturen</a></li>
  </ul>
</section>

Open- en sluittag

Alles tussen <ul> en </ul> hoort bij de lijst. De browser bouwt er een boom van: section, daarin een kop en een lijst, daarin items, daarin links. Die boom heet de DOM; JavaScript werkt er straks mee.

Inspringen is voor mensen

De browser kijkt alleen naar de tags, niet naar de spaties. Toch springt de AI netjes in: zo zie je in één oogopslag wat waarin zit. Valt iets ‘uit zijn vak’, kijk dan eerst of een sluittag ontbreekt of tags elkaar kruisen.

Bouwsteen 2 van 9

CSS

Bepaalt hoe de pagina eruitziet: kleuren, lettertypes, lay-out.

Wat is het?

Cascading Style Sheets: de taal die bepaalt hoe de HTML eruitziet. Kleuren, lettertypes, afstanden, de hele lay-out.

Wat doet het?

Maakt van kale structuur een vormgegeven pagina. Dezelfde HTML met andere CSS is een totaal andere pagina.

Zo ziet het eruit

button {
  background: #F15324;
  color: white;
  border-radius: 48px;
}

Zo herken je het

eindigt op .cssregels in accolades { }selectors: button, .klasse, #id

Een selector zegt op welke elementen de regel slaat

selectorkiestvoorbeeld
buttonalle elementen van dat typebutton { color: white; }
.openalles met class="open".open { font-weight: bold; }
#nieuwhet ene element met id="nieuw"#nieuw { margin-top: 24px; }
nav alinks die ergens in een nav staannav a { color: navy; }
li.klaareen li die ook class klaar heeftli.klaar { opacity: 0.5; }
button:hoveralleen als de muis erop staatbutton:hover { background: white; }
input[type="email"]een input met dat attribuutinput[type="email"] { width: 320px; }

Tekst

  • color kleur van de letters
  • font-size grootte, bv. 18px
  • font-family lettertype
  • font-weight dikte: 400 of 700
  • text-align links, midden, rechts

Ruimte

  • margin ruimte buiten het element
  • padding ruimte binnen de rand
  • width en height afmetingen
  • gap ruimte tussen kinderen

Vorm en kleur

  • background achtergrondkleur
  • border rand: 2px solid #002661
  • border-radius ronde hoeken
  • box-shadow schaduw

Lay-out

  • display: flex kinderen naast elkaar
  • display: grid in kolommen en rijen
  • justify-content verdeling horizontaal
  • align-items uitlijning verticaal
  • position vastzetten op een plek

Elk element is een doos

margin
border
padding
inhoud

In CSS

.kaart {
  width: 300px;
  padding: 24px;
  border: 2px solid #002661;
  margin: 16px;
  display: flex;
  gap: 12px;
}

Naast elkaar met flex

display: flex op een ouder zet de kinderen op één rij; flex-direction: column zet ze onder elkaar. gap is de ruimte ertussen, justify-content verdeelt de ruimte in de richting van de rij, align-items lijnt uit in de andere richting. Deze presentatie is er zelf een voorbeeld van: de kaartjes rechts staan in een grid, de knoppen onderaan in een flex-rij.

Bouwsteen 3 van 9

JavaScript

Maakt de pagina interactief en stuurt gegevens naar de server.

Wat is het?

De programmeertaal van de browser. Draait op de computer van de bezoeker, niet op de server.

Wat doet het?

Maakt de pagina levend: reageert op klikken, controleert invoer en haalt gegevens op zonder de pagina te verversen.

Zo ziet het eruit

const knop = document.querySelector('button');
knop.addEventListener('click', () => {
  fetch('/taken', { method: 'POST' });
});
// Klik op de knop: stuur de taak naar de server

Zo herken je het

eindigt op .jsconst, function, =>addEventListener, fetch

Waarden een naam geven en code hergebruiken

const naam = 'Melk kopen';  // vaste waarde
let aantal = 3;  // mag later veranderen
const taken = ['Melk kopen', 'Offerte sturen'];  // lijst
const taak = { taak: 'Melk kopen', klaar: false }; // object

function isOpen(taak) {
  return !taak.klaar;  // ! betekent 'niet'
}
console.log(isOpen(taak));  // true

const, let, function

const is een naam voor een waarde die niet verandert, let mag wel veranderen. Een function is een stuk code met een naam dat je vaker gebruikt. (taak) => { … } is de korte schrijfwijze die de AI vaak kiest.

Lezen als

= is ‘wordt’, === is ‘is gelijk aan’, ! is ‘niet’. Accolades { } groeperen regels, een puntkomma sluit een regel af en // begint commentaar dat de browser negeert.

Een taak aan de lijst op de pagina toevoegen

const lijst = document.querySelector('#taken');  // zoek het element in de pagina
const item = document.createElement('li');  // maak een nieuw element
item.textContent = 'Melk kopen';  // zet er tekst in
item.classList.add('open');  // geef het een class, voor de CSS
lijst.appendChild(item);  // hang het in de lijst

De DOM

De browser maakt van de HTML een boom van objecten: de DOM. JavaScript kan die boom lezen en veranderen, en wat je verandert zie je meteen op het scherm. De HTML op schijf verandert niet; alleen wat de browser laat zien.

Veelgebruikt

querySelector zoekt met een CSS-selector, textContent leest of zet tekst, classList.add en .remove schakelen een class, createElement en appendChild maken nieuwe elementen, remove() haalt er een weg.

Reageren op het formulier en de server aanroepen

formulier.addEventListener('submit', async (event) => {
  event.preventDefault();  // pagina niet verversen
  const antwoord = await fetch('/taken', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ taak: 'Melk kopen' })
  });
  const data = await antwoord.json();  // het antwoord, als JSON
});

Events

Een event is iets wat gebeurt: click, submit, input, change, keydown. Met addEventListener koppel je er een functie aan die dan draait. preventDefault zet het standaardgedrag uit, hier het verversen van de pagina.

fetch, async, await

fetch stuurt een verzoek naar de server. Dat duurt even, dus await wacht op het antwoord zonder de pagina te blokkeren; async hoort bij een functie waarin je await gebruikt. antwoord.json() maakt van de tekst weer een object.

Bouwsteen 4 van 9

Python

De programmeertaal waarin de logica op de server geschreven is.

Wat is het?

Een programmeertaal die leest als Engels. Draait op de server of op je eigen computer, nooit in de browser.

Wat doet het?

Alle logica achter de schermen: rekenen, beslissen, gegevens verwerken en met de database praten.

Zo ziet het eruit

def aantal_open(taken):
    nog_te_doen = [t for t in taken if not t['klaar']]
    return len(nog_te_doen)
# Geen accolades: het inspringen bepaalt wat bij elkaar hoort

Zo herken je het

eindigt op .pydef, import, returngeen accolades, inspringen telt

Een bestand schrijven en uitvoeren

# taken.py
taken = ['Melk kopen', 'Offerte sturen', 'Training geven']
print('Nog', len(taken), 'taken open')

# in de terminal
$ source .venv/bin/activate  # de omgeving aan
(.venv) $ python taken.py  # van boven naar beneden
Nog 3 taken open  ← wat print() zegt, zie je hier
(.venv) $  ← klaar, de prompt is terug

Python voert je bestand uit

python taken.py leest het bestand van boven naar beneden en stopt als het klaar is. Een programma dat moet blijven draaien stop je met Ctrl+C. Windows: .venv\Scripts\activate, en vaak python in plaats van python3.

De terminal is je dashboard

Alles wat print() zegt en elke foutmelding komt hier terecht. Je ziet er ook of de omgeving aanstaat: (.venv) vooraan de regel. Gaat er iets mis, dan is dit de plek waar je kijkt én waar je de melding kopieert voor de AI.

Zo weet je welk package je nodig hebt

# de onderste regel van een foutmelding:
ModuleNotFoundError: No module named 'pandas'
# dus:
$ pip install pandas  # dat package installeren, in de venv
$ pip install -r requirements.txt  # alles uit de lijst van het project in één keer

Er zijn er tienduizenden; deze kom je vaak tegen

packagewat je ermee doet
pandastabellen: CSV en Excel lezen, filteren, samenvatten
requestsiets van internet ophalen, een API aanroepen
openpyxlExcel-bestanden lezen en schrijven
matplotlibgrafieken maken
python-dotenvwachtwoorden en instellingen uit .env lezen
sqlalchemy, psycopg2met een database praten (bouwsteen 8)

Een foutmelding lees je van onderen naar boven

Traceback (most recent call last):
  File "taken.py", line 12, in open_taken  ← waar: bestand, regel, functie
    taak = data['taak']
KeyError: 'taak'  ← wat: de sleutel 'taak' ontbreekt

De meldingen die je het vaakst ziet

meldingbetekentwat je doet
ModuleNotFoundError: No module named 'pandas'venv staat uit, of package ontbreektvenv aan, pip install pandas
SyntaxError / IndentationErrortypfout of verkeerd ingesprongen (regelnummer erbij)naar die regel, of aan de AI geven
NameError: name 'taken' is not defineddie naam bestaat (nog) niet: typfout, of te vroegde naam controleren
KeyError: 'taak'de gegevens zien er anders uit dan verwachtprint(data) vlak ervoor
FileNotFoundErrorbestand staat niet waar het script kijktvanuit de projectmap starten

Bouwsteen 5 van 9

Flask

Maakt van Python een webserver: ontvangt verzoeken, stuurt antwoorden terug.

Wat is het?

Een klein webframework voor Python: kant-en-klare onderdelen om van een Python-programma een webserver te maken.

Wat doet het?

Luistert op adressen (routes), ontvangt verzoeken uit de browser en stuurt pagina’s of gegevens terug.

Zo ziet het eruit

from flask import Flask, jsonify
app = Flask(__name__)
@app.route('/taken')  # het adres waarop de server luistert
def taken():
    return jsonify(alle_taken())

Zo herken je het

meestal app.pyfrom flask import Flask@app.route('/…')

In de terminal, en dan in de browser

$ pip install flask  # eenmalig, in de venv
$ flask --app app run --debug  # of: python app.py
 * Running on http://127.0.0.1:5000  ← open dit in de browser
127.0.0.1 - - "GET /taken HTTP/1.1" 200  ← per aanvraag één regel

# in de adresbalk van de browser:
http://127.0.0.1:5000/  → de route '/'
http://127.0.0.1:5000/taken  → de route '/taken'
http://127.0.0.1:5000/bestaat-niet  → 404 Not Found

127.0.0.1 en :5000

127.0.0.1 (ook localhost) is je eigen computer, :5000 de poort waarop Flask luistert; erachter komt de route. Alleen jij kunt erbij, zolang de terminal openstaat. Online, bij Azure of Render, wordt dit een echt adres met https.

Als het niet werkt

Niets te zien: de server staat niet aan, kijk in de terminal. Address already in use: er draait al een Flask in een ander venster, daar Ctrl+C. 404: die route bestaat niet. 500: fout in de Python-code, de melding staat in de terminal. --debug herlaadt bij elke wijziging.

Elk adres krijgt een functie

from flask import Flask, request, jsonify

@app.route('/taken', methods=['GET', 'POST'])
def taken():
    if request.method == 'POST':  # er komt een nieuwe taak binnen
        data = request.get_json()  # JSON uit de browser, als dict
        taak_id = opslaan(data['taak'])
        return jsonify({'id': taak_id}), 201  # 201 = aangemaakt
    return jsonify(alle_taken())  # GET: de hele lijst, als JSON

GET, POST, PUT, DELETE

GET haalt op, POST maakt nieuw, PUT wijzigt, DELETE verwijdert; één adres kan meerdere methodes hebben. Een deel van het adres kan variabel zijn: /taken/<int:id> geeft het nummer uit /taken/3 aan de functie.

Request, response, statuscode

Wat binnenkomt zit in request: get_json() voor JSON, form voor een formulier, args voor ?zoek=melk. Wat teruggaat maakt jsonify, met een statuscode: 200 oké, 201 aangemaakt, 400 fout verzoek, 404 niet gevonden, 500 fout op de server.

De mappen van een Flask-project

mijn-app/
├── app.py  ← de routes
├── taken.db  ← de database
├── requirements.txt
├── templates/
│   └── index.html  ← HTML met {{ }} en {% %}
└── static/
    ├── style.css
    └── script.js

Een template: HTML met gaten

<ul>
{% for taak in taken %}
  <li>{{ taak.taak }}</li>
{% endfor %}
</ul>

# in app.py:
return render_template('index.html', taken=alle_taken())

Hier komen de bouwstenen samen

render_template vult de HTML in templates/ met gegevens uit Python; de taal met {{ }} en {% %} heet Jinja. Uit static/ haalt Flask de CSS en JavaScript. De browser krijgt dus gewone HTML, CSS en JS, maar de inhoud komt uit de database. Dit is de vaste mappenindeling die de AI bijna altijd maakt.

Bouwsteen 6 van 9

JSON

Het formaat waarin browser en server gegevens uitwisselen.

Wat is het?

JavaScript Object Notation: een tekstformaat om gegevens netjes op te schrijven. Geen taal, maar een afspraak over de vorm.

Wat doet het?

Is de gemeenschappelijke taal tussen browser en server, en tussen apps onderling. Ook veel gebruikt voor instellingen en configuratie.

Zo ziet het eruit

{
  "taak": "Melk kopen",
  "klaar": false,
  "prioriteit": 2
}

Zo herken je het

eindigt op .json"sleutel": waardedubbele aanhalingstekens

Meer is er niet

soortin JSONin Python wordt hetin JavaScript
tekst (string)"Melk kopen"strstring
getal (number)2 of 2.5int / floatnumber
waar/onwaar (boolean)true / falseTrue / Falsetrue / false
niets (null)nullNonenull
lijst (array)["Melk", "Brood"]listarray
object{"taak": "Melk"}dictobject

Wat er níét in zit

Geen datums (die gaan als tekst, bijvoorbeeld "2026-10-26"), geen commentaar, geen functies, geen enkele aanhalingstekens. Dat maakt JSON simpel en daardoor overal leesbaar.

Zo ziet het antwoord van /taken eruit

{
  "lijst": "Boodschappen",
  "aantal": 2,
  "taken": [
    { "id": 1, "taak": "Melk kopen",  "klaar": false, "labels": ["winkel"] },
    { "id": 2, "taak": "Brood halen", "klaar": true,  "labels": [] }
  ]
}

Objecten in lijsten in objecten

Een object met daarin een lijst, met daarin weer objecten. Zo ziet bijna elk API-antwoord eruit: iets over het geheel bovenaan, de rijen in een lijst eronder. De inspringing laat zien wat waarin zit.

De weg erheen

In JavaScript: data.taken[0].taak → "Melk kopen". In Python: data['taken'][0]['taak']. Punt of sleutel voor een object, een nummer tussen haken voor een lijst, en tellen vanaf 0.

In de browser (JavaScript)

const tekst = JSON.stringify(taak); // object → tekst
const terug = JSON.parse(tekst);  // tekst → object
const data = await antwoord.json(); // van fetch

Op de server (Python)

import json
tekst = json.dumps(taak)  # dict → tekst
terug = json.loads(tekst)  # tekst → dict
return jsonify(taak)  # in Flask

Valkuilen die de foutmelding verklaren

Dubbele aanhalingstekens zijn verplicht, enkele niet toegestaan. Geen komma na het laatste item. Geen commentaar. True in Python wordt true in JSON, en andersom. Een fout als Unexpected token of JSONDecodeError betekent bijna altijd: de tekst is geen geldige JSON. Plak hem in een JSON-checker en je ziet de regel.

Bouwsteen 7 van 9

SQL

De taal waarmee de server de database bevraagt: ‘geef me alle open taken’.

Wat is het?

Structured Query Language: de taal waarmee je een database vragen stelt en opdrachten geeft. Uitgesproken als ‘sequel’.

Wat doet het?

Haalt gegevens op, voegt toe, wijzigt en verwijdert. ‘Geef me alle open taken, belangrijkste eerst.’

Zo ziet het eruit

SELECT taak, prioriteit
FROM taken
WHERE klaar = 0
ORDER BY prioriteit;  -- open taken, belangrijkste eerst

Zo herken je het

SELECT, FROM, WHERE, INSERT.sql, of als tekst in Pythoneindigt op een puntkomma ;

SELECT · lezen

SELECT taak, klaar FROM taken;

Welke kolommen, uit welke tabel. * betekent alle kolommen.

INSERT · toevoegen

INSERT INTO taken (taak, klaar)
VALUES ('Melk kopen', 0);

Eén nieuwe rij; de kolommen en de waarden in dezelfde volgorde.

UPDATE · wijzigen

UPDATE taken SET klaar = 1
WHERE id = 3;

Vergeet je WHERE, dan wijzig je álle rijen. Dat is de klassieke fout.

DELETE · verwijderen

DELETE FROM taken
WHERE id = 3;

Zonder WHERE is de tabel leeg. Geen prullenbak; daarom is een back-up belangrijk.

Precies de rijen die je wilt

SELECT taak, prioriteit
FROM taken
WHERE klaar = 0 AND prioriteit <= 2  -- twee voorwaarden tegelijk
  AND taak LIKE '%melk%'  -- bevat 'melk'
ORDER BY prioriteit, taak  -- sorteren, DESC voor aflopend
LIMIT 10;  -- maximaal 10 rijen

WHERE

Vergelijken met =, <>, <, >; combineren met AND, OR, NOT; zoeken in tekst met LIKE en % als joker; IN (1, 2) voor een rijtje; IS NULL voor leeg.

Tellen en groeperen

COUNT(*) telt rijen: SELECT COUNT(*) FROM taken WHERE klaar = 0. SUM, AVG, MIN, MAX rekenen over een kolom; GROUP BY lijst_id doet dat per groep.

Twee tabellen die bij elkaar horen

CREATE TABLE lijsten (id INTEGER PRIMARY KEY, naam TEXT NOT NULL);
CREATE TABLE taken (
  id       INTEGER PRIMARY KEY,
  taak     TEXT NOT NULL,
  klaar    INTEGER DEFAULT 0,
  lijst_id INTEGER REFERENCES lijsten(id)  -- wijst naar een lijst
);
SELECT taken.taak, lijsten.naam
FROM taken JOIN lijsten ON taken.lijst_id = lijsten.id;

Sleutels

PRIMARY KEY: het unieke nummer van een rij, automatisch opgehoogd. REFERENCES: deze kolom bevat het nummer van een rij in een andere tabel, een foreign key. Zo hoort elke taak bij precies één lijst.

JOIN

Plakt rijen uit twee tabellen aan elkaar via die sleutel. Daardoor hoef je de naam van de lijst niet in elke taak te herhalen; je slaat hem één keer op en haalt hem erbij als je hem nodig hebt.

Bouwsteen 8 van 9

Database

Bewaart alle gegevens geordend in tabellen, ook als de app uit staat.

Wat is het?

Een programma dat gegevens geordend bewaart in tabellen met rijen en kolommen. Bijvoorbeeld SQLite, PostgreSQL of MySQL.

Wat doet het?

Bewaart alles veilig, ook als de app uit staat, en zoekt razendsnel in grote hoeveelheden gegevens.

Zo ziet het eruit: de tabel ‘taken’

idtaakklaarprioriteit
1Melk kopen02
2Offerte sturen11
3Training voorbereiden01

Zo herken je het

een bestand als taken.db of .sqlitetabellen, rijen, kolommenimport sqlite3 in Python

Twee tabellen: ‘taken’ wijst met lijst_id naar een rij in ‘lijsten’

taken

idtaakklaarprioriteitlijst_id
1Melk kopen021
2Offerte sturen112
3Training voorbereiden012

id primary key · lijst_id foreign key

⟶lijst_id = id

lijsten

idnaam
1Boodschappen
2Werk

id primary key

Elke kolom heeft een type

INTEGER heel getal, REAL kommagetal, TEXT tekst, BOOLEAN (in SQLite gewoon 0 of 1), datums als tekst in de vorm 2026-10-26. Een rij is één ding, een kolom één eigenschap.

Primary key en foreign key

id is in elke tabel de primary key: uniek, automatisch opgehoogd, nooit hergebruikt. lijst_id in taken is een foreign key: de id van een rij in lijsten. lijst_id = 2 betekent dus ‘hoort bij lijst 2, Werk’, zonder die naam in elke taak te herhalen.

Lokaal: een bestand naast je code

SQLite: taken.db in je projectmap, niets te installeren, zit in Python. Hier begint de AI bijna altijd. Let op: het bestand staat in .gitignore, dus het gaat níét mee naar GitHub of naar de hosting.

Online: een database-server

PostgreSQL of MySQL bij een dienst als Supabase, Neon, Railway of Azure. Je app maakt verbinding via een adres met wachtwoord. Nodig zodra de app online draait of meerdere mensen tegelijk werken. Dezelfde SQL.

Wat verandert er in de code

pip install psycopg2-binary, in .env een regel DATABASE_URL met het adres van de server (postgresql://…), en de verbinding leest dat adres in plaats van taken.db. De tabellen en de SQL blijven gelijk; de AI zet dit in één stap om.

Vuistregel

Begin lokaal met SQLite. Ga online zodra je app online gaat (de hosting heeft jouw bestand niet) of zodra je samenwerkt. NoSQL-databases zoals MongoDB bewaren documenten in plaats van tabellen; voor een takenlijst heb je die niet nodig.

Openen, opdracht geven, bewaren, sluiten

import sqlite3

conn = sqlite3.connect('taken.db')  # open (of maak) het bestand
cur = conn.cursor()
cur.execute('INSERT INTO taken (taak) VALUES (?)', ('Melk kopen',))
conn.commit()  # pas nu is het echt opgeslagen
rijen = cur.execute('SELECT * FROM taken WHERE klaar = 0').fetchall()
conn.close()

Vraagtekens, nooit plakken

Het ? wordt veilig ingevuld door de database. Zelf tekst van de gebruiker in de query plakken is SQL-injectie, het bekendste beveiligingslek. Zie je f'... {taak} ...' in een query, dan is dat fout.

ORM: SQLAlchemy

De AI kiest vaak een ORM: Python-klassen in plaats van SQL, zoals Taak.query.filter_by(klaar=False). De SQL wordt dan voor je geschreven. Herken het aan db.Model en db.session.

Bouwsteen 9 van 9

Git

Legt elke wijziging in de code vast, zodat je altijd terug kunt.

Wat is het?

Een versiebeheersysteem: houdt bij wie wat wanneer in de code veranderde. GitHub is de online plek waar je dat deelt.

Wat doet het?

Maakt snapshots (commits) van je project. Fout gemaakt? Terug naar gisteren. Samenwerken zonder elkaars werk te overschrijven.

Zo ziet het eruit

$ git add .
$ git commit -m "Taken opslaan in de database"
$ git push
# Elke commit is een snapshot van het hele project, met een berichtje erbij

Zo herken je het

een verborgen map .gitcommit, push, pull, brancheen repository op GitHub

De woorden die je steeds hoort

begripwat het is
repository (repo)de map van je project mét de hele geschiedenis, bewaard in de verborgen map .git
commiteen snapshot van alle bestanden op dat moment, met een bericht en een unieke code (hash)
brancheen aparte lijn om iets uit te proberen zonder de hoofdlijn te raken; de hoofdlijn heet main
mergetwee lijnen weer samenvoegen, bijvoorbeeld je experiment terug in main
remote / originde online kopie van de repo, meestal op GitHub
clonede hele repo van GitHub naar je computer halen, geschiedenis en al

Lokaal en online in sync houden

$ git clone https://github.com/jij/mijn-app.git  # eenmalig, op elke computer
$ git pull  # wijzigingen van GitHub halen
$ git push  # jouw commits naar GitHub sturen

Deployen

Hosting zoals Azure App Service, Render of Railway koppel je aan je GitHub-repo. Elke push naar main zet automatisch de nieuwe versie online. GitHub is de weg naar ‘het staat live’.

Samenwerken

Iedereen werkt in een kopie van dezelfde repo: pull voordat je begint, push als je klaar bent. Veranderen twee mensen dezelfde regel, dan laat Git beide versies zien en kies jij.

Archief op elke computer

Andere laptop, nieuwe collega, laptop kapot? git clone en je hebt alles terug, met de hele geschiedenis. Alleen de database en .env staan er niet in; die zet je apart over.

Wat je elke werksessie typt (of de AI laat typen)

$ git status  # wat is er veranderd?
$ git add .  # alles klaarzetten
$ git commit -m "Taak verwijderen werkt"
$ git push  # naar GitHub; gekoppelde hosting zet het online
$ git log --oneline  # de geschiedenis, één regel per commit
$ git checkout -- app.py  # wijziging in één bestand ongedaan maken
$ git revert a1b2c3  # een commit netjes terugdraaien

.gitignore

Een lijstje van wat níét mee moet: taken.db (gegevens), .env (wachtwoorden en sleutels), .venv, __pycache__, node_modules. Staat iets hierin, dan ziet Git het niet.

De vibecoding-regel

Vraag de AI om na elke werkende stap een commit te maken met een duidelijk bericht. Werkt iets niet meer? git log, en terug naar de laatste goede. Zo kan de AI nooit meer wegnemen dan één stap.

Alles samen

Eén klik, de hele keten door

Wat er gebeurt als je in de to-do app op ‘Opslaan’ klikt.

1

HTML

Je klikt op de knop Opslaan in de browser.

2

JavaScript

Zet de taak om in JSON en stuurt die naar /taken.

3

Flask

Vangt het verzoek op bij de route /taken.

4

Python

Controleert de taak en schrijft een SQL-opdracht.

5

SQL + Database

INSERT INTO taken: de database bewaart de taak.

6

JSON terug

Het antwoord komt aan en JavaScript zet de taak in de lijst.

Git

Staat buiten deze keten. Het legt vast hoe de code veranderde, niet wat de gebruiker deed. Na elke werkende stap: commit.

De test

Welke bouwsteen is dit?

Negen stukjes code, zoals de AI ze schrijft. Roep de bouwsteen.

A

<button>Opslaan</button>

B

h1 { color: #F15324; }

C

knop.addEventListener('click',
  opslaan);

D

for taak in taken:
    print(taak)

E

@app.route('/taken')
def taken():

F

{ "taak": "Melk kopen",
  "klaar": false }

G

SELECT * FROM taken
WHERE klaar = 0;

H

id  | taak        | klaar
1   | Melk kopen  | 0

I

git commit -m "Eerste versie"

De kernvraag

Je hoeft de code niet te schrijven. Je moet wel zien wat ’ie doet.

Herken je de negen bouwstenen, dan stuur jij de AI. Niet andersom.

← → navigeren · N notities · F volledig scherm