feat: Add public Netlify skills for AI coding agents

CLAUDE.md

@@ -0,0 +1,18 @@
+# Netlify Context and Tools
+
+This repository contains public Netlify skills — factual platform reference for AI agents working with Netlify projects.
+
+## Repository Structure
+
+- `context/` — Steering guides (e.g., POWER.md for Kiro deployments)
+- `skills/` — Netlify platform skills for Claude Code and other AI agents
+
+## Skills
+
+The `skills/` directory contains 11 skills covering Netlify platform primitives. See `skills/CLAUDE.md` for a guide on when to use each skill.
+
+## Contributing
+
+Skills should be factual and platform-focused — not opinionated about frameworks, ORMs, or workflow preferences. They help any agent work correctly with Netlify primitives.
+
+Each skill follows the standard SKILL.md format with YAML frontmatter (`name` and `description`). Keep SKILL.md files under 500 lines. Use `references/` subdirectories for detailed content.

README.md

@@ -0,0 +1,60 @@
+# Netlify Context and Tools
+
+Public Netlify skills for AI coding agents. Each skill is a focused, factual reference for a Netlify platform primitive — designed to help agents build correctly on Netlify without needing to search docs.
+
+## Skills
+
+| Skill | What it covers |
+|---|---|
+| [netlify-functions](skills/netlify-functions/SKILL.md) | Serverless functions — modern syntax, routing, background/scheduled/streaming |
+| [netlify-edge-functions](skills/netlify-edge-functions/SKILL.md) | Edge compute — Deno runtime, middleware, geolocation |
+| [netlify-blobs](skills/netlify-blobs/SKILL.md) | Object storage — key-value and binary data |
+| [netlify-db](skills/netlify-db/SKILL.md) | Managed Postgres (Neon) with Drizzle ORM and migrations |
+| [netlify-image-cdn](skills/netlify-image-cdn/SKILL.md) | Image transformation and optimization via CDN |
+| [netlify-forms](skills/netlify-forms/SKILL.md) | HTML form handling, AJAX submissions, spam filtering |
+| [netlify-config](skills/netlify-config/SKILL.md) | `netlify.toml` — redirects, headers, build settings, deploy contexts |
+| [netlify-cli-and-deploy](skills/netlify-cli-and-deploy/SKILL.md) | CLI commands, Git vs manual deploys, environment variables |
+| [netlify-frameworks](skills/netlify-frameworks/SKILL.md) | Framework adapters for Vite, Astro, TanStack, and Next.js |
+| [netlify-caching](skills/netlify-caching/SKILL.md) | CDN cache control, cache tags, purge, stale-while-revalidate |
+| [netlify-ai-gateway](skills/netlify-ai-gateway/SKILL.md) | AI Gateway proxy for OpenAI, Anthropic, and Google SDKs |
+
+### References
+
+Some skills include `references/` subdirectories with deeper content:
+
+- [User-uploaded images pipeline](skills/netlify-image-cdn/references/user-uploads.md) — composing Functions + Blobs + Image CDN
+- [Vite on Netlify](skills/netlify-frameworks/references/vite.md)
+- [Astro on Netlify](skills/netlify-frameworks/references/astro.md)
+- [TanStack Start on Netlify](skills/netlify-frameworks/references/tanstack.md)
+- [Next.js on Netlify](skills/netlify-frameworks/references/nextjs.md)
+
+## Usage
+
+### Claude Code
+
+Add this repo as a skill source in your project's `CLAUDE.md`:
+
+```
+Read skills from https://github.com/netlify/context-and-tools/tree/main/skills
+```
+
+Or clone the repo and reference the skills directory locally.
+
+The `skills/CLAUDE.md` file acts as a router — it tells agents which skill to read based on what they're trying to do.
+
+### Other AI agents
+
+Each `SKILL.md` file is a self-contained reference with YAML frontmatter (`name` and `description`) and markdown body. Feed them into any agent's context as needed.
+
+## Design Principles
+
+- **Factual, not opinionated** — platform behavior and API reference, not workflow preferences
+- **Composable** — skills cover individual primitives; agents combine them as needed
+- **Concise** — each SKILL.md stays under 500 lines; detailed content goes in `references/`
+- **Current** — covers modern Netlify patterns (v2 functions, Vite plugin, AI Gateway)
+
+## Contributing
+
+Keep skills focused on Netlify platform primitives. Each skill should answer "how does this Netlify feature work?" rather than "how should I structure my project?"
+
+Follow the existing format: YAML frontmatter with `name` and `description`, markdown body, code examples with TypeScript where applicable. Use `references/` subdirectories for content that would push a SKILL.md past 500 lines.

