How to Run and Host Claude (Anthropic) Skills Without Claude Desktop (2026)

Do not index

if you've been searching "how to run claude skills without claude desktop," you're probably dealing with one of these situations:

• you need to use a skill in a browser because you can't install desktop apps on your work machine.

• you're on windows or linux and don't want another desktop app dependency.

• you want to deploy a skill headlessly in an app, API, or CI pipeline.

• you need to share a skill with customers or teammates without making them install anything.

• you want to monetize or distribute a skill like SaaS (link, login, billing) instead of shipping zip files.

here's the good news: as of 2026, claude skills (officially called agent skills, and often searched as "anthropic skills") work across multiple surfaces including the web (claude.ai), CLI (claude code), API, and agent SDK. you don't need claude desktop.

the confusing part? runtime environments, packaging rules, and sharing models differ dramatically between surfaces. skills don't automatically sync between claude.ai, claude code, and the API. (claude developer platform docs)

this guide shows you every practical way to run skills without desktop, and how to choose the right one for your needs.

The Fastest Method for Your Use Case (Decision Tree)

don't waste time reading about methods you don't need. pick your scenario:

you want to use a skill personally (no coding, no installs)

→ use claude.ai (web) → settings → capabilities → upload or enable skills

you want skills in your dev workflow (local repos, automation, plugins)

→ use claude code CLI → put skills in ~/.claude/skills/ or .claude/skills/

you want to run skills in production (your app or backend service)

→ use claude API + code execution + skills API → load via container parameter

you want customers to run a skill via a shareable link (zero setup)

→ run it on an always-on cloud instance (e.g. agent37 cloud) and share the link to the front end you put on it

the rest of this guide explains how each method works, what the constraints are, and how to make your skills portable across all of them.

What Are Claude Skills? (And Why Desktop Isn't Required)

anthropic's current terminology is agent skills: filesystem-based, modular capabilities that package metadata, instructions, and optional resources or scripts into a single folder.

here's the core idea that makes skills work everywhere:

this three-layer architecture works like this:

① metadata is always loaded (so claude knows what's available: name, description).

② instructions load only when triggered (the main SKILL.md file with your workflows).

③ resources and scripts load only when needed (templates, reference docs, helper code).

this architecture is why skills can be powerful without bloating context, and why they can run in multiple environments (web, CLI, API, hosted runtimes) without requiring desktop. (claude developer platform docs)

you're not locked into one app. you're using an open standard published by anthropic (announced december 18, 2025) that works across their ecosystem.

3 Critical Differences Between Skill Runtime Environments

1) skills do NOT automatically sync between surfaces

this trips up almost everyone.

skills you upload to claude.ai aren't automatically available in claude code or via the API. anthropic explicitly documents this limitation: you have to manage and upload skills separately for each surface. (claude developer platform docs)

if you build a skill and want it everywhere, you'll upload it multiple times (or use a hosted runtime that handles this for you).

2) runtime constraints vary dramatically

this is critical if you're trying to run skills that call APIs, scrape websites, or install packages:

surface	network access	package installation
claude API	no	no
claude.ai (web)	depends on plan/admin	N/A (sandboxed)
claude code (CLI)	yes (local environment)	yes (local environment)

the API constraint is the most surprising. anthropic's docs make it clear: claude API skills have no network access and cannot install packages during execution. you only get what's already in the code execution container.

if your skill scrapes websites or calls external APIs, it won't work via the API without redesigning the architecture. (claude developer platform docs)

3) packaging rules differ (portability matters)

some surfaces are stricter than others about file naming and metadata:

→ claude code and API require SKILL.md (uppercase) and strict naming rules for the name field: lowercase letters, numbers, hyphens only (e.g., brand-guidelines). (claude code docs)

→ claude.ai help center examples sometimes show Skill.md and "human-friendly" names like brand guidelines. (claude help center)

best practice for portability: use the stricter subset. name your file SKILL.md (uppercase) and use lowercase-hyphen name values. then your skill will work everywhere. (claude code docs)

How to Run Claude Skills in Your Browser (Claude.ai)

this is the "i just want it working" option.

if you're trying to use a skill personally (or share it within your team), the web interface is the simplest path. you upload a zip, toggle it on, and claude automatically uses it when relevant.

