Graphify C# Find Usages

What is it

Graphify C# Find Usages is a compiler-accurate "Find Usages" engine for C# codebases, purpose-built to feed AI coding agents better navigation context. In plain English: when an AI assistant like Claude Code or Cursor tries to answer "where is this method used?" or "what breaks if I change this signature?", it usually relies on fuzzy text search or an approximate language server. Graphify instead parses the actual C# compilation model — Roslyn's semantic graph — so every reference it returns is grounded in the real type system, not pattern matching.

The business significance is bigger than C#. AI coding agents are bottlenecked by context quality, not model IQ. A tool that hands agents a precise, machine-readable usage graph becomes infrastructure — an MCP server, VS Code extension, or CLI that every agent workflow depends on. That is a sticky, defensible position in a market where "AI writes code" is commoditizing fast but "AI understands your code" is still unsolved. Graphify is selling precision to the layer everyone else is guessing at.

Why now

Three forces converged in 2025-2026 to make this viable now rather than two years ago. First, Model Context Protocol (MCP) shipped and became the de facto standard for connecting tools to agents — Anthropic, OpenAI, and a growing ecosystem of IDEs now speak it. Before MCP, you had to build a bespoke integration per editor. Now one server reaches every agent.

Second, AI coding agents hit a wall on large codebases. Cursor, Windsurf, and Claude Code users report agents confidently editing the wrong call site because grep-based retrieval missed an overload or a dynamic dispatch. The demand for "compiler-accurate" retrieval is a direct reaction to real, repeated failure.

Third, Roslyn has matured into a stable, well-documented public API that any indie dev can build on without licensing friction. Microsoft's own tooling lags — Visual Studio's Find All References is editor-locked and not agent-accessible. That gap between a mature underlying API and an unmet agent-era need is exactly the window indie developers exploit. In 12-18 months, expect Microsoft or JetBrains to close it.

Market Evidence

The signal is early but clean: 2 independent sources (Hacker News and GitHub), 3 total mentions, 100% growth rate, stage marked "emergent," trend score 62/100. That combination — low absolute volume, high growth rate, dual-source confirmation — is the classic fingerprint of a pre-mainstream tool. It is not yet hype (hype shows up as 50+ mentions with flat growth), and it is not dead (dead shows one source, zero growth).

The HN thread (story_49667188) is the load-bearing signal. Developer tooling that gets organic HN discussion from a cold start usually reflects genuine practitioner pain, not marketing. The GitHub presence confirms someone shipped code, not just an idea. Three mentions is thin, so treat this as a "watch and validate" signal, not a "quit your job" signal.

The honest read: demand score of 55/100 says interest exists but is not yet urgent at scale. Market score of 68/100 is stronger, meaning the addressable buyers are real and reachable. This is a market where the first credible, well-marketed entrant can define the category before the noise arrives. Move now, but validate with 20 customer conversations before writing production code.

Who's Behind It

The driving force is the indie AI-tooling community clustered around MCP servers and Claude Code / Cursor extensions — the same crowd that produced early MCP hits like filesystem and GitHub servers. The GitHub repo behind Graphify is the primary artifact; the HN poster is likely a solo developer or a two-person team, not a funded startup.

The "whales" to watch are adjacent, not direct. Anthropic (MCP steward), Microsoft (owns Roslyn and VS Code), and Cursor/Anysphere (owns the agent UX) all have the power to absorb this feature. Below them sit established code-intelligence players — Sourcegraph, Snyk (via DeepCode lineage), and JetBrains — who already sell "understand your code" and could bolt on agent-facing usage graphs.

Competitive dynamics favor speed over capital here. No whale has shipped a dedicated, agent-first C# usage engine, because for Microsoft it is a feature and for Sourcegraph it is a niche inside a broad platform. That is the classic indie wedge: too small for the giant, too specialized for the generalist.

TAM & Market Size

The buyers are professional C#/.NET developers working in AI-assisted workflows. There are roughly 6-8 million .NET developers worldwide, with an estimated 25-35% now using AI coding assistants regularly — call it 1.5-2.5 million addressable users. Not all will pay for a usage-graph tool, but the ones on large enterprise codebases (banking, insurance, healthcare, game studios on Unity) have acute pain and real budgets.

