Deploy to Render

Deploys an app to Render from a Git repo: writes and validates a render.yaml Blueprint with services, databases and secrets, or creates one service through the Render MCP server, then checks status and logs. Use when an app needs hosting on Render.

DevOpsPack: OpenAI skills479 linesrender-deploy
Author
Source
openai/skills/skills/.curated/render-deploy @ 49f948f
License
Apache-2.0

About this skill

What it does

The skill puts an application on Render from a Git repository on GitHub, GitLab or Bitbucket; without a remote it stops and asks you to push one. It reads the code for runtime, commands, variables, datastores and port, then takes one of two routes.

Blueprint is the default for anything beyond one service. The agent writes render.yaml with web, worker, cron, static or private services and datastores, plan: free unless you say otherwise, and secrets marked sync: false for you to fill in the dashboard. It validates the file with render blueprints validate, commits and pushes it, and hands you a dashboard deeplink; you press Apply yourself. Direct creation covers a single web service or static site without datastores: the agent creates it and sets its variables through the Render MCP server (create_web_service, update_environment_variables). Then it confirms the deploy is live, reads error logs and metrics, and checks the app binds to 0.0.0.0:$PORT.

assets/ holds six render.yaml templates, from a static SPA to Django with a Celery worker, Postgres and Redis. Ten references cover the Blueprint spec, runtimes, service types, MCP calls, post-deploy checks and troubleshooting.

When to use it, and when not

Use it to deploy an app to Render, to write a render.yaml Blueprint, or to create databases, cron jobs and other Render resources.

A prebuilt Docker image cannot be created through MCP: the skill sends you to the dashboard or to a Blueprint with runtime: image. For deeper diagnostics it suggests a render-debug skill that is not in this catalog.

How to run it

