Introducing the Nango API integrations builder skill

Skills have taken the developer world by storm, and we are no exception.

Today, we are excited to officially launch our skill for coding agents to build product integrations.

The skill combines guidance on using Nango with general best practices for building customer-facing API integrations.

Over the last few weeks, we used this skill internally to build 200+ API integrations autonomously with OpenCode. This has given us plenty of reps to discover and fix edge cases, so the skill performs well across a wide range of tasks and APIs.

Here is a quick demo of Claude Code building a simple Gmail tool call with Sonnet 4.6 in less than 90 seconds:

How to use this skill

Using the skill is straightforward:

1. Install the Nango CLI and create a nango-integrations folder with nango init
2. Install the skill: npx skills add NangoHQ/skills
3. Prompt your agent:

Build a Nango action for Gmail that fetches the last 5 emails
from the email address I pass in as a parameter.
It should fetch subject, timestamp, and plaintext body of the emails.

Use the connection id `899c28c0-cbe3-4197-9f8c-2a3700a53d9a` from
the `google-mail` integration in the `dev` environment to test.
Test with the sender email `suraj@pointer.io`
  

That’s it: The agent will autonomously research the API, write the requested action or sync, test it with the test credentials, and iterate until it works.

Once the integration works, our skill also instructs the agent to write unit tests for the integration, with the help of our CLI: The Nango CLI includes a command that automatically records responses from the external API and turns them into test fixtures.

More detailed instructions are available on our docs.

How we built the skill

You can explore all our skills on GitHub: https://github.com/NangoHQ/skills

When we started building this project a few weeks ago, we weren’t sure how much context the skill would have to provide.

As it turns out, a lot.

Today, the skill covers:

• Meta instructions: When to use the skill, etc.
• Integration building instructions: Steps, decision trees, preconditions
• Checklists for different parts of the process: User inputs, API research, integration building
• Information about the Nango project structure & SDK
• References: Technical references on Nango docs with more details
• Common integration patterns (code snippets & examples)
• CLI usage examples

The analogy of “skills are expertise for LLMs” rings true: With this added context, the coding agent behaves very similarly to an engineer who has built dozens of API integrations on Nango.

And in a way, this is true: We built the skill by letting OpenCode autonomously build ~200 API integrations across five different APIs.

Every time it got something wrong, we analyzed the issue, improved the skill, and reran the generation. This forced us to encode issues in general, transferable rules in the skills file, rather than whack-a-mole fixes for individual integrations.

Skills parts & assembly pipeline

As the skill grew, it became progressively harder to keep an overview of all the different parts and how they fit together.

Templates to the rescue: Instead of a single monolithic file, we split the skill into 16 parts. Each part covers a small, atomic aspect of the process. An assembly step takes these parts and builds the final skill.

Besides a better editing experience, this also allows us to share snippets between different skills. While we haven’t used this much yet, we expect this to be very useful as we grow the number of specialized skills available.

What’s next

We continuously improve the API integrations builder skill as we build more integrations with AI on Nango. You can expect daily updates!

For now, we are focused on testing the skill with more APIs and use-cases to ensure it works well for a wide range of integrations.

We are also exploring API-specific skills or instructions that encode quirks, best practices, undocumented behaviours, or other API-specific issues.

We would love to hear your feedback and are excited to keep pushing AI-assisted integration building in the coming weeks!