Adeel Ali March 25, 2026

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.

Further brainstorming with Nathaniel turned into 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.

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

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:

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:

  1. 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.
  2. 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.
  3. 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.
  4. 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. 
  5. 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.

Key Resources: