Claude Architect · Les

Codegeneratie en productiviteit voor ontwikkelaars

CLAUDE.md, planmodus, ingebouwde tools en onderzoek

Les 2 van 413 stappen

Codegeneratie en productiviteit voor ontwikkelaars is een gratis Claude Architect-les op CoddyKit. Dit is les 2 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.

Scenario 4: productiviteit van ontwikkelaars

Deze les sluit aan bij Scenario 4 — Productiviteit van ontwikkelaars, een van de acht examenscenario's. De taak van de architect is hier om Claude Code een effectieve teamgenoot te maken binnen een echte repository: onbekende code onderzoeken, wijzigingen veilig plannen en teamconventies blijvend vastleggen.

Drie pijlers wegen in dit scenario het zwaarst mee op het examen:

  • CLAUDE.md — blijvend, gedeeld projectgeheugen.
  • Planningsmodus — eerst verkennen en voorstellen doen, daarna pas bewerken.
  • Ingebouwde tools en stapsgewijs onderzoek — Glob, Grep, Read, Write, Edit en Bash gebruiken in een gedisciplineerde lus.

Als je deze beslissingen goed neemt, kun je de meeste D3-vragen (Configuratie en workflows) aan.

De hiërarchie van CLAUDE.md

CLAUDE.md is persistente context die automatisch in elke sessie wordt geladen. Er zijn drie scopes en het kiezen van de juiste scope is een veelvoorkomende beslissing op het examen:

  • Gebruikersniveau ~/.claude/CLAUDE.md — persoonlijke voorkeuren. NIET gedeeld via VCS, dus nieuwe teamleden zien het nooit.
  • Projectniveau ./CLAUDE.md of .claude/CLAUDE.md — vastgelegd in de repository en gedeeld met het hele team.
  • Mapniveau — beperkt tot een deelboom en geladen wanneer je in die map werkt.

Vuistregel: alles wat elke bijdrager moet volgen, hoort in het bestand op projectniveau. Teamconventies alleen in je bestand op gebruikersniveau zetten is een klassiek antwoord met een valstrik.

# Project memory — committed to VCS, shared with the team
# ./CLAUDE.md

## Build
- `yarn build` then run `dist/main.js`

## Conventions
- Use absolute imports from `src/`
- All API errors return structured `{ code, message }`
- Never commit secrets; read from env vars

CLAUDE.md modulair maken met @imports

Een monolithische CLAUDE.md wordt onhandelbaar en verbruikt bij elke beurt contexttokens. Twee mechanismen houden het bestand beknopt:

  • @path-imports — laad modulaire bestanden in, bijvoorbeeld @./standards/coding-style.md, zodat gedeelde standaarden in hun eigen bestanden met versiebeheer staan.
  • Bestanden in .claude/rules/ — elk bestand bevat YAML-frontmatter met een paths-glob en wordt alleen geladen wanneer je overeenkomende bestanden bewerkt. Dit bespaart context ten opzichte van alles in één altijd geladen CLAUDE.md stoppen.

Gebruik regels voor richtlijnen met een beperkte scope (bijvoorbeeld testconventies) die meestal niet relevant zijn.

---
# .claude/rules/testing.md
paths:
  - "**/*.test.ts"
  - "**/*.spec.ts"
---

# Loaded ONLY when editing test files
- Use the existing `makeTestClient()` helper
- One assertion concern per `it(...)` block
- Never mock the database; use the in-memory fixture

Geheugen bewerken: /memory en /compact

Twee slashopdrachten beheren context die lang behouden moet blijven:

  • /memory bewerkt CLAUDE.md rechtstreeks en behoudt wijzigingen tussen sessies — gebruik het om een moeizaam verworven conventie vast te leggen, zodat die de volgende keer wordt afgedwongen.
  • /compact comprimeert het huidige gesprek om ruimte vrij te maken in het contextvenster. Let op: door progressieve samenvatting worden getallen, percentages en datums vaag. Als exacte waarden belangrijk zijn, bewaar ze dan buiten de samenvatting letterlijk in plaats van op /compact te vertrouwen.

Op het examen wordt graag het verschil benadrukt tussen blijvend geheugen (CLAUDE.md) en tijdelijke compressie (/compact) — ze lossen verschillende problemen op.