similar to how you might create a custom GPT, skills on claude.ai let you package expertise and workflows into reusable modules (but with more power and flexibility than customGPTs offer).

Requirements for Web-Based Skills

skills are available for pro, max, team, and enterprise plans. you also need code execution enabled. (claude help center)

if you're on a free plan, you can't use skills on claude.ai yet.

Step-by-Step: Enable Skills in Claude.ai

here's how to enable skills in your browser:

① open claude.ai and go to settings → capabilities.

② make sure code execution and file creation is toggled on.

③ scroll to the skills section.

④ toggle built-in skills (excel, word, powerpoint, PDF) on or off.

⑤ click upload skill to add a custom skill (you'll need a zip file).

claude will automatically use enabled skills when your conversation matches their description. you generally don't have to "call" them explicitly. (claude help center)

Team & Enterprise: Provision Skills Organization-Wide

if you're on a team or enterprise plan, owners can provision skills centrally so every user in your workspace sees them without uploading anything.

here's how:

① go to admin settings → capabilities.

② enable code execution and file creation and skills.

③ use upload skill in admin settings to provision a skill for everyone.

④ set the default status (enabled or disabled) for users.

this is powerful when you have proprietary workflows you want everyone on your team to access. (claude help center)

How to Package Skills for Claude.ai Uploads

anthropic's help center recommends this structure:

① create a folder containing at least a Skill.md file (or SKILL.md for portability).

② add YAML frontmatter at the top with name and description:

---
name: brand-guidelines
description: helps claude follow our brand voice, tone, and style rules
---

# brand guidelines skill

when the user asks about brand voice or style, follow these rules:

1. always use sentence case for headings

2. avoid jargon unless technical context requires it

3. use active voice

...

③ zip the folder. make sure the skill folder is at the root of the zip (not files at the root).

④ upload the zip in settings → capabilities → skills → upload skill.

portability tip: even though claude.ai examples sometimes show Skill.md, use SKILL.md (uppercase) so you don't break compatibility with claude code or the API later. (claude code docs)

Install Partner Skills from the Skills Directory

claude's help center describes a skills directory with partner-built skills for tools like notion, figma, and atlassian. these are designed to work with their MCP (model context protocol) connectors.

the typical flow is:

① browse the skills directory (usually linked from claude.ai or anthropic's docs).

② download the skill zip (often from the partner's github repo).

③ upload it in claude.ai → settings → capabilities → skills.

Common Claude.ai Troubleshooting

issue	likely cause
skills section not visible	code execution isn't enabled
claude isn't using the skill	it's toggled off, or the description is too vague
upload fails	zip too large, missing `Skill.md`, name contains invalid characters, folder structure incorrect

if claude isn't triggering your skill, the most common fix is improving the description. make it explicit about what the skill does and include the exact keywords users will say. (claude help center)

How to Run Claude Skills with Claude Code CLI

this is best when you want skills tied to repos, dev workflows, and automation.

if you're a developer who lives in the terminal, claude code (the CLI) gives you more control than the web interface. you can commit skills into your repos, restrict tool usage, and hook into your existing workflows.

when you're building AI assistants or your own chatbot-style products, the CLI approach gives you the developer-friendly control you need for production workflows.

Where Claude Code Looks for Skills

claude code's documentation defines four locations where it searches for skills, in this order of precedence:

① personal: ~/.claude/skills/

② project: .claude/skills/ (in your current repo)

③ plugin-bundled skills (from installed plugins)

④ managed settings (enterprise override)

skills in project folders (.claude/skills/) take precedence when you're working in that repo. this is perfect for team-specific workflows.

Creating Your First Skill in Claude Code

here's how to create your first skill:

step 1: create a directory for your skill:

mkdir -p ~/.claude/skills/explaining-code

step 2: create ~/.claude/skills/explaining-code/SKILL.md with YAML frontmatter and instructions:

---
name: explaining-code
description: explains code snippets in plain English, focusing on what the code does and why
---

# explaining code skill

when the user asks you to explain code:

1. read the code carefully

2. describe what it does in plain English

3. highlight any gotchas or edge cases

4. suggest improvements if relevant

step 3: verify it loaded by asking claude code:

claude> what skills are available?

claude should list your new skill. (claude code docs)

How Skill Triggering Works (Fix "Not Running" Issues)

claude code loads only each skill's name and description at startup. when your request matches, claude asks permission to use the skill before loading the full content.

if your description says "helps with branding" but users say "check if this follows our style guide," claude might not trigger it. (claude code docs)

make descriptions explicit, specific, and keyword-rich.

Advanced Controls Available Only in Claude Code

claude code includes metadata controls that don't work on other surfaces:

→ allowed-tools: restrict which tools the skill can use without prompting. example: only allow read and write, not bash.

→ context: fork: run the skill in a forked context so it doesn't pollute your main conversation history.

→ hooks: run checks before or after tool usage (e.g., security scans before bash commands).

→ visibility controls: user-invocable: false makes a skill only callable by other skills (not directly by users).

these are extremely useful if you're running skills in dev environments and need safety guardrails. (claude code docs)

How to Share Skills Without Desktop Requirements

claude code's docs outline two main distribution paths:

1) commit skills into repos

put skills in .claude/skills/ and commit them. everyone who clones the repo gets the skills automatically.

2) bundle skills into plugins

create a plugin with a skills/ directory and distribute via a plugin marketplace.

both paths let you share skills without requiring teammates to install desktop. (claude code docs)

Claude Code Troubleshooting Checklist

if your skill isn't working in claude code, check these:

• file must be exactly SKILL.md (case-sensitive).

• YAML frontmatter must start on line 1 with --- and be valid YAML (spaces, not tabs).

• the skill folder must be in one of the four search locations.

• run claude --debug to see loading errors and warnings.

most issues come down to file naming or invalid YAML. (claude code docs)

How to Run Claude Skills via the Claude API

if your goal is "run this skill inside my SaaS, automation, or pipeline," the API is the official production-grade path.

the claude API lets you upload custom skills, load them into the code execution container, and use them programmatically in your own applications. no desktop, no web interface, no CLI required.

but there's one critical constraint you need to know upfront.

The Critical Constraint: No Internet Access in API Skills

anthropic's developer docs are explicit: claude API skills have no network access and cannot install packages during execution.

you only get what's already preinstalled in the code execution container.

this means:

✗ no API calls to external services

✗ no web scraping

✗ no pip install or npm install during runtime

✗ no webhooks or database connections

if your skill needs any of these, you'll have to redesign the architecture (e.g., use tool calling to let your backend handle network operations, then pass results back to claude). (claude developer platform docs)

this single limitation is why many "real-world" skills are hard to run purely via the API.

What You CAN Do with the API

despite the network constraint, the API supports:

• using pre-built agent skills (powerpoint pptx, excel xlsx, word docx, PDF pdf)

• uploading custom skills via the skills API (POST /v1/skills)

• loading skills into the code execution container via the messages API (container.skills)

• running skills with stateful file operations across multi-turn conversations

• downloading generated files (excel, powerpoint, PDFs, etc.) via the files API

(claude developer platform docs)

API Prerequisites (as of January 2026)

to use skills on the API, you need:

① an API key (obviously)

② beta headers in your requests:

betas=[
    "code-execution-2025-08-25",
    "skills-2025-10-02",
    "files-api-2025-04-14"
]

③ code execution tool enabled:

tools=[{"type": "code_execution_20250825", "name": "code_execution"}]

(claude docs: skills guide)

Using Skills in a Messages API Request (Core Pattern)

Include Up to 8 Skills Per Request

the skills guide states you can include up to 8 skills per request in the container parameter.

example structure:

container={
    "skills": [
        {"type": "anthropic", "skill_id": "xlsx", "version": "latest"},
        {"type": "custom", "skill_id": "skill_abc123", "version": "latest"},
    ]
}

Pin Skill Versions for Consistency

both anthropic skills and custom skills support versioning. anthropic-managed skills use date-based versions (e.g., "2025-01-15"). custom skill versions are auto-generated timestamps, and you can request "latest". (claude docs: skills guide)

Multi-Turn Conversations: Reuse the Same Container

the API supports reusing the same container ID across messages so skills can keep working with files statefully across turns.

when you get a response, extract the container_id and pass it back in the next request. this is how skills maintain state (e.g., editing the same excel file across multiple messages). (claude docs: skills guide)

Long-Running Skills: Handle pause_turn Events

the skills guide describes pause_turn stop reasons for long-running skill operations. when you get a pause_turn, send the response back to claude to continue. (claude docs: skills guide)

How to Download Generated Files (Excel/PPT/PDF/Word)

when skills generate files, the response includes file_id values. you must download them using the files API:

file_content = client.files.retrieve(file_id=file_id)

(claude docs: skills guide)

Creating Custom Skills via the Skills API

Upload Requirements and Constraints

anthropic's skills guide lists these requirements when creating a custom skill:

✓ must include SKILL.md at the top level

✓ all files share a common root directory

✓ total upload size under 8MB

✓ name must be lowercase letters/numbers/hyphens only (max 64 characters)

✓ no reserved words in name ("anthropic", "claude")

✓ description must be non-empty (max 1024 characters)

this matters if you're converting a "claude.ai skill" that used spaces or uppercase in the name. you'll need to normalize it for API uploads.

Operational Tooling (List/Retrieve/Delete/Versions)

the skills API supports:

→ listing skills: GET /v1/skills

→ retrieving details: GET /v1/skills/{skill_id}

→ deleting versions: DELETE /v1/skills/{skill_id}/versions/{version}

→ deleting entire skill: DELETE /v1/skills/{skill_id} (after deleting all versions)

(claude docs: skills guide)

How Skills Load in the API Container

when you specify skills in a request:

① skill metadata goes into the system prompt (so claude knows what's available).

② skill files are copied into the container (e.g., under /skills/{directory}/).

③ claude uses them automatically when relevant.

(claude docs: skills guide)

Production Code Example (Portable Mental Model)

here's what production code looks like (simplified python example):

import anthropic

client = anthropic.Anthropic()

resp = client.beta.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=2048,
    betas=[
        "code-execution-2025-08-25",
        "skills-2025-10-02",
        "files-api-2025-04-14"
    ],
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
    container={
        "skills": [
            {"type": "anthropic", "skill_id": "xlsx", "version": "latest"},
            # add custom skills here:
            # {"type": "custom", "skill_id": "skill_...", "version": "latest"},
        ]
    },
    messages=[{
        "role": "user",
        "content": "create an excel budget spreadsheet with formulas for income and expenses."
    }],
)

# download files if generated
for content_block in resp.content:
    if content_block.type == "file":
        file_content = client.files.retrieve(file_id=content_block.file_id)
        # save to disk, upload to S3, etc.

(claude docs: skills guide)

How to Host Anthropic Skills Online So Others Can Use Them

everything above covers running skills yourself. hosting is the flip side of the same problem: you've built a skill and want other people to use it without installing claude desktop, configuring MCP servers, or becoming developers. when someone says "host an anthropic skill online," they mean standing up a runtime where others can execute your skill safely.

be clear about what hosting actually has to handle. claude desktop and claude.ai give you all of this for free locally:

a secure execution environment: containers, VMs, or a sandbox runtime that isolates users from each other

session state: conversation history, working directories, and file persistence between interactions

network policy: default deny with allowlists, or full egress, depending on what the skill needs

secrets handling: api keys and oauth tokens kept secure and separate from the model

tool permissions: allow/block/prompt controls with audit logs for every action

cost controls: token limits, timeouts, concurrency caps, and rate limiting to prevent abuse

observability: logs, traces, error capture, and tool-call auditing for debugging

distribution and UX: a web ui, authentication, and billing if you charge

anthropic explicitly highlights prompt injection and unintended actions as core risks when deploying agents that execute code. whichever hosting option you pick has to take those seriously.

there are four realistic options:

hosting option	best for	the catch
claude.ai org provisioning	distributing skills inside one company	not public; users need claude accounts in your org
custom web app on the messages api	teams with engineering who need specific UI/UX	no network access or runtime installs in the container
self-hosted agent sdk	full control, complex automation, strict compliance	you become a security-sensitive infrastructure operator
always-on hosted instance (agent37 cloud)	shipping now without building infrastructure	you still own the front end and billing

Option 1: Provision Skills Inside an Organization (Claude.ai)

covered step-by-step earlier in this guide (team & enterprise provisioning). owners upload the skill once in admin settings and everyone in the workspace gets it. the catch: this isn't public hosting. users must have claude accounts in your org and work through the claude interface, so you can't hand a customer a link to run your skill independently. if you need customer-facing access, you need one of the next three options.

Option 2: Build a Custom Web App on the Messages API

best for teams comfortable with custom development who need specific ui/ux. you build a web ui backed by the claude messages api: your server takes user input, sends it to claude with your skill loaded via container.skills (the exact request pattern is in the api section above), and returns the response.

browser/ui
  → your backend (auth, rate limits, billing)
      → claude messages api (skills + code execution)
      → optional: MCP connector (remote tools)
  → storage (files, outputs, session logs)
  → observability (logs, traces, audits)

MCP (model context protocol) fits here: if your skill needs live data from notion, jira, a CRM, or a database, MCP delegates those integrations cleanly. constraints to know: the MCP connector needs its own beta headers, only tool calls from the MCP spec are supported, and remote MCP servers must be publicly exposed over HTTPS.

the hidden gotcha is runtime dependencies. api skills cannot install packages at runtime, so everything must already exist in the code execution container. if your skill assumes pip install mid-run, redesign it or move to option 3 or 4. this path works best for skills that are mostly reasoning and file transforms.

Option 3: Self-Host the Claude Agent SDK (Full Control)

best for "real automation" workflows that need bash, python, filesystem operations, and multi-step processes on infrastructure you control. anthropic's hosting guide for the agent sdk makes the production requirements explicit:

run the sdk inside sandboxed container environments for process isolation

python 3.10+ or node 18+ (node is required for the claude code CLI: npm install -g @anthropic-ai/claude-code)

baseline resources of roughly 1 GiB RAM, 5 GiB disk, and 1 CPU per instance, adjusted per workload

outbound HTTPS to api.anthropic.com, plus any MCP servers or external tools

choose your sandbox strategy upfront: anthropic's docs list providers like modal, cloudflare sandboxes, daytona, e2b, fly machines, and vercel sandbox. this choice controls latency, cost, file persistence, and what happens when something goes wrong. unless you enjoy operating container fleets, use one of them.

treat the agent as semi-trusted code execution: permission systems (allow/block/prompt) for tools and commands, static analysis on risky bash, sandbox modes that restrict filesystem and network, egress allowlists, and proxy patterns that keep credentials outside the agent boundary.

what you get is maximum flexibility: custom network policies, your own dependency stack, persistent working directories. what you pay is that you're now operating a security-sensitive, multi-tenant compute product, with billing, quotas, abuse prevention, and observability to build like any saas. for most individual creators this is overkill. it makes sense when skills are part of an existing platform with strict infrastructure requirements.

Option 4: Rent an Always-On Instance (Agent37 Cloud)

best for getting a skill online this week without becoming an infrastructure company. agent37 cloud provisions an always-on cloud computer with one api call: a persistent linux instance that runs hermes (the default template), openclaw, or any public docker image. you set up the agent sdk or claude code on it once, add your skills, and every user request hits the same persistent runtime.

always-on from $3.44/mo, metered per minute from a prepaid balance, no seats, delete anytime

kernel-level isolation (gVisor) with hard disk quotas

files, memory, and sessions persist until you delete the instance

public ports and custom domains, so the front end for your skill can live at your own url

scheduled runs, webhooks, a files api, logs, and metrics built in

bring your own anthropic key (it goes straight from the container to the model provider), or use managed credentials metered at cost behind a per-instance spend cap

white-label by default: your customers never see agent37, and a white-label starter kit (a multi-tenant dashboard you fork and rebrand) exists if you're selling access under your own brand

what it deliberately doesn't do: there's no skills marketplace and no revenue share. billing your users is yours to own, which also means everything you charge is yours to keep. new workspaces get a $1 starter credit (about a week of the cheapest instance) to test the setup.

when self-hosting (option 3) is still better: bespoke compliance that requires your own infrastructure boundary, or embedding skills into an existing platform with strict internal constraints. the next section walks through the agent37 path in more detail.

How to Host and Monetize Claude Skills on the Web (Agent37)

here's the reality: anthropic gives you multiple official runtimes, but none are "a skill as a shareable, monetizable web product" out of the box.

what each method actually gives you:

• claude.ai skills → great for you and your org, but sharing externally requires others to have the right plan and upload zips manually.

• claude code → perfect for developers, but your customers won't install a CLI to "use your skill."

• claude API → powerful for product teams, but has no network access, and requires engineering, hosting, billing infrastructure, and ongoing maintenance. (claude developer platform docs)

agent37 exists to close that gap.

agent37 cloud gives you the missing runtime layer: an always-on cloud computer that runs your skill 24/7 behind an api, so users hit a link instead of installing anything. creators who want to monetize their claude code skills put their own front end and billing on top; the instance is white-label by default, so your customers never see agent37.

if you've outgrown chat-only tools, this is the shape of the fix: not another chatbot builder, but a persistent machine that runs claude's full agent capabilities server-side.

When a Hosted Runtime Makes Sense

if your definition of success is:

"my customers can use this skill right now in the browser"

→ you don't want users uploading zips or running commands. they should click a link, log in, and start using it.

"i don't want to ship source files"

→ distributing a zip means anyone can inspect, modify, or redistribute your skill. a hosted runtime keeps your IP protected.

"i want to charge for access without racking servers"

→ you keep billing on your side (a stripe checkout is a weekend project) and let the hosted runtime handle the hard part: running the skill reliably for every customer.

then a hosted runtime is the cleanest path.

How It Works on Agent37

① create a workspace at agent37.com/cloud (new workspaces get a $1 starter credit, roughly a week of the cheapest instance)

② provision an instance with POST /v1/instances: an always-on computer running hermes (the default template), openclaw, or any public docker image

③ set up claude code or the agent sdk on it and drop your skills onto the instance (your anthropic key goes straight from the container to the model provider)

④ run turns via POST /v1/responses on your instance url (with SSE streaming), or expose your own web front end on a public port with a custom domain

⑤ share the link with users and, if you're charging, plug in your own billing. files, memory, and sessions persist until you delete the instance

pricing: instances start at $3.44/mo always-on, metered per minute from a prepaid balance. no seats, no revenue share: agent37 charges for compute, not a cut of your product.

What Makes Agent37 Different from Other Platforms

skills running on an agent37 cloud instance can do everything claude code can do locally, because the instance is a real linux computer:

✓ execute in a sandbox environment

✓ access the internet

✓ make API calls

✓ scrape websites

✓ run bash commands

✓ execute python scripts

✓ process files (CSVs, PDFs, etc.)

✓ generate documents

this is fundamentally more powerful than customGPTs. you're running actual claude agent SDK workflows on the web, not just a chatbot with uploaded context.

plus operational extras you'd otherwise have to build: scheduled and cron runs, a files api, shell command execution, webhooks, logs, metrics, public ports, and custom domains.

if you're trying to monetize a skill, this is the fastest way to get from "i built this" to "people can use it": the runtime is rented, and the business on top stays 100% yours.

this is the gap: anthropic made skills portable by format. an always-on runtime makes them usable by people who will never install anything.

The Portability Playbook: Write Once, Run Anywhere

this is where most skill authors lose weeks.

you build a skill for claude.ai, then try to run it via the API and it breaks because of naming rules or network calls. or you build for claude code and upload to claude.ai and the description doesn't trigger properly.

here's how to make a skill that works everywhere.

1) Use the Open Standard (Stick to the Strict Subset)

anthropic published agent skills as an open standard for cross-platform portability (announced december 18, 2025). (anthropic engineering blog)

to maximize compatibility across claude code, API, and claude.ai, do this:

✓ file name: SKILL.md (uppercase, not Skill.md)

✓ YAML name: lowercase letters, numbers, hyphens only (e.g., brand-guidelines, not brand guidelines)

✓ description: extremely explicit about actions and trigger keywords users will say

(claude code docs)

yes, claude.ai examples sometimes show Skill.md and friendly names. but if you use the stricter subset, you'll never have compatibility issues.

2) Design for the Harshest Runtime First (Usually the API)

if you want the same skill to run via the API and everywhere else, assume:

✗ no network access

✗ no runtime dependency installs

then, optionally add "enhanced mode" behavior when network and package installs are available (in claude.ai or claude code). (claude developer platform docs)

example: your skill could check if network is available, and if so, fetch live data. if not, use cached reference data bundled in the skill.

3) Use Progressive Disclosure Aggressively

anthropic's docs emphasize that skills scale because you don't load everything into context at once. (claude developer platform docs)

structure your skill like an onboarding guide:

my-skill/
  SKILL.md         # quickstart + routing rules (load first)
  REFERENCE.md     # deep reference (load only if needed)
  CHECKLISTS.md    # situation-specific playbooks
  scripts/
    validate.py    # deterministic operations

this aligns with how skills are meant to work: metadata first, then instructions, then resources/scripts as needed.

4) Treat Skills Like Software Installs (Security)

anthropic is blunt: skills can include instructions and code, and a malicious skill could cause tool misuse or data exfiltration.

best practices from anthropic's docs include:

• only install skills from trusted sources

• audit all bundled files and scripts before use

• don't hardcode secrets (use environment variables)

• be careful with skills that fetch external URLs (prompt injection / dependency compromise risks)

• for claude code, restrict tools with allowed-tools where appropriate

(claude developer platform docs)

if you're hosting a skill publicly (options 2 through 4 in the hosting section), the bar is higher. this checklist separates "cool demo" from "you can actually sell this":

isolation and blast radius: one sandbox per user or session, never shared across customers, with cpu, memory, and time limits enforced and an ephemeral filesystem unless persistence is explicitly needed

network controls: default deny with explicit allowlists. if you allow egress, route it through a proxy that enforces destinations and strips secrets

tool permissions: implement allow/block/prompt at the tool layer and audit-log every tool call (user, timestamp, args, result size)

prompt injection hygiene: don't blindly execute instructions found in files or web pages, and prefer summarized search results over raw scraped content

MCP trust boundaries: only connect to MCP servers you trust. anthropic explicitly warns these are third-party services you should evaluate

a hosted runtime covers part of this for you (agent37 cloud isolates every instance at the kernel level with gVisor and enforces hard disk quotas), but tool permissions and injection hygiene are still your skill's job.

5) Make Your Skill Host-Ready (Descriptions, Compatibility, Dependencies)

if your skill doesn't activate reliably in someone else's runtime, nothing else matters. three habits carry most of the weight:

keep the description under 200 characters. the spec technically allows more, but different surfaces enforce stricter limits than the open spec, and short, keyword-rich descriptions reduce upload friction and improve activation.

declare compatibility like you mean it. the compatibility field exists for environment requirements: "requires outbound HTTPS to api.example.com", "requires git and jq", "designed for claude code / agent sdk". in hosted settings this prevents invisible misconfigurations.

plan your dependency story upfront. api-hosted skills can't install packages at runtime, so either bundle what you need as scripts that run on the preinstalled environment, or choose a runtime where you control the installed stack (a self-hosted sdk deployment or an always-on instance).

Troubleshooting: Why Your Skill Won't Run

Claude.ai (Web) Troubleshooting

issue	fix
don't see skills section	code execution isn't enabled, or your org disabled it
skill upload fails	zip too large, missing required file (`Skill.md`), invalid name/description, folder structure incorrect
skill doesn't trigger	description is too vague; add explicit trigger terms that users will actually say

