Netlify Serverless and Edge Functions Agent Skills: A Complete Guide

Netlify serverless and edge functions agent skills enable AI agents to automatically generate, deploy, and manage serverless and edge compute code on the Netlify platform.

The VoltAgent/awesome-agent-skills repository catalogs two primary Netlify-focused agent skills that streamline edge and serverless development. These skills—netlify/netlify-functions and netlify/netlify-edge-functions—provide templates, metadata, and deployment automation that allow AI agents to scaffold handlers, wire up routing, and push code to production without manual boilerplate.

Netlify Serverless Functions Skill

The netlify/netlify-functions skill targets classic Netlify Serverless Functions—Node.js (or Go, Rust) handlers that execute on demand in managed AWS Lambda containers behind Netlify's CDN.

Architectural Details

• Deployment path: Individual files under netlify/functions/ (or netlify/functions/*.js)
• Runtime: Managed AWS Lambda environment with auto-scaling per request volume
• Handler signature: Receives event and context objects containing request metadata
• Performance: Cold-start latency typically under 100ms

Key Capabilities

• Async handlers for background task processing
• Access to Netlify secrets, environment variables, and built-in request metadata
• Automatic request routing based on file path structure

Serverless Function Example

// File: netlify/functions/hello.ts
import type { Handler } from '@netlify/functions';

export const handler: Handler = async (event, context) => {
  // Access query string: ?name=John
  const name = event.queryStringParameters?.name ?? 'World';
  return {
    statusCode: 200,
    body: JSON.stringify({ message: `Hello, ${name}!` }),
    headers: {
      'Content-Type': 'application/json',
    },
  };
};

The skill automatically supplies the correct Handler type, default export structure, and parameter access patterns.

Netlify Edge Functions Skill

The netlify/netlify-edge-functions skill targets Edge Functions—ultra-low-latency JavaScript/TypeScript code that executes on Netlify's edge nodes using V8 isolates, before the origin request is made.

Architectural Details

• Deployment path: Files under netlify/edge-functions/ (or netlify/edge-functions/*.js)
• Runtime: Cloudflare-compatible V8 isolate workers at the CDN edge
• Execution timing: Runs at the edge node, intercepting requests before they reach origin
• Performance: No cold-start penalty; sub-50ms response times with warm functions

Key Capabilities

• request object for accessing incoming request details
• params for route parameters
• geo object for geolocation-based personalization (country, region)
• cookies for reading/writing cookies at the edge

Runtime Limitations

• Subset of Node APIs only (no filesystem access, limited timers)
• Lightweight runtime designed for edge execution

Edge Function Example

// File: netlify/edge-functions/geo-greet.ts
import { NetlifyEdge } from '@netlify/edge-functions';

export default async (request: Request, context: NetlifyEdge) => {
  const { country, region } = context.geo; // Geolocation data from the edge
  const greeting = country === 'US' ? 'Howdy' : 'Hello';
  return new Response(`${greeting} from ${region || country}!`);
};

The skill provides the NetlifyEdge context object and demonstrates geolocation-based personalization patterns.

Agent-Driven Workflow Integration

Netlify serverless and edge functions agent skills integrate into automated development workflows through a four-stage process:

1. Skill Invocation

AI agents (Claude Code, Gemini CLI, OpenCode) select the appropriate Netlify skill based on developer intent. For example, "create an API endpoint for a contact form" triggers the netlify-functions skill.

2. Prompt-to-Code Generation

The skill contains templates and metadata that instruct the agent to:

• Scaffold the function file at the correct path
• Inject required imports (@netlify/functions or @netlify/edge-functions)
• Wire up the correct handler signature (Handler type or NetlifyEdge context)

3. Deployment Automation

After generation, the skill can trigger Netlify CLI commands:

netlify deploy --prod

This handles environment variable sync, preview branch creation, and production deployment.

4. Runtime Execution

Netlify's platform automatically invokes the generated code based on routing rules in netlify.toml, with no additional configuration required.

Composed Skill Example

User: "Add a Netlify serverless function that stores a contact form submission in Netlify Blob storage."

Agent (using netlify-functions skill):
  - Generates `netlify/functions/contact.ts` with a handler that parses JSON body
  - Calls `netlify/blobs` skill to upload the payload
  - Updates netlify.toml to expose `/api/contact` route
  - Runs `netlify deploy --prod`

This demonstrates skill composition—combining multiple Netlify skills (functions + blobs) in a single automated workflow.

Repository Structure and References

The Awesome Agent Skills repository references these skills in its documentation:

File	Purpose	Location
README.md – Netlify section	Lists all Netlify-related Agent Skills	README.md#skills-by-netlify-team
LICENSE	Open-source license for the collection	LICENSE
CONTRIBUTING.md	Guidelines for adding new Netlify skills	CONTRIBUTING.md

The actual skill implementations reside in the external officialskills.sh registry; the Awesome Agent Skills repository serves as a curated index.

Summary

• Two core skills power Netlify agent workflows: netlify-functions for serverless Lambda containers and netlify-edge-functions for V8 isolate edge execution.
• Serverless functions deploy to netlify/functions/, run in AWS Lambda, handle async tasks, and auto-scale with ~100ms cold starts.
• Edge functions deploy to netlify/edge-functions/, execute on V8 isolates at the CDN edge, provide geolocation/personalization data, and deliver sub-50ms responses with no cold starts.
• Agent workflow covers four stages: skill invocation, prompt-to-code generation, deployment automation via Netlify CLI, and runtime execution through netlify.toml routing.
• Skill composition enables agents to combine multiple Netlify capabilities (functions + blobs + more) in unified automated workflows.

Frequently Asked Questions

What is the difference between Netlify serverless functions and edge functions?

Netlify serverless functions run in managed AWS Lambda containers behind the CDN, handling on-demand compute with full Node.js API access and typical cold-start latencies around 100ms. Edge functions execute on V8 isolates directly at CDN edge nodes, run before the origin request, offer geolocation and cookie access for personalization, and deliver sub-50ms responses with no cold-start penalty—but with limited Node.js API availability.

Where do I place serverless and edge function files in a Netlify project?

Serverless functions belong in netlify/functions/ (or netlify/functions/*.js), while edge functions go in netlify/edge-functions/ (or netlify/edge-functions/*.js). The Netlify platform automatically detects and deploys files in these directories, with routing rules configurable in netlify.toml for custom path mappings.

How do agent skills automate Netlify function deployment?

The netlify-functions and netlify-edge-functions agent skills provide templates and metadata that instruct AI agents to scaffold correct file structures, inject proper imports and handler signatures, and optionally trigger netlify deploy CLI commands. This automation eliminates manual boilerplate for handler configuration, environment variable setup, and production deployment.

Can I combine Netlify skills with other capabilities in agent workflows?

Yes, agent skills compose together. A single workflow can invoke netlify-functions to generate an API endpoint, netlify/blobs to handle storage, and netlify core skills to manage deployment—all coordinated through the agent's skill selection and execution logic.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}