Price tolerance: individual devs will pay $8-15/month for a tool that saves real debugging time. Teams will pay $20-40/seat/month. Enterprises with code-intelligence budgets already spend $30-50/seat on Sourcegraph-class tools and would slot an agent-navigation add-on into that line item.

Opportunity score of 58/100 and demand score of 55/100 tell you the market is real but not yet frothy — you are early, which is good for positioning and bad for immediate revenue. Realistic first-year serviceable market: 5,000-15,000 paying users if execution and distribution land well. The .NET enterprise segment is the profit center; the indie dev segment is the distribution and credibility engine.

Competitive Landscape

Direct competitors: essentially none dedicated to agent-facing C# usage graphs. The closest are Roslyn-based tools (OmniSharp, the C# Dev Kit) that power editors but do not expose a clean agent API, and general code-intelligence platforms (Sourcegraph, Snyk Code) that offer cross-language reference finding but are heavyweight, expensive, and not optimized for LLM consumption.

Indirect: grep-based retrieval inside Cursor, Windsurf, and Claude Code — free, ubiquitous, and wrong often enough to create your demand. Your differentiation is precision: semantic accuracy where text search fails (overloads, generics, partial classes, dynamic dispatch).

Competition score of 35/100 is low, which cuts both ways — little competition means little validation of willingness to pay. The real threat is absorption: Microsoft adding an MCP endpoint to C# Dev Kit, or Cursor shipping native Roslyn indexing. If Big Tech enters, you have roughly 6-12 months of head start. That window is enough to build brand, integrations, and a paying base — but only if you ship fast and go multi-language before they catch up.

Business Model

Recommended: freemium + team subscription, with an open-source core. Give the CLI and basic MCP server away free (drives adoption, stars, and the top of funnel). Charge for the VS Code extension's advanced features and for team/enterprise seats with private-repo indexing, audit logs, and SSO.

Why this fits: developer tools win through bottom-up adoption, and free OSS is the cheapest distribution channel in existence. The paid tier captures teams who need it in CI and across private repos.

Pricing:

• Free: CLI + MCP server, public repos, single workspace.
• Pro: $12/month or $99/year — VS Code extension, private repos, unlimited workspaces.
• Team: $29/seat/month — shared index, CI integration, SSO, priority support.
• Enterprise: custom, starting $15k/year — on-prem indexing, audit, SLA.

12-month forecast:

• Conservative: 3,000 free users, 300 Pro, 40 teams → ~$60k ARR.
• Base: 10,000 free, 1,200 Pro, 150 teams → ~$220k ARR.
• Optimistic: 30,000 free, 4,000 Pro, 500 teams → ~$700k ARR.

CAC estimate: $15-40 via content/SEO and OSS community (near-zero paid). Payback period: 2-4 months on Pro, under 2 months on team seats. The economics work because distribution is organic.

MVP Blueprint

Goal: a working, demoable tool in 2-7 days that proves the core value — compiler-accurate usages exposed to an AI agent.

Core features ONLY:

1. Roslyn-based usage finder: given a symbol (method, property, type), return all semantic references with file, line, and context.
2. MCP server wrapper: expose find_usages(symbol) and get_references(file, position) as MCP tools any agent can call.
3. CLI: graphify usages <symbol> --project <path> for scriptability and CI.
4. Single-repo indexing, no incremental updates, no cross-repo.

Cut everything else: no auth, no cloud, no team features, no multi-language, no UI beyond CLI output.

Tech stack: C# / .NET 8, Roslyn (Microsoft.CodeAnalysis), the official MCP C# SDK or a thin JSON-RPC server, packaged as a dotnet global tool. For the VS Code extension, wrap the CLI and register an MCP provider.

Fastest path to launch: build the Roslyn finder first (day 1-2), wrap it in MCP (day 3), add CLI ergonomics (day 4), record a 90-second demo showing Cursor/Claude Code correctly navigating a tricky C# codebase (day 5), publish to GitHub + HN (day 6-7). The demo is the product marketing. Ship the free OSS version to maximize stars and inbound.

Commercial Opportunities

1. Agent-navigation MCP server for .NET enterprises. Target: platform/DevEx teams at banks, insurers, and large SaaS firms running 1M+ line C# monorepos with AI assistants. Expected revenue: $3k-15k/month per enterprise. Why it beats alternatives: enterprises cannot use cloud-only tools for private code, so an on-prem, compiler-accurate MCP server is a must-have, not a nice-to-have.