# Persist a convention into CLAUDE.md (survives future sessions)
/memory

# Compress the running conversation to reclaim context window
/compact

Planningsmodus: verkennen voordat je bewerkt

Met planningsmodus kan Claude de codebase verkennen en een aanpak voorstellen die je goedkeurt voordat er wijzigingen worden aangebracht. Gebruik deze modus wanneer:

  • De wijziging groot is of veel bestanden raakt.
  • Er meerdere haalbare aanpakken zijn om af te wegen.
  • Er een architectuurbeslissing bij betrokken is.
  • Je eerst onbekende code veilig wilt verkennen.

Voor een oplossing in één bestand of een duidelijke stacktrace kun je de planningsmodus overslaan en meteen direct uitvoeren — de planningskosten zijn daar verspild. De modus afstemmen op de omvang van de taak is de kernbeslissing die dit scenario toetst.

Ontdekking isoleren met de Explore-subagent

Onderzoek produceert veel uitvoer — bestandsdumpen, zoekresultaten, traceringen — die het hoofdcontextvenster kunnen overspoelen. De Explore-subagent zondert dit ontdekkingswerk af en geeft een samengevat overzicht terug in plaats van onbewerkte ruis.

Dit is hetzelfde principe als bij een Skill met context: fork: voer het rommelige, veel tokens kostende deel uit in een geïsoleerde context, zodat de hoofdsessie gefocust blijft. Combineer de planningsmodus met een verkenningsstap voor grote, onbekende wijzigingen.

---
# .claude/skills/audit-deps.md
name: audit-deps
description: Scan the repo for outdated/vulnerable dependencies
context: fork          # isolate verbose scan output
allowed-tools: [Bash, Grep, Read]
argument-hint: "[package-name]"
---

Run the dependency audit and report only actionable findings.

De ingebouwde toolset

Claude Code wordt geleverd met een gerichte set ingebouwde tools. Het is cruciaal voor het examen dat je weet waarvoor elke tool dient:

  • Glob — bestanden zoeken op patroon, bijvoorbeeld **/*.test.tsx.
  • Grep — de inhoud van bestanden doorzoeken.
  • Read — een bestand in de context laden.
  • Write — een bestand maken.
  • Edit — een precieze wijziging op basis van een unieke overeenkomst.
  • Bash — shellopdrachten uitvoeren.

Glob vindt bestanden op naam of patroon; Grep vindt bestanden op basis van wat erin staat. Die twee door elkaar halen is een veelvoorkomende afleider.

# Glob: locate files by pattern
**/*.service.ts

# Grep: search contents across the repo
grep -rn "process_refund" src/

# Bash: run the test suite
yarn test --runInBand

Edit versus Read+Write

Edit voert een precieze wijziging uit door een unieke tekenreeks in het bestand te vinden. Als de doeltekenreeks niet uniek is, mislukt de wijziging — dat is een veiligheidsfunctie, geen fout.

De juiste terugvaloptie is het bestand Readen en daarna de volledige gecorrigeerde versie Writen (of de overeenkomst uitbreiden met meer omliggende context, zodat deze uniek wordt). Forceer geen dubbelzinnige wijzigingen; daarmee loop je het risico de verkeerde overeenkomst te veranderen.

Edit is bedoeld voor chirurgisch precieze, ondubbelzinnige wijzigingen; Read+Write voor bredere of dubbelzinnige herschrijvingen.

# Pseudocode of the decision
# 1) Try a unique-match Edit
#    old_string must appear EXACTLY once in the file
# 2) If the match is not unique -> Edit fails
# 3) Fallback: Read the whole file, then Write the corrected version
#    (or add more surrounding lines to old_string to disambiguate)

Stapsgewijs onderzoek

Het examen beloont een gedisciplineerde onderzoekslus in plaats van de hele repository in de context te dumpen. Het standaardpatroon:

  1. Grep de toegangspunten (waar begint deze functie?).
  2. Read de relevante bestanden die je hebt gevonden.
  3. Grep naar gebruik van de symbolen die je hebt ontdekt.
  4. Read de gebruikers om de impact te begrijpen.

Hiermee beperk je het bereik stap voor stap en voorkom je het probleem dat informatie in een overvolle context verloren raakt. Beperk de uitgebreide tooluitvoer tijdens het proces tot de relevante velden.

