Hoe ik Opving te Houden voor Claude Code en Leerde Houden van Guard Hooks

Stel je dit voor: je zit gezellig in je fauteuil, nippend van je koffie, terwijl je favoriete AI-agent (of het nu Claude Code, Cursor of GitHub Copilot CLI is) vrolijk rapporteert over het voltooien van een refactoring-taak. Plotseling flitst rm -rf of, nog grappiger, sudo rm -rf / over het terminalscherm. De koffie blijft in je keel steken en uren onbetaalde arbeid — die wijzigingen die je nog niet hebt gecommit — verdwijnen in digitale oblivion.

Vertrouwd gevoel van machteloosheid voor "hallucinaties" van neurale netwerken? In mijn praktijk gebeurde zulke momenten een paar keer, en elke keer was het een pijnlijke les. Daarom trok het destructive_command_guard project (of simpelweg dcg) onmiddellijk mijn aandacht. Het is geen "revolutionair platform", gewoon een hele snelle en stoere waakhond voor je terminal.

Wat is dit beest

Kort samengevat is dcg een hook geschreven in Rust met hoge prestaties. Het onderschept het communicatieproces tussen jou (of je AI-agent) en de commandoregel. De enige taak is om een destructief commando te onderscheppen voordat het de kans krijgt om iets te breken.

Het tool ondersteunt vrijwel alles wat momenteel trending is in de AI-ontwikkelingswereld: Claude Code, Codex CLI, Gemini CLI, Copilot CLI, Cursor IDE, Grok en zelfs exotische opties zoals Hermes Agent. De utility werkt op Linux, macOS en Windows (via WSL of native via PowerShell).

Waarom gewoon grep je niet zal redden

Het zou kunnen lijken alsof, waarom een heel Rust-project bouwen als je een simpel Bash- of Python-script kunt schrijven? De auteur van het project, Jeffrey Emanuel, ging deze weg: de eerste versie was in Python. Maar al snel werd duidelijk dat moderne taken een genuanceerdere aanpak vereisen.

Context is alles

dcg zoekt niet alleen naar de string rm -rf. Het analyseert context. Als een agent "don't use rm -rf /" in documentatie schrijft, begrijpt de hook dat dit data is en blokkeert de bestandsschrijving niet. Maar zodra het om daadwerkelijk uitvoeren van het commando gaat — gaat de blokkade in werking.

Hiervoor wordt een verificatiesysteem met drie niveaus gebruikt:

1. Snelle substring-zoekopdracht (Quick Reject) via SIMD-instructies. Dit kost microseconden.
2. Normalisatie van commando's (extra spaties worden verwijderd, absolute paden worden vervangen door relatieve).
3. Controleren tegen complexe patronen met behulp van reguliere expressies.

Bescherming tegen "verborgen" bedreigingen

Een interessant kenmerk — scannen van Heredocs en inline scripts. Als een agent besluit om rm -rf aan te roepen, zal een eenvoudige commandoregel-filter het doorlaten. dcg graaft in dergelijke constructies, parseert ze met AST (Abstract Syntax Trees) en vindt verdachte functieaanroepen.

Wat het precies blokkeert

Out-of-the-box, zelfs als je niets hebt geconfigureerd, beschermt dcg tegen de engste dingen:

• rm -rf, sudo rm -rf /, dd if=/dev/zero.
• git push --force buiten tijdelijke mappen.
• Schijfformattering, partitieverwijdering en andere systeemgeneugten.

Maar het beste deel is de "packs" (beveiligingspakketten). Er zijn er meer dan 50 in de repository. Je kunt beveiliging activeren voor specifieke technologieën in je dcg.toml:

[packs]
enabled = [
    "database.postgresql",    # Заблокирует DROP TABLE
    "kubernetes.kubectl",     # Не даст удалить namespace по ошибке
    "cloud.aws",              # Спасет от случайного terminate-instances
    "containers.docker",      # Ограничит docker system prune
]

Hoe het er in de praktijk uitziet

Stel dat je agent besloot door te draaien en alle wijzigingen ongedaan te maken. Je ziet zoiets in de terminal:

════════════════════════════════════════════════════════════════
BLOCKED  dcg
────────────────────────────────────────────────────────────────
Reason:  git reset --hard destroys uncommitted changes

