skill-creator

Skill Creator

Overview

Skill Creator is a TypeScript CLI that takes an OpenAPI spec, GraphQL schema, or MCP server URL and generates a complete, reusable AI agent skill — wrapper scripts, reference docs, usage notes, and all. It hit 500 GitHub stars within two weeks of its late May 2026 launch, which tracks with how aggressively the developer tooling space is moving toward agent-first workflows.

The project is built by sandiiarov, a developer who’s clearly been living in the API tooling trenches. The repo is a single maintainer operation with 72 forks already, suggesting people aren’t just starring it — they’re building on it. The codebase is clean TypeScript, tested on Node 26, and published as a single npm package (@asnd/skill-creator).

The core problem it solves is painfully familiar to anyone working with AI coding agents: you have an API your agent needs to use, but the only way to make that happen is pasting giant OpenAPI specs or documentation URLs into every single conversation. Context windows fill up, agents hallucinate endpoint paths, and you end up re-explaining the same API in every session. Skill Creator collapses that workflow into one command. Point it at a spec, and it produces a structured skill directory with discoverable commands, wrapper scripts, and focused documentation that any future agent session can reference without re-reading the full spec.

Why it matters

We’re in the middle of a shift where AI coding agents are becoming the primary interface for developers. Claude Code, Cursor, Codex, Windsurf, Gemini CLI — the list grows every month. But there’s a missing layer between “here’s a raw API spec” and “here’s a thing my agent can actually use reliably.” MCP (Model Context Protocol) is solving part of this for tool integrations, but most of the world’s APIs are still documented as OpenAPI specs or GraphQL schemas, not MCP servers.

Skill Creator sits in that gap. It’s not trying to replace MCP or compete with API gateways. It’s solving the specific friction of making any API source agent-consumable with minimal effort. The generated skills include wrapper scripts that expose commands list, commands search, and commands help — turning opaque API specs into discoverable, self-documenting CLI tools that agents can navigate without guessing.

The broader trend here is the “agent skill” ecosystem that’s forming around coding assistants. Projects like Cursor’s rules files, Claude Code’s custom commands, and Pi’s skill system are all trying to solve the same problem: how do you give an agent persistent, reusable knowledge? Skill Creator takes a pragmatic approach — don’t build a platform, just generate the files.

Key Features

Multi-Source Input Support. Skill Creator handles three distinct API specification formats: OpenAPI (REST), GraphQL schemas (via endpoint introspection or SDL files), and MCP servers (both HTTP Streamable/SSE and stdio transport). This isn’t a one-trick tool — it covers the majority of how modern APIs are documented and exposed. Each input type gets its own template and generation logic.

Agent-Agnostic Installation. The generated skills work across the entire landscape of coding agents. Out of the box, it supports Pi, Claude Code, Codex, Cursor, OpenCode, Gemini CLI, GitHub Copilot, Cline, and Windsurf. Install a skill globally or per-project. The wrapper scripts use npx -y @asnd/skill-creator internally, so consumers don’t even need a global install — zero-dependency consumption.

Self-Improving Skill Loop. This is the most clever architectural decision. Generated skills are tracked in a lock file (~/.skill-creator/lock.json). A companion improvement skill monitors real agent usage and patches the generated skill’s “Gotchas” section when the agent discovers reusable patterns, corrections, or faster workflows. The skill literally gets better the more you use it. The lock file check prevents the improvement skill from touching skills that weren’t generated by Skill Creator, which is a nice safety boundary.

Runtime CLI for Direct API Access. Beyond skill generation, the tool doubles as a general-purpose CLI for interacting with APIs directly. Run npx @asnd/skill-creator --spec ./openapi.yaml run --pretty <command> <flags> to make API calls from the shell without writing any client code. Useful for quick testing, CI pipelines, or situations where you just need to hit an endpoint once.

Secrets-Aware Design. Authentication headers can reference environment variables or file paths (--auth-header 'Header:env:API_KEY' or --auth-header 'Header:file:/path/token'). Generated skills inherit this pattern, keeping secrets out of documentation and committed files. This isn’t an afterthought — it’s how the tool is designed to work in real development environments.

Caching and Reproducibility. Remote specs, schemas, and MCP tool lists are cached under ~/.cache/skill-creator with configurable TTL. Specs are saved as reference files inside the generated skill directory, so future runs are reproducible even if the upstream spec changes. Override the cache directory with SKILL_CREATOR_CACHE_DIR for CI environments.

Structured Discovery Commands. Generated wrapper scripts expose three discovery commands: commands list (all available operations), commands search (fuzzy search across commands), and commands help (detailed usage for a specific command). This turns a flat API spec into a navigable interface that agents can explore incrementally instead of reading the entire spec upfront.

