If you haven’t come across MCP before - it stands for Model Context Protocol, a new open standard that allows AI assistants and IDEs to fetch live, structured information from external sources like documentation, APIs, or SDKs. In simple terms, an MCP server makes your docs “readable” to AI - so instead of developers browsing a page, their IDE or AI assistant can query your documentation directly and return precise, context-rich answers.
Developers can ask a question and get an up-to-date, context-rich answer without ever leaving their editor.
Clicks are disappearing. Search is becoming invisible.
The developer’s learning journey has gone from reading books → browsing tutorials → asking communities → chatting with LLMs → and now, simply coding with intelligence built into their IDE.
The last two shifts - the rise of LLMs and the move toward in-IDE intelligence - have completely changed where and how developers access information. Instead of visiting documentation pages, developers now rely on AI assistants embedded in their workflow. These assistants fetch and summarize content automatically, often without the developer ever opening a browser. As a result, documentation is still being used, but increasingly consumed by machines, not humans.
This shift is already showing up in the data.
Decline in Traditional Documentation Usage
Over the last two years, we’ve looked at how developers are using documentation across more than 150 developer-first companies. The trend is clear - developers are visiting documentation sites less and less.
There’s been a steady drop in unique visitors and pageviews, even for fast-growing products. The fall is most visible on API reference pages, where dwell time has gone down sharply. At the same time, we’re seeing an increase in direct traffic coming from bots and AI agents - not humans. This traffic often originates from automated crawlers, LLMs, or integrations that fetch documentation content to index it for contextual use elsewhere.
Why is this happening?
As developer workflows become increasingly AI-assisted, documentation is no longer browsed - it’s queried. AI assistants index documentation into vector stores and serve responses contextually through chat interfaces, code assistants, and IDE extensions. Developers are getting answers inline, often before they ever open a browser.
This shift fundamentally breaks how documentation performance has traditionally been measured. Metrics like pageviews, bounce rate, or time-on-page were designed for a browser-first world. In an AI-mediated, IDE-native environment, they no longer reflect real usage or value
It’s already hurting real teams
This shift isn’t just showing up in analytics dashboards - it’s starting to materially impact developer-first businesses.
A recent public comment from a well-known open-source framework maintainer captures this reality starkly. Despite the framework growing faster than ever, documentation traffic has dropped sharply as developers increasingly rely on AI assistants instead of visiting docs directly. In his words, documentation traffic was down ~40% compared to early 2023 - and revenue tied to that discovery funnel had fallen even more dramatically.
The painful irony is clear:
The product is more popular than ever, but the traditional signals that sustained the business are disappearing.
This is the blind spot modern developer teams are now grappling with:
usage is happening, value is being delivered - but visibility is collapsing.
When documentation metrics break, so do the business models built on top of them.
The New Frontier for Developer Marketing & Product Insights
What teams really need now is a way to understand developer intent - what someone is actually trying to do, not just where they went. It’s about context: why a query was made, what problem a developer is facing, and how the documentation or product can help right then and there. Analytics needs to evolve from counting visits to capturing intent.
And when you start looking at intent, a new set of opportunities opens up. You can spot friction points by identifying repeated or similar queries - for example, if there are multiple searches for “auth refresh token timeout”, it usually means developers are struggling with authentication. Frequent searches for “rate limit exceeded” might signal unexpected API constraints that need better handling or documentation.
You can also measure documentation effectiveness in a more meaningful way - not by how many people viewed a page, but by whether their query got resolved. You can spot emerging developer intents early, often before they turn into support tickets or feature requests. You can see what use cases developers are trying to build, based on the sequence and nature of their questions. And you can pinpoint pain points developers face while integrating, testing, or debugging - insights that traditional page-level analytics could never reveal.
In the IDE-native world, understanding intent becomes the new form of analytics - one that finally reflects what developers are actually trying to achieve, not just what they clicked on.
Introducing the Reo.Dev MCP Intent Gateway
As developer learning moves inside the IDE, companies need a way to bridge what’s happening in those environments with their documentation and product insights. That’s where the Reo.Dev MCP Intent Gateway comes in.
At its core, the Reo.Dev MCP Intent Gateway acts as a front-facing layer for all MCP content servers. It exposes a branded endpoint (for example, docs.company.com/mcp-server) and processes every incoming query passing through it. Each query is logged and enriched with metadata - such as IP, IDE type, region, and detected intent - creating a structured view of how developers are interacting with your documentation through AI tools and IDE assistants.
The value of this gateway extends across teams:
- For Product teams, it surfaces what developers are trying to build, the problems they’re running into, and which features drive the most questions.
- For Engineering teams, it provides visibility into friction points and repeated troubleshooting patterns that can inform better developer experience design.
- For GTM teams, it transforms technical engagement data into meaningful buying signals - helping identify in-market accounts, usage trends, and expansion opportunities.
And because developer trust is non-negotiable, privacy and security are built into every layer of the gateway. We understand how important it is to handle data responsibly, so we make sure every query is encrypted, anonymized, and processed safely. The gateway never stores personal or sensitive information and fully respects your existing authentication and permission settings.In short - it captures intent while staying fully compliant with privacy and security best practices.
The Reo MCP Intent Gateway turns previously invisible developer interactions into actionable, trustworthy insights - connecting documentation, developer intent, and go-to-market outcomes through a secure, privacy-first foundation.
Ecosystem Momentum
The shift toward MCP-based documentation and developer experience is picking up pace fast. What started as an experiment by a few forward-thinking companies is quickly becoming an industry-wide movement - where documentation, SDKs, and tutorials are no longer just read by developers, but also consumed by AI tools inside the IDE.
Redpanda is a great example. The company now provides a dedicated MCP server for its documentation, allowing developers to access setup guides, configuration examples, and troubleshooting help directly from within their IDE or AI assistant. They’ve even extended it to operations - letting AI agents interact with Redpanda Cloud resources (like listing topics or creating clusters) securely through the MCP interface.
Platforms like Mintlify and Kapa.ai are driving this forward from the documentation side. Both now support MCP endpoints, which means companies using them can make their docs instantly available to AI assistants - no extra setup required. GitBook has also begun rolling out similar capabilities, enabling hosted documentation to be fetched contextually through IDE-based AI tools.
Even beyond documentation platforms, tools like Netlify and LangGraph are experimenting with MCP servers for hosted content and APIs - a sign that this shift is expanding beyond documentation into the broader developer ecosystem.
The trend is clear: soon, every major DevTool company will expose MCP endpoints for their docs, SDKs, and tutorials, making documentation not just searchable - but queryable, contextual, and alive inside the developer’s workflow.
The Future of Developer Experience
The way developers learn and discover information is being completely redefined. Documentation is no longer just static content - it’s turning into a real-time knowledge service that lives wherever developers work. Instead of reading through long pages, developers will interact with docs dynamically through their IDEs or AI assistants, asking questions and getting instant, contextual answers.
The IDE is becoming the new browser for developer learning. Every coding environment is evolving into a smart, connected workspace - one that can access documentation, SDKs, and examples directly through protocols like MCP. The “click-and-search” era is giving way to “type-and-understand,” where developers never have to leave their workflow to find what they need.
As this shift happens, analytics will also evolve. Metrics like pageviews or time-on-page will give way to intent signals - insights about what developers are trying to build, what’s confusing them, and how effectively the documentation resolves those moments. Understanding why a question was asked will matter far more than tracking where it came from.
And in this new loop of knowledge exchange, gateway layers like Reo.Dev will become critical infrastructure. They’ll serve as the connective tissue between content providers, AI models, and developer environments - ensuring that information flows securely, contextually, and insightfully across the ecosystem.
The future of developer experience is interactive, intelligent, and intent-driven - where learning happens in real time, right inside the code.
