I asked Claude to find all callers of a method in my solution. It read 14 files. 18,000 tokens. 12 seconds. And it still missed two.
The model isn’t the problem. The interface is.
AI assistants treat your <code>.cs</code> files like plain text. No type resolution, no cross-project awareness, no semantic understanding. Just grep-and-pray. Every non-trivial question on a real .NET solution triggers a file-reading spree that eats your context window alive.
<h2>What I did about it</h2>
I built RoslynLens, an open-source MCP server that exposes your .NET solution as structured, semantic queries powered by Roslyn.
Instead of reading files, your AI asks questions:
<pre><code>find_callers(&quot;IPaymentGateway.Charge&quot;) → 4 results, file + line, 85 tokens
find_implementations(&quot;IOrderRepository&quot;) → 3 classes, 60 tokens
detect_antipatterns(&quot;Checkout.*&quot;) → 5 issues, severity + fix, 180 tokens
</code></pre>
Same answers. 99% fewer tokens.
<h2>Two commands to get started</h2>
<pre><code>dotnet tool install --global RoslynLens
claude mcp add --scope user --transport stdio roslyn-lens -- roslyn-lens
</code></pre>
RoslynLens auto-discovers your <code>.sln</code> file and starts serving. No config, no setup.
<h2>What it unlocks</h2>
Navigation — find symbols, references, callers, overrides, dead code — across the entire solution, instantly.
Inspection — public API surface, type hierarchies, project dependency graph, compiler diagnostics — without opening a single file.
Analysis — cyclomatic and cognitive complexity, 18 anti-pattern detectors (async void, sync-over-async, hardcoded secrets…), AST-based duplicate detection.
Architecture (new in v1.3.0) — this is where it gets interesting. Four graph intelligence tools built on label-propagation over the full type-reference graph:
<ul>
<li><code>findgodnodes</code> — your coupling hotspots, statistically identified</li>
<li><code>get_communities</code> — is your “modular” monolith actually modular? Now you know</li>
<li><code>findsurprisingdependencies</code> — the cross-namespace edges that will bite you in refactoring</li>
<li><code>findisolatedsymbols</code> — types that reference nothing and are referenced by nothing</li>
</ul>
Ask Claude “which modules are too tightly coupled?” and it runs these tools in sequence. Actionable answer, ~600 tokens, no file reading.
<h2>The result</h2>
Your AI assistant stops guessing and starts reasoning. Architectural questions that used to require reading dozens of files now cost a fraction of a single one.
RoslynLens doesn’t make the model smarter. It stops it from working blind.
<hr>
GitHub: <a href="https://github.com/jfmeyers/roslyn-lens" target="_blank" rel="noopener nofollow">jfmeyers/roslyn-lens</a> - Apache-2.0
<a href="http://nuget.org" target="_blank" rel="noopener nofollow">nuget.org</a>: <a href="https://www.nuget.org/packages/RoslynLens/" target="_blank" rel="noopener nofollow">https://www.nuget.org/packages/RoslynLens/</a>
v1.3.0 — released today with graph intelligence tools.

All about .NET, C#, and ASP.NET Core. News, tutorials, articles, projects, and more. 

.NET

RoslynLens is an open-source MCP server that exposes .NET solutions as structured semantic queries powered by Roslyn, allowing AI assistants like Claude to answer code navigation and architecture questions without reading raw source files. Instead of consuming thousands of tokens scanning .cs files, the AI calls targeted tools like find_callers, find_implementations, and detect_antipatterns that return precise results at a fraction of the token cost. Version 1.3.0 adds graph intelligence tools for architectural analysis including coupling hotspot detection, module community detection, surprising dependency discovery, and isolated symbol identification. Setup requires two commands and no configuration.

Your AI Assistant Is Reading Your .NET Code Blind and Burning Your Tokens — Here's the Fix