render-deploy
Deploy applications to Render by analyzing codebases, generating render.yaml Blueprints, and providing Dashboard deeplinks
Install / Use
npx skills add openai/skills --skill render-deployInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
OperationsSupported Platforms
Our assessment of render-deploy
render-deploy scores 99/100 on our quality scale, 4th of 745 Operations skills we index (top 1%).
Its SKILL.md is 17 KB long, well organised into 35 sections with 26 code examples: a thorough specification that gives an agent plenty to work with.
With 27,599 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so render-deploy is actively maintained.
- Our last check on 2026-11-14 found the source still online.
- No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
- Its trust signals score 88/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
ReviewOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands (1 minor note below). An AI review judged it risky: Line 111 instructs the agent to install the Render CLI by piping a remote script into a shell (`curl -fsSL https://raw.githubusercontent.com/render-oss/cli/main/bin/install.sh | sh`), which is explicitly flagged as risky for skill/rules fil.
- noteInstalls by piping a downloaded script into a shellline 111
- Linux/macOS: `curl -fsSL https://raw.githubusercontent.com/render-oss/cli/main/bin/install.sh | sh`
AI review: risky
- Line 111 instructs the agent to install the Render CLI by piping a remote script into a shell (`curl -fsSL https://raw.githubusercontent.com/render-oss/cli/main/bin/install.sh | sh`), which is explicitly flagged as risky for skill/rules fil
- The skill repeatedly tells the agent to run authentication and deployment commands (`render login`, `render blueprints validate`, `git push`, MCP calls) on the user's behalf, increasing the agent's operational scope.
- It advises rerunning with `sandbox_permissions=require_escalated` when network access is blocked, which can weaken sandbox restrictions during deployment.
AI review by kimi-k2.7-code on 2026-10-02. Automated pattern scan on 2026-10-02. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
render-deploy compared with similar skills
All 4 of these similar skills score higher than render-deploy; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| render-deploy (this skill)by openai | 99 | 27.6k | 2mo ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| Agent-Reachby Panniantong | 100 | 112.3k | 8d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 81.9k | today | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 79.8k | today | CLAUDE.md |
Frequently asked questions
- How do I install render-deploy?
- Run
npx skills add openai/skills --skill render-deploy. The install tabs above show the steps for each supported agent. - Which AI agents does render-deploy work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is render-deploy safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands (1 minor note below). An AI review judged it risky: Line 111 instructs the agent to install the Render CLI by piping a remote script into a shell (
curl -fsSL https://raw.githubusercontent.com/render-oss/cli/main/bin/install.sh | sh), which is explicitly flagged as risky for skill/rules fil. It declares no license and scores 88/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand. - Is render-deploy still maintained?
- The repository was last updated about 2 months ago, so render-deploy is actively maintained.
Skill content
View source on GitHubname: render-deploy description: Deploy applications to Render by analyzing codebases, generating render.yaml Blueprints, and providing Dashboard deeplinks. Use when the user wants to deploy, host, publish, or set up their application on Render's cloud platform.
Deploy to Render
Render supports Git-backed services and prebuilt Docker image services.
This skill covers Git-backed flows:
- Blueprint Method - Generate render.yaml for Infrastructure-as-Code deployments
- 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:
- Ask whether they want to deploy from a Git repo or a prebuilt Docker image.
- 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:
- Get a Render API key:
https://dashboard.render.com/u/*/settings#api-keys
- Add this to
~/.cursor/mcp.json(replace<YOUR_API_KEY>):
{
"mcpServers": {
"render": {
"url": "https://mcp.render.com/mcp",
"headers": {
"Authorization": "Bearer <YOUR_API_KEY>"
}
}
}
}
- Restart Cursor, then retry
list_services().
Claude Code
Walk the user through these steps:
- Get a Render API key:
https://dashboard.render.com/u/*/settings#api-keys
- 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>"
- Restart Claude Code, then retry
list_services().
Codex
Walk the user through these steps:
- Get a Render API key:
https://dashboard.render.com/u/*/settings#api-keys
- Set it in their shell:
export RENDER_API_KEY="<YOUR_API_KEY>"
- 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
- 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:
- API Key (CLI):
export RENDER_API_KEY="rnd_xxxxx"(Get from https://dashboard.render.com/u/*/settings#api-keys) - Login:
render login(Opens browser for OAuth)
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.
Method 1: Blueprint Deployment (Recommended for Complex Apps)
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: freeunless 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, orpserv - 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 schedulestatic: 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:
- Authenticate (CLI): run
render whoami -o json(if not logged in, runrender loginor setRENDER_API_KEY) - Validate (recommended): run
render blueprints validate- If the CLI isn't installed, offer to install it and provide the command.
- Commit + push:
git add render.yaml && git commit -m "Add Render deployment configuration" && git push origin main - Open Dashboard: Use the Blueprint deeplink and complete Git OAuth if prompted
- Fill secrets: Set env vars marked
sync: false - 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.
Step 5: Generate Deeplink
Get the Git repository URL:
git remote get-url origin
This will return a URL from your Git provider. **If the URL is
Truncated for display — read the full file on GitHub.
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
Agent-Reach
112.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
ruflo
81.9k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
headroom
79.8kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
