Reason
LLMs are surprisingly bad at understanding real codebases.
Not because they’re “dumb”, but because the way we provide context today is fragmented, lossy, and hard to reason about - pasted files, partial trees, snapshots, or vague summaries.
After running into this repeatedly while working with React/TypeScript projects, I ended up building a CLI to make context explicit and deterministic.
That solved part of the problem.
The real improvement came when I wired that deterministic context into a live AI workflow using MCP.
The problem
Most AI-assisted coding workflows rely on some variation of:
- pasted files
- large snapshots
- “just include the folder”
- implicit assumptions about project structure
This breaks down quickly:
- context gets truncated
- important relationships are lost
- results vary between runs
- CI or automation becomes impossible
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 idea
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
- hooks
- props
- dependencies
- relationships
The output is JSON, designed to be stable across runs and usable by both humans and machines.
From CLI to workflow
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 is as follows:
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.
Instead of pasting files, the model queries explicit structure.
What the full workflow enables
Once context is deterministic and queryable:
- results become reproducible
- AI behavior becomes inspectable
- automation and CI become possible
- tools stop relying on implicit assumptions
The model no longer guesses the shape of your codebase — it consumes it.
What LogicStamp does (end to end)
- Zero-config CLI
- Static analysis via the TypeScript AST
- Deterministic, stable output
- Produces AI-ready context bundles
- MCP server exposes context to AI tools at runtime
No magic, no agents, no memory tricks — just structure and contracts.
Why deterministic context matters
When context is deterministic:
- results are reproducible
- workflows don’t drift
- CI pipelines can reason about structure
- AI becomes a consumer of systems, not a guesser of files
Even outside of AI, having a stable structural representation of a codebase turns out to be useful in surprising places.
Open source
The project is open source:
- CLI: https://github.com/LogicStamp/logicstamp-context
- MCP: https://github.com/LogicStamp/logicstamp-mcp
- Docs: https://logicstamp.dev
I’d love feedback - especially from people building devtools or working with AI-assisted workflows.
Top comments (0)