Hoe kan een codeerbot een bug repareren, tests uitvoeren en committen terwijl jij de controle behoudt?

Question

Accepted Answer

Een codeer**bot** kan een bugfix van begin tot eind uitvoeren — reproduceren, lokaliseren, repareren, verifiëren, committen — maar jij behoudt de controle door de lus in te perken met **beperkte machtigingen, menselijke goedkeuring en kleine omkeerbare stappen**. De bot doet het typen; jij beslist wat daadwerkelijk wordt gemerged.

## De lus

```text
1. REPRODUCE  → write/run a failing test that demonstrates the bug (red)
2. LOCATE     → search the codebase, read the relevant files, form a hypothesis
3. PROPOSE    → draft a minimal fix (you can review the plan before any edit)
4. VERIFY     → run tests + lint/typecheck → fix is proven by the test going green
5. REVIEW     → show the DIFF for your approval (nothing committed yet)
6. COMMIT     → only after approval, on a branch, with a clear message
```

Het kernidee is **test-gestuurde verificatie**: de bot stelt niet vast dat iets "gerepareerd" is — het bewijst dit door een falende test succesvol te maken. De falende test uit stap 1 is het objectieve signaal dat de wijziging werkelijk werkt.

## Controlomechanismen

```text
- SCOPED PERMISSIONS → allowlist safe commands (test, lint); prompt for the rest
- APPROVAL GATES     → human confirms destructive/irreversible actions + the final commit
- SMALL STEPS        → one focused change at a time → easy to review and revert
- BRANCH / WORKTREE   → work isolated from main; throw it away if it goes wrong
- DIFF REVIEW        → read the actual diff before commit, not just the agent's summary
```

```bash
# The agent runs the suite itself and reports the result before proposing a commit
npm test -- --runInBand   # red before the fix, green after → objective verification
git diff                  # you review every line that will be committed
```

Het uitvoeren op een **branch of git worktree** betekent dat het ergste geval `git checkout main` is — het experiment heeft je werkende staat nooit aangeraakt. Kleine, omkeerbare commits maken elke stap makkelijk in te zien en terug te draaien.

## Waarom het belangrijk is

Bot-gestuurde codering verschuift je van het typen van elke regel naar **reviewen en sturen**. De voordelen zijn reëel, maar net zo reëel is het risico dat een bot vol vertrouwen een verkeerde of schadelijke wijziging uitrolt. Door een menselijke goedkeuringsstap vóór commits te handhaven, te verifiëren met tests in plaats van proza te vertrouwen, en werk in een branch te isoleren, kun je de snelheid van automatisering benutten terwijl jij diegene blijft die bepaalt wat `main` bereikt.