Claude Architect · Les

Sessies isoleren voor reviews

Review in een nieuwe instance zonder generatiecontext

Les 3 van 413 stappen

Sessies isoleren voor reviews 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.

Het probleem van vooringenomenheid van de auteur

Wanneer Claude code genereert en deze vervolgens in dezelfde sessie beoordeelt, is de beoordeling aangetast. Het model heeft zijn eigen redenering nog in de context en verdedigt daardoor eerder zijn keuzes dan dat het deze ter discussie stelt.

Dit is het antipatroon van zelfbeoordeling in dezelfde sessie. De auteur behoudt de onderbouwing van elke beslissing en markeert zijn eigen aannames zelden als verdacht.

Het examenprincipe is duidelijk: een beoordeling door een onafhankelijke, nieuwe instantie is beter dan zelfbeoordeling in dezelfde sessie. In CI/CD betekent dit dat de beoordelaar nooit context mag delen met de generator.

Waarom een nieuwe instantie wint

Een beoordelaar die vanuit een leeg contextvenster start, benadert de diff als een buitenstaander. Deze heeft geen belang bij de reden waarom een functie op een bepaalde manier is geschreven en beoordeelt de code dus uitsluitend op haar eigen merites.

  • Generatiecontext = de prompts, verkenning en redenering waarmee de code is geproduceerd.
  • Beoordelingscontext = alleen de code, de standaarden en de beoordelingscriteria.

Door deze gescheiden te houden, verwijder je de bevestigingsbias waardoor een zelfbeoordeling het eigen werk goedkeurt. Sessie-isolatie is het mechanisme dat deze scheiding in een pijplijn afdwingt.

Niet-interactieve modus in CI

Pijplijnen hebben geen terminal waarin je kunt typen, dus Claude Code moet in de niet-interactieve modus (afdrukmodus) worden uitgevoerd. Gebruik -p (of --print) om één prompt door te geven, één resultaat terug te krijgen en vervolgens af te sluiten.

Dit vormt de basis voor een geïsoleerde beoordelingsstap: elke aanroep is een nieuw proces met een eigen schone context, volledig gescheiden van een eventuele eerdere generatiestap.

# Non-interactive review invocation in a CI job
claude -p "Review the staged diff for correctness and security issues." \
  --output-format json

Parseerbare uitvoer voor de poort

Een CI-stap heeft door machines leesbare resultaten nodig, geen proza. Voeg --output-format json toe, zodat de pijplijn bevindingen kan parseren en kan beslissen of de build slaagt of mislukt.

Door JSON-uitvoer met een schema te combineren, wordt het resultaat deterministisch te verwerken: je poortscript leest gestructureerde velden in plaats van in vrije tekst te zoeken naar woorden als "LGTM" of "done" — wat een antipatroon is.

claude -p "$(cat .ci/review-prompt.md)" \
  --output-format json \
  > review-result.json

# Gate script parses structured fields, never scans text
jq '.findings[] | select(.severity == "blocker")' review-result.json

Twee processen, twee contexten

Het schoonste isolatiepatroon in CI/CD is het splitsen van generatie en beoordeling in twee afzonderlijke aanroepen van Claude Code. De generatietaak schrijft code; een latere, onafhankelijke taak met -p beoordeelt deze.

Omdat elke aanroep een eigen proces is, neemt de beoordelaar nooit de conversatiegeschiedenis van de generator over. Dit weerspiegelt de multi-agentregel uit het examen: subagenten nemen de geschiedenis van een coördinator niet over — context moet expliciet worden doorgegeven en mag nooit worden verondersteld.

# Stage 1 — generation (its own session/context)
claude -p "Implement the feature described in TICKET-412."

# Stage 2 — review (a brand-new process, zero shared context)
claude -p "Review the resulting diff against our coding standards." \
  --output-format json

Hervatten is geen isolatie

Het is verleidelijk om de generatiesessie te --resume en te vragen het eigen werk te beoordelen. Doe dat niet. Een hervatte sessie brengt de oorspronkelijke redenering weer in de context — precies de vertekening bij zelfbeoordeling die je wilt vermijden.

Er is nog een risico: resultaten van hervatte tools kunnen verouderd zijn als de codebase is gewijzigd sinds ze zijn vastgelegd. Soms is een nieuwe sessie met een gestructureerde samenvatting beter dan een sessie met een naam rechtstreeks hervatten.

Kies voor een onbevooroordeelde beoordeling standaard altijd een nieuwe sessie.

# --resume continues a NAMED session (keeps prior context — biased for review)
claude --resume feature-412 -p "Now review what you wrote."   # avoid for review

# fork_session branches from a shared point — still inherits context
# For review, prefer a clean -p invocation instead.

Voer alleen de diff en de regels aan

Een geïsoleerde beoordelaar moet een compacte, relevante lading ontvangen: de diff die moet worden geïnspecteerd plus de toe te passen standaarden. Beperk uitgebreide tooluitvoer tot de relevante velden — een overvolle context veroorzaakt het effect lost-in-the-middle, waarbij het model veel meer aandacht heeft voor het begin en einde dan voor het midden.

Houd de beoordelingscriteria dicht bij het begin of einde van de prompt, zodat ze niet midden in de context begraven raken.

git diff --staged > /tmp/diff.patch

claude -p "You are an independent reviewer with no prior context.

Review ONLY this diff against the rules below.

<rules>$(cat .ci/review-rules.md)</rules>

<diff>$(cat /tmp/diff.patch)</diff>" \
  --output-format json

