Ship apps to the cloud by just telling Claude what you want.
This repo contains the official Claude Agent Skills for the Nexlayer AI Cloud Platform. Pair them with the Nexlayer MCP server and Claude turns into a senior cloud engineer that actually ships — fullstack webapps, APIs, AI models, multi-pod systems — to a live https://*.nexlayer.ai URL.
No YAML you don't understand. No "what's a Dockerfile" rabbit holes. No "wait, why is my frontend trying to reach db.pod from the browser?" debugging session. You describe the app. Claude builds, pushes, validates, deploys, and hands you a URL.
There are three pieces. They each do one thing:
YOU CLAUDE NEXLAYER MCP
┌─────────┐ ┌─────────────┐ ┌───────────────┐
│ "ship │ ───► │ reads the │ ───► │ 56 tools: │
│ this" │ │ SKILL.md │ │ build, push, │
└─────────┘ │ for the │ │ validate, │
│ game plan │ │ deploy, │
└─────────────┘ │ debug, ... │
│ └───────────────┘
▼ │
decides what │
tools to call ──────────────────┘
│
▼
https://your-app.nexlayer.ai
| Piece | What it is | What it gives you |
|---|---|---|
| Claude | The pilot. Reads your intent, makes decisions. | Natural-language UX. |
| Skill (this repo) | The playbook. SKILL.md tells Claude how to deploy to Nexlayer correctly. | Knowledge. Prevents the 12 mistakes everyone makes their first time. |
| Nexlayer MCP | The hands. 56 tools for build, push, validate, deploy, status, debug, domains, registry, credits. | Execution. Claude calls these — you don't. |
The skill is the brain. The MCP is the hands. Without both, Claude is guessing.
Pick your surface:
| Surface | How |
|---|---|
| claude.ai (web) | https://nexlayer.com/docs/mcp → "Install on claude.ai" |
| Claude for Work | Same link, "Install on Claude for Work" |
| Claude Desktop | Same link, "Install on Desktop" |
| Claude Code | claude mcp add nexlayer ... (full command in the docs) |
Verify it's working — ask Claude: "check my Nexlayer credits". If you get a credit balance back, you're in.
In Claude (any surface that supports skills), point it at this repo's skill folder. The skill auto-loads when you mention deploying, shipping, hosting, or Nexlayer.
Open a project folder (or a fresh repo) and tell Claude what you want. Example prompts to copy:
Deploy this app to Nexlayer.
Ship this Next.js + FastAPI + Postgres + Redis stack to Nexlayer.
Use a preview URL. I want a live link in under 5 minutes.
Host this Ollama model on Nexlayer with a chat UI in front of it,
expose the chat at /, the model API at /api/llm.
Migrate this from Vercel to Nexlayer. Keep the existing env vars.
Claude will:
- Check your auth.
- Read your project, generate a Dockerfile if you don't have one (targeting
linux/amd64— the thing you'd forget). - Build and push the image to
registry.nexlayer.iousing your per-user JWT. - Write a valid
nexlayer.yamlwith the right<% URL %>vs.podrules baked in. - Validate it before deploying (so you see errors before paying for a deploy).
- Deploy.
- Watch pod status until they're running.
- Hand you the live URL.
If something breaks, you ask "what happened?" and Claude reads the deployment logs. You don't kubectl anything. You don't even SSH.
Not a synthetic list — these are the actual shapes the skill knows how to deploy:
- Fullstack webapps — Next.js / Vite / SvelteKit + an API + Postgres + Redis. The skill knows browser env vars (
NEXT_PUBLIC_*,VITE_*,REACT_APP_*) MUST use<% URL %>, never.pod. This is the bug everyone hits. - AI models behind an API — Ollama, vLLM, custom inference servers. The skill knows the GPU pod conventions.
- Multi-agent systems — multiple cooperating services with internal
.podDNS for server-to-server traffic. - Background workers + queue + DB — Celery/BullMQ/Sidekiq patterns with Redis and Postgres pods.
- Static frontends + serverless-feeling APIs — single-pod or split.
- Migrations from Vercel / Railway / Render / Fly.io — the skill has a reference doc for each.
If it runs in a container on linux/amd64, this skill can ship it.
Copy any of these into Claude with the skill + MCP loaded:
Day 1 — first deploy
"Look at this repo. Deploy it to Nexlayer with a preview URL. Don't ask me a bunch of questions — make sensible defaults and tell me what you chose."
Adding a database
"Add a Postgres pod to my Nexlayer deploy. 10Gi volume, mounted correctly. Update DATABASE_URL on the API pod and redeploy."
Going to production
"Promote my preview deploy to production. The domain is myapp.com — walk me through DNS verification."
It broke
"My Nexlayer deploy says 'pod failing'. Pull the logs and tell me what's wrong in plain English."
You want to be lazy
"Ship it." (The skill picks up Nexlayer-context if there's a
nexlayer.yamlor you've deployed before.)
Without the skill, Claude will hallucinate plausible-but-wrong YAML — pod names with capital letters, :latest tags (rejected by the registry), localhost in env vars, frontend code reaching db.pod from the browser, ARM-built images that won't run, Postgres volumes mounted at /var/lib/postgresql/data (silently breaks on restart).
With the skill, Claude has the hard constraints in front of it before it writes a single character of YAML:
| Trap | Without skill | With skill |
|---|---|---|
| App name | MyApp (rejected) |
my-app |
| Image tag | :latest (rejected by registry) |
:v0.0.1 or git SHA |
| Build platform | host arch, often ARM (fails on Nexlayer) | linux/amd64 |
| Frontend env var | API_URL=http://api.pod:8000 (browser can't resolve) |
API_URL=<% URL %>/api |
| Postgres volume | /var/lib/postgresql/data (breaks restart) |
/var/lib/postgresql |
| Server-to-server | public URL (slow, hairpin) | db.pod:5432 |
| Secrets | dropped in vars |
proper secrets field |
These aren't theoretical. They're the support tickets.
| Skill | Description |
|---|---|
nexlayer-deploy |
The full deploy playbook. Decision tree, hard constraints, communication rules (<% URL %> vs .pod), pre-deploy checklist, production code expectations, registry login, deeper references. |
More skills will land here as they ship (likely candidates: nexlayer-debug, nexlayer-migrate).
The skill describes the workflow. The MCP is the toolkit Claude actually uses. Quick map of the 56 tools by category:
| Category | Tools (selected) | What it lets Claude do |
|---|---|---|
| Auth & account | nexlayer_check_credits, nexlayer_get_jwt_token, nexlayer_check_updates |
Verify the user is signed in and has credits before doing anything expensive. |
| Build & registry | nexlayer_build_and_push_image, nexlayer_validate_yaml, nexlayer_get_schema |
Build for linux/amd64, push to registry.nexlayer.io with the user's JWT, validate YAML before deploy. |
| Deploy | nexlayer_deploy, nexlayer_check_deployment_status, nexlayer_get_deployment_events, nexlayer_get_deployment_logs, nexlayer_delete_deployment |
Ship it. Watch it. Read logs in plain English. Tear it down. |
| Domains | nexlayer_add_domain_to_profile, nexlayer_check_domain_configuration, nexlayer_verify_name_servers_configuration, nexlayer_get_domain_setup_guide |
Take a deploy from preview to production on your own domain. |
| Live debug | nexlayer_debug_deploy_proxy, nexlayer_debug_pod_describe, nexlayer_debug_proxy_exec, nexlayer_debug_file_edit, nexlayer_debug_pod_restart, nexlayer_debug_db_query |
Exec into pods, edit files in place, query the DB, restart services — all from chat. |
| AI quick-deploys | nexlayerAI_deploy_chatbot, nexlayerAI_deploy_code_copilot, nexlayerAI_deploy_code_reviewer, nexlayerAI_deploy_content_guard, nexlayerAI_deploy_multi_agent, nexlayerAI_deploy_translation_hub |
One-shot deploy of common AI app shapes — chatbot, copilot, multi-agent, etc. |
| Skills server | nexlayer_get_skills, nexlayer_get_skill_content |
Pull MCP-side reference docs (PRODUCTION-READINESS, BUILD-AND-PUSH, POD-TEMPLATES, LAUNCHFILE-SCHEMA, ANTIPATTERNS, TROUBLESHOOTING, MIGRATION, etc.) on demand. |
| Account ops | nexlayer_purchase_credits, nexlayer_apply_coupon, nexlayer_upgrade_plan, nexlayer_generate_api_key, nexlayer_list_api_keys, nexlayer_revoke_api_key, nexlayer_get_referral, nexlayer_submit_issue, nexlayer_feedback |
Manage credits, plan, API keys, support — without leaving chat. |
You don't memorize this. The skill tells Claude which tools to call and in what order. You just describe what you want.
Behind the scenes, when you say "deploy this":
1. nexlayer_check_credits ─► authed? credits available?
2. inspect repo ─► Dockerfile present? framework?
3. generate Dockerfile (if needed) ─► multi-stage, linux/amd64
4. nexlayer_build_and_push_image ─► returns target image ref + login cmd
5. build with crane / kaniko / docker ─► pushed to registry.nexlayer.io
6. nexlayer_get_schema ─► current YAML structure
7. write nexlayer.yaml ─► with the rules baked in
8. nexlayer_validate_yaml ─► MUST pass — fail fast, cheap
9. nexlayer_deploy ─► ship it
10. nexlayer_check_deployment_status ─► poll until pods running
11. show https://<noun-noun>.nexlayer.ai
Steps 1, 4, 6, 8, 9, 10 are MCP tool calls. Steps 2, 3, 5, 7 are Claude reading and writing files locally. Step 11 is Claude handing you the URL.
"Claude isn't picking up the skill."
The skill loads based on the description field. Try a more explicit prompt: "Use the nexlayer-deploy skill to ship this." Once it loads, future prompts in the same session pick it up automatically.
"Claude isn't calling the MCP tools." The MCP isn't connected. Ask Claude: "check my Nexlayer credits". If it says it can't, reinstall the MCP — see https://nexlayer.com/docs/mcp.
"My deploy failed."
Tell Claude "pull the deployment logs and explain what broke." It'll call nexlayer_get_deployment_logs + nexlayer_get_deployment_events and translate the output. The skill's TROUBLESHOOTING reference doc covers the common cases.
"My image won't push."
You're probably on ARM and built for linux/arm64. The skill enforces --platform linux/amd64 — if you bypassed it, rebuild with that flag.
"The frontend can't reach the API."
You used .pod in a NEXT_PUBLIC_* / VITE_* / REACT_APP_* var. Browsers can't resolve .pod — that's internal cluster DNS. Use <% URL %> for any var the browser will see.
PRs welcome. Each new skill goes in skills/<skill-name>/SKILL.md with this frontmatter shape:
---
name: skill-name
description: Trigger-rich description — list verbs, surfaces, and the brand name so Claude knows when to load it.
---If you're adding a skill that wraps Nexlayer MCP behavior, keep the bar high: every claim in the SKILL.md must be enforced by an MCP tool (validation, schema fetch, status check). Don't write playbooks that depend on Claude remembering rules — make Claude check.
- Nexlayer: https://nexlayer.com
- Nexlayer MCP: https://nexlayer.com/docs/mcp
- Claude Agent Skills: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview
- Issues: https://github.com/Nexlayer/nexlayer-claude-skills/issues
- License: MIT