skills/CLAUDE.md

@@ -0,0 +1,45 @@
+# Netlify Skills
+
+This project deploys on Netlify. Use these skills for guidance on Netlify platform primitives. Each skill provides specific, factual reference for working with a Netlify feature.
+
+## When to Use Each Skill
+
+**Building API endpoints or server-side logic?**
+Read `netlify-functions/SKILL.md` for modern function syntax, routing, background/scheduled functions.
+
+**Need low-latency middleware, geo-based logic, or request manipulation?**
+Read `netlify-edge-functions/SKILL.md` for edge compute patterns.
+
+**Storing files, images, or simple key-value data?**
+Read `netlify-blobs/SKILL.md` for object storage API.
+
+**Need a relational database?**
+Read `netlify-db/SKILL.md` for Neon Postgres setup, Drizzle ORM, and migrations. It also covers when Blobs is a better fit.
+
+**Optimizing or transforming images?**
+Read `netlify-image-cdn/SKILL.md` for the image transformation endpoint and clean URL patterns. For user-uploaded images, see `netlify-image-cdn/references/user-uploads.md`.
+
+**Adding HTML forms?**
+Read `netlify-forms/SKILL.md` for form detection, AJAX submissions, spam filtering, and file uploads.
+
+**Configuring netlify.toml (redirects, headers, build settings)?**
+Read `netlify-config/SKILL.md` for the complete configuration reference.
+
+**Deploying, managing env vars, or running local dev?**
+Read `netlify-cli-and-deploy/SKILL.md` for CLI commands, Git vs manual deploys, and environment variable management.
+
+**Setting up a framework (Vite, Astro, TanStack, Next.js)?**
+Read `netlify-frameworks/SKILL.md` for adapter/plugin setup. Framework-specific details are in `netlify-frameworks/references/`.
+
+**Controlling CDN caching behavior?**
+Read `netlify-caching/SKILL.md` for cache headers, stale-while-revalidate, cache tags, and purge.
+
+**Adding AI capabilities?**
+Read `netlify-ai-gateway/SKILL.md` for AI Gateway setup with OpenAI, Anthropic, or Google SDKs.
+
+## General Rules
+
+- Use `Netlify.env.get("VAR")` for environment variables in functions (not `process.env`)
+- Never hardcode secrets — use Netlify environment variables
+- Add `.netlify` to `.gitignore`
+- For framework-specific patterns, check the framework reference before writing custom Netlify Functions — the adapter may handle it

skills/netlify-ai-gateway/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: netlify-ai-gateway
+description: Guide for using Netlify AI Gateway to access AI models. Use when adding AI capabilities (text generation, image generation, embeddings) to a Netlify project. Covers supported providers (OpenAI, Anthropic, Google), SDK configuration via base URL override, environment variables, and usage from Netlify Functions.
+---
+
+# Netlify AI Gateway
+
+Netlify AI Gateway provides access to AI models from multiple providers without managing API keys directly. It is available on all Netlify sites.
+
+## How It Works
+
+The AI Gateway acts as a proxy — you use standard provider SDKs (OpenAI, Anthropic, Google) but point them at Netlify's gateway URL instead of the provider's API. Netlify handles authentication, rate limiting, and monitoring.
+
+## Setup
+
+1. Enable AI on your site in the Netlify UI
+2. The environment variable `OPENAI_BASE_URL` is set automatically by Netlify
+3. Install the provider SDK you want to use
+
+No provider API keys are needed — Netlify's gateway handles authentication.
+
+## Using OpenAI SDK
+
+```bash
+npm install openai
+```
+
+```typescript
+import OpenAI from "openai";
+
+const openai = new OpenAI();
+// OPENAI_BASE_URL is auto-configured — no API key or base URL needed
+
+const completion = await openai.chat.completions.create({
+  model: "gpt-4o-mini",
+  messages: [{ role: "user", content: "Hello!" }],
+});
+```
+
+## Using Anthropic SDK
+
+```bash
+npm install @anthropic-ai/sdk
+```
+
+```typescript
+import Anthropic from "@anthropic-ai/sdk";
+
+const client = new Anthropic({
+  baseURL: Netlify.env.get("ANTHROPIC_BASE_URL"),
+});
+
+const message = await client.messages.create({
+  model: "claude-sonnet-4-5-20250929",
+  max_tokens: 1024,
+  messages: [{ role: "user", content: "Hello!" }],
+});
+```
+
+## Using Google AI SDK
+
+```bash
+npm install @google/generative-ai
+```
+
+```typescript
+import { GoogleGenerativeAI } from "@google/generative-ai";
+
+const genAI = new GoogleGenerativeAI("placeholder");
+// Configure base URL via environment variable
+
+const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
+const result = await model.generateContent("Hello!");
+```
+
+## In a Netlify Function
+
+```typescript
+import type { Config, Context } from "@netlify/functions";
+import OpenAI from "openai";
+
+export default async (req: Request, context: Context) => {
+  const { prompt } = await req.json();
+  const openai = new OpenAI();
+
+  const completion = await openai.chat.completions.create({
+    model: "gpt-4o-mini",
+    messages: [{ role: "user", content: prompt }],
+  });
+
+  return Response.json({
+    response: completion.choices[0].message.content,
+  });
+};
+
+export const config: Config = {
+  path: "/api/ai",
+  method: "POST",
+};
+```
+
+## Environment Variables
+
+| Variable | Provider | Set by |
+|---|---|---|
+| `OPENAI_BASE_URL` | OpenAI | Netlify (automatic) |
+| `ANTHROPIC_BASE_URL` | Anthropic | Netlify (automatic) |
+
+These are configured automatically when AI is enabled on the site. No manual setup required.
+
+## Local Development
+
+With `@netlify/vite-plugin` or `netlify dev`, gateway environment variables are injected automatically. The AI Gateway is accessible during local development after the site has been deployed at least once.
+
+## Available Models
+
+The gateway supports models from OpenAI, Anthropic, and Google. Use standard model identifiers (e.g., `gpt-4o-mini`, `claude-sonnet-4-5-20250929`, `gemini-2.5-flash`). Available models may change — refer to Netlify's AI Gateway documentation for the current list.