# 1) Find the entry point
grep -rn "router.post('/refund'" src/

# 2) Read the handler file (Read tool)
# 3) Grep usages of the function it calls
grep -rn "processRefund(" src/

# 4) Read each consumer to assess blast radius

Je bereik uitbreiden met MCP

Ingebouwde tools bestrijken het lokale bestandssysteem en de shell. Als je externe systemen wilt bereiken — een GitHub-repository, een database of een issuevolgsysteem — verbind je een MCP-server.

  • Serverprimitieven: Tools (acties), Resources (alleen-lezengegevens, zoals schema's en catalogi), Prompts (sjablonen).
  • Bereik: project .mcp.json (gedeeld via VCS) versus gebruiker ~/.claude.json (persoonlijk).
  • Geheimen geef je door via omgevingsvariabelen zoals ${GITHUB_TOKEN} — commit tokens nooit.
  • Kies bij standaardintegraties bij voorkeur een onderhouden MCP-server van de community in plaats van zelf een server te bouwen.
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" }
    }
  }
}

Opdrachten en Skills

Herbruikbare werkstromen staan op twee plaatsen. .claude/commands/ is de verouderde vorm; .claude/skills/ is de huidige vorm. Beide volgen dezelfde regel voor het bereik:

  • Projectbereik (in de repository) — gedeeld met het team via VCS.
  • Gebruikersbereik (~/.claude/) — persoonlijk en niet gedeeld.

De frontmatter van een Skill geeft je echte controle: context: fork om uitgebreide uitvoer te isoleren, allowed-tools om mogelijkheden te beperken (minimale bevoegdheden), en argument-hint om invoer te documenteren. Verpak terugkerend onderzoek als een Skill met projectbereik, zodat het hele team dit consistent uitvoert.

---
# .claude/skills/triage-bug.md  (project scope -> shared via VCS)
name: triage-bug
description: Reproduce a bug, locate root cause via incremental investigation
context: fork
allowed-tools: [Grep, Read, Bash]
argument-hint: "<issue-id or stack trace>"
---

Grep entry points, Read suspects, Grep usages, then summarize root cause.

Korte controle: je aanpak kiezen

Een scenariovraag over het configureren van Claude Code voor een werkstroom die de productiviteit van ontwikkelaars verhoogt.

Samenvatting: essentiële productiviteit voor ontwikkelaars

Belangrijkste punten voor scenario 4:

  • Bereik van CLAUDE.md: op projectniveau (gedeeld via VCS) voor teamregels; op gebruikersniveau persoonlijk en niet gedeeld; op mapniveau voor deelbomen.
  • Houd het compact: imports met @path maken de configuratie modulair, en .claude/rules/ met een paths-glob wordt alleen geladen wanneer dat relevant is.
  • /memory bewaart conventies; /compact comprimeert, maar maakt getallen en datums vager.
  • Planningsmodus voor grote wijzigingen, wijzigingen met meerdere aanpakken of architectuurwijzigingen; directe uitvoering voor oplossingen in één bestand en duidelijke stacktraces. De Explore-subagent zondert luidruchtig ontdekkingswerk af.
  • Ingebouwde tools: Glob (vinden op patroon), Grep (inhoud doorzoeken), Read, Write, Edit (unieke overeenkomst; terugvallen op Read+Write), Bash. Onderzoek stapsgewijs: toegangspunten Greppen -> Read -> gebruik Greppen -> gebruikers Readen.
  • MCP breidt het bereik uit naar externe systemen; geef de voorkeur aan communityservers, stel het bereik in via .mcp.json en gebruik omgevingsvariabelen voor geheimen.

Stem de tool en modus af op de taak en laat duurzame configuratie het onthouden voor je doen.

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 “Codegeneratie en productiviteit voor ontwikkelaars” gratis?

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

CLAUDE.md, planmodus, ingebouwde tools en onderzoek 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 2 van 4.

Hoe lang duurt de les “Codegeneratie en productiviteit voor ontwikkelaars”?

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. Supportagent en onderzoek met meerdere agents
  2. Codegeneratie en productiviteit voor ontwikkelaars
  3. CI/CD en gestructureerde extractie
  4. Conversationele patronen en agentische tools
← Terug naar Claude Architect