Official agent skill

Neon Postgres Branches

by neondatabase in neondatabase/agent-skills

Choose and create the right Neon branch type for testing and development.

OfficialApache-2.0Auto-check: notesDevOps & Cloud

Install Neon Postgres Branches

skills CLI
$ npx skills add neondatabase/agent-skills --skill neon-postgres-branches -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install neondatabase/agent-skills neon-postgres-branches --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/neondatabase/agent-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/neon-postgres-branches .claude/skills/neon-postgres-branches && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
neon-postgres-branches
GitHub stars
100
Token cost
~3.4k tokens
SKILL.md length
1,485 words
Files
1
Skills in repo
8
Repo updated
First seen
Licence
Apache-2.0

At a glance

Choose and create the right Neon branch type for testing and development.

  • Works in 2 steps: If the user wants to test complex… → If the user needs to avoid copying…
  • Users ask about Neon branching
  • SKILL.md covers Branch Type Decision, Tool Selection: CLI or MCP, Create a Normal Branch… and Create a Schema-Only Branch…, plus 7 more sections
  • Calls npm

What it does

Neon Postgres Branches is an agent skill from neondatabase/agent-skills, published by the product's own GitHub organization. Choose and create the right Neon branch type for testing and development. Use when users ask about Neon branching, migration testing with real data, isolated test environments, schema-only branch workflows for sensitive data, resetting a branch from its parent, branch expiration and CI/CD branch lifecycles, or branch creation via Neon CLI or Neon MCP. Triggers include "Neon branch", "test migrations safely", "branch production data", "schema-only branch", "reset branch", "branch per PR" and "sensitive data…

Its SKILL.md is about 3.4k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in DevOps & Cloud, covering MCP servers and CI/CD. It works with Neon and Model Context Protocol. The repository describes itself as: Agent Skills for Neon Severless Postgres. The licence is Apache-2.0.

When your agent uses it

  • Users ask about Neon branching
  • Migration testing with real data
  • Isolated test environments
  • Schema-only branch workflows for sensitive data

Example prompts

  • “Neon branch”
  • “test migrations safely”
  • “branch production data”
  • “/neon-postgres-branches”

Requirements

  • Node.js

Workflow steps

2 steps, taken from the first numbered list in SKILL.md.

  1. If the user wants to test complex migrations, performance, or behavior against production-like data, choose a normal branch.
  2. If the user needs to avoid copying sensitive data, choose a schema-only branch.

What it can do on your machine

Read from SKILL.md and the folder at commit bfd013c. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • npm

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • neon.com
    • github.com
    • console.neon.tech

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Neon Postgres Branches loads about 3.4k tokens when it runs. Until then it costs about 136 tokens; SKILL.md has 1,485 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~136
When it runs · the whole SKILL.md, loaded when a task matches
~3.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NoteMentions a .env fileSKILL.md:206
    - Ask: "Do you want me to update your `.env` `DATABASE_URL` to this new branch connection string?"

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from neondatabase/agent-skills at commit bfd013c, republished under its Apache-2.0 licence (© neondatabase). 1,485 words, ~3,412 tokens.

Download SKILL.mdSave it as .claude/skills/neon-postgres-branches/SKILL.md (or your agent's skills folder).
name
neon-postgres-branches
description
Choose and create the right Neon branch type for testing and development. Use when users ask about Neon branching, migration testing with real data, isolated test environments, schema-only branch workflows for sensitive data, resetting a branch from its parent, branch expiration and CI/CD branch lifecycles, or branch creation via Neon CLI or Neon MCP. Triggers include "Neon branch", "test migrations safely", "branch production data", "schema-only branch", "reset branch", "branch per PR" and "sensitive data testing".
metadata.parent
neon
metadata.source
https://github.com/neondatabase/agent-skills/tree/main/skills/neon-postgres-branches

FIRST: Use the parent neon skill for a Neon overview, getting started with Neon, Neon development best practices, and more.

If the neon skill is not installed, fetch it from https://neon.com/docs/ai/skills/neon/SKILL.md or install it with:

bash
neon skills -s neon -y

Lakebase Postgres Branching

Outcome: a created Neon branch — or a clear, actionable next step if creation cannot proceed. Choose the correct branch type, then execute branch creation with the CLI (or MCP where the CLI isn't usable).

  • Normal branch for realistic migration and query testing with real data.
  • Schema-only branch (Beta) for sensitive data workflows where structure is needed without copying rows.

Branch Type Decision

Use this decision rule first:

  1. If the user wants to test complex migrations, performance, or behavior against production-like data, choose a normal branch.
  2. If the user needs to avoid copying sensitive data, choose a schema-only branch.

If the request is ambiguous, ask one clarifying question: "Do you need realistic data for testing, or only schema structure because the data is sensitive?"

Tool Selection: CLI or MCP

Support both the Neon CLI and the Neon MCP server, but default to the CLI. Use MCP only when the CLI is unavailable or blocked in your environment, cannot be authenticated, or the user explicitly asks for MCP.

Selection order
  1. Check the CLI first:
    • Run neon --version to confirm the CLI is installed.
    • Run neon projects list to confirm auth/context.
  2. If the CLI is missing, direct installation via quickstart.
  3. If the CLI is installed but not authenticated, guide the user through neon auth (or API key auth), then continue.
  4. Switch to MCP when the CLI cannot be used — no CLI access in the environment, execution blocked, or authentication not possible — or when the user explicitly asks for MCP. Confirm Neon MCP tools are available and authenticated (for example, listing projects works), then follow the MCP branch flow below.
  5. If neither path is successful, use the Neon REST API:
MCP branch flow
  1. Choose normal vs schema-only based on data sensitivity and migration-testing goals.
  2. Use branch tools (for example, create_branch) to create the branch.
  3. Validate with read tools (for example, describe_branch).
  4. For migration workflows, prefer branch-based migration flows before applying to main.

Create a Normal Branch (Preferred for Real-Data Migration Testing)

Use this when the user needs realistic testing conditions. Real production-like data can expose edge cases your seed or data migration scripts miss, which helps catch migration issues before going live.

Link: https://neon.com/docs/introduction/branching.md

Steps
  1. Settle the tool path first (see Selection order): verify the CLI with neon --version, and fall back to MCP only if the CLI isn't usable.

  2. Ensure project context is set (neon set-context --project-id <your-project-id>) or include --project-id on commands.

  3. Create the branch:

    bash
    neon branches create \
      --name <branch-name> \
      --parent <parent-branch-id-or-name> \
      --expires-at 2026-12-15T18:02:16Z
  4. Optionally fetch a connection string for the new branch:

    bash
    neon connection-string <branch-name>

Create a Schema-Only Branch (Beta, Sensitive Data)

Use this when users must not copy production rows into the test branch.

Link: https://neon.com/docs/guides/branching-schema-only.md

Steps
  1. Settle the tool path first (see Selection order): verify the CLI with neon --version, and fall back to MCP only if the CLI isn't usable.

  2. Create the schema-only branch:

    bash
    neon branches create \
      --name <schema-only-branch-name> \
      --parent <parent-branch-id-or-name> \
      --schema-only \
      --expires-at 2026-12-15T18:02:16Z

    If multiple projects exist, include --project-id:

    bash
    neon branches create \
      --name <schema-only-branch-name> \
      --parent <parent-branch-id-or-name> \
      --schema-only \
      --project-id <your-project-id> \
      --expires-at 2026-12-15T18:02:16Z
Beta Support Guidance (Mandatory)

Schema-only branching is in Beta. If users report unexpected behavior, errors, or missing capabilities:

  1. Ask them to share feedback in the Neon Console:
  2. Recommend opening a support conversation in the Neon Discord:

Reset from Parent

Use this when a child branch has drifted and the user wants a clean refresh from the parent branch's latest schema and data.

Link: https://neon.com/docs/guides/reset-from-parent.md

What it does
  • Fully replaces the child branch schema and data with the parent's latest state.
  • Does not merge; local changes on the child branch are lost.
  • Keeps the same connection details, but active connections are briefly interrupted during reset.
When to recommend it
  • Development or staging branch is too far behind production.
  • User wants to start a new feature from a clean parent-aligned state.
  • Team wants to refresh staging from production for consistent testing baselines.
Hard constraints and blockers
  • Only child branches can be reset (root branches and schema-only root branches cannot be reset from parent).
  • If the target branch has children, reset is blocked until those child branches are removed.
  • After a parent branch is restored from snapshot, reset-from-parent may be unavailable for up to 24 hours.
  • Reset-from-parent always uses the current parent state; use Instant restore for point-in-time recovery needs.
CLI usage
bash
neon branches reset <id|name> --parent --preserve-under-name <backup-branch-name>

If project context is not already set, include the project ID:

bash
neon branches reset <id|name> --parent --preserve-under-name <backup-branch-name> --project-id <project-id>

--preserve-under-name keeps the pre-reset state as a backup branch for rollback, but adds one extra branch to clean up later.

Optional context setup to avoid repeating --project-id:

bash
neon set-context --project-id <project-id>
Console and API usage
  • Console: Open the target child branch, then select Reset from parent from Actions.
  • API: Use the restore endpoint for the branch and set source_branch_id to the parent branch ID.

Notes and Caveats

  • Schema-only branches are for structure-only cloning and sensitive/compliant data controls.
  • Schema-only branches are independent root branches (no parent branch and no shared history), so reset-from-parent does not apply.
  • For migration testing that depends on real-world row shapes, volumes, and edge cases, prefer normal branches.
  • Root branch allowances and per-branch storage limits can cap how many schema-only branches users can create.
  • If a user is unsure, default recommendation is:
    • Normal branch for migration validation.
    • Schema-only branch for compliance and privacy constraints.
Show full SKILL.md (586 more words)Show less

Useful Workflow Patterns

If the user asks for process recommendations (not just a single command), suggest these:

  • One branch per PR: Create branch when PR opens, delete when merged/closed, keep migration tests isolated.
  • One branch per test run: Create branch at pipeline start, run migrations/tests, delete at end for deterministic CI.
  • One branch per developer: Isolated dev environments with production-like shape; avoid team collisions on shared test data.
  • PII-aware branching: If production has sensitive data, derive dev/PR branches from an anonymized branch or use schema-only branches.
  • Ephemeral lifecycle hygiene: Set branch expiration and automate cleanup so old branches do not accumulate avoidable storage/history cost.
Post-creation environment update prompt

After branch creation, ask whether the user wants to update local environment credentials to point at the new branch.

  • Ask: "Do you want me to update your .env DATABASE_URL to this new branch connection string?"
  • If yes, write the new branch connection string to the requested env file/key.
  • If no, leave credentials unchanged and share the connection string for manual use.
  • Never overwrite an existing env key without explicit confirmation.

Neon Infrastructure as Code (neon.ts)

Beyond creating branches imperatively (CLI / MCP / API above), you can program what configuration new branches receive declaratively in neon.ts — Neon's infrastructure-as-code file (see the neon skill for the full reference). The branch property is a function of the branch being evaluated that returns its settings, so every branch born from your project gets a consistent lifecycle and compute profile without per-branch flags.

bash
npm i @neon/config
typescript
// neon.ts
import { defineConfig } from "@neon/config/v1";

export default defineConfig({
  branch: (branch) => {
    if (branch.exists) return {}; // never reconcile existing branches
    if (branch.isDefault) return { protected: true };
    if (branch.name.startsWith("preview/") || branch.name.startsWith("dev")) {
      return {
        parent: "main",
        ttl: "7d", // ephemeral: auto-expire 7 days after creation (max 30d)
        postgres: {
          computeSettings: {
            autoscalingLimitMinCu: 0.25, // scale to zero
            autoscalingLimitMaxCu: 1, // keep throwaway branches cheap
            suspendTimeout: "5m",
          },
        },
      };
    }
    return {};
  },
});

The closure receives a read-only descriptor of the target branch — name, exists, isDefault, parentId, and more — and returns the tuning to apply: parent, ttl (auto-expiry), protected, and postgres.computeSettings. This is the declarative complement to the Ephemeral lifecycle hygiene and per-PR / per-test patterns above: instead of remembering --expires-at on every neon branches create, the TTL and compute profile live in version control and apply to every matching branch.

Because neon checkout applies this policy when it creates a branch, a fresh preview/* or dev-* branch comes up already expiring and scaled-to-zero. Checking out an existing branch doesn't reconcile it — run neon deploy (alias for neon config apply) to apply changes to a branch that already exists.

Branching in CI/CD

Common CI/CD use cases for Neon branches:

  • Per-PR preview deployments: Branch on PR open, deploy the preview against it, delete on close. Each PR gets an isolated database branch. Injecting the branch's DATABASE_URL into the deployed app is hosting-provider-specific — see preview-branches-with-cloudflare, preview-branches-with-vercel, or preview-branches-with-fly for tested patterns.
  • Migration testing in CI: Run risky schema changes against a branch with production-like data before merge.
  • Schema diff visibility: Use the schema-diff GitHub Action to auto-comment a DB-layer diff on the PR.

Examples

Example 1: Migration testing with realistic data

User input: "I need to test a risky migration against production-like data."

Agent output shape:

  1. Recommend a normal branch and explain why.
  2. Share docs link: https://neon.com/docs/introduction/branching
  3. Check the tool path first (CLI with neon --version; MCP only if the CLI isn't usable).
  4. Provide commands:
    • neon branches create --name migration-test --parent main --expires-at 2026-12-15T18:02:16Z
    • neon connection-string migration-test
Example 2: Sensitive data development workflow

User input: "We cannot copy production data because of compliance."

Agent output shape:

  1. Recommend schema-only branch and explain why.
  2. Share docs link: https://neon.com/docs/guides/branching-schema-only
  3. Check the tool path first (CLI with neon --version; MCP only if the CLI isn't usable).
  4. Provide command:
    • neon branches create --name compliance-dev --parent main --schema-only --project-id <your-project-id> --expires-at 2026-12-15T18:02:16Z
  5. Mention Beta support path:

Further Reading

© neondatabase, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/neon-postgres-branches of neondatabase/agent-skills.

Open the folder on GitHubat commit bfd013c

Compare with similar skills

Neon Postgres Branches next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Neon Postgres Branches compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Neon Postgres Branches this skillneondatabase/agent-skills100—~3.4kAutomated safety check: NotesApache-2.0
Publishingadeze/raindrop-mcp188—~398Automated safety check: PassMIT
Frontmcp Deploymentagentfront/frontmcp146—~9.2kAutomated safety check: NotesApache-2.0
Cloudbase CLITencentCloudBase/CloudBase-AI-Toolkit1.1k1 repos~1.7kAutomated safety check: PassMIT
Docs Tooling Notionlangchain-ai/docs425—~1.7kAutomated safety check: PassMIT
Engineering Advanced Skillsalirezarezvani/claude-skills28k—~1.1kAutomated safety check: PassMIT

Similar skills

  • Publishing

    adeze/raindrop-mcp

    Publishing and release workflow with semantic-release and GitHub Actions

    188 GitHub stars~398 tokensUpdated 2 mo ago
    DevOps & CloudAuto-check passed
  • Frontmcp Deployment

    agentfront/frontmcp

    A skill your agent uses when deploying, building for production, packaging, or shipping a FrontMCP server.

    146 GitHub stars~9.2k tokensUpdated yesterday
    DevOps & CloudAuto-check: notes
  • Cloudbase CLI

    TencentCloudBase/CloudBase-AI-Toolkit

    CloudBase CLI (tcb, 云开发CLI, Tencent CloudBase命令行) resource management skill.

    1.1k GitHub starsUsed in 1 repo~1.7k tokens
    DatabasesAuto-check passed
  • Docs Tooling Notion

    langchain-ai/docs

    Official

    Document new or changed docs-team tooling on the Notion tooling pages.

    425 GitHub stars~1.7k tokensUpdated today
    DevOps & CloudAuto-check passed
  • Engineering Advanced Skills

    alirezarezvani/claude-skills

    Index of 37 advanced engineering agent skills for Claude Code, Codex, Gemini CLI, Cursor, OpenClaw.

    28k GitHub stars~1.1k tokensUpdated 1 mo ago
    DevOps & CloudAuto-check passed
  • Claude Docs Consultant

    centminmod/my-claude-code-setup

    Consult official Claude Code documentation from code.claude.com using selective fetching.

    2.7k GitHub stars~959 tokensUpdated today
    Agent WorkflowsAuto-check passed

More from neondatabase/agent-skills

All 8 skills in this repo
  • Neon Auth

    neondatabase/agent-skills

    Official

    Add authentication to a new app. An agent skill from neondatabase/agent-skills.

    100 GitHub stars~3.1k tokensUpdated yesterday
    Auto-check passed
  • Neon Postgres

    neondatabase/agent-skills

    Official

    Guides and best practices for working with Lakebase Postgres on Neon: connections, pooled vs direct, schema migrations, branching, autoscaling, scale-to-zero, instant restore, read replicas, IP…

    100 GitHub stars~4.1k tokensUpdated yesterday
    Auto-check: notes
  • Neon

    neondatabase/agent-skills

    Official

    Overview of Neon, a complete set of cloud backend primitives around Lakebase Postgres: Auth, Object Storage, Functions, and the AI Gateway.

    100 GitHub stars~8.7k tokensUpdated yesterday
    Auto-check: notes
  • Neon AI Gateway

    neondatabase/agent-skills

    Official

    One API and one credential for frontier and open-source LLMs, built into your Neon branch and powered by Databricks.

    100 GitHub stars~5.1k tokensUpdated yesterday
    Auto-check: notes
  • Neon Functions

    neondatabase/agent-skills

    Official

    Long-running, serverless Node.js HTTP functions deployed onto your Neon branch, with DATABASEURL injected automatically and compute that runs next to your data.

    100 GitHub stars~12k tokensUpdated yesterday
    Auto-check: notes
  • Neon Object Storage

    neondatabase/agent-skills

    Official

    S3-compatible object storage that branches with your Neon project, so files and the database stay in sync across every branch.

    100 GitHub stars~3.5k tokensUpdated yesterday
    Auto-check: notes

Questions about Neon Postgres Branches

What does Neon Postgres Branches do?

Choose and create the right Neon branch type for testing and development. Neon Postgres Branches is an agent skill from neondatabase/agent-skills, published by the product's own GitHub organization. Choose and create the right Neon branch type for testing and development.

When should I use Neon Postgres Branches?

Neon Postgres Branches fits situations like: users ask about Neon branching; migration testing with real data; isolated test environments; schema-only branch workflows for sensitive data.

How do I install Neon Postgres Branches in Claude Code?

Run `npx skills add neondatabase/agent-skills --skill neon-postgres-branches -a claude-code`. Or copy the skill folder (skills/neon-postgres-branches in neondatabase/agent-skills) into .claude/skills/neon-postgres-branches in your project. Claude Code loads it when a task matches its description.

How do I install Neon Postgres Branches in Codex?

Run `npx skills add neondatabase/agent-skills --skill neon-postgres-branches -a codex`. Or copy the skill folder (skills/neon-postgres-branches in neondatabase/agent-skills) into .agents/skills/neon-postgres-branches in your project. Codex loads it when a task matches its description.

Can I use Neon Postgres Branches in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add neondatabase/agent-skills --skill neon-postgres-branches -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/neon-postgres-branches, .gemini/skills/neon-postgres-branches, .github/skills/neon-postgres-branches and .opencode/skills/neon-postgres-branches in your project.

What does Neon Postgres Branches need to run?

Going by SKILL.md and its folder, Neon Postgres Branches needs the command-line tools its instructions call (npm). Our summary lists: Node.js.

Does Neon Postgres Branches access the network?

SKILL.md names 3 domains. As links in the text: neon.com, github.com and console.neon.tech. This is read from the text; nothing was executed.

Is Neon Postgres Branches safe to install?

Our automated static check of SKILL.md found notes only (mentions a .env file), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Neon Postgres Branches use?

Neon Postgres Branches is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Neon Postgres Branches use?

About 3.4k tokens (SKILL.md is roughly 14k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Neon Postgres Branches?

Skills that share tags, products or a category with Neon Postgres Branches: Publishing (adeze/raindrop-mcp, 188 stars), Frontmcp Deployment (agentfront/frontmcp, 146 stars), Cloudbase CLI (TencentCloudBase/CloudBase-AI-Toolkit, 1.1k stars) and Docs Tooling Notion (langchain-ai/docs, 425 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Neon Postgres Branches?

neondatabase (a GitHub organization, an official publisher) maintains it in neondatabase/agent-skills, which has 100 GitHub stars. The repository holds 8 skills in this directory. The repository was last updated on October 7, 2026.

Source: neondatabase/agent-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.