(claude help center)

Claude Code (CLI) Troubleshooting

issue	fix
skill won't load	wrong directory or wrong filename (`SKILL.md` is case-sensitive)
no error message	run `claude --debug` to see loading errors
skill triggers but fails	check YAML frontmatter syntax (spaces, not tabs); verify paths in scripts use forward slashes

(claude code docs)

Claude API Troubleshooting

issue	fix
skill not available	missing required beta headers or tools config
skill fails with network error	API skills have no network access by design (docs)
upload fails	check 8MB size cap, `name` rules (lowercase-hyphen only), `description` non-empty
prompt caching breaks	adding/removing skills changes the system prompt; keep skills list consistent across requests when using caching

(claude docs: skills guide)

The Strategic Insight: Distribution Is the Remaining Challenge

anthropic has made skills portable by format (they published the open standard) and available across products (web, CLI, API). (anthropic engineering blog)

what's still hard for most skill creators is distribution and "running for other people":

• claude.ai is account-bound (and for teams, org-bound). (claude help center)

• claude code is dev-centric and requires CLI comfort.

• API integration is engineering-heavy and network-limited. (claude developer platform docs)

so the market gap isn't "can skills run without desktop?" (they can).

the gap is: can skills run without installs, without engineering, and with a business model?

that's where agent37 fits: not another app to install, but an always-on cloud instance for your skill (from $3.44/mo) with isolation, persistence, scheduling, domains, and logs already handled. the only thing left to build is your product.