skills/netlify-blobs/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: netlify-blobs
+description: Guide for using Netlify Blobs object storage. Use when storing files, images, documents, or simple key-value data without a full database. Covers getStore(), CRUD operations, metadata, listing, deploy-scoped vs site-scoped stores, and local development.
+---
+
+# Netlify Blobs
+
+Netlify Blobs is zero-config object storage available from any Netlify compute (functions, edge functions, framework server routes). No provisioning required.
+
+```bash
+npm install @netlify/blobs
+```
+
+## Getting a Store
+
+```typescript
+import { getStore } from "@netlify/blobs";
+
+const store = getStore({ name: "my-store" });
+
+// Use "strong" consistency when you need immediate reads after writes
+const store = getStore({ name: "my-store", consistency: "strong" });
+```
+
+## CRUD Operations
+
+These are the **only** store methods. Do not invent others.
+
+### Create / Update
+
+```typescript
+// String or binary data
+await store.set("key", "value");
+await store.set("key", fileBuffer);
+
+// With metadata
+await store.set("key", data, {
+  metadata: { contentType: "image/png", uploadedAt: new Date().toISOString() },
+});
+
+// JSON data
+await store.setJSON("key", { name: "Example", count: 42 });
+```
+
+### Read
+
+```typescript
+// Text (default)
+const text = await store.get("key");                    // string | null
+
+// Typed retrieval
+const json = await store.get("key", { type: "json" });  // object | null
+const stream = await store.get("key", { type: "stream" });
+const blob = await store.get("key", { type: "blob" });
+const buffer = await store.get("key", { type: "arrayBuffer" });
+
+// With metadata
+const result = await store.getWithMetadata("key");
+// { data: any, etag: string, metadata: object } | null
+
+// Metadata only (no data download)
+const meta = await store.getMetadata("key");
+// { etag: string, metadata: object } | null
+```
+
+### Delete
+
+```typescript
+await store.delete("key");
+```
+
+### List
+
+```typescript
+const { blobs } = await store.list();
+// blobs: [{ etag: string, key: string }, ...]
+
+// Filter by prefix
+const { blobs } = await store.list({ prefix: "uploads/" });
+```
+
+## Store Types
+
+- **Site-scoped** (`getStore()`): Persist across all deploys. Use for most cases.
+- **Deploy-scoped** (`getDeployStore()`): Tied to a specific deploy lifecycle.
+
+## Limits
+
+| Limit | Value |
+|---|---|
+| Max object size | 5 GB |
+| Store name max length | 64 bytes |
+| Key max length | 600 bytes |
+
+## Local Development
+
+Local dev uses a sandboxed store (separate from production). For Vite-based projects, install `@netlify/vite-plugin` to enable local Blobs access. Otherwise, use `netlify dev`.
+
+**Common error**: "The environment has not been configured to use Netlify Blobs" — install `@netlify/vite-plugin` or run via `netlify dev`.