Use Cases

• Internal API teams — Generate skills for your company’s internal APIs so any developer on the team can use them through their coding agent without reading documentation. New team members onboard faster when their agent already knows the API surface.

• Third-party API integration — Working with Stripe, Twilio, GitHub, or any API that publishes an OpenAPI spec? Generate a skill once and use it across all your projects. No more re-reading docs for every new codebase.

• GraphQL-heavy projects — If your team uses GraphQL, Skill Creator introspects the schema and generates discoverable commands. This is particularly useful for large schemas where finding the right query or mutation is half the battle.

• MCP server adoption — As MCP becomes the standard for tool integration, Skill Creator bridges the gap between existing APIs and the MCP ecosystem. Generate a skill from an MCP server to give your agent structured access without manual configuration.

• CI/CD automation — Use the runtime CLI to make API calls in deployment scripts, health checks, or integration tests without writing language-specific client code.

• API documentation as code — Generated skill directories serve as living documentation that stays in sync with the actual API surface, unlike hand-written docs that drift over time.

Pros and Cons

Pros:

• Solves a real, daily friction point for developers using coding agents. The “paste an API spec into every conversation” problem is universal, and this is the cleanest solution I’ve seen.
• Multi-source support (OpenAPI, GraphQL, MCP) means it’s not locked into one API paradigm. Most teams have a mix of REST and GraphQL services.
• The self-improving skill loop is genuinely clever — skills get better with use, which compounds value over time.
• Single npm package, no infrastructure dependencies. Works entirely locally with npx.
• MIT licensed, actively maintained with commits in the last 48 hours.

Cons:

• Node.js 22+ requirement excludes teams on older LTS versions. Node 22 only went LTS in October 2024, and many production environments haven’t upgraded yet.
• Single maintainer project with 544 stars — adoption is growing fast but the bus factor is one. Enterprise teams should evaluate whether the generated output is simple enough to maintain independently.
• The self-improvement loop only works with agents that have file-write access to the skill directory. Some sandboxed agent environments may not support this.
• No built-in authentication for MCP stdio servers that require environment setup beyond simple env vars. Complex auth flows still need manual configuration.

Getting Started

# Install the skill-creator command for your agent
npx @asnd/skill-creator command install --agent claude-code --scope global

# Generate a skill from an OpenAPI spec
npx @asnd/skill-creator generate \
  --template openapi \
  --name stripe \
  --spec https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json \
  --agent claude-code \
  --scope project

# Generate a skill from a GraphQL endpoint
npx @asnd/skill-creator generate \
  --template graphql \
  --name pokeapi \
  --graphql https://graphql-pokeapi.graphonaut.app/v1beta \
  --agent claude-code \
  --scope project

# Generate a skill from an MCP server
npx @asnd/skill-creator generate \
  --template mcp-http \
  --name context7 \
  --mcp https://mcp.context7.com/mcp \
  --agent claude-code \
  --scope project

# Use the runtime CLI directly
npx @asnd/skill-creator --spec ./openapi.yaml commands list
npx @asnd/skill-creator --spec ./openapi.yaml run --pretty <command> <flags>

Alternatives

MCP (Model Context Protocol) — Anthropic’s protocol for connecting AI agents to external tools and data sources. MCP is the right long-term solution if you control the server side and can add an MCP server implementation. Skill Creator is the pragmatic middle ground for the thousands of APIs that only have OpenAPI or GraphQL specs and won’t get native MCP support anytime soon. Use MCP when you can build the server; use Skill Creator when you can’t.

Swagger Codegen / OpenAPI Generator — These generate language-specific API clients from OpenAPI specs, which is a different problem. They produce typed SDK code for your application, not agent-consumable skills. If you need a TypeScript client for your React app, use OpenAPI Generator. If you need your coding agent to understand and use an API without you explaining it every time, use Skill Creator.

Manual Skill Files — You can always hand-write SKILL.md files and wrapper scripts for your coding agent. For simple APIs with 5-10 endpoints, this might be faster. Skill Creator earns its keep on complex APIs with dozens or hundreds of endpoints where manual authoring would take hours and drift out of sync with the spec.

Verdict

Skill Creator fills a gap that almost every developer using AI coding agents has felt but rarely articulated: APIs are documented for humans, not for agents. The tool is pragmatic, well-engineered, and solves a real problem without overengineering the solution. At 544 stars in under two weeks with 72 forks, the developer community is responding to the same pain point. The self-improving skill loop is the feature that elevates this from “useful CLI” to “compounding productivity tool.” If you’re working with any API that publishes an OpenAPI spec, GraphQL schema, or MCP server — and in 2026, who isn’t — give it five minutes. You’ll know immediately if it fits your workflow.