The Problem: Why LLMs Struggle with Real Codebases
LLMs are bad at understanding real codebases.
The way we provide context today is fragmented, lossy, and hard to reason about:
- Pasted files - incomplete, out of context
- Partial trees - missing critical relationships
- Large snapshots - overwhelming, hard to navigate
- Vague summaries - imprecise, unreliable
This approach solved part of the problem, but the real breakthrough came when I wired deterministic context into a live AI workflow using the Model Context Protocol (MCP).
The Current State: What's Broken
Most AI-assisted coding workflows rely on some variation of:
- Pasting files or partial code into chat
- Including entire folder snapshots
- "Just include the folder" assumptions
- Implicit assumptions about project structure
This breaks down quickly:
- ❌ Context gets truncated - important details are lost
- ❌ Relationships are lost - component dependencies become unclear
- ❌ Results vary between runs - non-deterministic behavior
- ❌ CI/automation becomes impossible - no stable foundation
You can often feel that the model is missing something - but you can't point to a stable, inspectable source of truth for what it actually knows about your codebase.
The Solution: Structured Context Instead of Snapshots
Instead of snapshots, I wanted structured context.
So I built LogicStamp, a CLI that statically analyzes a React/TypeScript project and produces deterministic, machine-readable context bundles.
Rather than shipping raw files, it extracts structure:
- Components - with their contracts and APIs
- Hooks - dependencies and state management
- Props - type signatures and relationships
- Dependencies - explicit component graphs
- Relationships - how pieces connect
The output is JSON, designed to be:
- ✅ Stable across runs - deterministic output
- ✅ Machine-readable - structured data, not prose
- ✅ Human-inspectable - clear, organized format
From CLI to Workflow: The MCP Integration
A CLI alone still leaves one question unanswered:
How does an AI assistant actually consume this context?
That's where LogicStamp MCP comes in.
The Workflow
┌─────────────────┐
│ AI Assistant │
│ (Claude/Cursor)│
└────────┬────────┘
│
│ Queries via MCP
│
▼
┌─────────────────┐
│ LogicStamp MCP │
│ Server │
└────────┬────────┘
│
│ Invokes CLI
│
▼
┌─────────────────┐
│ LogicStamp CLI │
│ Static Analysis │
└────────┬────────┘
│
│ Generates
│
▼
┌─────────────────┐
│ Context Bundles │
│ (JSON) │
└─────────────────┘
The MCP server invokes the LogicStamp CLI on demand.
The CLI statically analyzes the codebase and generates deterministic context bundles.
The MCP then exposes that structured context to AI tools at runtime.
Instead of pasting files, the model queries explicit, regenerated structure.
What This Enables: The Full Workflow Benefits
Once context is deterministic and queryable:
Reproducibility
- ✅ Results become reproducible - same input, same output
- ✅ Workflows don't drift - consistent behavior over time
Inspectability
- ✅ AI behavior becomes inspectable - you can see exactly what context was used
- ✅ Stable source of truth - no guessing what the model knows
Automation
- ✅ CI pipelines become possible - automated testing of AI workflows
- ✅ Tools stop relying on implicit assumptions - explicit contracts instead
Better Understanding
- ✅ The model no longer guesses - it consumes structured data
- ✅ Relationships are explicit - dependency graphs, not assumptions
What LogicStamp Does: End-to-End
Zero-Config CLI
stamp context # Generate context bundles
stamp context style # Include style metadata (Tailwind, SCSS, etc.)
Static Analysis
- Uses TypeScript AST for accurate parsing
- Extracts component contracts, props, hooks, dependencies
- Builds explicit dependency graphs
Deterministic Output
- Stable JSON format
- Consistent across runs
- Version-controlled friendly
AI-Ready Context Bundles
- Optimized for LLM consumption
- Structured, not prose
- Complete component contracts
MCP Server Integration
- Exposes context to AI tools at runtime
- On-demand regeneration
- Query-based access
No magic, no agents, no memory tricks - just structure and contracts.
Why Deterministic Context Matters
When context is deterministic:
For Development
- Results are reproducible - same question, same answer
- Workflows don't drift - consistent behavior over time
- Debugging becomes possible - you can inspect what the model saw
For Automation
- CI pipelines can reason about structure - automated testing of AI workflows
- Version control becomes meaningful - track changes to structure, not just code
- Integration becomes reliable - stable APIs for tooling
For AI
- AI becomes a consumer of systems - structured data, not guessing
- No more implicit assumptions - explicit contracts
- Better understanding - complete picture, not fragments
Even outside of AI, having a stable structural representation of a codebase turns out to be useful in surprising places:
- Documentation generation
- Architecture analysis
- Dependency tracking
- Refactoring support
Open Source
The project is open source and available now:
- CLI: logicstamp-context - The core CLI tool
- MCP: logicstamp-mcp - The MCP server integration
- Docs: logicstamp.dev/docs - Complete documentation
Get Started
# Install the CLI
npm install -g @logicstamp/context
# Generate context for your project
stamp context
# Use with MCP (see docs for setup)
# https://logicstamp.dev/docs/mcp/getting-started
Feedback Welcome
I'd love feedback, especially from People working with AI-assisted workflows - What problems are you facing?
Top comments (0)