2. VS Code / Cursor extension for individual .NET devs. Target: senior C# developers using AI assistants daily. Expected: $8k-25k/month at scale. Why it wins: lowest-friction distribution, direct proximity to where developers already work, natural upsell into team plans.

3. CI "impact analysis" service. Target: engineering managers who need to know what an AI-generated PR touches before merge. Expected: $5k-20k/month. Why it beats alternatives: converts a dev convenience into a governance/compliance product with a bigger budget owner.

Product Ideas

🥇 Graphify MCP Server — One-line value prop: "Compiler-accurate Find Usages for any AI coding agent, over MCP." Target user: C#/.NET developers on Cursor, Claude Code, Windsurf. Why now: MCP just standardized agent-tool connections, and no dedicated C# usage server exists — first mover defines the category.

🥈 Graphify VS Code Extension — One-line value prop: "See every real usage of your C# symbol, powered by Roslyn, built for AI workflows." Target user: individual .NET devs and small teams. Why now: VS Code is the dominant editor and the extension marketplace is a proven distribution and monetization channel.

🥉 Graphify CI Impact Bot — One-line value prop: "Know exactly which C# call sites an AI-generated PR affects, before you merge." Target user: engineering managers and platform teams in regulated .NET shops. Why now: AI-generated PRs are flooding review queues, and managers need automated, accurate impact analysis to keep quality gates meaningful.

SEO Opportunity

Search interest in "MCP server C#", "Roslyn find usages", and "AI code navigation" is rising from a small base — classic early-trend SEO. SEO difficulty is 30/100, which is low; you can rank with focused content.

Target long-tail keywords: "MCP server for C#", "Roslyn find all references API", "C# code navigation for AI agents", "Cursor C# find usages", "compiler-accurate code search .NET".

Content strategy tip: publish a technical deep-dive ("How Roslyn semantic search beats grep for AI agents") with benchmark numbers, plus a comparison post against text-search retrieval. Technical, evidence-heavy posts rank fast in dev-tool SEO and attract exactly the buyers you want.

Risk Assessment

The thesis breaks if AI agents get good enough at code navigation without external tools — plausible if frontier models gain native repo-graph understanding. It also breaks if Microsoft ships an MCP endpoint in C# Dev Kit, commoditizing your core.

Top 3 risks:

1. Tech: model-side improvements make external usage graphs redundant (medium probability, 18-36 month horizon).
2. Market: developers tolerate imprecise grep results and never pay for precision (medium-high; the free tier may be all anyone wants).
3. Execution: you build for C# only and get outflanked by a multi-language competitor (high if you stall).

Cheap validation: before writing production code, post the HN/GitHub demo and measure inbound requests for private-repo/enterprise support. Run 20 customer calls with senior .NET devs. If fewer than 5 say "I'd pay for this today," walk away. Set a hard 90-day checkpoint: if you have no paying users or LOIs by then, pivot to multi-language or exit.

Action Plan

Today: clone the repo, run the demo, and reproduce the core Roslyn usage query yourself. Confirm the claim holds on a real, messy codebase.

Low-cost validation (this week): publish a 90-second demo video and a short technical post, then DM 20 senior .NET developers using Cursor/Claude Code and ask one question: "How often does your AI agent edit the wrong call site?" Count the pain.

If signal confirms: build the MCP server + CLI MVP, open-source it, and launch on HN and r/csharp.

Timeline:

• Week 1: validate pain, ship OSS MVP, launch publicly.
• Month 1: 1,000+ stars, first 50 Pro signups, one design-partner enterprise.
• Month 3: 300+ paying users, $5k+ MRR, decision on multi-language expansion (TypeScript next).

Related Terms

Three connected trends: (1) MCP servers — the protocol layer that makes Graphify distributable to every agent; this is the distribution rail. (2) AI coding agents (Cursor, Claude Code, Windsurf) — the demand source; their accuracy problems are Graphify's reason to exist. (3) Roslyn-based code intelligence — the technical foundation; maturity here is what makes a 30-day build realistic. Together they form a tight, self-reinforcing loop: agents need context, MCP delivers it, Roslyn guarantees it is correct. Graphify sits exactly at the intersection.