if you've built a skill that solves a real problem, you should be able to share a link and start charging. not ship zip files, not require installs, not build your own SaaS platform from scratch.

for creators who want distribution without the typical engineering overhead, that changes the job from "build a saas platform" to "build a skill and put a front end on a rented runtime."

anthropic solved format portability. hosting solves distribution. the business model on top is yours to keep.

FAQ: Running Claude Skills Without Desktop

can i run skills on windows without claude desktop?

yes. use claude.ai (web), claude code (CLI), or the API. all three work on windows without requiring desktop.

do skills work the same everywhere?

no. runtime constraints differ (especially network access). skills on the API have no network access and can't install packages. claude.ai and claude code have fewer restrictions. packaging rules also vary slightly (use the stricter SKILL.md + lowercase-hyphen name for portability).

how do i share a skill with non-technical users?

if they're in your organization, provision via claude.ai team/enterprise. if they're customers, host the skill on an always-on instance (like agent37 cloud) and share the link to your front end; they never install anything.

what's the difference between claude.ai skills and claude code skills?

same format (agent skills open standard), but different environments. claude.ai is web-based with account/org provisioning. claude code is CLI-based with repo and plugin distribution. both use SKILL.md and YAML frontmatter.

can i monetize skills without building my own platform?

not the way app stores work, no: there's no official paid skills marketplace with a revenue split today. the practical path is to host the skill on an always-on instance (agent37 cloud starts at $3.44/mo), put your own checkout in front of it, and keep everything you charge. our guide on monetizing claude code skills covers pricing and packaging.

