AI coding assistants have changed how we write software. They generate components, explain APIs, write tests, and even review pull requests. But there's still one area where they regularly fail: knowing what's actually supported in browsers today.
Mozilla recently demonstrated this problem in a surprisingly direct way. While testing Claude Code on recently released Firefox features, they found that the model confidently claimed Firefox didn't support the Web Serial API—and that Mozilla wasn't even planning to implement it. There was just one problem: Firefox had already shipped it.
That's the story behind Mozilla's new MDN MCP Server, and why it might be one of the most important AI tools released for frontend developers this year.
When people talk about AI mistakes, they usually talk about hallucinations. But browser compatibility is a different problem. The issue isn't necessarily that the model is inventing information—it's that the web moves faster than training datasets.
Every few weeks browsers ship new APIs, new CSS features, new HTML capabilities, updated compatibility data, and new Baseline statuses. A model trained months ago may simply not know about those changes, and when it doesn't know, it often fills in the gaps with outdated information. The result is something that looks correct, until you check MDN.
Mozilla's team wanted to measure how well an AI coding assistant could answer questions about modern browser features, so they tested Claude Code Opus 4.7 on recently released Firefox 151 functionality, including:
light-dark()
support for images:buffering
pseudo-classshadowrootslotassignment
attributeThese are exactly the kinds of features that expose weaknesses in AI systems: they're new, they're niche, and they often weren't widely documented when the model was trained.
The most striking result involved the Web Serial API. When Mozilla asked about browser support, Claude Code confidently responded that Firefox did not support the API—and even more surprisingly, it claimed Mozilla had no plans to ever support it. The answer sounded authoritative. The problem? Firefox 151 had already shipped Web Serial support.
Not only was the information wrong, it was wrong in a way that many developers would probably trust. This is what makes browser compatibility such a difficult problem for AI: a response can be articulate, detailed, and completely disconnected from reality.
Imagine asking an AI:
Does Firefox support the Web Serial API?
Without access to current documentation, the model has only two options: remember information from training, or infer an answer. If the feature shipped after training—or wasn't prominent enough to appear frequently in training data—the answer can easily be outdated. And because language models are designed to produce coherent responses, they rarely say "I don't know." Instead, they produce an answer that sounds plausible. That's exactly what Mozilla observed.
To address this problem, Mozilla launched the MDN MCP Server. MCP stands for Model Context Protocol, an open standard that allows AI models to interact with external tools and data sources. Instead of relying entirely on memory, the model can retrieve information when it needs it.
Think of it as the difference between:
Developer → AI Memory → Answer
and:
Developer → AI → MDN → Answer
The answer is no longer constrained by what the model remembers—it can be grounded in current documentation.
The server exposes MDN resources in a format optimized for AI systems, including documentation search, full MDN documentation, and Browser Compatibility Data (BCD). Instead of scraping web pages and parsing HTML, an AI assistant can access structured information directly. And that's where things get interesting.
After enabling the MDN MCP Server, Mozilla repeated the evaluation and the difference was significant. Rather than relying on outdated knowledge, Claude Code could retrieve information directly from MDN and Browser Compatibility Data. As a result:
In other words, the model stopped guessing and started checking.
This was the part that surprised me most. Mozilla reported that responses generated with the MDN MCP Server enabled were roughly twice as fast. At first glance, that sounds backwards—shouldn't querying an external service make things slower?
Apparently not. Without MCP, the assistant often needed to search the web, open multiple pages, parse HTML, extract relevant information, and then synthesize a response. With MCP, documentation is already available through structured tools designed specifically for machine consumption. Less searching, less parsing, less guesswork—the result was both faster and more accurate answers.
This becomes useful almost immediately in day-to-day frontend work. With MCP enabled, you can ask questions that would previously have returned outdated answers:
Is the View Transitions API safe to use in production?
Using the latest MDN documentation, create a React hook
for the View Transitions API.
Using MDN compatibility data, explain whether
requestIdleCallback is safe to use in production.
Instead of relying entirely on training data, the assistant can validate its answer against current documentation before responding. That kind of real-time verification is a significant improvement for anyone building modern web applications.
Although Mozilla demonstrates the setup using Claude Code, the MDN MCP Server is not tied to a specific AI provider. It can be used with any MCP-compatible client, including:
As MCP becomes more widely adopted, access to authoritative documentation will likely become a standard feature rather than a nice-to-have.
To add the MDN MCP Server in Claude Code, run:
claude mcp add --transport http mdn https://mcp.mdn.mozilla.net/
The most important takeaway isn't that Mozilla launched another developer tool—it's that they exposed a fundamental limitation of modern AI systems. The Web Serial API example is fascinating because it demonstrates that an AI can be completely confident and completely wrong at the same time. The solution isn't necessarily a bigger model; it's better access to reliable information.
For years, we've treated AI as a replacement for documentation. Mozilla's experiment suggests something different: the future may be AI that reads the documentation with us.
For a long time, the safest workflow looked like this: ask the AI, open MDN, verify everything. Mozilla's MCP Server doesn't eliminate that responsibility, but it significantly reduces the distance between the answer and the source of truth. And if an AI can stop arguing with documentation that already exists, that's probably a good place to start.