The Categories Anthropic Didn’t Try to Eat
When a platform company ships a developer tool, the standard founder reaction is panic, and that is exactly what happened when Anthropic released Claude Code, then the MCP standard, then better and better models, with a wave of “are they going to eat us” posts following every release.
We wrote one of those posts ourselves in Will Claude Code Eat ByteBell?, and the short answer was that Claude Code is a consumer of code intelligence rather than a provider of it, but the longer answer is more interesting and it is what we want to lay out in this post.
Anthropic has been remarkably disciplined about what they build, because they shipped exactly the things a frontier model company should ship, which is a great model, a great agent that demonstrates what the model can do, and a protocol that lets the agent plug into everything else, and then they stopped. The categories they deliberately did not build are the categories the rest of the developer tools ecosystem now gets to occupy, and this post maps those categories not as a victory lap since Anthropic could change their mind about any of them tomorrow, but as a map of where to safely build.
What Anthropic Actually Shipped
Before we talk about what they didn’t build, it is worth being precise about what they did build, because the discipline of the list is part of the point. They shipped a frontier model family in Claude Opus, Sonnet, and Haiku, which is the part of the stack that is unambiguously their core competency and the one place where you would expect them to spend most of their engineering hours. They shipped Claude Code, which is a command line agent that demonstrates what the model can do when it is given tools, file access, and a real task, and it was released as a way to make the model’s coding ability visible rather than as a standalone developer tools play. They shipped MCP, the Model Context Protocol, which is a standard for how agents talk to external tools and data sources, and they released it open with no proprietary advantage for Anthropic baked into the protocol itself. And they shipped a consumer chat product through claude.ai, the desktop apps, and the mobile apps, which is the surface the average person uses.
That is the list. Everything else in the developer tools world that touches Claude, including IDE extensions, code indexers, copilots, review bots, agent platforms, and MCP servers, was left to other companies, and the pattern is consistent enough across 4 years of shipping that it has stopped looking accidental.
The 5 Categories Anthropic Didn’t Build
Category 1: Organisation wide code intelligence
The category in question is the persistent, pre computed graph that knows how all of an organisation’s repositories connect to each other, which service calls which API, which microservice handles refunds, and what will break if you change the user schema, and it is the category that ByteBell sits in.
What Anthropic did instead is build Claude Code to read files at runtime, which means every session starts from scratch and the agent will happily open 30 files in your repo to answer a question, but it does not remember between sessions and it has no model of repositories beyond the one you are currently inside. The reason they did not build it is that indexing is not a frontier model problem at all, since it is a data engineering problem involving crawlers, diff aware re indexing, graph storage, cross repo edge resolution, and deployment topology, and none of it makes the model smarter while all of it requires a different muscle from what Anthropic has been hiring for.
The companies that play in this category are Sourcegraph, which went enterprise only after their 2025 pivot with SCIP indexers per language, Augment Code, which is cloud hosted, raised 25M Series A, and ByteBell, which is the cross repo, on prem first version for the mid market that Sourcegraph abandoned when they discontinued Cody Free and Cody Pro in 2025.
The reason this category is structurally safe from Anthropic is that a frontier model company makes margin on tokens, while a code intelligence company makes margin on saved tokens by replacing brute force file reading with surgical graph queries, which means the business models are structurally opposed and Anthropic would have to cannibalise their own consumption in order to build it.
Category 2: The IDE itself
This is the actual editor surface where developers spend their day, including Cursor, Windsurf, Zed, JetBrains, and VS Code, and it is the most obvious category Anthropic could have entered and very visibly chose not to.
What Anthropic did instead was build Claude Code as a CLI tool, ship extensions for some editors, and leave the editor wars entirely to Microsoft, Cursor, and the open source community. The reason they did not build it is that editors are a winner take most consumer product with 20 years of muscle memory at stake, since Microsoft owns VS Code, JetBrains owns the professional Java and Python world, and Cursor and Windsurf are both venture funded and moving extremely fast, so Anthropic walking in to make a 13th editor in 2025 would have been a strategic error and they clearly knew it.
The companies playing here are Microsoft with VS Code, JetBrains across their entire suite, Cursor with about 3B, Zed which is the Rust native open source option, and a long tail of niche editors that serve specific languages or workflows. Even if Anthropic decided to ship an editor tomorrow, it would have to displace 20 years of incumbent muscle memory across millions of developers, which is a far less rational use of their engineering hours than just shipping MCP and letting every editor consume their model.
Category 3: The autocomplete and Tab layer
This is the ghost text that appears as you type, which is the bread and butter of GitHub Copilot, Cursor Tab, Codeium, and Tabnine, and it is fast, low latency, and suggests the next few tokens rather than running a multi step task.
Anthropic did essentially nothing in this category, because Claude is not optimised for sub 100ms autocomplete latency and Claude Code is designed for tasks rather than for keystrokes. The reason they did not build it is that autocomplete is a fundamentally different product from agentic coding, since it requires a small, fast, distilled model running on every keystroke, and the economics are brutal because autocomplete is a loss leader for Copilot that gets subsidised by Microsoft’s enterprise distribution, so Anthropic has no comparable distribution and no reason to commoditise their own frontier model into a 50 millisecond keystroke responder.
The companies playing here are GitHub Copilot, Cursor Tab, Codeium, Tabnine, Supermaven, and Continue, and the category is safe because a frontier model company that builds a flagship autocomplete ends up competing against its own pricing, since Copilot at $10/month only works because Microsoft eats the margin to lock in GitHub users, and Anthropic does not have GitHub.
Category 4: Code review and PR analysis
This is the category of bots that read your pull requests, find bugs, surface architectural concerns, flag breaking changes, and post comments on your code, and it includes Greptile, CodeRabbit, Qodo, and Bito.
Claude Code can review code if you ask it to, but Anthropic has not shipped a bot, a GitHub App, a PR analyser, or any product positioned specifically as a review tool, and the category is left wide open. The reason they did not build it is that code review is a workflow product rather than a model product, since it needs deep GitHub, GitLab, and Bitbucket integrations, PR webhooks, comment threading, suppression rules, team by team configuration, and most importantly a sales motion to engineering leaders who already buy review tooling separately, and none of this looks like what Anthropic puts on a roadmap.
The companies playing here are Greptile at a $180M valuation, CodeRabbit, Qodo which was formerly known as CodiumAI, Bito, and increasingly internal home grown bots that engineering teams are building on top of Claude or GPT for themselves. The category is safe because the buyer is an engineering manager rather than an individual developer, the product is a workflow integration rather than an AI capability, and the defensibility lives in GitHub App distribution and noise suppression heuristics rather than in the model itself.
Category 5: The symbolic editing and refactoring layer
This is the category of IDE grade operations that a senior engineer takes for granted, including atomic rename across a codebase, moving a symbol between files, finding every reference, inlining a function, and extracting a method, and it is powered by the Language Server Protocol or by JetBrains’s own analyser depending on the editor.
Claude Code edits code by reading files, generating diffs, and writing them back, which is genuinely impressive but does not speak LSP and does not perform atomic, semantics aware refactoring, so it can do what a careful human with a text editor can do but it cannot do what a senior engineer with PyCharm can do in 2 clicks. The reason Anthropic did not build it is that LSP integration is per language plumbing, with 40 plus languages each having their own quirks, server installation, type system, and refactoring semantics, and it is an engineering tax that scales linearly with language coverage while earning no model improvement at the end of all that work.
The main player here is Serena, which has 24.2K stars on GitHub and is the heavyweight in this category, along with Aider’s tool use layer and the IDEs themselves through their built in refactoring, and none of these are Anthropic. The category is safe because atomic refactoring is an editor problem that belongs next to the editor rather than next to the model, and Anthropic is perfectly happy to let Serena or any other MCP compatible refactor tool slot into Claude Code’s tool list rather than build it themselves.
The Pattern
When you look at the 5 categories together a clear logic emerges, which is that Anthropic is building the model and the protocol while letting everything else be built by other people who can plug into the protocol, and this is exactly the same play that AWS made with EC2 when they shipped the primitive and let an ecosystem of databases, monitoring tools, deployment platforms, and ORMs grow on top, the same play Stripe made with the payments API when they shipped the primitive and let billing, invoicing, fraud detection, and analytics get built by others, and the same play Twilio made with SMS.
The reason it works is the same in every one of those cases, which is that a horizontal primitive earns more margin than a vertical product if you can resist the temptation to compete with your own ecosystem, and Anthropic has been disciplined about exactly that temptation so far, since MCP is open, Claude Code is intentionally minimal, and the model is sold as an API to anyone who wants to build on it including people who build products that compete with Claude Code itself.
What This Means for Anyone Building Underneath
If you are building a developer tools company that touches Claude, the question is not whether Anthropic will eat you but whether you are building in a category that Anthropic has structurally chosen not to enter, and the good categories where you can build for years without looking over your shoulder share 4 properties.
The first property is that the category requires infrastructure that does not make the model smarter, including indexers, graph databases, GitHub integrations, and LSP servers, since Anthropic’s roadmap is intelligence rather than infrastructure and they are simply not going to spend engineering hours on the parts that do not move the model forward. The second property is that the category has a different buyer than Anthropic’s API customers, since engineering managers, security teams, platform engineering groups, and devops leaders are not the same buyer as the individual developer with a Claude subscription, and the sales motion required to reach them is one Anthropic has shown no interest in building. The third property is that the category has an integration moat, which could be GitHub Apps, MCP server registries, IDE extension marketplaces, or CI/CD pipelines, and these are distribution channels Anthropic does not own and cannot easily acquire. The fourth property is that the category has a data sovereignty story, including on prem deployment, air gapped operation, and BYOK support, since Anthropic is a SaaS company by design and they cannot beat you on the claim that your code never leaves your servers.
ByteBell sits in the intersection of all 4 of these properties, and so does Serena in a different way, and so do Greptile and CodeRabbit, and so do the various MCP server companies that have emerged across 2025 and 2026. The categories that are not safe and where Anthropic could land on you tomorrow are the ones that look like Claude Code with a different colour scheme, because a general purpose coding agent that competes head on with Claude Code is squarely in the line of fire while a vertical product underneath it is not.
The Honest Caveats
Anthropic could change their mind about any of this, since they have the model, the brand, the distribution, and enough capital to enter any of these categories if they decide it is worth their time, and the history of platform companies is full of “they will never build this” announcements that aged badly, with Slack’s reaction to Microsoft Teams and Dropbox’s reaction to iCloud being the canonical examples that every founder should keep in mind.
So this is not a guarantee, it is an observation about revealed strategy, and as of mid 2026 Anthropic has shown about 4 years of consistent discipline about where they build and where they stop. The smart move is not to assume that discipline lasts forever but to use the window of time that the discipline gives you to build something deep enough that even if Anthropic eventually enters the category, the switching cost keeps you alive long enough to find the next moat. Move fast, build deep integrations, get distribution, and make your data asset richer than they can replicate, because that is what every successful platform adjacent company has done from Snowflake adjacent to AWS, to Datadog adjacent to the cloud providers, to MongoDB adjacent to the operating systems underneath it.
Closing Thought
The framing of “is Anthropic going to eat me” assumes Anthropic is a monolithic platform company expanding in every direction, but they are not, since they are a frontier model company with 1 excellent demo product and a deliberately open protocol, and the categories around them are not battlegrounds so much as they are invitations.
The 5 categories above, which are organisation wide code intelligence, the IDE, autocomplete, code review, and symbolic refactoring, are 5 real businesses that Anthropic has consciously chosen not to be in, and some of them will end up as billion dollar standalone companies while some will get acquired and some will fail, but none of them will fail because Anthropic ate them, because Anthropic was never trying to eat them in the first place.
We built ByteBell in the first of those 5 categories and the other 4 are wide open too, so if you are thinking about where to build, look at what the platform shipped, look at what they deliberately did not ship, and build in the gap, because the gap is much bigger than most people think.