whether you're building an internal assistant or a customer-facing product, agent37 handles the infrastructure so you can focus on the skill itself.

is there a size limit for skills?

yes. claude API uploads have an 8MB cap. claude.ai uploads have size limits (exact cap varies by plan). keep skills lean by using progressive disclosure and loading resources only when needed.

why can't API skills access the internet?

security and isolation. the code execution container has no network access by design. (anthropic docs) if you need network operations, use tool calling to let your backend handle them and pass results back to claude.

what's the easiest way to get started?

for personal use: upload a skill to claude.ai (settings → capabilities → skills). for sharing with customers: provision an agent37 cloud instance, load your skill, and share the link (the $1 starter credit covers about a week of testing).

can i embed a hosted skill on my own website?

yes, if you control the runtime. an agent37 cloud instance exposes public ports and custom domains, so the front end you build for your skill can live on your own domain and be embedded anywhere you like. with a custom messages-api app, you own the ui entirely.

what happens to users when i update my skill?

on claude.ai, every user has to re-upload the new zip. on the api, you upload a new version and pin it (or request "latest"). on a hosted instance, you update the skill files once on the server and every user is on the new version immediately. no "please download v2" emails.

do my users need their own anthropic api keys?

no. whoever operates the runtime holds the key. on an agent37 cloud instance, your key goes straight from the container to the model provider (or you use managed credentials metered at cost behind a spend cap). users just use your product.

can i see how people use my hosted skill?

instrument the front end like any web product. on the runtime side, agent37 cloud exposes logs and metrics per instance, and if you self-host the sdk you own the whole observability stack. keep tool-call audit logs from day one; they double as debugging and security evidence.

what about a voice interface?

nothing in the skills format is voice-specific. if you want voice, wire speech-to-text and text-to-speech into the web app in front of your runtime. the skill itself doesn't change.