Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Refactoring en verbetering van bestaande code

Les 6 van 20 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Legacy-code omvormen tot moderne code
  2. Structurele refactoring
  3. Modernisering van code
  4. Kwaliteitsverbetering
  5. Refactoring op basis van patronen
  6. Verificatie van de refactoring
  7. Belangrijkste punten

Legacy-code omvormen tot moderne code

Refactoring is een van de meest tijdrovende taken in de ontwikkeling, en zelden de meest beloonde: niemand feliciteert u met het opsplitsen van een bestand van 800 regels. Precies daarom hoopt het zich op, sprint na sprint, totdat het de ware oorzaak wordt van uw vertraging. Codex reduceert uren handmatig werk tot minuten, terwijl het bestaande gedrag behouden blijft – het enige dat echt telt bij een refactor.

Structurele refactoring

Het meest voorkomende geval is het alles-in-één-bestand dat niemand durft aan te raken omdat het overal wordt geïmporteerd.

"Refactor src/utils/helpers.ts: this file is 800 lines long. 
Split it into thematic modules in src/utils/ (string.ts, 
date.ts, validation.ts, formatting.ts). Update all imports 
across the project."

Codex blinkt uit in dit soort taken: het identificeert functies, groepeert ze per thema, maakt de nieuwe bestanden aan en werkt vervolgens elke import in het project bij. Die laatste stap is meestal wat handmatige refactoring ontmoedigt – veertig bestanden om te fixen, één gemiste import, en de build faalt op het slechtst mogelijke moment. Het resultaat is objectief verifieerbaar: als tests eerder slaagden en nog steeds slagen, is de opsplitsing correct.

Modernisering van code

Het andere grote geval is de update naar moderne patronen, waarbij de transformatie mechanisch is maar zo repetitief dat deze steeds weer naar de backlog wordt verschoven.

"Migrate all callbacks in src/lib/database.ts to 
async/await. Preserve existing error handling."

Het uitgangspunt is op callbacks gebaseerde JavaScript met zijn cascaderende foutafhandeling:

function getUser(id, callback) {
  db.query("SELECT * FROM users WHERE id = ?", [id], 
    (err, rows) => {
      if (err) return callback(err);
      callback(null, rows[0]);
    });
}

Dit is wat Codex produceert:

async function getUser(id: string): Promise<User> {
  const rows = await db.query(
    "SELECT * FROM users WHERE id = ?", 
    [id]
  );
  return rows[0];
}

Er gebeurden drie dingen in één keer: TypeScript-types verschenen, callbacks maakten plaats voor async/await, en de foutafhandeling vereenvoudigde omdat uitzonderingen nu natuurlijk propageren. De bedrijfslogica blijft identiek – en dat is precies wat u controleert tijdens de review, niet de elegantie van het resultaat.

Kwaliteitsverbetering

U kunt ook richten op een specifieke kwaliteitsdimensie in plaats van een syntactische transformatie, mits u de vereisten opsomt.

"In src/api/, improve error handling:
- Replace generic try/catch blocks with typed errors
- Add appropriate HTTP error codes
- Add logging with request context
- Ensure Prisma errors are mapped correctly"

Zo geformuleerd, wordt het verzoek punt voor punt verifieerbaar tijdens de review. Een losse prompt als “verbeter de foutafhandeling” zou iets plausibels maar onbruikbaars opleveren, omdat noch u, noch de agent zou weten wanneer het doel bereikt was.

Refactoring op basis van patronen

De krachtigste variant bestaat uit het aanwijzen van een reeds conform bestand en het verzoeken om generalisatie.

"All React components in src/components/ that use 
useState for forms must migrate to react-hook-form. 
Apply the same pattern as src/components/LoginForm.tsx, 
which is already migrated."

Codex leest de referentiecomponent, extraheert het patroon en past dit toe op de doelcomponenten, terwijl het randgevallen afhandelt – zoals aangepaste validatie of side-effects – in plaats van een blinde vervanging uit te voeren. De praktische implicatie is interessant: de eerste component, degene die u zelf migreert, betaalt voor alle anderen. Investeer zorg in dit modelbestand; het is een specificatie waard.

Verificatie van de refactoring

Codex draait tests na elke refactoring, maar een refactoring die slaagt voor de tests is niet per se klaar voor release. Vier controles vormen het minimum, en elk adresseert een ander risico.

ControleOpdrachtWat het verifieert
Unit-testsnpm run testGedrag behouden
Typesnpx tsc --noEmitGeen typefouten
Lintingnpm run lintConventies gerespecteerd
Buildnpm run buildGereed voor productie

Het typische geval dat deze lijst rechtvaardigt: het verplaatsen van bestanden laat tests groen omdat ze importeren vanuit een barrel-bestand, maar breekt de productie-build door een circulaire import die niets anders onthult. Voeg deze vier opdrachten toe aan uw AGENTS.md-bestand, en Codex zal ze na elke wijziging uitvoeren zonder dat u eraan hoeft te denken of het eraan hoeft te herinneren.

Belangrijkste punten

  • Refactoring is de taak waarbij Codex de meeste tijdwinst oplevert
  • Referentieer een modelbestand om het refactoring-patroon te sturen
  • Codex werkt imports en referenties in het hele project bij
  • Verifieer altijd met tests, type-controle en build na refactoring
  • Documenteer verificatie-opdrachten in AGENTS.md