Govern What AI Is Allowed to See

Get Started Documentation

⚡ One-Line Install:

curl -sSL https://contextdigger.com/install.sh | bash

Installs the ContextDigger CLI. Works for updates too.

🧭 First commands to try:

cd your-project
cdg init
cdg dig backend-api

This creates a governed context bundle under .cdg/context/backend-api.txt that any coding assistant can read.

Latest
Multi-Strategy Sub-Area Creation
Parallel splitting strategies, hierarchical trees, interactive constraints
Works with Your AI Stack
ChatGPT, Claude, Gemini, Copilot, Cursor, Aider, Cody, Codeium, and more

The Philosophy: Managing AI Attention

ContextDigger introduces context aperture management, adjusting your AI focus for maximum clarity and precision.

Introducing industry-standard terminology:

Context Aperture • Attention Budget • Focus Discipline

Designed from the perspective of Autistic Intelligence, a mind that performs brilliantly with the right slice of input and becomes fragile under overload, ContextDigger treats context as something to be governed and protected, not flooded.

❌ The Problem: Attention Dilution

Wide aperture = diluted attention. AI transformer models exhibit measurable accuracy degradation when context exceeds optimal thresholds:

  • • Attention dilution - 176 files spreads AI attention too thin (8% per file)
  • • Wide aperture - Everything visible, nothing sharp
  • • Exceeded attention budget - AI "skims" rather than deeply understands
  • • Poor context scoping - No discipline around what's relevant

✅ The Solution: Aperture Control

Narrow aperture = concentrated attention. ContextDigger enforces focus discipline:

  • ✓ Context aperture: f/15 - Optimal 15-file focus depth
  • ✓ Attention budget management - Stay within 12K optimal token range
  • ✓ Guided context scoping - Auto-analysis suggests natural boundaries
  • ✓ Focus discipline - Intentional constraints enable precision

💡 The Core Insight

Like photography, AI context benefits from aperture control, not maximum exposure but optimal exposure.

When you exceed your attention budget, ContextDigger does not block you. It adjusts your context aperture, analyzing your files using 4 parallel strategies (directory, naming, role, imports) to suggest natural focus boundaries. Pick one, and you are working at optimal resolution in 30 seconds.

"More context ≠ better results. Focused context = precision. This is the foundation of focus discipline in AI-assisted development."

Start Here

Choose the path that matches what you need right now.

Understand AI Basics

Learn how tokens, context windows, and attention really work when you ask an AI to help with code.

Learn Context Governance

Go deeper on Context Aperture, Attention Budgets, and what happens when Aperture is exceeded.

Run a Hands-on Lab

Add rate limiting to a checkout API and see how governed bundles change AI behavior in practice.

💡 NEW TO AI-ASSISTED CODING?

Understanding Context, Budgets, and AI Governance

Not sure what "budget", "refusal", or "context" mean? Or why they matter for AI tools? We explain everything in plain language.

Learn the Core Concepts → Why Budgets Matter Visit the AI School →

See It In Action

Real scenarios where ContextDigger transforms your workflow

🏢

Sarah: Salesforce Developer

From vague AI answers to exact code suggestions

❌ The Problem

Task: Add validation for Account.Industry field in her Salesforce org's test suite.

First Attempt: Sarah opens Claude Code, copies all 176 Apex test files from her /force-app/tests folder, and asks:

Sarah: "Add a test for Account.Industry field validation"
Claude: "You could add a test in one of your Account test files. Here's a generic example:
@isTest
static void testAccountIndustry() {
// Add your test here
}
"

The Frustration:

  • ✗"Which Account test file?" - Claude did not say
  • ✗Generic code - does not match her org test patterns
  • ✗10 minutes wasted - manually searching 176 files for AccountFieldTest.cls
  • ✗$0.74 per question - all 176 files processed for a generic answer

✅ The Solution

Sarah installs ContextDigger: curl install.sh | bash

$ cdg init
✓ Discovered 12 code areas in your project
$ cdg dig salesforce-tests
❌ ERROR: Area too large (176 files > 15 files budget)
💡 ContextDigger analyzed your files and found natural groupings:
1. ✓ account-tests (23 files) - Account* test classes
2. ✓ opportunity-tests (34 files) - Opportunity* test classes
3. ✓ lead-tests (19 files) - Lead* test classes
Your choice (1-3): 1
✓ Created: account-tests (23 files)
📄 Context file: .cdg/context/account-tests.txt

Second Attempt: Sarah copies the 23-file context to Claude Code and asks the same question:

Sarah: "Add a test for Account.Industry field validation"
Claude: "In AccountFieldTest.cls line 47, add this test method after testNameValidation():
@isTest
static void testIndustryValidation() {
Account acc = TestDataFactory.createAccount();
acc.Industry = 'Invalid Value';
Test.startTest();
Database.SaveResult result = Database.insert(acc, false);
Test.stopTest();
System.assert(!result.isSuccess());
}
"

The Result: Exact file (AccountFieldTest.cls), exact line (47), code that matches her org's patterns (TestDataFactory), proper assertions. Copy-paste ready.

Before ContextDigger: 176 files → generic answer → 10 min wasted → $0.74/question
After ContextDigger: 23 files → exact answer → 30 seconds → $0.03/question (96% cheaper)
The Insight: Sarah didn't know context overload was the problem until ContextDigger showed her

✦
⚛️

Marcus: React Developer

From vague answers to architectural clarity in 30 seconds

❌ The Problem

Task: Marcus joins a React app and needs to understand: "How does the session timeout work in our authentication flow?"

First Attempt: Opens Cursor, copies all 500+ component files from src/components/

Marcus (Cursor): "How does our session timeout work?"
Cursor: "Session timeouts in React apps typically use setTimeout or
libraries like react-idle-timer. Here's a generic example..."
[Shows generic code with no connection to actual app]

The Frustration:

  • ✗"Which components handle timeout?" - Cursor did not say
  • ✗Generic tutorial code - not their actual implementation
  • ✗500 files is too much context - AI could not find the pattern
  • ✗15 minutes of manual browsing through src/components/auth/

💡 The Discovery: A teammate mentions ContextDigger manages attention budget automatically

✅ The Solution

Marcus installs ContextDigger: curl install.sh | bash

$ cdg init
✓ Discovered 8 code areas
$ cdg split frontend-components -vv
🌳 HIERARCHICAL Tree View
⚠️ frontend-components (312 files - EXCEEDS BUDGET)
├─ ✓ components-auth (14 files)
│ ├─ ✓ auth-login-forms (7 files)
│ └─ ✓ auth-session-mgmt (7 files)
├─ ✓ components-dashboard (23 files)
└─ ✓ components-shared (15 files)
💡 ContextDigger found your auth components!
Select sub-area (1-4): 1
✓ Created: components-auth (14 files)
📄 Context file: .cdg/context/components-auth.txt

Second Attempt: Marcus copies the 14-file context to Cursor

Marcus (Cursor): "How does our session timeout work?"
Cursor: "Your session timeout is handled in SessionManager.tsx
line 34. It uses a 15-minute idle timer that triggers refreshToken()
in AuthContext.tsx. The timeout UI appears in SessionWarning.tsx."

The Result: Exact files (SessionManager.tsx, AuthContext.tsx, SessionWarning.tsx), exact line (34), architectural understanding of the timeout flow. Marcus understands the entire auth system in 30 seconds.

Before: 500 files → generic tutorial → 15 min wasted → no real answer
After: 14 files → exact architecture → 30 seconds → complete understanding
The Insight: Marcus didn't know where auth components were; ContextDigger's hierarchical tree showed him the entire structure

✦
🐍

Aisha: Python Backend Developer

From generic Django tutorials to exact model implementation

❌ The Problem

Task: Aisha inherits a Django project and needs to: "Add email verification to the User model"

First Attempt: Opens ChatGPT, copies all 45 Python files from backend/ directory (models, views, controllers all mixed)

