CLI Is All You Need

Mensen vragen me vaak: "Claude Code is duidelijk beter dan andere AI-codeertools, maar ik kan niet precies uitleggen waarom." De volgende blogpost van Marco Franzon legt de reden uitstekend uit. Zowel Claude Code als de recent populaire OpenClaw delen één fundamenteel kenmerk: ze verbinden beide de mogelijkheden van grote taalmodellen rechtstreeks met de terminal-opdrachtregel van het systeem. Dit is precies de reden dat AI meer kan dan alleen "een suggestie geven" -- het kan daadwerkelijk je projectmap binnengaan en aan het werk gaan: zoeken, wijzigen, uitvoeren, testen, committen en debuggen, waardoor een hechte geautomatiseerde ontwikkelingslus ontstaat. Veel mensen beschouwen de terminal als een "ouderwetse invoermethode", maar in werkelijkheid is het tegenovergestelde waar. 's Werelds meest kritieke informatiesystemen draaien allemaal op de opdrachtregel: banktransactieverwerking, luchtvaartboekingen en planning, logistieke sortering en tracking, en de kernprocessen van overheden en publieke instellingen. De opdrachtregel is al zo lang de "universele interface" omdat hij stabiel genoeg, universeel genoeg, combineerbaar genoeg en eenvoudig genoeg te automatiseren is. LLM's zijn getraind op enorme hoeveelheden opdrachtregeldata en kunnen de opdrachtregel met opmerkelijke precisie bedienen. Wanneer krachtige LLM's dus de flexibiliteit van de opdrachtregel ontmoeten, ontstaat een combinatie die de mensheid nog nooit eerder heeft gezien.

De MCP-hype is voorbij.

MCP (Model Context Protocol), dat de afgelopen twee jaar breed werd gezien als de toekomst van AI-agenttooling, is in de praktijk te omslachtig gebleken. In 2026 keren ontwikkelaars die snelheid en efficiëntie waarderen terug naar de terminal-opdrachtregel. Ze geven AI-LLM's direct toegang tot de Shell, zodat agents gereedschappen kunnen aanroepen die al tientallen jaren in de praktijk zijn bewezen -- tools zoals git, rg, grep, npm, docker, curl, jq en tail. Ontwikkelaars hebben geen aangepaste servers meer nodig of uitgebreide schemabeschrijvingen die hun contextvenster vullen. Alles wat je nodig hebt is een krachtig AI-model gecombineerd met Bash of Zsh, en AI-ondersteunde codeertools zoals Deep Code leveren opmerkelijke resultaten.

Waarom MCP zijn aantrekkingskracht verloor in het dagelijkse ontwikkelwerk

Voor typische ontwikkelworkflows voegt MCP vaak wrijving toe in plaats van dat het deze vermindert, om verschillende redenen:

• Tokenoverhead: Uitgebreide toolcatalogi en schemabeschrijvingen kostbare contextruimte.
• Het wiel opnieuw uitvinden: Aangepaste MCP-servers dupliceren vaak functionaliteit die standaard CLI-tools al betrouwbaar afhandelen.
• Slechte combineerbaarheid: Ontwikkelaars verliezen de piping, chaining en ad-hocwijzigingsmogelijkheden die Unix-systemen decennia geleden al perfectioneerden.
• Modelcompatibiliteit: Toonaangevende LLM's zijn uitgebreid getraind op Shell-gebruik. Deze modellen begrijpen parameters, pipes, foutmeldingen en documentatie met indrukwekkende nauwkeurigheid.

De beste praktijk is eenvoudig: Open je projectmap in Deep Code, verleen Shell-uitvoerrechten binnen veiligheidsrails, en geef het opdrachten die beschrijven wat je wilt bereiken. Deep Code plant, voert opdrachten uit, bewerkt bestanden, draait testen, commit code en debugt automatisch.

MCP heeft nog steeds waarde in gereguleerde bedrijfsomgevingen en SaaS-API-integraties die strikte typeveiligheid vereisen. Maar voor 80 tot 90 procent van het dagelijkse werk is het alleen maar ruis.

Scenario's waarin de opdrachtregel MCP overtreft

In mijn dagelijkse ontwikkelwerk kom ik regelmatig situaties tegen die de beperkingen van MCP pijnlijk duidelijk maken.

Projectbrede coderefactoring

Deep Code begint met een opdracht als: rg "oldDeprecatedFunction" . Het brengt de reikwijdte van de wijzigingen in kaart. Het voert gerichte bewerkingen uit in meerdere bestanden. Het controleert met git diff. Het draait npm test of cargo test. En dan commit het: refactor: remove deprecated API calls

In scenario's als deze is er geen GitHub MCP-server nodig -- alleen rg en git.

Full-stack debugging van productiebugs

Ik geef Deep Code deze instructie: Reproduceer de authenticatiefout in de stagingomgeving. Deep Code haalt de code op, start de stagingomgeving en monitort loginfouten. Het test API's met curl, start databases met docker-compose en draait specifieke testcases.

Geen Docker MCP nodig. Geen logging MCP nodig. Alleen een competente shell.

Een nieuwe microservice opzetten

Ik geef Deep Code deze instructie: Bouw een Rust-gebruikersprofiel-API met Axum + sqlx. Gebruik Postgres als database. Deep Code gebruikt de toolchain die al op de machine is geïnstalleerd (zoals Rust's cargo) om het project aan te maken, afhankelijkheden toe te voegen en de service te starten.

De bestaande toolchain is voldoende -- geen database MCP nodig.

Instabiele CI/CD-fouten verhelppen

Deep Code kloont de repo. Het draait de workflow lokaal met act. Het lokaliseert de fout. Het wijzigt .github/workflows/ci.yml of het Dockerfile. Het verifieert met docker build. Het pusht een branch. Het opent een PR met gh.

Allemaal standaard CLI-tools. Geen aangepaste CI-integratielaag nodig.

Patronen in ontwikkelaarsfeedback

Teams die de native opdrachtregelbenadering van Deep Code gebruiken, melden de volgende voordelen:

• Aanzienlijk snellere oplevering.
• Voorspelbaarder tokenverbruik.
• Meer transparantie in het gedrag van AI-ondersteunde tools.
• Eenvoudiger toezicht op en debuggen van AI-operaties.

Samengevat is de opkomende consensus helder: Stop met het bouwen van integraties. Bouw in plaats daarvan CLI-tools. Want Bash is de ultieme MCP.

De terminal is altijd al de universele ontwikkelomgeving geweest

In 2026 is de terminal ook de krachtigste interface voor AI-codeeragents. Tenzij je werkt met gespecialiseerde bedrijfstooling, kun je de zware MCP-stack volledig overslaan.

Open gewoon je projectmap in Deep Code, verleen Shell-toegang, beschrijf je taak en kijk hoe het aan het werk gaat.