Ernstcriteria met voorbeelden
Koppel elk ernstniveau aan een codevoorbeeld
Ernstcriteria met voorbeelden is een gratis Claude Architect-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Claude Architect. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Claude Architect bevat in totaal 4 lessen.
Waarom ernst criteria nodig heeft
Wanneer je Claude vraagt code te beoordelen, is een vage instructie zoals be more precise of only flag important issues de zwakste instructie die je kunt geven. Het model heeft geen gedeelde definitie van "belangrijk", waardoor de drempel per bestand verschuift.
Het principe voor het examen is duidelijk: expliciete criteria zijn beter dan vage bijvoeglijke naamwoorden. Een ernstschaal (Critical / High / Medium / Low) is alleen nuttig als elk niveau een opgeschreven regel heeft die het model consistent kan toepassen — en de betrouwbaarste manier om een regel vast te leggen is die te verankeren met een concreet codevoorbeeld.
Deze les bouwt stap voor stap een ernstschaal voor een CI/CD-beoordelingsagent, waarbij elk niveau aan een voorbeeld is gekoppeld.
De foutmodus: bijvoeglijke naamwoorden zonder ankers
Dit is het soort prompt dat er goed uitziet maar slecht presteert. De prompt noemt ernstniveaus maar definieert ze niet, waardoor het model moet gokken — en bij elke uitvoering anders gokt.
Het resultaat is precies het antipatroon waarvoor het examen waarschuwt: lawaaierige beoordelingen waarin een ontbrekende null-controle en een verkeerd gespelde opmerking beide als "High" worden gemarkeerd. Beoordelaars vertrouwen de labels niet meer.
system = (
"You are a code reviewer. "
"Rate each issue as Critical, High, Medium, or Low. "
"Be precise and only report important problems."
)
# Problem: 'important', 'precise', and the four levels are
# never defined. The bar is whatever the model infers today.De oplossing: één regel + één voorbeeld per niveau
De oplossing is structureel. Geef het model voor elk ernstniveau twee dingen:
- Een regel — een toetsbare voorwaarde ("veroorzaakt gegevensverlies, een beveiligingslek of een crash in productie").
- Een ankeringsvoorbeeld — een kort fragment dat ondubbelzinnig bij dat niveau hoort.
Dit is few-shot prompting toegepast op een schaal: 2-4 gerichte voorbeelden per onduidelijkheid. Het model generaliseert vanuit de ankers — het echoot ze niet alleen — dus een handvol goed gekozen voorbeelden kalibreert de hele schaal.
Critical — veranker met een beveiligingsvoorbeeld
Critical is gereserveerd voor problemen die gegevensverlies, een beveiligingslek of een crash in productie veroorzaken. Veranker dit met iets onmiskenbaars — hier: directe interpolatie van tekenreeksen in SQL.
Let erop dat het anker een dubbele functie heeft: het definieert de bovengrens van de schaal, zodat het model weet dat niets milders dit niveau mag bereiken.
CRITICAL = """
Critical: causes data loss, a security breach, or a
production crash. Always report, even if low-confidence.
Example (SQL injection):
query = f"SELECT * FROM users WHERE id = {user_input}"
db.execute(query)
Why: user_input is interpolated unescaped -> injectable.
"""High — veranker met een logische fout
High omvat verkeerd gedrag dat het proces niet laat crashen maar wel onjuiste resultaten oplevert — een logische fout, een verkeerd afgehandeld randgeval of een off-by-one-fout. Het anker maakt de grens met Critical concreet: geen beveiligingslek, geen crash, maar wel onjuiste uitvoer.
HIGH = """
High: produces incorrect results or a test failure, but
does not breach security or crash production.
Example (off-by-one):
for i in range(len(items) - 1):
process(items[i]) # last item never processed
Why: range stops one element early; silent wrong output.
"""Medium en Low — veranker het rustige uiteinde
Aan het lage uiteinde van de schaal lekken vage prompts de meeste fout-positieven, dus ook dit uiteinde moet je zorgvuldig verankeren.
- Medium — risico voor onderhoudbaarheid of betrouwbaarheid dat nog geen bug is (een ontbrekende time-out, een niet-afgehandeld maar zeldzaam foutpad).
- Low — alleen stijl en naamgeving; geen invloed op gedrag.
Door Low expliciet te definiëren, kun je later zeggen "rapporteer Low niet in controles vóór het samenvoegen" zonder dat het model tegensputtert.
MEDIUM = """
Medium: reliability or maintainability risk, not yet a bug.
Example:
requests.get(url) # no timeout -> can hang forever
"""
LOW = """
Low: style or naming only, no behavioral impact.
Example:
def calc(x): return x*2 # name 'calc' is unclear
"""De schaal samenvoegen in de systeemprompt
De verankerde niveaus worden één blok in de systeemprompt. Houd dit blok stabiel en vooraan — het is hetzelfde voor elk bestand dat je beoordeelt, waardoor het een perfecte prefix voor promptcaching is. Het verschil per bestand komt in de gebruikersbeurt, na de gecachte schaal.
import anthropic
client = anthropic.Anthropic()
system = [{
"type": "text",
"text": "You are a code reviewer.\n"
+ CRITICAL + HIGH + MEDIUM + LOW
+ "\nAssign exactly one level per finding using the\n"
"rules and examples above. When unsure between two\n"
"levels, pick the lower one.",
"cache_control": {"type": "ephemeral"},
}]Dwing structuur af: ernst als enum
Een opgeschreven schaal vertelt het model hoe het moet beslissen; gestructureerde uitvoer garandeert de vorm van het antwoord. Koppel ernst aan een JSON Schema enum, zodat het veld nooit een vrij tekstueel bijvoeglijk naamwoord zoals "prettyBad" kan zijn.
Onthoud deze examenregel: markeer een veld alleen als required als het altijd aanwezig is. severity en line bestaan altijd voor een echte bevinding, dus die zijn vereist; een optionele suggested_fix niet.
finding_schema = {
"type": "object",
"properties": {
"line": {"type": "integer"},
"severity": {
"type": "string",
"enum": ["critical", "high", "medium", "low"],
},
"rule": {"type": "string"},
"suggested_fix": {"type": "string"},
},
"required": ["line", "severity", "rule"],
"additionalProperties": False,
}De schaal koppelen aan de beoordelingsaanroep
Combineer nu de gecachte, verankerde schaal met het door enum beperkte schema in één verzoek. Het verschil is het enige veranderlijke onderdeel en staat daarom achteraan in de gebruikersbeurt.
Deze combinatie — expliciete criteria voor de beslissing, gestructureerde uitvoer voor de indeling — is het aanbevolen patroon van het examen voor betrouwbare extractie en classificatie.
resp = client.messages.create(
model="claude-opus-4-8",
max_tokens=4096,
thinking={"type": "adaptive"},
system=system, # cached rubric prefix
output_config={
"format": {
"type": "json_schema",
"schema": {
"type": "object",
"properties": {"findings": {
"type": "array", "items": finding_schema}},
"required": ["findings"],
"additionalProperties": False,
},
}
},
messages=[{"role": "user", "content": diff_text}],
)Ernst stuurt de poort, niet het model
Zodra ernst een zuivere enum is, wordt de beslissing om een samenvoeging te blokkeren bepaald door deterministische code, niet door een oordeel van het model. Het model classificeert; je pijplijn bepaalt de drempels.
Dit weerspiegelt het hookprincipe uit het examen: wanneer een fout echte gevolgen heeft (een mislukte samenvoeging), dwing je die af met deterministische code en niet met een probabilistische prompt. De schaal maakt de labels van het model betrouwbaar genoeg om als poort te gebruiken.
import json
findings = json.loads(resp.content[0].text)["findings"]
BLOCKING = {"critical", "high"}
blockers = [f for f in findings if f["severity"] in BLOCKING]
if blockers:
print(f"BLOCK MERGE: {len(blockers)} issue(s)")
raise SystemExit(1)
print("OK to merge (medium/low only)")Laat het model ernst niet zelf filteren
Een subtiele valkuil: als je het model in de fase van de bevinding vertelt dat het "alleen Critical en High mag rapporteren", verlaag je de trefkans — het laat stilletjes problemen vallen die het lager heeft ingeschaald, waardoor je mogelijk gewenste dekking verliest.
Het robuuste patroon: laat het model elke bevinding met de bijbehorende ernst rapporteren en filter daarna in een afzonderlijke vervolgstap (je set BLOCKING of een onafhankelijke beoordelingsronde). Eerst dekking, daarna rangschikking. Verankerde criteria maken die rangschikking achteraf betrouwbaar.
Korte controle: ernst verankeren
Pas de les toe op een realistische ontwerpkeuze.
Samenvatting: criteria waarnaar je kunt verwijzen
Belangrijkste punten:
- Vage bijvoeglijke naamwoorden verschuiven; opgeschreven regels niet. Vervang "belangrijk" door een toetsbare voorwaarde per ernstniveau.
- Veranker elk niveau met een codevoorbeeld. 2-4 gerichte few-shot-ankers kalibreren de schaal — het model generaliseert vanuit deze voorbeelden.
- Leg het label vast met een enum. Gestructureerde uitvoer zorgt dat
severityaltijd een van de geldige waarden is; vereist alleen velden die altijd aanwezig zijn. - Cache de schaal, varieer het verschil. Houd de stabiele criteria vooraan in de systeemprompt en plaats de code per bestand achteraan.
- Classificeer in het model, bepaal de poort in code. Rapporteer alle bevindingen met hun ernst en filter of blokkeer ze daarna deterministisch in een vervolgstap — filter nooit zelf in de fase van de bevinding.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 26
- Lessen
- 104
Veelgestelde vragen
Is de les “Ernstcriteria met voorbeelden” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Claude Architect, waaronder “Ernstcriteria met voorbeelden”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Claude Architect bevat in totaal 4 lessen.
Wat leer ik in “Ernstcriteria met voorbeelden”?
Koppel elk ernstniveau aan een codevoorbeeld Je oefent met Claude Architect door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Claude Architect te beginnen?
Ervaring vooraf is niet nodig. Claude Architect op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Ernstcriteria met voorbeelden”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Claude Architect?
Ja. Elke les over Claude Architect bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Expliciete criteria boven vage instructies
- Categorische voorbeelden
- Ernstcriteria met voorbeelden
- Minder fout-positieven