Detailed Analysis
A developer under the handle Samchon has released @ttsc/graph, a TypeScript-only code graph tool built directly on the TypeScript compiler, positioned as a direct challenge to existing "code graph" MCP (Model Context Protocol) servers used with Claude Code and similar coding agents. The core claim is provocative: popular code graph and code-search MCP tools, including ones like Serena, are not actually built on real compiler infrastructure and therefore cannot deliver accurate symbol resolution, call graphs, or type relationships. Instead, according to the author's benchmarking, these tools bloat context windows with oversized instructions (over 8,000 characters), expose dozens of overlapping tools (53 in one case), impose long prohibition lists (130 rules) restricting what the agent can do, and generate large indexes that consume tokens without delivering proportionate value. The author argues this actively degrades agent performance rather than assisting it — consuming more tokens while making the coding agent "stupid" and slower due to lengthy indexing times.
The technical distinction the author draws is between compiler-verified facts and heuristic or approximate indexing. @ttsc/graph is built directly atop the TypeScript compiler's own type-checking and resolution engine, meaning every symbol, call edge, signature, decorator, and test reference returned by the tool is guaranteed correct for the current on-disk source snapshot — it doesn't need to be re-verified by the agent through additional file reads. This is architecturally significant because it exposes a single MCP tool, inspect_typescript_graph, rather than dozens of overlapping tools, and it doesn't restrict or "castrate" the agent's own tool-calling behavior. The design intentionally distinguishes between compiler-resolved facts (which are always trustworthy) and ranked/heuristic operations like "tour" or "lookup" (where the graph selects a shortlist that the agent should judge for sufficiency before falling back to reading source directly). This nuance matters: it acknowledges the limits of automated retrieval while preserving trust in the parts of the system that are deterministic.
This development sits at the center of an increasingly important debate in the agentic coding ecosystem: how much structured context should be fed to LLM coding agents, and in what form. As tools like Claude Code, Cursor, and various MCP-based extensions proliferate, a cottage industry of "code graph," "codebase indexing," and "semantic search" tools has emerged, each claiming to give agents better situational awareness of large codebases without requiring them to read every file. However, this article's critique highlights a real tension: additional tooling and context injection can just as easily overwhelm an agent's limited context window and attention as it can help it, particularly when the underlying indexing is approximate (e.g., embedding-based or heuristic parsing) rather than grounded in a real compiler or type system. The heavy instruction sets and prohibition lists cited in the piece reflect a broader pattern where tool builders over-engineer guardrails to compensate for unreliable underlying data, ultimately making agents less autonomous and less efficient — the opposite of the intended effect.
For the Claude Code and Anthropic ecosystem specifically, this points to a maturing understanding among developers building on MCP: raw token efficiency and precision of returned data matter as much as feature breadth. Claude's agentic coding workflows depend heavily on tool outputs being both accurate and parsimonious, since verbose or noisy context degrades reasoning quality even when the underlying facts are technically available. The author's benchmark-driven approach — measuring token consumption and indexing time directly rather than relying on marketing claims — reflects a growing expectation that MCP tool authors substantiate performance claims empirically. The stated plan to extend this compiler-grounded methodology to other languages suggests an emerging pattern: rather than generic, language-agnostic semantic indexing layered on top of coding agents, the next generation of tools may increasingly be built per-language directly atop each language's own compiler or type-checker, trading broad applicability for verifiable correctness and minimal token overhead — a trade-off increasingly favored as agentic coding tools are deployed against larger, real-world production codebases.
Read original article →