Je .NET solution heeft 15 projecten, honderden bestanden en een berg gegenereerde code. Je opent Claude Code, vraagt om een feature toe te voegen, en halverwege de sessie begint het dingen te vergeten die je vijf minuten geleden hebt verteld.

Dat is geen bug. Dat is het contextvenster dat volloopt. En in een grote .NET solution loopt het snel vol.

Ik werk al maanden met Claude Code in solutions van 5 tot meer dan 30 projecten. Dit is wat ik heb geleerd over het schoonhouden van je context en het productief houden van je sessies.

Het probleem: .NET solutions zijn luidruchtig

Een typische .NET solution genereert een hoop spul dat je niet wilt dat Claude Code leest. Elk project heeft bin/ en obj/ mappen. Entity Framework maakt migratiebestanden die honderden regels lang kunnen zijn. Visual Studio genereert .Designer.cs bestanden, .g.cs bestanden en allerlei XML-artefacten.

Als Claude Code je solution scant, leest het alles. Elke migratie. Elk gegenereerd bestand. Elk gecompileerd artefact dat het kan vinden. Dat is contextbudget dat je uitgeeft aan ruis in plaats van signaal.

Het resultaat: Claude Code heeft geen ruimte meer voor de code die er echt toe doet — je business logic, je endpoints, je domeinmodellen.

.claudeignore — je eerste verdedigingslinie

Net zoals .gitignore aan Git vertelt wat het moet overslaan, vertelt .claudeignore aan Claude Code wat het moet negeren. Maak dit bestand aan in de root van je solution en zet erin wat Claude Code niet hoeft te lezen.

Dit is de .claudeignore die ik gebruik voor de meeste .NET solutions:

# Build output
bin/
obj/
publish/

# Gegenereerde code
*.Designer.cs
*.g.cs
*.g.i.cs
*.generated.cs

# Entity Framework migraties
**/Migrations/

# Frontend build-artefacten (als je een SPA hebt)
**/wwwroot/lib/
**/node_modules/

# IDE en tooling
.vs/
.idea/
*.user
*.suo

# Test output
TestResults/
coverage/

# NuGet
packages/

# Grote databestanden
**/*.bacpac
**/*.bak

Dit ene bestand kan de ruis in je solution met 60-80% verminderen. Migraties alleen al kunnen duizenden regels zijn die Claude Code niet nodig heeft om je huidige code te begrijpen.

Belangrijk: sluit je testprojecten niet uit. Claude Code heeft die nodig om tests te draaien en wijzigingen te verifiëren. En sluit ook je .csproj bestanden niet uit — die bevatten dependency-informatie die Claude Code helpt je architectuur te begrijpen.

/compact — context terugwinnen tijdens je sessie

Zelfs met een goede .claudeignore vreten lange sessies context. Je bent 20 minuten bezig, hebt Claude Code meerdere bestanden laten lezen, een paar wijzigingen gemaakt, en je merkt dat het langzamer en minder precies wordt.

Dan gebruik je /compact. Dit commando vertelt Claude Code om het gesprek tot nu toe samen te vatten en contextruimte vrij te maken. Het behoudt de belangrijke zaken — waar je mee bezig bent, welke bestanden je hebt gewijzigd, welke beslissingen je hebt genomen — en laat de details vallen die het niet meer nodig heeft.

Ik gebruik /compact ongeveer elke 15-20 minuten in een grote solution. Zie het als je bureau opruimen: je houdt de documenten waar je actief mee werkt en bergt de rest op.

Een goede gewoonte: nadat Claude Code een grote wijziging heeft afgerond en je hebt geverifieerd dat het werkt, draai /compact voordat je aan de volgende taak begint.

CLAUDE.md voor monorepos en multi-project solutions

Als je solution een dozijn projecten heeft, is één CLAUDE.md in de root niet genoeg. Claude Code ondersteunt CLAUDE.md bestanden in subdirectories — en die worden alleen geladen als Claude Code in die directory werkt.

Structureer het zo:

MijnSolution/
├── CLAUDE.md                    # Solution-niveau: architectuur, conventies
├── .claudeignore                # Wat overslaan
├── src/
│   ├── MijnApp.Api/
│   │   └── CLAUDE.md            # API-specifiek: endpoints, auth, middleware
│   ├── MijnApp.Domain/
│   │   └── CLAUDE.md            # Domeinregels, entity-conventies
│   └── MijnApp.Infrastructure/
│       └── CLAUDE.md            # EF Core config, externe services
└── tests/
    └── CLAUDE.md                # Testconventies, hoe tests draaien

