Skip to main content
The Nango AI builder generates production-ready functions using the IDE and model of your choice. You describe what you want to build, and the agent writes the TypeScript code, creates a test suite, validates it with a dry run, and iterates on any failures — all automatically. Unlike black-box integrations, the generated code is human-readable, version-controlled in your repository, and fully editable. You own the code.

​
Supported agents

The function builder works with 18+ AI frameworks as a Vercel skill, including:
  • Claude Code
  • Cursor
  • GitHub Copilot
  • Gemini CLI
  • Codex
  • OpenCode
  • Windsurf

​
Install the skill

Add the Nango function builder skill to your development environment: 
npx skills add NangoHQ/skills
This installs the nango-function-builder skill, which includes guidance for building both syncs and actions.
If your coding agent is already running, restart it after installing the skill so it picks up the new instructions.

​
Write a prompt

Tell your agent what you want to build. The more detail you provide, the better the initial output will be. Minimal prompt (action): 
I want to build a Nango action that will get specified Slack channel information.
Detailed prompt (action): 
I want to build a Nango action that will get Slack channel information.

Integration ID: slack
Connection ID: my-slack-connection
Inputs: channel_id
Outputs: id, name, is_private
API Reference: https://api.slack.com/methods/conversations.info
Detailed prompt (sync): 
I want to build a Nango sync that will store all Figma projects.

Integration ID: figma
Connection ID: my-figma-connection
Frequency: every hour
Inputs: team_id
Outputs: Project model with fields id, name, last_modified
API Reference: https://www.figma.com/developers/api#projects-endpoints
Include a link to the relevant API documentation whenever possible. The agent uses it to understand the exact endpoints, parameters, and response shapes.

​
What the agent does

Once you provide your prompt, the agent typically:
1

Generates the function code

Creates a complete action or sync implementation in your nango-integrations folder, including the function file and an updated index.ts import.
2

Creates a full test suite

Writes mock-based tests for your CI/CD pipeline, following patterns from hundreds of production Nango integrations.
3

Validates with a dry run

Runs nango dryrun against your connection to verify the function works against the real API.
4

Iterates on failures

Automatically debugs and fixes issues until the dry run passes. You end up with a fully tested, working function.

​
What gets generated

The agent produces two types of files: The function file — for example, slack/actions/get-channel.ts: 
import { createAction } from 'nango';
import * as z from 'zod';

export default createAction({
    description: 'Fetches information for a specified Slack channel',
    version: '1.0.0',
    input: z.object({
        channel_id: z.string()
    }),
    output: z.object({
        id: z.string(),
        name: z.string(),
        is_private: z.boolean()
    }),
    exec: async (nango) => {
        const { channel_id } = nango.input;

        const response = await nango.get({
            endpoint: '/conversations.info',
            params: { channel: channel_id }
        });

        const { channel } = response.data;
        return {
            id: channel.id,
            name: channel.name,
            is_private: channel.is_private
        };
    }
});
The index entry — index.ts: 
import './slack/actions/get-channel';

​
Reviewing and customizing

The generated code is yours to edit. Common customizations include:
  • Adjusting the output schema — add or remove fields from the Zod schema to match what your app needs
  • Adding error handling — throw nango.ActionError for domain-specific failures
  • Adding pagination — use nango.paginate() for endpoints that return paginated results
  • Adding checkpoints — for syncs fetching large datasets, add a checkpoint schema to save progress between runs

​
Deploying generated functions

Once you are satisfied with the generated code, deploy it to Nango: 
nango deploy dev
To deploy to production: 
nango deploy prod
Most teams automate deployment to production in their CI/CD pipeline by running nango deploy as part of their release process.

​
Also useful

Build docs developers (and LLMs) love

Get started for freeTalk to us