Expliciete criteria zijn beter dan vage verzoeken

Een geïsoleerde sessie heeft geen gedeelde aannames waarop ze kan terugvallen, dus de criteria moeten expliciet zijn. Precieze regels verminderen valse positieven drastisch.

  • Vaag: "be more precise" — levert luidruchtige, inconsistente signaleringen op.
  • Expliciet: "flag a comment only when it contradicts the code it describes" — levert bruikbare bevindingen op.

Voor CI-beoordelingen is het doel specifiek om valse positieven te minimaliseren — een beoordelaar die steeds vals alarm slaat, wordt genegeerd en tast het vertrouwen in de controlepoort aan.

Few-shotvoorbeelden voor consistentie

Voeg 2-4 gerichte few-shotvoorbeelden toe die de dubbelzinnige gevallen afdekken, zodat een geïsoleerde beoordelaar zich in verschillende uitvoeringen consistent gedraagt. Het model generaliseert daaruit — het herhaalt ze niet simpelweg.

Few-shot is het juiste hulpmiddel voor consistentie, randgevallen, de uitvoerindeling en het verminderen van verzonnen bevindingen. Een paar goed gekozen voorbeelden van flag / do-not-flag stemmen het oordeel van de beoordelaar af op de norm van je team.

<examples>
  <example verdict="flag">
    Code swallows the exception silently — masks failures. Report it.
  </example>
  <example verdict="do-not-flag">
    A TODO comment about future work is not a defect. Ignore it.
  </example>
</examples>

Gestructureerde uitvoer legt het oordeel vast

Dwing de beoordelaar om via een tool en JSON Schema een gestructureerd oordeel te geven. Stel tool_choice in op "any", zodat het model verplicht een tool moet aanroepen — zo garandeer je gestructureerde uitvoer in plaats van vrije tekst.

Markeer een veld alleen als required wanneer het altijd aanwezig is. Vereis nooit een veld dat mogelijk ontbreekt, anders verzint het model een waarde. Gebruik een enum met een optie "other" plus een vrij tekstveld voor details, zodat nieuwe typen bevindingen toch kunnen worden weergegeven.

review_tool = {
    "name": "submit_review",
    "description": "Return the review verdict and findings.",
    "input_schema": {
        "type": "object",
        "properties": {
            "verdict": {"enum": ["pass", "fail"]},
            "findings": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "category": {"enum": ["bug", "security", "style", "other"]},
                        "detail": {"type": "string"}
                    },
                    "required": ["category", "detail"]
                }
            }
        },
        "required": ["verdict"]
    }
}

# tool_choice="any" guarantees a tool call (structured output)
message = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=2048,
    tools=[review_tool],
    tool_choice={"type": "any"},
    messages=[{"role": "user", "content": review_prompt}],
)

Nieuwe uitvoeringen: rapporteer alleen nieuwe problemen

Wanneer een pull request wordt bijgewerkt en de beoordeling opnieuw wordt uitgevoerd, zou een nieuwe sessie alles opnieuw signaleren — ook items die al zijn erkend. Dat veroorzaakt ruis.

Het patroon voor de toets: neem bij een nieuwe uitvoering de eerdere resultaten op en rapporteer alleen nieuwe of nog niet opgeloste problemen. Zo behoud je sessie-isolatie — het blijft een schone beoordelaar — terwijl je de eerdere bevindingen expliciet als invoer meegeeft. De context wordt bewust overgedragen en niet overgenomen uit een hervatte generatiesessie.

claude -p "Independent re-review. Below are the diff and the findings
from the previous run. Report ONLY new issues or prior issues that
are still unfixed. Do not repeat resolved items.

<previous_findings>$(cat last-review.json)</previous_findings>
<diff>$(git diff --staged)</diff>" \
  --output-format json

Korte controle

Test hoe goed je de belangrijkste beslissing achter geïsoleerde beoordelingen begrijpt.

Samenvatting: isolatie door ontwerp

Belangrijkste punten voor sessiegeïsoleerde beoordelingen in CI/CD:

  • Een nieuwe instantie is beter dan zelfbeoordeling — de auteur verdedigt zijn eigen werk; een buitenstaander doet dat niet.
  • Afzonderlijke processen — beoordeel met een afzonderlijke aanroep van claude -p; hervat nooit de generatiesessie met --resume voor een beoordeling.
  • Niet-interactief + JSON — -p met --output-format json levert een schone context en parseerbare resultaten; zoek nooit in tekst naar signalen dat de uitvoering is voltooid.
  • Expliciete criteria + 2-4 few-shotvoorbeelden minimaliseren valse positieven en houden oordelen consistent.
  • tool_choice "any" dwingt gestructureerde uitvoer af; vereis alleen velden die altijd aanwezig zijn.
  • Bij nieuwe uitvoeringen geef je eerdere bevindingen expliciet mee en rapporteer je alleen nieuwe of niet-opgeloste problemen.
  • Nooit blokkerende beoordelingen vóór het samenvoegen via de Batch API laten lopen.
Gratis beginnen

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 “Sessies isoleren voor reviews” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Claude Architect, waaronder “Sessies isoleren voor reviews”, 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 “Sessies isoleren voor reviews”?

Review in een nieuwe instance zonder generatiecontext 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 “Sessies isoleren voor reviews”?

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

  1. Niet-interactieve modus
  2. Gestructureerde uitvoer
  3. Sessies isoleren voor reviews
  4. Testgeneratie en standaarden
← Terug naar Claude Architect