De root CLAUDE.md beschrijft de algehele architectuur en gedeelde conventies. De project-niveau bestanden beschrijven specifics die alleen relevant zijn als je in dat project werkt.

Zo laadt Claude Code alleen de context die het nodig heeft. Werk je aan een endpoint? Het leest de API CLAUDE.md. Los je een databaseprobleem op? Het leest die van Infrastructure. Geen verspilde context aan informatie die het nu niet nodig heeft.

Werk in gerichte sessies

Dit is de grootste mindshift voor werken met Claude Code in grote solutions: probeer niet alles in één sessie te doen.

Eén sessie, één focus. “Voeg het notificatie-endpoint toe en de bijbehorende tests.” Niet “Refactor het notificatiesysteem, voeg het nieuwe endpoint toe, werk de database bij, fix de logging, en oh update ook even de README.”

Als je naar een compleet ander deel van de solution overschakelt — zeg van de API-laag naar een background worker project — begin dan een nieuwe sessie. De context van het API-werk helpt je niet in het worker project. Het neemt alleen maar ruimte in.

Ik werk meestal in sessies van 20-30 minuten met een duidelijke focus. Eén feature, één projectgebied, één helder doel. Dan commit ik, begin opnieuw en ga verder.

/clear — wanneer opnieuw beginnen

/clear wist het hele gesprek en start een nieuwe sessie zonder je terminal te verlaten. Gebruik het wanneer:

  • Je een taak hebt afgerond en iets heel anders wilt doen
  • Claude Code verward raakt of zichzelf herhaalt
  • Je heen en weer bent gegaan over een aanpak en een schone lei wilt

Gebruik /clear niet als je midden in een wijziging zit die meerdere stappen beslaat. Als Claude Code halverwege is met het implementeren van een feature over meerdere bestanden, dan verliest het door het wissen van de context het overzicht van wat het al heeft gedaan. Gebruik dan /compact.

De vuistregel: /compact om bij te knippen, /clear om opnieuw te beginnen.

Structureer je prompts rond specifieke bestanden

In een klein project kun je zeggen “kijk naar de code en voeg een feature toe.” In een grote solution vraag je Claude Code dan om 200 bestanden te lezen om de 3 te vinden die het nodig heeft.

Wees specifiek:

In plaats van: “Voeg een notificatie-endpoint toe.”

Zeg: “Voeg in src/MijnApp.Api/Endpoints/ een notificatie-endpoint toe volgens hetzelfde patroon als UserEndpoints.cs. De query handler hoort in src/MijnApp.Application/Notifications/.”

Je wijst Claude Code naar precies de juiste bestanden en directories. Het besteedt context aan de code die ertoe doet, niet aan het scannen van je hele solution om uit te zoeken waar dingen thuishoren.

Hetzelfde geldt voor het fixen van bugs. In plaats van “de notificatie-feature is kapot,” zeg “de GetNotifications handler in src/MijnApp.Application/Notifications/GetNotificationsHandler.cs geeft een lege lijst terug terwijl er resultaten zouden moeten zijn. De test in tests/MijnApp.Tests/Notifications/GetNotificationsTests.cs laat het verwachte gedrag zien.”

Meer context in je prompt betekent minder context die Claude Code moet besteden om dingen uit te zoeken.

Een praktisch voorbeeld

Zo ziet mijn typische workflow eruit in een grote .NET solution:

  1. Begin een nieuwe sessie in de solution root
  2. Vertel Claude Code waar je mee bezig bent: “Ik moet een soft-delete feature toevoegen aan de Order entity in het Domain project, de EF Core configuratie updaten in Infrastructure, en een delete endpoint toevoegen in de API.”
  3. Werk het stap voor stap door: eerst domain, dan infrastructure, dan API
  4. Draai tests na elke stap: “Draai de tests in tests/MijnApp.Domain.Tests”
  5. /compact nadat de domeinwijzigingen klaar zijn voordat je naar infrastructure gaat
  6. Commit als de feature compleet is
  7. /clear voordat je aan de volgende taak begint

Deze aanpak houdt de context gefocust, de sessies behapbaar en de resultaten voorspelbaar.

Begin vandaag met optimaliseren

Als je met Claude Code werkt in een .NET solution met meer dan een handvol projecten, maak dan vandaag nog een .claudeignore bestand aan. Het kost vijf minuten en het verschil is direct merkbaar.

Kijk dan naar je CLAUDE.md. Is het één groot bestand dat alles probeert te beschrijven? Splits het op. Zet projectspecifieke context waar het thuishoort.

En het allerbelangrijkste: stop met proberen alles in één sessie te doen. Gericht werken met schone context wint het altijd van marathonsessies. Je contextvenster is een resource — besteed het aan de code die ertoe doet.