At PayPal DevDay 2025, Nathaniel Olson shared a problem that felt uncomfortably familiar: AI coding assistants were confidently integrating APIs from outdated documentation. Not because the official docs and SDKs were missing. Because the AI was never grounded in them.
That observation landed hard. Because once you see it, you start noticing it everywhere. Further brainstorming with Nathaniel brought up a product idea, then a pilot, and now a launch: API Context Plugins.
The problem with AI-assisted API integration
Whenever I see an AI coding demo, I find myself asking the same question: is this another impressive proof of concept, or something a serious company could actually use in production?
That distinction matters. For enterprise teams, AI-generated code is only useful if it is secure, reliable, and grounded in reality. No serious team wants to ship an integration where:
- 50% of the code came from deprecated API documentation
- authentication is implemented using the wrong SDK version
- the payment flow calls an endpoint that does not even exist
And yet this happens more often than many teams would like to admit. Not because AI cannot write code, but because AI is often missing the one thing API integration depends on: reliable, version-aware API context.
Why AI gets API integrations wrong
Most coding assistants are trained on public code and documentation, much of which is incomplete, outdated, or disconnected from the version a developer is actually using. That becomes especially problematic with APIs.
In an ever-expanding API ecosystem, asking AI to guess how to integrate them inevitably leads to mistakes
There are millions of APIs in the ecosystem. Their documentation changes. SDKs evolve. Authentication models differ. Recommended integration workflows can be highly specific. So when an AI assistant tries to integrate an API using model memory alone, or by scraping public docs on the fly, mistakes are almost inevitable.
The result is predictable: developers spend more time reviewing and correcting AI output than they should, which undermines both trust and productivity. That is why the bottleneck is no longer code generation. The real bottleneck is reliable API context.
How API Context Plugins Solve This?
Now imagine a different approach, where an API came with deterministic, version-aware context for AI, grounded in
- OpenAPI definitions
- current SDK versions
- idiomatic code samples
- recommended integration workflows.
These are the guardrails needed by production AI to bring maturity and stability, and that's exactly what we are introducing with APIMatic Context Plugins.
They package the most important API artifacts, SDKs, code samples, docs, and integration guidance, into a format that modern coding assistants can consume directly. Instead of asking an AI assistant to guess how your API works, you give it the context it needs to integrate your API correctly. That changes the role of the API portal. It is no longer just a destination for human developers. It becomes a context engine for AI-assisted development.
Using OpenAPI as Context, and Why It Is Not Enough on Its Own
If you are wondering, why didn't we simply use OpenAPI spec as the context? The answer is: OpenAPI is the right place to start. In fact, it is the foundation of what we are building with Context Plugins.
A well-designed OpenAPI definition gives structure to an API. It describes endpoints, parameters, request and response schemas, authentication models, and the formal contract between an API provider and its consumers. That makes it extremely valuable as a machine-readable source of truth.
But there is an important difference between describing an API and helping an AI assistant implement it correctly. That difference becomes clear when you compare two approaches:
- giving the coding assistant only OpenAPI and API reference material as context
- giving it an API Context Plugin built from OpenAPI plus richer implementation artifacts
The table below summarizes that difference across five steps of an AI-assisted integration workflow:
| Step | OpenAPI / API Reference Only | API Context Plugin |
|---|---|---|
| 1. User Query | Generic query path; heavier reliance on LLM interpretation → more failure modes | Specialized tools constrain LLM behavior → more reliable intent handling |
| 2. Knowledge Source | Generic retrieval from API index; raw specs (schemas, params, endpoints); developer must translate into code manually | Task-aware tool selection; multi-source context (SDKs, typed schemas, workflows); SDKs effectively bridge API → implementation |
| 3. Response Returned to IDE Agent | Descriptive, interpretation-heavy responses; LLM must infer implementation details | Actionable, code-ready responses; leverages LLM strengths (adaptation of concrete examples) |
| 4. Code Generation | Partial implementation; generic HTTP boilerplate; manual auth; no SDK patterns; weak error handling; no real-world examples | Complete implementation; type-safe SDK code; SDK-handled auth; correct initialization; robust error handling; real-world patterns included |
| 5. Developer Rework | Significant manual effort; research usage patterns; debug auth/API issues; iterate repeatedly | Minimal rework; near production-ready output; faster path to working integration |
How Context Plugins Work
It's a one-click installation that changes how API context reaches developers in their AI-assisted IDEs. Watch how a developer goes from documentation to working integration in under 2 minutes:
Case study: Updating Payment Methods in Legacy Code
The PayPal conversation was not just an interesting idea. We put it into practice to evaluate Context Plugins beyond simple demos. We ran experiments (watch this video) on two well-established .NET applications:
- nopCommerce, a mature ASP.NET Core e-commerce platform
- eShop, Microsoft's .NET microservices reference application.
These were not toy projects. They involved working inside real application structures and executing non-trivial integration and migration tasks, exactly the kind of work where AI often struggles because correctness depends on context. We compared AI-assisted development with and without Context Plugins. Across the benchmark experiments, we observed:
In the eShop migration scenario, the Context Plugin-assisted implementation also produced cleaner architecture and better maintainability than the non-plugin approach. Detailed case study can be found here: https://www.apimatic.io/product/context-plugins/case-study
More Use Cases
In addition to the above case study, here are a few examples to see API context plugin in action. You can give them a try by copy pasting the given prompts in your favourite coding assistant:
- A storefront & instant checkout with Adyen: A lightweight storefront that lets you create products in seconds and instantly generate Adyen Payment Link-backed checkout pages, complete with responsive product detail views, hosted payment pages, and a real-time dashboard of orders and payment status.
- Food Roulette: Find a nearby restaurant via Google Maps: This app allows the user to provide their location on the map and picks a random restaurant within a specific radius of user's location. The app shows photos from Google Places and the user gets the option to see the directions or spin again.
- Music DNA card generator with Spotify: A personalized Music DNA card generator that analyzes your Spotify listening history to reveal your audio personality, top genres, radar chart of audio features, and hidden gem artists — all in one shareable card.
- Slack activity heat-map: A real-time Slack workspace analytics app that scans channels, analyzes message activity, identifies top contributors, and delivers rich reports — both as a Block Kit message posted to Slack and as an interactive Chart.js dashboard in your browser.
- Birthday Buzz with Twilio: BirthdayBuzz is a web application that manages contacts and automatically sends personalized "Happy Birthday" SMS messages using the Twilio API. It is built with an APIMatic-generated TypeScript SDK for seamless Twilio integration.
Why this Matters for Mainstream Developers (Not Just "Vibe Coders")
It's easy to assume Context Plugins are mainly for experimental or greenfield work. That's not where the real value is. The hardest integrations happen when developers are working in an existing production codebase, following established architectural patterns, integrating with multiple internal services, and operating under strict correctness and compliance requirements. An obstacle for AI-generated code is identified as it degrades under complexity.
"AI struggles with complex, multi-step tasks that require holding many moving pieces in mind simultaneously. Reliability degrades as complexity increases, either through larger steps or larger artifacts. Small errors accumulate, and quality drops when working with large codebases or long documents"
— Augmented Coding Patterns, Lada Kessler
Conclusions & Resources
AI can generate code, but code generation is no longer the hardest problem. The real problem is making sure that code is reliable enough for production.
That requires guardrails. It requires determinism. It requires context grounded in the actual API, the current SDKs, and the intended workflows. That is the role of APIMatic Context Plugins. They bring the maturity, stability, and control needed to make AI-assisted API integration practical, not just impressive.
Top comments (0)