The install command below puts the whole folder in place. You need the Render MCP server or the Render CLI (render), plus a Render API key; the CLI also accepts render login. SKILL.md gives the MCP setup (https://mcp.render.com/mcp) for Claude Code, Codex and Cursor. Note that the Blueprint route pushes render.yaml to main. To call it yourself:

  • Claude Code: /render-deploy, or ask for the skill by name.
  • Codex: $render-deploy.
  • Cursor: type / in the Agent chat and pick render-deploy.

Example: /render-deploy Deploy this Django app to Render with Postgres and a Celery worker.

OpenAI has marked openai/skills deprecated; our copy is pinned to a commit there, and as of November 2026 openai/plugins has no newer version of this skill.

How it differs from similar skills

Deploy to Netlify and Deploy to Vercel upload the project from your machine and return a preview link in one step; this skill deploys from Git, describes databases and background services as code and leaves the final Apply to you. Web frameworks on Cloudflare Workers moves a framework app onto Cloudflare Workers; it describes no databases or background services and leaves the deploy commands to the Wrangler and cf skills. Dockerfile review checks the image a runtime: docker service builds from. Release checklist gives a go or no-go first.

Install

Run one command — it saves SKILL.md and the files it uses into your agent's skills folder. Claude Code and Codex pick up a new skill without a restart; if it does not show up, restart the agent.

Claude Code — macOS, Linux
curl -fsSL --create-dirs -o ~/.claude/skills/render-deploy/SKILL.md https://anymodel.org/en/skills/openai/render-deploy/SKILL.md -o ~/.claude/skills/render-deploy/LICENSE.txt https://anymodel.org/en/skills/openai/render-deploy/LICENSE.txt -o ~/.claude/skills/render-deploy/agents/openai.yaml https://anymodel.org/en/skills/openai/render-deploy/agents/openai.yaml -o ~/.claude/skills/render-deploy/assets/docker.yaml https://anymodel.org/en/skills/openai/render-deploy/assets/docker.yaml -o ~/.claude/skills/render-deploy/assets/go-api.yaml https://anymodel.org/en/skills/openai/render-deploy/assets/go-api.yaml -o ~/.claude/skills/render-deploy/assets/nextjs-postgres.yaml https://anymodel.org/en/skills/openai/render-deploy/assets/nextjs-postgres.yaml -o ~/.claude/skills/render-deploy/assets/node-express.yaml https://anymodel.org/en/skills/openai/render-deploy/assets/node-express.yaml -o ~/.claude/skills/render-deploy/assets/python-django.yaml https://anymodel.org/en/skills/openai/render-deploy/assets/python-django.yaml -o ~/.claude/skills/render-deploy/assets/render-small.svg https://anymodel.org/en/skills/openai/render-deploy/assets/render-small.svg -o ~/.claude/skills/render-deploy/assets/render.png https://anymodel.org/en/skills/openai/render-deploy/assets/render.png -o ~/.claude/skills/render-deploy/assets/static-site.yaml https://anymodel.org/en/skills/openai/render-deploy/assets/static-site.yaml -o ~/.claude/skills/render-deploy/references/blueprint-spec.md https://anymodel.org/en/skills/openai/render-deploy/references/blueprint-spec.md -o ~/.claude/skills/render-deploy/references/codebase-analysis.md https://anymodel.org/en/skills/openai/render-deploy/references/codebase-analysis.md -o ~/.claude/skills/render-deploy/references/configuration-guide.md https://anymodel.org/en/skills/openai/render-deploy/references/configuration-guide.md -o ~/.claude/skills/render-deploy/references/deployment-details.md https://anymodel.org/en/skills/openai/render-deploy/references/deployment-details.md -o ~/.claude/skills/render-deploy/references/direct-creation.md https://anymodel.org/en/skills/openai/render-deploy/references/direct-creation.md -o ~/.claude/skills/render-deploy/references/error-patterns.md https://anymodel.org/en/skills/openai/render-deploy/references/error-patterns.md -o ~/.claude/skills/render-deploy/references/post-deploy-checks.md https://anymodel.org/en/skills/openai/render-deploy/references/post-deploy-checks.md -o ~/.claude/skills/render-deploy/references/runtimes.md https://anymodel.org/en/skills/openai/render-deploy/references/runtimes.md -o ~/.claude/skills/render-deploy/references/service-types.md https://anymodel.org/en/skills/openai/render-deploy/references/service-types.md -o ~/.claude/skills/render-deploy/references/troubleshooting-basics.md https://anymodel.org/en/skills/openai/render-deploy/references/troubleshooting-basics.md
Codex, Cursor — macOS, Linux
curl -fsSL --create-dirs -o ~/.agents/skills/render-deploy/SKILL.md https://anymodel.org/en/skills/openai/render-deploy/SKILL.md -o ~/.agents/skills/render-deploy/LICENSE.txt https://anymodel.org/en/skills/openai/render-deploy/LICENSE.txt -o ~/.agents/skills/render-deploy/agents/openai.yaml https://anymodel.org/en/skills/openai/render-deploy/agents/openai.yaml -o ~/.agents/skills/render-deploy/assets/docker.yaml https://anymodel.org/en/skills/openai/render-deploy/assets/docker.yaml -o ~/.agents/skills/render-deploy/assets/go-api.yaml https://anymodel.org/en/skills/openai/render-deploy/assets/go-api.yaml -o ~/.agents/skills/render-deploy/assets/nextjs-postgres.yaml https://anymodel.org/en/skills/openai/render-deploy/assets/nextjs-postgres.yaml -o ~/.agents/skills/render-deploy/assets/node-express.yaml https://anymodel.org/en/skills/openai/render-deploy/assets/node-express.yaml -o ~/.agents/skills/render-deploy/assets/python-django.yaml https://anymodel.org/en/skills/openai/render-deploy/assets/python-django.yaml -o ~/.agents/skills/render-deploy/assets/render-small.svg https://anymodel.org/en/skills/openai/render-deploy/assets/render-small.svg -o ~/.agents/skills/render-deploy/assets/render.png https://anymodel.org/en/skills/openai/render-deploy/assets/render.png -o ~/.agents/skills/render-deploy/assets/static-site.yaml https://anymodel.org/en/skills/openai/render-deploy/assets/static-site.yaml -o ~/.agents/skills/render-deploy/references/blueprint-spec.md https://anymodel.org/en/skills/openai/render-deploy/references/blueprint-spec.md -o ~/.agents/skills/render-deploy/references/codebase-analysis.md https://anymodel.org/en/skills/openai/render-deploy/references/codebase-analysis.md -o ~/.agents/skills/render-deploy/references/configuration-guide.md https://anymodel.org/en/skills/openai/render-deploy/references/configuration-guide.md -o ~/.agents/skills/render-deploy/references/deployment-details.md https://anymodel.org/en/skills/openai/render-deploy/references/deployment-details.md -o ~/.agents/skills/render-deploy/references/direct-creation.md https://anymodel.org/en/skills/openai/render-deploy/references/direct-creation.md -o ~/.agents/skills/render-deploy/references/error-patterns.md https://anymodel.org/en/skills/openai/render-deploy/references/error-patterns.md -o ~/.agents/skills/render-deploy/references/post-deploy-checks.md https://anymodel.org/en/skills/openai/render-deploy/references/post-deploy-checks.md -o ~/.agents/skills/render-deploy/references/runtimes.md https://anymodel.org/en/skills/openai/render-deploy/references/runtimes.md -o ~/.agents/skills/render-deploy/references/service-types.md https://anymodel.org/en/skills/openai/render-deploy/references/service-types.md -o ~/.agents/skills/render-deploy/references/troubleshooting-basics.md https://anymodel.org/en/skills/openai/render-deploy/references/troubleshooting-basics.md
Claude Code — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE.txt','agents/openai.yaml','assets/docker.yaml','assets/go-api.yaml','assets/nextjs-postgres.yaml','assets/node-express.yaml','assets/python-django.yaml','assets/render-small.svg','assets/render.png','assets/static-site.yaml','references/blueprint-spec.md','references/codebase-analysis.md','references/configuration-guide.md','references/deployment-details.md','references/direct-creation.md','references/error-patterns.md','references/post-deploy-checks.md','references/runtimes.md','references/service-types.md','references/troubleshooting-basics.md') { $p = Join-Path "$HOME\.claude\skills\render-deploy" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/openai/render-deploy/$f" -UseBasicParsing -OutFile $p }
Codex, Cursor — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE.txt','agents/openai.yaml','assets/docker.yaml','assets/go-api.yaml','assets/nextjs-postgres.yaml','assets/node-express.yaml','assets/python-django.yaml','assets/render-small.svg','assets/render.png','assets/static-site.yaml','references/blueprint-spec.md','references/codebase-analysis.md','references/configuration-guide.md','references/deployment-details.md','references/direct-creation.md','references/error-patterns.md','references/post-deploy-checks.md','references/runtimes.md','references/service-types.md','references/troubleshooting-basics.md') { $p = Join-Path "$HOME\.agents\skills\render-deploy" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/openai/render-deploy/$f" -UseBasicParsing -OutFile $p }

Any other agent: save the file into its skills folder, or give it the link to the file: https://anymodel.org/en/skills/openai/render-deploy/SKILL.md

SKILL.md

Raw

Deploy to Render

Render supports Git-backed services and prebuilt Docker image services.

This skill covers Git-backed flows:

  1. Blueprint Method - Generate render.yaml for Infrastructure-as-Code deployments
  2. Direct Creation - Create services instantly via MCP tools

Blueprints can also run a prebuilt Docker image by using runtime: image, but the render.yaml still must live in a Git repo.

If there is no Git remote, stop and ask the user to either:

  • Create/push a Git remote (can be minimal if only the Blueprint is needed), or
  • Use the Render Dashboard/API to deploy a prebuilt Docker image (MCP cannot create image-backed services).

Prerequisites

  • When sandboxing blocks the deployment network calls, rerun with sandbox_permissions=require_escalated.
  • The deployment might take a few minutes. Use appropriate timeout values.

When to Use This Skill

Activate this skill when users want to:

  • Deploy an application to Render
  • Create a render.yaml Blueprint file
  • Set up Render deployment for their project
  • Host or publish their application on Render's cloud platform
  • Create databases, cron jobs, or other Render resources

Happy Path (New Users)

Use this short prompt sequence before deep analysis to reduce friction:

  1. Ask whether they want to deploy from a Git repo or a prebuilt Docker image.
  2. Ask whether Render should provision everything the app needs (based on what seems likely from the user's description) or only the app while they bring their own infra. If dependencies are unclear, ask a short follow-up to confirm whether they need a database, workers, cron, or other services.

Then proceed with the appropriate method below.

Choose Your Source Path

Git Repo Path: Required for both Blueprint and Direct Creation. The repo must be pushed to GitHub, GitLab, or Bitbucket.

Prebuilt Docker Image Path: Supported by Render via image-backed services. This is not supported by MCP; use the Dashboard/API. Ask for:

  • Image URL (registry + tag)
  • Registry auth (if private)
  • Service type (web/worker) and port

If the user chooses a Docker image, guide them to the Render Dashboard image deploy flow or ask them to add a Git remote (so you can use a Blueprint with runtime: image).

Choose Your Deployment Method (Git Repo)

Both methods require a Git repository pushed to GitHub, GitLab, or Bitbucket. (If using runtime: image, the repo can be minimal and only contain render.yaml.)

Method Best For Pros
Blueprint Multi-service apps, IaC workflows Version controlled, reproducible, supports complex setups
Direct Creation Single services, quick deployments Instant creation, no render.yaml file needed

Method Selection Heuristic

Use this decision rule by default unless the user requests a specific method. Analyze the codebase first; only ask if deployment intent is unclear (e.g., DB, workers, cron).

Use Direct Creation (MCP) when ALL are true:

  • Single service (one web app or one static site)
  • No separate worker/cron services
  • No attached databases or Key Value
  • Simple env vars only (no shared env groups) If this path fits and MCP isn't configured yet, stop and guide MCP setup before proceeding.

Use Blueprint when ANY are true:

  • Multiple services (web + worker, API + frontend, etc.)
  • Databases, Redis/Key Value, or other datastores are required
  • Cron jobs, background workers, or private services
  • You want reproducible IaC or a render.yaml committed to the repo
  • Monorepo or multi-env setup that needs consistent configuration

If unsure, ask a quick clarifying question, but default to Blueprint for safety. For a single service, strongly prefer Direct Creation via MCP and guide MCP setup if needed.

Prerequisites Check

When starting a deployment, verify these requirements in order:

1. Confirm Source Path (Git vs Docker)

If using Git-based methods (Blueprint or Direct Creation), the repo must be pushed to GitHub/GitLab/Bitbucket. Blueprints that reference a prebuilt image still require a Git repo with render.yaml.

git remote -v
  • If no remote exists, stop and ask the user to create/push a remote or switch to Docker image deploy.

2. Check MCP Tools Availability (Preferred for Single-Service)

MCP tools provide the best experience. Check if available by attempting:

list_services()

If MCP tools are available, you can skip CLI installation for most operations.

3. Check Render CLI Installation (for Blueprint validation)

render --version

If not installed, offer to install:

  • macOS: brew install render
  • Linux/macOS: curl -fsSL https://raw.githubusercontent.com/render-oss/cli/main/bin/install.sh | sh

4. MCP Setup (if MCP isn't configured)

If list_services() fails because MCP isn't configured, ask whether they want to set up MCP (preferred) or continue with the CLI fallback. If they choose MCP, ask which AI tool they're using, then provide the matching instructions below. Always use their API key.

Cursor

Walk the user through these steps:

  1. Get a Render API key:
https://dashboard.render.com/u/*/settings#api-keys
  1. Add this to ~/.cursor/mcp.json (replace <YOUR_API_KEY>):
{
  "mcpServers": {
    "render": {
      "url": "https://mcp.render.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}
  1. Restart Cursor, then retry list_services().

Claude Code

Walk the user through these steps:

  1. Get a Render API key:
https://dashboard.render.com/u/*/settings#api-keys
  1. Add the MCP server with Claude Code (replace <YOUR_API_KEY>):
claude mcp add --transport http render https://mcp.render.com/mcp --header "Authorization: Bearer <YOUR_API_KEY>"
  1. Restart Claude Code, then retry list_services().

Codex

Walk the user through these steps:

  1. Get a Render API key:
https://dashboard.render.com/u/*/settings#api-keys
  1. Set it in their shell:
export RENDER_API_KEY="<YOUR_API_KEY>"
  1. Add the MCP server with the Codex CLI:
codex mcp add render --url https://mcp.render.com/mcp --bearer-token-env-var RENDER_API_KEY
  1. Restart Codex, then retry list_services().

Other Tools

If the user is on another AI app, direct them to the Render MCP docs for that tool's setup steps and install method.

Workspace Selection

After MCP is configured, have the user set the active Render workspace with a prompt like:

Set my Render workspace to [WORKSPACE_NAME]

5. Check Authentication (CLI fallback only)

If MCP isn't available, use the CLI instead and verify you can access your account:

# Check if user is logged in (use -o json for non-interactive mode)
render whoami -o json

If render whoami fails or returns empty data, the CLI is not authenticated. The CLI won't always prompt automatically, so explicitly prompt the user to authenticate:

If neither is configured, ask user which method they prefer:

6. Check Workspace Context

Verify the active workspace:

get_selected_workspace()

Or via CLI:

render workspace current -o json

To list available workspaces:

list_workspaces()

If user needs to switch workspaces, they must do so via Dashboard or CLI (render workspace set).

Once prerequisites are met, proceed with deployment workflow.


Blueprint Workflow

Step 1: Analyze Codebase

Analyze the codebase to determine framework/runtime, build and start commands, required env vars, datastores, and port binding. Use the detailed checklists in references/codebase-analysis.md.

Step 2: Generate render.yaml

Create a render.yaml Blueprint file following the Blueprint specification.

Complete specification: references/blueprint-spec.md

Key Points:

  • Always use plan: free unless user specifies otherwise
  • Include ALL environment variables the app needs
  • Mark secrets with sync: false (user fills these in Dashboard)
  • Use appropriate service type: web, worker, cron, static, or pserv
  • Use appropriate runtime: references/runtimes.md

Basic Structure:

services:
  - type: web
    name: my-app
    runtime: node
    plan: free
    buildCommand: npm ci
    startCommand: npm start
    envVars:
      - key: DATABASE_URL
        fromDatabase:
          name: postgres
          property: connectionString
      - key: JWT_SECRET
        sync: false  # User fills in Dashboard

databases:
  - name: postgres
    databaseName: myapp_db
    plan: free

Service Types:

  • web: HTTP services, APIs, web applications (publicly accessible)
  • worker: Background job processors (not publicly accessible)
  • cron: Scheduled tasks that run on a cron schedule
  • static: Static sites (HTML/CSS/JS served via CDN)
  • pserv: Private services (internal only, within same account)

Service type details: references/service-types.md Runtime options: references/runtimes.md Template examples: assets/

Step 2.5: Immediate Next Steps (Always Provide)

After creating render.yaml, always give the user a short, explicit checklist and run validation immediately when the CLI is available:

  1. Authenticate (CLI): run render whoami -o json (if not logged in, run render login or set RENDER_API_KEY)
  2. Validate (recommended): run render blueprints validate
    • If the CLI isn't installed, offer to install it and provide the command.
  3. Commit + push: git add render.yaml && git commit -m "Add Render deployment configuration" && git push origin main
  4. Open Dashboard: Use the Blueprint deeplink and complete Git OAuth if prompted
  5. Fill secrets: Set env vars marked sync: false
  6. Deploy: Click "Apply" and monitor the deploy

Step 3: Validate Configuration

Validate the render.yaml file to catch errors before deployment. If the CLI is installed, run the commands directly; only prompt the user if the CLI is missing:

render whoami -o json  # Ensure CLI is authenticated (won't always prompt)
render blueprints validate

Fix any validation errors before proceeding. Common issues:

  • Missing required fields (name, type, runtime)
  • Invalid runtime values
  • Incorrect YAML syntax
  • Invalid environment variable references

Configuration guide: references/configuration-guide.md

Step 4: Commit and Push

IMPORTANT: You must merge the render.yaml file into your repository before deploying.

Ensure the render.yaml file is committed and pushed to your Git remote:

git add render.yaml
git commit -m "Add Render deployment configuration"
git push origin main

If there is no Git remote yet, stop here and guide the user to create a GitHub/GitLab/Bitbucket repo, add it as origin, and push before continuing.

Why this matters: The Dashboard deeplink will read the render.yaml from your repository. If the file isn't merged and pushed, Render won't find the configuration and deployment will fail.

Verify the file is in your remote repository before proceeding to the next step.

Get the Git repository URL:

git remote get-url origin

This will return a URL from your Git provider. If the URL is SSH format, convert it to HTTPS:

SSH Format HTTPS Format
[email protected]:user/repo.git https://github.com/user/repo
[email protected]:user/repo.git https://gitlab.com/user/repo
[email protected]:user/repo.git https://bitbucket.org/user/repo

Conversion pattern: Replace git@<host>: with https://<host>/ and remove .git suffix.

Format the Dashboard deeplink using the HTTPS repository URL:

https://dashboard.render.com/blueprint/new?repo=<REPOSITORY_URL>

Example:

https://dashboard.render.com/blueprint/new?repo=https://github.com/username/repo-name

Step 6: Guide User

CRITICAL: Ensure the user has merged and pushed the render.yaml file to their repository before clicking the deeplink. If the file isn't in the repository, Render cannot read the Blueprint configuration and deployment will fail.

Provide the deeplink to the user with these instructions:

  1. Verify render.yaml is merged - Confirm the file exists in your repository on GitHub/GitLab/Bitbucket
  2. Click the deeplink to open Render Dashboard
  3. Complete Git provider OAuth if prompted
  4. Name the Blueprint (or use default from render.yaml)
  5. Fill in secret environment variables (marked with sync: false)
  6. Review services and databases configuration
  7. Click "Apply" to deploy

The deployment will begin automatically. Users can monitor progress in the Render Dashboard.

Step 7: Verify Deployment

After the user deploys via Dashboard, verify everything is working.

Check deployment status via MCP:

list_deploys(serviceId: "<service-id>", limit: 1)

Look for status: "live" to confirm successful deployment.

Check for runtime errors (wait 2-3 minutes after deploy):

list_logs(resource: ["<service-id>"], level: ["error"], limit: 20)

Check service health metrics:

get_metrics(
  resourceId: "<service-id>",
  metricTypes: ["http_request_count", "cpu_usage", "memory_usage"]
)

If errors are found, proceed to the Post-deploy verification and basic triage section below.


Method 2: Direct Service Creation (Quick Single-Service Deployments)

For simple deployments without Infrastructure-as-Code, create services directly via MCP tools.

When to Use Direct Creation

  • Single web service or static site
  • Quick prototypes or demos
  • When you don't need a render.yaml file in your repo
  • Adding databases or cron jobs to existing projects

Prerequisites for Direct Creation

Repository must be pushed to a Git provider. Render clones your repository to build and deploy services.

git remote -v  # Verify remote exists
git push origin main  # Ensure code is pushed

Supported providers: GitHub, GitLab, Bitbucket

If no remote exists, stop and ask the user to create/push a remote or switch to Docker image deploy.

Note: MCP does not support creating image-backed services. Use the Dashboard/API for prebuilt Docker image deploys.

Direct Creation Workflow

Use the concise steps below, and refer to references/direct-creation.md for full MCP command examples and follow-on configuration.

Step 1: Analyze Codebase

Use references/codebase-analysis.md to determine runtime, build/start commands, env vars, and datastores.

Step 2: Create Resources via MCP

Create the service (web or static) and any required databases or key-value stores. See references/direct-creation.md.

If MCP returns an error about missing Git credentials or repo access, stop and guide the user to connect their Git provider in the Render Dashboard, then retry.

Step 3: Configure Environment Variables

Add required env vars via MCP after creation. See references/direct-creation.md.

Remind the user that secrets can be set in the Dashboard if they prefer not to pass them via MCP.

Step 4: Verify Deployment

Check deploy status, logs, and metrics. See references/direct-creation.md.


For service discovery, configuration details, quick commands, and common issues, see references/deployment-details.md.


Post-deploy verification and basic triage (All Methods)

Keep this short and repeatable. If any check fails, fix it before redeploying.

  1. Confirm the latest deploy is live and serving traffic
  2. Hit the health endpoint (or root) and verify a 200 response
  3. Scan recent error logs for a clear failure signature
  4. Verify required env vars and port binding (0.0.0.0:$PORT)

Detailed checklist and commands: references/post-deploy-checks.md

If the service fails to start or health checks time out, use the basic triage guide: references/troubleshooting-basics.md

Troubleshooting

Escalated Network Access

If deployment fails due to network issues (timeouts, DNS errors, connection resets), rerun the deploy with escalated permissions (use sandbox_permissions=require_escalated). The deploy requires escalated network access when sandbox networking blocks outbound requests.

Example guidance to the user:

The deploy needs escalated network access to deploy to Render. I can rerun the command with escalated permissions—want me to proceed?

Optional: If you need deeper diagnostics (metrics/DB checks/error catalog), suggest installing the render-debug skill. It is not required for the core deploy flow.

Connect through AnyModel API

This skill runs on whatever model your agent uses. Point Claude Code, Codex or Cursor at AnyModel to run it on Claude, GPT, Gemini and more with one key — pay per token, no subscription.

More from the pack OpenAI skills

ASP.NET Core apps

Guides the agent through current ASP.NET Core practice: choosing Blazor, Razor Pages, MVC or Minimal APIs, Program.cs and middleware order, auth, EF Core, tests and upgrades to .NET 10. Use when building, reviewing or upgrading an ASP.NET Core app.

ChatGPT Apps SDK

Builds ChatGPT apps on the Apps SDK: reads current OpenAI docs first, picks an app archetype, plans MCP tools, adapts an official example or scaffolds a Node server and widget, then tests in Developer Mode. Use when building or fixing an app inside ChatGPT.

CLI creator from API docs

Builds a durable CLI from API docs, an OpenAPI spec, curls or a script: JSON output, doctor and dry-run commands, safe auth, installed on PATH and paired with a companion skill. Use when an agent keeps hitting the same service through ad hoc calls.

Define a measurable goal

Turns a fuzzy intention into one measurable goal with a validator, scope and stop condition, then registers it via get_goal and create_goal. Use before goal-backed or long-running agent work, when "done" needs a number or a check.

Address GitHub PR comments

Fetches all comments, reviews and inline threads on the current branch's GitHub PR with a gh GraphQL script, numbers them and fixes only the ones you pick. Use when a PR has review comments to work through and you want to choose which get changed.

Fix failing GitHub Actions checks

Finds failing GitHub Actions checks on a PR with gh, pulls the logs, extracts the failure snippet and drafts a fix plan, changing code only after approval. Use when a PR's CI is red and you want the cause and a plan before any edit.

Jupyter notebooks

Creates and tidies Jupyter notebooks for experiments or tutorials from bundled templates via a stdlib script, with structure patterns and a run-top-to-bottom checklist. Use when starting a notebook or turning a messy one into something others can rerun.

Linear issues and projects

Works with Linear issues, projects and cycles through Linear's MCP server in a fixed order: setup, scope, read, then write, with sample workflows for triage, sprints and releases. Use when an agent should read or update Linear as part of a task.

Deploy to Netlify

Deploys the current project to Netlify with `npx netlify`: checks the login, links the folder to a site by Git remote or creates one, builds locally and returns a preview or production URL. Use when you want to publish a site to Netlify from your machine.

Browser automation with Playwright CLI

Drives a real browser from the terminal with playwright-cli: snapshots give element refs for clicks and typing, plus screenshots, console, network and traces, with no test files written. Use when a task needs a browser clicked through step by step.

Security best-practice review

Checks Python, JavaScript/TypeScript and Go code against bundled security specs for ten frameworks, writes a report by severity with line numbers and fixes one finding at a time. Use when you explicitly ask for a security best-practice review.

Repository threat model

Writes a repository-grounded threat model: trust boundaries, assets, attacker capabilities and ranked abuse paths with mitigations, asking you to confirm key assumptions before the final file. Use when you explicitly ask to threat model a codebase.

Sentry issues and events

Reads Sentry issues and events through the sentry CLI without changing anything: recent production errors, issue and event details, AI root-cause summaries, with PII redacted. Use when you ask what is failing in production according to Sentry.

Deploy to Vercel

Deploys a project to Vercel, as a preview unless told otherwise, through the Vercel CLI or, without an account, a bundled script that uploads the folder and returns a preview link and a claim link. Use when you want a shareable deployment link fast.

Figma MCP design context

Reads Figma frames through the Figma MCP server in a fixed order (design context, metadata, screenshot) and rebuilds them with the project's components and tokens; also covers server setup in Codex. Use when connecting Figma MCP or coding from a frame link.

Figma use_figma prerequisite

Sets the rules an agent must load before every use_figma call that runs Plugin API JavaScript in a Figma file: return values, page resets, colours, fonts, node IDs, small validated steps. Use when creating or editing anything inside a Figma file.

Implement a Figma design in code

Implements a Figma frame or component as code in your repo with 1:1 visual parity: fetches context and a screenshot, maps the output to project tokens and components, then runs a validation checklist. Use when a Figma link must become production UI.

Generate a Figma design from an app

Builds or updates a full screen in Figma from code or a description, section by section, using the file's published components, variables and styles instead of hardcoded values. Use when a page from your app should exist as a Figma screen.

Figma design system from a codebase

Builds a Figma design system library from a codebase in five supervised phases: discovery, variables and styles, page structure, components one by one, QA. Use when a product needs a Figma library that matches its code tokens and components.

Figma Code Connect components

Links published Figma components to the code components that implement them via Code Connect: finds unmapped ones, matches them in the codebase, maps only what the user approves. Use when a Figma library and its code both exist but are not linked.

Figma design system rules

Writes project rules for turning Figma designs into code into CLAUDE.md, AGENTS.md or a Cursor rules file, based on Figma's rule template and an analysis of the codebase. Use when setting up an agent for regular Figma-to-code work in a repo.

Create a new Figma file

Creates a blank Figma design file or FigJam board in your drafts, resolving the plan through whoami, and returns the file key and URL. Use when the next Figma step needs a fresh file to write into.