Aisha (ChatGPT): "Add email verification to our User model"
ChatGPT: "In Django, email verification typically involves creating
a token and sending an email. Here's a generic example using
django-allauth..."
[Shows generic tutorial code with library she's not using]

The Frustration:

  • "Which file is the User model?" - ChatGPT could not find it
  • Suggested django-allauth - but project uses custom auth
  • 45 mixed files confused the AI - models, views, serializers all blended
  • 20 minutes manually searching for user_model.py

💡 The Discovery: Aisha reads about ContextDigger's file intelligence extraction (no AI needed, just regex)

✅ The Solution

Aisha installs ContextDigger: curl install.sh | bash

$ cdg init
✓ Discovered 6 code areas
$ cdg split backend-api -v
📊 DETAILED Sub-Area Analysis with File Intelligence
1. ✓ backend-api-models (12 files)
📁 Sample Files (intelligence extracted):
• models/user_model.py (67 lines)
Purpose: User model for authentication
Role: model
Imports: django.db, django.contrib.auth
2. ✓ backend-api-views (18 files)
Role: view/controller
3. ✓ backend-api-serializers (15 files)
💡 ContextDigger separated models from views!
Your choice (1-3): 1
✓ Created: backend-api-models (12 files)
📄 Context file: .cdg/context/backend-api-models.txt

Second Attempt: Aisha copies the 12-file model context to ChatGPT

Aisha (ChatGPT): "Add email verification to our User model"
ChatGPT: "I can see your User model in user_model.py line 12.
Since you're using custom auth (not django-allauth), add these fields:
email_verified (BooleanField) and verification_token (CharField).
Then update your UserSerializer to include them."

The Result: Exact file (user_model.py), exact line (12), approach that matches their custom auth system (not generic django-allauth). ChatGPT even referenced their UserSerializer because it saw the actual project structure.

Before: 45 mixed files → generic tutorial → 20 min searching → wrong library suggested
After: 12 isolated models → exact implementation → matches custom auth → copy-paste ready
The Insight: ContextDigger's file intelligence (Purpose, Role, Imports) separated models from views WITHOUT Aisha reading any code

⚡

David: Full-Stack TypeScript Developer

From manual file hunting to surgical precision in one command

❌ The Problem

Task: David needs to: "Add OAuth2 refresh token logic to our authentication service"

The Manual Approach: David knows auth lives in src/services/auth/ somewhere, but the backend-services folder has 80+ TypeScript files (auth, payments, notifications, email, etc.)

The Frustration:

  • 10 minutes manually browsing to find the 8 auth service files
  • Tries VS Code + Copilot with all 80 service files → vague answer
  • "Should I use passport-jwt or jsonwebtoken?" - Copilot does not know their stack
  • Generic OAuth2 tutorial code - does not match their TypeScript types
David (VS Code + Copilot): "Add refresh token to auth"
Copilot: "Here's a generic OAuth2 refresh token example...
[Shows generic code without types, doesn't reference existing services]

💡 The Discovery: David learns ContextDigger supports glob patterns. He can create a sub area with surgical precision.

✅ The Solution

David installs ContextDigger: curl install.sh | bash

The Power User Move: David knows exactly what he wants. He skips the suggestions and uses a glob pattern.

$ cdg create-subarea backend-services auth 'src/services/auth/**/*.ts'
📊 Sub-Area Preview:
Parent: backend-services
Name: auth
Pattern: src/services/auth/**/*.ts
Matched Files: 8
• auth-service.ts
• token-manager.ts
• jwt-validator.ts
• session-store.ts
...
Total Lines: 847
✅ Created: backend-services-auth
Budget: 8/15 files ✓, 847/3,000 lines ✓
📄 Context file: .cdg/context/backend-services-auth.txt

Second Attempt: David copies the 8-file context to VS Code + Copilot

David (VS Code + Copilot): "Add OAuth2 refresh token logic"
Copilot: "I can see you're using TokenManager.ts for JWT handling.
Add a refreshToken method here that validates the refresh token,
checks expiration in SessionStore.ts, and generates new access/refresh
pairs using your existing JwtValidator.ts..."
[Shows code using actual TypeScript interfaces and existing services]

The Result: Exact implementation using TokenManager.ts, SessionStore.ts, and JwtValidator.ts. Copilot understood the architecture and used the existing TypeScript types. Copy and paste ready.

Before: 80 files OR 10 min manual search → generic OAuth2 tutorial → wrong types
After: One glob command → 8 exact files → TypeScript implementation using actual services
The Insight: David knew the structure; ContextDigger's glob patterns gave him surgical control without browsing

Try These Examples Yourself →
✅ Native Core - AST Symbol Indexing

Context-Free Code Intelligence

Eliminate context window limits forever. ContextDigger indexes your entire codebase locally using AST parsing, enabling instant symbol lookups, cross project search, and semantic code queries with zero tokens used and zero latency.

⚡
Instant Queries
Find symbols in <50ms, not seconds
💰
Zero Token Cost
All indexing runs locally, no API calls
♾️
Unlimited Scale
Handle 10M+ lines with ease
View Technical Roadmap →

See How ContextDigger Transforms Your Workflow

From unbounded AI scanning to governed context bundles. Watch how ContextDigger enforces Context Aperture and Attention Budgets across your workflow with any AI tool.

😓

Before ContextDigger

🤔 ? ? ? ?
  • ❌ Lost in large codebase
  • ❌ Constant context switching
  • ❌ Forget important locations
  • ❌ Manual file searching
🎯

After ContextDigger

😊 ✓ ✓ ✓
  • ✅ Auto-discovered code areas
  • ✅ Instant navigation & context
  • ✅ Smart bookmarks everywhere
  • ✅ Team collaboration built-in

Your Workflow Transformed

⚡ /init-dig Discover areas 🗺️ /dig area Navigate code 📍 /mark-spot Save location 🎯 /goto-spot Jump back 👥 /dig-team Team sync

5 simple commands to transform how you navigate code in Claude

Team Collaboration Built-In

.cdg/ Shared Knowledge 👨‍💻 Alice 👩‍💻 Bob 👨‍💼 Charlie 👩‍💼 Diana

Real-time Presence

See who's working where

Shared Discoveries

Auto-sync via git

Team Knowledge

Notes & bookmarks

Deep Code Intelligence

backend-api database auth frontend mobile-app 95% !

Dependencies

Map connections

Coverage

Track tests

Hotspots

Find issues

Impact

See changes

Stop losing time every time you switch code areas.
Start working with governed context and clear boundaries.

Try ContextDigger Now →
0.2s
Scan Time
135k
Files Handled
100%
Native Rust
0
Dependencies

👥 Built for Solo Developers & Teams

👤 Built for Your Individual Workflow

🎓 Built for Learning & Growth

ContextDigger keeps your personal exploration organized. Track your own progress, maintain context, and sync across your machines.

ContextDigger adapts to your workflow. Use it solo or enable git-based team collaboration with zero server setup.

Get visibility into how your team understands the codebase and where features are actually implemented.

Coordinate documentation efforts across your team and track which code areas have been documented.

Perfect for onboarding, studying open source projects, or exploring new frameworks. Learn at your own pace with structured guidance.

👤

Individual Developers

  • ✓ Bookmark important code locations
  • ✓ Track your exploration history
  • ✓ Sync discoveries across machines via git
  • ✓ Keep everything private if you prefer
👥

Development Teams

  • ✓ See what teammates are working on (via git sync)
  • ✓ Share bookmarks and code area discoveries
  • ✓ Decentralized - no server setup required
  • ✓ Team sync via git push/pull workflow

Team Collaboration Via Git

No configuration, no servers, no accounts. Just commit your .cdg/ directory and your team can pull your discoveries.

View Team Setup Guide →

Everything You Need to Govern Context in Large Codebases

Auto-discovery, bookmarks, history tracking, and context preservation

Auto-discovery, bookmarks, history tracking, git-based team sharing, and more

Understand architecture, dependencies, and team activity at a glance

Map code structure, track documentation coverage, and maintain accuracy

Structured exploration, guided discovery, and progressive understanding

Team visibility, knowledge distribution, and exploration metrics

🔍

Auto-Discovery

Automatically detects logical code areas based on directory structure and content analysis

Automatically maps your product's architecture and identifies feature boundaries

Automatically discovers code areas that need documentation and organizes content structure

📍

Precision Bookmarks

Mark important locations and jump back instantly from anywhere in the codebase

Mark code sections you've documented and track what still needs coverage

Save important discoveries and build your personal learning roadmap

📊

History Tracking

See where you've been, what you've explored, and pick up where you left off

Monitor team exploration patterns and identify which code areas are well-understood

Track your learning progress and see how your understanding has grown over time

🎯

Context Preservation

Never lose your place. ContextDigger remembers your exploration path

Maintain context across features, dependencies, and team handoffs

⚡

Zero Friction

Commands run instantly without approval prompts. One-line installation

🔒

Privacy First

Your data stays local. Share with team via git or keep it private

Your data stays local. Share with team via git workflow or keep it private

Ready to Navigate with Precision?

Ready to Collaborate More Effectively?

Ready to Understand Your Product Better?

Ready to Document More Efficiently?

Ready to Learn Faster?

Ready to Get Team Visibility?

Install ContextDigger in less than a minute and start exploring your codebase more effectively.

Install ContextDigger and start sharing knowledge with your team via git.

Install ContextDigger and get visibility into your product's architecture and team's code exploration.

Install ContextDigger and create better documentation faster with automatic code discovery.

Install ContextDigger and start learning complex codebases with structured guidance.

Install ContextDigger and monitor your team's codebase knowledge distribution.

Get Started → Team Setup Guide View Tutorial

Want to talk about ContextDigger?

If you have questions about context governance, Autistic Intelligence, or using ContextDigger with your tools, you can reach Sam directly through a short message.

Open the contact page →