Ik heb het Ultra Plan van Claude Code getest — Dit is de waarheid
Ik was halverwege een dependency-migratie — tRPC v10 vervangen door v11 in een monorepo met 47 route-definities — toen een vriend een bericht dropte in onze Discord: "Heb je /ultraplan al geprobeerd?"
Mijn eerlijke eerste reactie? Scepsis. Ik gebruikte de lokale planmodus van Claude Code al maanden trouw. Shift+Tab, het plan beoordelen, overschakelen naar bewerkingsmodus, uitvoeren. Het ritme was een tweede natuur geworden. Waarom zou ik dat proces overdragen aan een cloudgebaseerde planningssessie als mijn terminalworkflow al snel was?
Toen voerde ik /ultraplan migrate all tRPC v10 routes to v11 with backward-compatible type exports uit en zag iets wat ik niet verwacht had. Binnen enkele seconden gaf mijn terminal me een URL. Ik opende die in de browser. En daar zat een gestructureerd implementatieplan dat niet alleen de bestanden opsomde die gewijzigd moesten worden — het bracht de dependency-ketens tussen routes in kaart, signaleerde drie brekende type-signatures waar ik niet aan gedacht had, en genereerde een Mermaid-diagram dat de migratievolgorde toonde die testfouten onderweg zou minimaliseren.
Mijn lokale planmodus had dat nog nooit gedaan. Niet een keer.
Dat was twee weken geleden. Sindsdien heb ik Ultra Plan op tien verschillende prompts losgelaten — eenvoudige modelwissels, complexe refactors, greenfield scaffolding, beveiligingsaudits — en het bij elke prompt vergeleken met de lokale planmodus. Wat ik ontdekte was genuanceerder dan "Ultra Plan is beter." De waarheid omvat drie verborgen planningsmodi, een AB testing-systeem waarvan de meeste gebruikers niet weten dat het bestaat, en een zeer specifieke reeks scenario's waarin Ultra Plan echt transformatief is versus waar het gewoon een mooiere UI is voor dezelfde output.
Hier is alles wat ik geleerd heb.
Wat Ultra Plan eigenlijk is (en waarom het bestaat)
Voordat ik op de testresultaten inga, heb je het juiste mentale model nodig. Want Ultra Plan is niet simpelweg "planmodus maar dan in de cloud." De architectuur is fundamenteel anders, en dat verschil begrijpen verandert hoe je het gebruikt.
Wanneer je lokale planmodus uitvoert met Shift+Tab in Claude Code, vindt de planning plaats binnen je terminalsessie. Hetzelfde contextvenster. Dezelfde modelinstantie. Dezelfde beperkingen. De AI leest je codebase, denkt na over de wijzigingen en presenteert een plan — allemaal binnen de grenzen van je huidige conversatie.
Ultra Plan breekt dat model volledig open. Wanneer je /ultraplan typt gevolgd door je prompt, start Claude Code een speciale planningssessie op in Anthropic's Cloud Container Runtime — wat zij CCR noemen. Die externe sessie krijgt Opus 4.6, tot 30 minuten toegewijde rekentijd, en toegang tot je repository via een cloud-gesynchroniseerde snapshot. De planning vindt plaats buiten je machine, in een omgeving die speciaal gebouwd is voor diepgaande analyse.
Het praktische verschil? Je terminal blijft vrij. Terwijl Ultra Plan je migratiestrategie in de cloud doorrekent, kun je gewoon doorcoderen, tests draaien of een andere Ultra Plan-sessie starten voor een compleet andere taak. Ik heb drie Ultra Plan-sessies tegelijk gehad draaien terwijl ik lokaal een CSS-probleem aan het debuggen was. Probeer dat maar eens met lokale planmodus.
Zodra het plan klaar is, krijg je een sessie-URL die in je browser opent. En hier wijkt de ervaring scherp af van alles in de terminal.
De web-UI die verandert hoe je plannen beoordeelt
Ik zal eerlijk zijn: de webinterface is de grootste verbetering in gebruiksgemak die Ultra Plan biedt. En dat zeg ik als iemand die in de terminal leeft.
Wanneer een plan in je browser verschijnt, kijk je naar een rijk document — geen muur van markdown die door je terminal scrolt. Kopjes. Inklapbare secties. Inline codeblokken met syntaxkleuring. En cruciaal: twee functies die collaboratieve planning werkbaar maken: inline commentaar op specifieke delen van het plan, en emoji-reacties voor snelle signalering.
Dat klinkt triviaal. Dat is het niet.
Dit is waarom. Wanneer ik een plan in de terminal beoordeel, ziet mijn feedbackloop er zo uit: het plan lezen, terugscrollen naar het deel waarmee ik het oneens ben, typen "eigenlijk, voor stap 3 zou ik liever het repository pattern gebruiken in plaats van directe queries," wachten tot de AI het hele plan opnieuw genereert, het hele ding opnieuw lezen. Met de web-UI klik ik op stap 3, typ mijn commentaar inline, en vraag om een gerichte herziening. De AI werkt die sectie bij zonder de rest aan te raken. De iteratiesnelheid is dramatisch sneller.
De Mermaid-diagrammen zijn inconsistent — soms verschijnen ze, soms niet (meer daarover zo). Maar wanneer ze wel verschijnen, zijn ze oprecht nuttig. Voor de tRPC-migratie genereerde Ultra Plan een dependency-flowchart die liet zien welke routes afhankelijk waren van gedeelde type-definities, wat betekende dat ik in een oogopslag kon zien dat het migreren van userRouter voor authRouter drie downstream consumers zou breken. Die visuele weergave had me handmatig twintig minuten gekost.
Nadat je een plan goedkeurt — met of zonder herzieningen — krijg je drie opties:
- Uitvoeren in de cloud — het plan draait op afstand en kan direct een PR openen
- Hier implementeren — teleporteer het plan terug naar je huidige terminalsessie
- Nieuwe sessie starten — wis je huidige conversatie en begin opnieuw met het plan als context
Ik gebruik optie 2 in zo'n 80% van de gevallen. Het plan arriveert in mijn terminal als gestructureerde context, en ik ga lokaal verder met de uitvoering waar ik volledige controle heb over bestandsoperaties, testruns en de Git-workflow. Optie 1 is verleidelijk voor eenvoudige taken, maar ik heb gemerkt dat uitvoering nog steeds baat heeft bij lokaal toezicht — vooral wanneer het plan bestanden betreft die veranderd zijn sinds de cloud-snapshot werd gemaakt.
Dat gezegd hebbende, het cloud-uitvoeringspad is waar Ultra Plan naartoe gaat. En voor teams die een planning-naar-PR-pipeline willen met minimale menselijke tussenkomst, is het al bijna zover.
Tien prompts, twee modi, een eerlijke vergelijking
Over functies praten is makkelijk. Wat ertoe doet is prestatie. Dus ik heb dezelfde tien prompts door zowel Ultra Plan als lokale planmodus gehaald, en de output vergeleken op vier dimensies: snelheid, plankwaliteit, risicodetectie en uitvoerbaarheid.
Dit is wat ik getest heb:
Eenvoudige taken:
- Qwen 3.5 vervangen door Gemma 4 als lokaal inferentiemodel
- Een dark mode-toggle toevoegen aan een bestaande React-component
- Een databasekolom hernoemen met een migratie
Gemiddelde complexiteit: 4. Authenticatie-middleware refactoren van sessiegebaseerd naar JWT 5. Rate limiting toevoegen aan alle API-endpoints met configureerbare drempels 6. Een Prisma-schema migreren van PostgreSQL naar MySQL
Hoge complexiteit: 7. tRPC v10 upgraden naar v11 in een monorepo 8. Een multi-tenant data-isolatielaag implementeren 9. End-to-end-encryptie toevoegen voor gebruikersberichten 10. Een codebase auditen op OWASP Top 10-kwetsbaarheden
De resultaten splitsten zich netjes langs complexiteitslijnen — maar niet op de manier die ik verwacht had.
Waar Ultra Plan gelijk was aan lokale planmodus (en niets meer)
Voor prompts 1 tot en met 3 — de eenvoudige taken — bood Ultra Plan nul noemenswaardig voordeel ten opzichte van lokale planmodus. De plannen waren structureel vergelijkbaar. Dezelfde bestanden werden geidentificeerd. Dezelfde stappen werden voorgesteld. Het enige verschil was presentatie: de output van Ultra Plan zag er mooier uit in de browser.
Het wisselen van Qwen 3.5 naar Gemma 4 genereerde vrijwel identieke plannen in beide modi. Lokaal plan: wijzig de modelconfiguratie, update het inferentie-endpoint, pas de tokenizer-instellingen aan, test. Ultra Plan: dezelfde stappen, iets uitgebreidere beschrijvingen, een opmerking over compatibiliteitscontrole — maar niets wat ik niet zelf opgepikt zou hebben.
Voor eenvoudige taken voegt de extra roundtrip naar de cloud latentie toe zonder inzicht toe te voegen. Lokale planmodus handelde deze af in 15-30 seconden. Ultra Plan had 45-90 seconden nodig voor hetzelfde resultaat, omdat de cloudsessie moet opstarten, je repo-snapshot moet synchroniseren en de web-UI moet renderen.
Mijn aanbeveling: als je de wijziging in een zin kunt beschrijven en je al weet welke bestanden geraakt moeten worden, blijf dan bij lokale planmodus. Het snelheidsvoordeel is reeel.
Waar Ultra Plan voorsprong nam — en met hoeveel
Prompts 4 tot en met 6 — gemiddelde complexiteit — toonden de eerste betekenisvolle kloof. Ultra Plan begon dingen op te pikken die lokale planmodus miste.
De JWT-migratie (prompt 4) is een goed voorbeeld. Lokale planmodus gaf me een redelijk plan: maak het JWT-hulpprogramma, werk de auth-middleware bij, pas het login-endpoint aan om tokens uit te geven, voeg token-vernieuwingslogica toe. Solide. Correct. Maar het miste het sessie-opruimprobleem — bestaande gebruikers hadden actieve sessies die ongeldig gemaakt moesten worden tijdens het migratievenster. Het vermeldde ook niet de noodzaak om de CORS-configuratie bij te werken voor het nieuwe Authorization-header-patroon.
Ultra Plan pikte beide op. Het plan bevatte een specifieke migratiestap voor actieve sessies, een terugvalstrategie als JWT-verificatie faalde voor een drempel aan gebruikers, en een CORS-updatesectie. De risicodetectie was merkbaar diepgaander.
Voor de Prisma-migratie (prompt 6) stelde lokale planmodus een eenvoudige schema-herschrijving voor. Ultra Plan signaleerde vier MySQL-specifieke valkuilen: het @db.Text type-verschil, het ontbreken van native array-ondersteuning waarvoor een join-tabel nodig was, het verschil in hoofdlettergevoeligheid bij stringvergelijkingen, en een indexlengte-beperking die een van mijn samengestelde indexen zou breken. Drie van die vier zouden runtime-fouten hebben veroorzaakt waar ik uren aan had zitten debuggen.
De kloof werd groter bij hoge complexiteit. De tRPC v10-naar-v11-migratie (prompt 7) was waar Ultra Plan echt zijn waarde bewees. Lokale planmodus produceerde een redelijke migratiegids. Ultra Plan produceerde wat ik alleen kan omschrijven als een engineeringdocument — compleet met dependency-ordening, type-compatibiliteitsanalyse, een lijst van verouderde API's die ik gebruikte met hun v11-vervangers, en een gefaseerde uitrolstrategie waarmee ik route-per-route kon migreren in plaats van alles-in-een-keer.
De beveiligingsaudit (prompt 10) toonde het meest dramatische verschil. Lokale planmodus identificeerde oppervlakkige problemen: ontbrekende invoervalidatie, een paar SQL-injectievectoren, hardcoded secrets. Ultra Plan vond die plus drie dieper liggende problemen: een onveilige directe objectreferentie in het gebruikersprofiel-endpoint, een race condition in de wachtwoord-resetflow die hergebruik van tokens mogelijk maakte, en een ontbrekende rate limit op het login-endpoint die het kwetsbaar maakte voor credential stuffing. Het lokale plan signaleerde 6 problemen. Ultra Plan signaleerde er 11.
Maar hier wordt het verhaal ingewikkelder.
De drie verborgen modi waar niemand je over vertelt
Na het uitvoeren van deze tests stoorde de inconsistentie me. Waarom genereerde Ultra Plan Mermaid-diagrammen voor sommige prompts maar niet voor andere? Waarom produceerde de beveiligingsaudit een analyse vanuit meerdere perspectieven terwijl de modelwissel in feite dezelfde output gaf als de lokale modus?
Ik dook in de broncode van Claude Code — specifiek de gelekte systeemprompts die naar boven kwamen na het npm source map-incident in maart 2026 — en vond iets dat alles verklaart.
Ultra Plan draait niet een planningsmodus. Het draait er drie. En Anthropic wijst ze dynamisch toe, onzichtbaar, op basis van serverconfiguratie.
Simple Plan is de basislijn. Het is structureel vergelijkbaar met lokale planmodus — een eenvoudige analyse die bestanden identificeert, stappen voorstelt en een helder plan uitvoert. Geen diagrammen. Geen multi-perspectiefanalyse. Wanneer je een Simple Plan krijgt, krijg je in feite lokale planmodus met een mooiere UI en cloud-uitvoering. Dit is wat ik kreeg voor de eenvoudige taken.
Visual Plan voegt diagrammen toe. Dezelfde analytische diepte als Simple Plan, maar met Mermaid- en Asy-diagramgeneratie als extra laag. De dependency-flowchart die ik kreeg voor de tRPC-migratie? Dat was een Visual Plan. De diagrammen zijn geen decoratie — ze coderen structurele relaties die platte tekst moeilijk kan overbrengen. Maar de analyse zelf is niet diepgaander dan Simple Plan.
Deep Plan is degene die het spel verandert. En het is degene die mijn beveiligingsaudit-resultaten verklaarde.
Deep Plan activeert een multi-agentsysteem. Niet een model dat over je probleem nadenkt — meerdere gespecialiseerde sub-agents, elk gericht op een andere dimensie:
- Een agent analyseert code en architectuur — onderzoekt de structurele implicaties van de wijziging
- Een agent localiseert alle bestanden die aangepast moeten worden — niet alleen de voor de hand liggende, maar ook downstream consumers en testbestanden
- Een agent identificeert risico's, randgevallen en dependency-conflicten — de "wat kan er misgaan"-specialist
- Een agent beoordeelt het complete plan op logische consistentie, ontbrekende mitigaties en uitvoeringsvolgorde
Deze agents draaien parallel, dragen hun bevindingen bij aan een gedeelde context, en het systeem synthetiseert hun output tot een verenigd plan. De beveiligingsaudit die 11 problemen vond in plaats van 6? Dat was Deep Plan. De risico-agent signaleerde specifiek de race condition in de wachtwoord-resetflow — iets dat een single-pass analyse consequent mist omdat het redeneren over gelijktijdige state vereist.
Hier is het deel dat me frustreerde: je kunt niet kiezen welke modus je krijgt.
Je bent onderdeel van een AB test (en Anthropic weet het)
De modustoewijzing is niet willekeurig in de muntje-opgooi-zin. Anthropic bestuurt het via serverconfiguraties — in feite een feature flag-systeem dat bepaalt welke planningsvariant elke gebruiker voor elke sessie ontvangt. De gelekte broncode bevestigt dat dit een opzettelijk AB testing-framework is.
Anthropic meet verschillende dingen via dit systeem:
- Gebruikersacceptatiepercentages voor elke planningsvariant — keuren mensen Simple Plans even vaak goed en voeren ze die even vaak uit als Deep Plans?
- Effectiviteit van planningsprompts — welke systeemprompts produceren plannen waar gebruikers ook daadwerkelijk mee aan de slag gaan?
- Modelprestaties — de infrastructuur kan worden gebruikt om aankomende modelversies tegen elkaar te testen in live planningsscenario's
Dit verklaart waarom mijn ervaring inconsistent was tussen sessies. Sommige van mijn Ultra Plan-sessies raakten Simple Plan (vrijwel identiek aan lokale modus), terwijl andere Deep Plan raakten (dramatisch beter). Ik vergeleek niet "Ultra Plan vs lokaal plan" op een gecontroleerde manier. Ik vergeleek "welke variant Anthropic's AB-systeem me toewees" met lokaal plan.
Toen ik dit besefte, ging ik terug en draaide de hoge-complexiteit-prompts meerdere keren opnieuw. De tRPC-migratie produceerde merkbaar verschillende plannen over drie sessies — een met diagrammen, een zonder, een met de multi-agent risicoanalyse. Dezelfde prompt. Dezelfde repo-status. Verschillende planningsvarianten.
Voor gebruikers die om consistentie geven — en als je productiesoftware bouwt, zou je dat moeten doen — is dit het belangrijkste om nu over Ultra Plan te begrijpen. Het kwaliteitsplafond is oprecht hoog. De kwaliteitsvloer is in feite lokale planmodus met extra latentie. En je hebt geen controle over welke je krijgt.
Die onzekerheid is waarom ik voor nu een specifieke workflow heb gekozen die me het beste van beide werelden geeft. Maar voordat ik die deel, is er nog een technisch detail dat de moeite waard is om te begrijpen.
Hoe Ultra Plan je codebase leest (en waar het tekortschiet)
Wanneer je /ultraplan activeert, uploadt Claude Code niet je hele repository naar Anthropic's cloud. Het maakt een snapshot — een punt-in-tijd-kopie gesynchroniseerd naar de CCR-omgeving waar de planningssessie draait. De planningsagent leest vervolgens uit deze snapshot alsof het een lokale codebase is.
Dit creert een subtiele maar belangrijke beperking: de cloudsessie ziet geen wijzigingen die je maakt nadat je Ultra Plan hebt gestart. Als je een Ultra Plan activeert voor een databasemigratie en vervolgens het schema lokaal wijzigt terwijl het plan wordt gegenereerd, zal het plan gebaseerd zijn op het oude schema. Ik ben hier een keer ingetrapt — een plan goedgekeurd dat verwees naar een kolom die ik al had hernoemd tijdens het planningsvenster.
Het 30-minuten rekenvenster is ruim voor de meeste taken. Mijn langste Ultra Plan-sessie — de volledige OWASP-audit — was in ongeveer 8 minuten klaar. Maar het venster is relevant voor extreem grote repositories waar de initiele codebase-analyse aanzienlijke tijd kost. Anthropic heeft geen repo-groottelimieten voor CCR gepubliceerd, maar in mijn tests planden repo's onder de 500MB aan broncode (exclusief node_modules en build-artefacten) zonder problemen.
Nog iets over de snapshot-aanpak: Ultra Plan werkt het beste met GitHub-gehoste repositories. De synchronisatie vertrouwt op de remote van je repo, wat betekent dat lokale-only repo's of repo's met grote uncommitted wijzigingen plannen kunnen produceren op basis van onvolledige context. Ik heb geleerd om altijd te committen en pushen voordat ik /ultraplan gebruik voor iets belangrijks.
Als je liever wilt dat iemand een geoptimaliseerde Claude Code-workflow voor je opzet — compleet met Ultra Plan-integratie, aangepaste skills en agent-orchestratie — neem ik dat soort opdrachten aan. Je kunt zien wat ik gebouwd heb op fiverr.com/s/EgxYmWD.
Mijn daadwerkelijke workflow — Hoe ik Ultra Plan vandaag gebruik
Na twee weken testen is dit de workflow waar ik op uitgekomen ben. Het is niet "gebruik altijd Ultra Plan" of "sla het helemaal over." Het is voorwaardelijk, en de voorwaarden zijn specifiek.
Voor taken die ik in een zin kan beschrijven en waarbij ik de betrokken bestanden al ken: Lokale planmodus. Geen cloud-roundtrip nodig. Shift+Tab, beoordelen, uitvoeren. Snel.
Voor taken met meer dan 5 bestanden, dependency-ketens of brekende wijzigingen: Ultra Plan. De multi-agent analyse (wanneer je Deep Plan krijgt) vangt risico's op die single-pass planning consequent mist. De web-UI maakt iteratie sneller. Zelfs wanneer ik Simple Plan krijg, is de browsergebaseerde beoordeling comfortabeler voor complexe plannen.
Voor beveiligingsaudits en architectuurbeoordelingen: Ultra Plan, altijd. De Deep Plan-variant is dramatisch beter in het vinden van niet-voor-de-hand-liggende kwetsbaarheden. En aangezien dit beoordelingen met hoge inzet zijn waar het missen van een randgeval reele consequenties heeft, neem ik liever de latentie-hit voor de kans op een diepgaandere analyse.
Voor tijdkritische wijzigingen waar elke seconde telt: Lokale planmodus. De cloud-roundtrip van Ultra Plan voegt 30-90 seconden toe voordat je zelfs maar het plan ziet. Wanneer de productie plat ligt en ik snel een fix nodig heb, is die latentie onacceptabel.
Voor multitasking: Ultra Plan is onverslaanbaar. Ik start regelmatig twee of drie Ultra Plan-sessies voor verschillende taken, en beoordeel en keur ze goed naarmate ze klaar zijn. Deze parallelle planningsworkflow is iets wat lokale modus simpelweg niet kan — elk lokaal plan blokkeert je terminal totdat het klaar is.
De Deep Plan Skill-workaround
Hier is het meest tactische punt in dit hele bericht.
Aangezien Anthropic je niet laat kiezen welke planningsvariant je krijgt, en Deep Plan verreweg de beste resultaten oplevert, heb ik de Deep Plan-systeempromptstructuur geextraheerd en omgezet in een aangepaste Claude Code-skill.
De aanpak: maak een skill die het multi-agent analysepatroon van Deep Plan lokaal nabootst. De skill instrueert Claude Code om de prompt door vier opeenvolgende lenzen te analyseren — architectuurimpact, bestandsidentificatie, risicobeoordeling en planbeoordeling — voordat het een verenigd plan synthetiseert. Het is niet identiek aan het echte Deep Plan (dat echte parallelle agents draait in CCR), maar het benadert in mijn tests 80% van de kwaliteitsverbetering.
Hier is het skelet:
---
name: deep-plan
description: >
Multi-perspective planning for complex code changes.
Trigger when user asks for a detailed plan, migration
strategy, or architecture review.
---
## Deep Plan — Multi-Agent Analysis Skill
### Phase 1: Architecture Analysis
Analyze the requested change from a structural perspective.
Identify affected modules, data flows, and integration points.
Map dependencies between components.
### Phase 2: File Discovery
Locate ALL files that need modification — not just the obvious
targets. Include test files, type definitions, configuration
files, and downstream consumers.
### Phase 3: Risk Assessment
For each proposed change, identify:
- Edge cases that could cause runtime failures
- Breaking changes for existing consumers
- Race conditions or state management issues
- Security implications
- Rollback complexity
### Phase 4: Plan Synthesis & Review
Combine findings from all phases into a unified implementation
plan. Order steps by dependency chain. Flag any phase where
findings conflict. Include rollback procedures for each step.
### Output Format
Use numbered steps with sub-items. Include file paths.
Generate a Mermaid dependency diagram if more than 5 files
are affected. End with a risk summary table.
Dit geeft me Deep Plan-kwaliteitsanalyse op afroep, zonder de AB testing-loterij. De afweging is snelheid — dit lokaal draaien duurt langer dan een single-pass plan omdat het vier opeenvolgende analysepassen zijn. Maar voor complexe taken bespaart de extra twee minuten planning uren aan debugging.
Ik gebruik nog steeds het daadwerkelijke /ultraplan-commando voor multitasking-scenario's en wanneer ik de web-UI-beoordelingservaring wil. Maar voor mijn planningen met de hoogste inzet — die waarbij ik gegarandeerde diepgang nodig heb — geeft de aangepaste skill me controle die Ultra Plan momenteel niet biedt.
Wat dit onthult over de richting van Claude Code
Stap even terug van de tactische details en bekijk wat Ultra Plan onthult over Anthropic's routekaart.
De CCR-infrastructuur is niet alleen voor planning. Het is een algemene cloud-uitvoeringsomgeving. Vandaag draait het planningssessies. Morgen — en dit is speculatie op basis van de architectuur, geen insiderkennis — zou het volledige implementatiesessies, testsuites of zelfs continuous integration-pipelines aangedreven door Claude Code-agents kunnen draaien.
Het AB testing-framework is even veelzeggend. Anthropic gebruikt live Ultra Plan-sessies om planningsprompts te optimaliseren en te meten welke benaderingen plannen produceren die gebruikers daadwerkelijk uitvoeren. Dit is een live feedbackloop voor het verbeteren van de planningscapaciteit van het model. Elke keer dat je een Ultra Plan goedkeurt of afwijst, draag je data bij aan dat optimalisatieproces.
De multi-agent Deep Plan-architectuur is het meest vooruitziende onderdeel. Vandaag draait het drie tot vier gespecialiseerde sub-agents voor planning. Het patroon generaliseert naar elke complexe taak: implementatie-agents, test-agents, documentatie-agents, security review-agents — elk met gespecialiseerde systeemprompts, parallel draaiend, hun output synthetiserend. De agent teams-functie van Claude Code doet hier lokaal al iets van. De infrastructuur van Ultra Plan suggereert dat Anthropic de cloud-backbone bouwt om dit op schaal te draaien.
Ik verwacht drie dingen in de komende zes maanden:
- Door gebruikers selecteerbare planningsmodi — de AB testing-fase zal eindigen en we krijgen de keuze tussen Simple, Visual of Deep Plan
- Verbeteringen in cloud-uitvoering — plannen uitvoeren in CCR met directe PR-creatie wordt het standaardpad voor teams
- Persistente planningssessies — de mogelijkheid om Ultra Plan-sessies op te slaan, te delen en ernaar terug te keren tussen teamleden
Of die voorspellingen uitkomen of niet, de richting is duidelijk: Claude Code wordt een planning-first tool waarbij uitvoering het makkelijke deel is.
De eerlijke afwegingen die je moet kennen
Ultra Plan is geen pure upgrade. Hier zijn de beperkingen waar ik in de praktijk tegenaan ben gelopen, en geen van het promotionele materiaal vermeldt ze.
De snapshot-vertraging is reeel. Je cloudsessie plant tegen een bevroren kopie van je repo. Als je actief aan het ontwikkelen bent terwijl het plan wordt gegenereerd, krijg je aanbevelingen op basis van verouderde code. Commit en push altijd voordat je Ultra Plan start voor kritieke taken.
Je kunt de planningsvariant niet kiezen. Dit is mijn grootste frustratie. Deep Plan is aanzienlijk beter dan Simple Plan, maar het systeem bepaalt welke je krijgt. Voor een functie die bedoeld is om te helpen bij planning met hoge inzet, voelt de willekeurigheid als een ontwerpfout — zelfs als de AB testing-reden logisch is vanuit het perspectief van Anthropic.
De web-UI vereist context-switching. Van terminal naar browser springen om een plan te beoordelen breekt de flow. Ik ben een toetsenbordgerichte ontwikkelaar. Elke keer dat ik naar de muis grijp om op een plansectie in de browser te klikken, sterft een klein deel van me. Het inline commentaar is geweldig zodra je er bent, maar de overgang van terminal naar browser is schokkend.
Latentie is belangrijk voor iteratief werk. Wanneer ik in een strakke bouw-test-debug-cyclus zit, wint de 15-seconden doorlooptijd van lokale planmodus het elke keer van de 45-90 seconden van Ultra Plan. Ultra Plan is een diep-denk-tool, geen snelle-feedback-tool.
Het 30-minuten venster is grotendeels theoretisch. Geen van mijn Ultra Plan-sessies overschreed 10 minuten. Maar als je met een uitzonderlijk grote codebase werkt of vraagt om een analyse die duizenden bestanden moet lezen, kan het venster een beperking worden. Ik heb het persoonlijk niet bereikt.
Vereist Claude Code op het web. Ultra Plan heeft een verbonden account en een GitHub-gehoste repository nodig. Als je werkt met lokale-only repo's, private GitLab-instanties of in een air-gapped omgeving, is Ultra Plan geen optie. Lokale planmodus is dan je enige pad.
Dit zijn geen dealbreakers. Het zijn het soort wrijvingspunten die ertoe doen wanneer je beslist of je een nieuwe tool gaat inzetten voor productiewerk versus er alleen maar mee spelen in side projects. Weet ze van tevoren.
Dus moet je Ultra Plan echt gebruiken?
Twee weken geleden had ik een simpel antwoord gegeven. Nu is het eerlijker.
Als je bezig bent met complexe refactors, dependency-upgrades, beveiligingsaudits of architectuurwijzigingen — en je kunt de AB testing-loterij tolereren — is Ultra Plan het waard om toe te voegen aan je workflow. Het kwaliteitsplafond wanneer je Deep Plan treft is betekenisvol hoger dan wat lokale planmodus ook maar produceert. De web-UI maakt planbeoordeling en iteratie sneller voor niet-triviale wijzigingen. En de parallelle planningscapaciteit is oprecht uniek.
Als het meeste van je werk gerichte wijzigingen aan bekende bestanden betreft, is lokale planmodus nog steeds sneller en voorspelbaarder. Voeg geen cloudlatentie toe voor taken die geen cloudschaal-analyse nodig hebben.
Als je gegarandeerde Deep Plan-kwaliteit wilt zonder de willekeurigheid, bouw dan de aangepaste skill die ik hierboven beschreef. Draai hem lokaal. Accepteer de snelheidsafweging voor de dieptegarantie.
En als je het type ontwikkelaar bent dat het gedrag van je tools nauwlettend volgt — wat, als je tot hier gelezen hebt, je waarschijnlijk bent — blijf dan de AB testing-patronen in de gaten houden. Draai dezelfde prompt meerdere keren. Let op wanneer je diagrammen krijgt versus wanneer niet. Let op wanneer de risicoanalyse oppervlakkig is versus chirurgisch. Begrijpen welke variant je ontvangt helpt je om je vertrouwen in de output te kalibreren.
Het ding dat niemand zegt over Ultra Plan is dit: het is geen afgeronde functie. Het is een research preview die tegelijkertijd dient als een live optimalisatieplatform voor Anthropic's planningscapaciteiten. Je bent tegelijkertijd een tool aan het gebruiken en aan het trainen. Dat is geen kritiek — het is de realiteit van bouwen aan de frontier van AI-ondersteunde ontwikkeling. Maar het betekent dat het Ultra Plan dat je vandaag gebruikt niet het Ultra Plan zal zijn dat je over drie maanden gebruikt. En die toekomstige versie, geinformeerd door miljoenen echte planningssessies, zal vrijwel zeker beter zijn dan wat een van ons kan bouwen met aangepaste skills.
Ik houd /ultraplan in mijn dagelijkse routine. Ik houd mijn Deep Plan-skill als backup. En ik draai beide, vergelijk outputs, en sla elk verschil op als datapunt.
Want de engineers die hun tools diepgaand begrijpen — niet alleen wat de tools doen, maar hoe ze onder de motorkap werken — zijn degenen die er het meeste uit halen. Dat is waar geweest sinds de eerste compiler, en het is nog steeds waar.
Veelgestelde vragen
Hoe start ik Ultra Plan in Claude Code?
Typ /ultraplan gevolgd door je planningsprompt in de Claude Code-terminal. De sessie start op in Anthropic's cloud, en je ontvangt een browser-URL om het gegenereerde plan te beoordelen. Je hebt een Claude Code on the web-account en een GitHub-gehoste repository nodig.
Is Ultra Plan sneller dan lokale planmodus?
Qua planningsberekening draait Ultra Plan tot 2x sneller omdat het gebruik maakt van toegewijde cloudresources met Opus 4.6. Maar de totale roundtrip — inclusief cloud-opstart en browserbeoordeling — voegt 30-90 seconden toe vergeleken met de 15-30 seconden doorlooptijd van lokale planmodus voor eenvoudige taken.
Kan ik kiezen tussen Simple Plan, Visual Plan en Deep Plan?
Momenteel niet. Anthropic wijst planningsvarianten toe via serverconfiguratie als onderdeel van hun AB testing-framework. Je kunt Deep Plan-kwaliteit benaderen door een aangepaste skill te bouwen die het multi-agent analysepatroon lokaal repliceert.
Werkt Ultra Plan met prive-repositories?
Ultra Plan vereist een GitHub-repository die toegankelijk is via je Claude Code on the web-account. Lokale-only repo's, GitLab-gehoste repo's en air-gapped omgevingen worden niet ondersteund. Voor die setups blijft lokale planmodus de enige optie.
Wat gebeurt er met mijn code tijdens Ultra Plan-sessies?
Claude Code maakt een alleen-lezen snapshot van je repository die naar de cloud wordt gesynchroniseerd. De planningsagent analyseert deze snapshot — hij kan je lokale bestanden niet wijzigen. Wijzigingen vinden alleen plaats nadat je het plan goedkeurt en een uitvoeringspad kiest (cloud of lokaal).
Laten we samenwerken
Op zoek naar het bouwen van AI-systemen, het automatiseren van workflows of het opschalen van je tech-infrastructuur? Ik help je graag.
- Fiverr (maatwerk builds & integraties): fiverr.com/s/EgxYmWD
- Portfolio: mejba.me
- Ramlit Limited (enterprise-oplossingen): ramlit.com
- ColorPark (design & branding): colorpark.io
- xCyberSecurity (beveiligingsdiensten): xcybersecurity.io