Command: git reset --hard HEAD~5

Tip: Consider using 'git stash' first to save your changes.
════════════════════════════════════════════════════════════════

De blokkade komt met behulpvol advies. In de meeste gevallen realiseert de agent zich, nadat zo'n afwijzing is ontvangen, de fout en suggereert een veiliger pad, bijvoorbeeld door git stash te gebruiken.

Technische ingewanden en prestaties

Wat mij veroverde was de prestatiebenadering. De auteur claimt sub-milliseconde latentie. Voor wie van details houdt:

• Rust + SIMD: processor vectorinstructies worden gebruikt voor razendsnel trefwoordzoeken.
• Dubbele Regex Engine: eenvoudige patronen worden afgehandeld door een snelle engine met lineaire uitvoeringstijd, terwijl complexe (waar lookaheads/lookbehinds nodig zijn) worden verwerkt door een krachtigere maar langzamere regex.
• Zero-allocatie: in hot paths probeert het programma geen heap-geheugen toe te wijzen, wat kritisch is wanneer de hook bij elke toetsaanslag of agent-commando wordt aangeroepen.

Trouwens, het project implementeert een fail-open filosofie. Als dcg niet genoeg tijd heeft om het commando te analyseren binnen het toegewezen tijdbudget (200ms standaard), laat het het door. Dit wordt gedaan zodat het tool nooit een "rem" wordt die normaal werk belemmert. Mijns inziens een redelijk compromis tussen beveiliging en gemak.

Hoe te integreren in je werkproces

De gemakkelijkste manier om het uit te proberen is door het installatiescript uit de README uit te voeren. Het bepaalt je OS, downloadt de juiste binary en configureert instellingen in AI-agent configs.

Voor Claude Code ziet het eruit als het toevoegen van een sectie aan claude_desktop_config.json:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [{ "type": "command", "command": "dcg" }]
      }
    ]
  }
}

En als je in een team werkt en wilt controleren of niemand een destructieve git push --force of gebroken CI-pipeline heeft gecommit, is er een scan-modus:

dcg scan --staged

Je kunt het koppelen aan een pre-commit hook en het zal alle bestanden controleren die je naar Git probeert te pushen.

Enkele woorden over de nadelen

Er zijn geen perfecte tools. Wat kan er misgaan?

1. Valse positieven: Ondanks geavanceerd parsen kan dcg soms perfect legitieme commando's blokkeren. Voor dit geval is er een "nooduitgang" via de DCG_BYPASS omgevingsvariabele of het DCG_UNLOCK_CODE systeem.
2. Configuratiecomplexiteit: Als je iets specifieks nodig hebt, moet je in TOML-configs duiken.
3. Rust Nightly: Als je het project zelf vanuit de bron wilt bouwen, heb je de nightly versie van Rust nodig, aangezien 2024-editie-functies worden gebruikt.

Wie heeft dit nodig

Als je AI-agents meer dan eens per week gebruikt en ze vertrouwt om commando's in de terminal uit te voeren — installeer het zonder aarzeling. Het is goedkope verzekering. Dit is vooral relevant voor beginners die misschien niet onmiddellijk opmerken dat het "cache-opschoning" commando dat door het neurale netwerk werd gesuggereerd eigenlijk de helft van het systeem wist.

Voor ervaren ontwikkelaars is het meer een manier om zenuwen te besparen. We weten allemaal hoe gemakkelijk het is om op Ctrl+C te drukken op de automatische piloot, en dan frantic te onthouden wanneer de laatste backup was.

dcg is dat ene tool dat stil op de achtergrond draait en "niet om eten vraagt" totdat een kritiek moment arriveert. Het doet geen magie, het parseert gewoon strings goed en weet hoe slechte commando's eruitzien. In een wereld waar we steeds meer code schrijven en uitvoeren overlaten aan machines, worden zulke "digitale zekeringen" een verplicht onderdeel van de werkomgeving.

Het is de moeite waard om het op zijn minst te proberen om te zien hoe snel moderne Rust-software is. En heb jij ooit je AI vertrouwd om bestanden te verwijderen? Hoe liep dat af?