Model or dataset
sandiiarov/skill-creator avatar
sandiiarov/skill-creator

skill-creator: turn an OpenAPI spec, a GraphQL schema or an MCP server into a slash command

Turn any MCP server, OpenAPI spec, or GraphQL endpoint into a CLI at runtime.

612 stars39 forksTypeScriptMIT

At a glance

What is it?
skill-creator installs one slash command that asks an agent to read a spec or a server and emit a small wrapper skill with a SKILL.md, a script and a dated reference copy. The design detail that keeps it out of your hand-written work is the lock file: the improvement companion only touches skills it generated.
Who is it for?
Use skill-creator if your agents keep re-reading the same API documentation, and if you would rather commit a small wrapper script per service than a wall of pasted docs. Do not use it for a one-off call, where the runtime CLI does the same job without generating files.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 166 days ago.
What is it written in?
Mainly TypeScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • sandiiarov/skill-creator612 ★ · +10
Star history
Repository2026-09-212026-11-15
sandiiarov/skill-creator602612

10 Stars in the last 55 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

One npx command installs a prompt command and a companion skill

Installation is a single invocation through npx:

bash
npx @asnd/skill-creator command install --agent pi --scope global

That writes two things: a prompt command at `~/.pi/agent/prompts/skill-creator.md`, and a companion skill directory at `~/.pi/agent/skills/skill-creator-improvement/`. Switching `--scope` from `global` to `project` installs the same pair inside the current repository instead, and `--no-improvement-skill` installs only the prompt command when you do not want the second half.

The runtime requirement is unusually specific. Node.js must satisfy `^22.22.2 || ^24.15.0 || >=26.0.0`, three ranges with patch-level floors on the two lower branches, and CI runs on Node 26.

The premise of the whole tool is stated in one line: rather than pasting API documentation into every chat, you install one slash command and let your agent build reusable command-line skills for the tools your team already uses.

Nine agents, one flag, and the supported list is agent CLIs

The `--agent` flag is the whole targeting mechanism. Alongside `pi`, the README names `claude-code`, `codex`, `cursor`, `opencode`, `gemini-cli`, `github-copilot`, `cline` and `windsurf`, which is nine targets in total.

Reading that list closely says something about scope. Every entry is an agent with its own command surface and its own configuration directory, which is why the install path for `pi` is nested under `~/.pi/agent/` rather than written to a shared location. Chat interfaces are not on the list, which matches the tool's design: what gets installed is a prompt file and a skill directory that an agent loads, and there is nowhere for that to live in a chat window.

The same reasoning applies to usage. You open your agent and run the slash command with the source you want turned into a skill, then answer whatever install questions are missing, and the agent does the work. Passing `--agent` and `--scope` at generation time rather than install time means the same install can produce a project-local skill for one repository and a global one for another.

Generated scripts shell out to npx, so there is no global install to keep in sync

A generated skill is three things in a directory named after the skill: a `SKILL.md`, a `scripts/` directory holding one executable named after the skill, and a `references/` directory holding the captured spec.

The reference filename carries a date stamp in the pattern `openapi-spec-MM-DD-YYYY.json`, so what the skill was built against stays visible in the filename. That is a snapshot, not a live link, which means a later API change will not be picked up by the skill until it is regenerated.

The wrapper exposes four command shapes rather than one: `commands list`, `commands search <term>`, `commands help <command>` and `run --pretty <command> <flags>`.

The important implementation detail is that generated scripts invoke `npx -y @asnd/skill-creator` internally. Consumers of a generated skill do not need a global install of anything, and the skill keeps working when the underlying package is upgraded, since the wrapper resolves the current version at call time. The price is that every invocation pays for a package resolution.

The lock file is what keeps the improvement skill away from your own work

The companion `skill-creator-improvement` skill is allowed to edit generated skills during real use. When an agent hits a reusable gotcha, finds a custom field, corrects a command pattern or finds a faster workflow, it writes that into the generated skill's `## Gotchas` section directly.

The boundary is a file. Generated skills are tracked in `~/.skill-creator/lock.json`, and the improvement skill only operates on skills present there. That is what stops it rewriting a hand-written skill that happens to sit in the same directory.

The other half of the loop is prompt-side. After each generation the companion skill's description is refreshed to include every tracked generated skill name, which raises the odds the agent activates it in the first place. It is a small, deliberate piece of prompt engineering: a skill that is never selected cannot improve anything, and a skill that selects itself edits only its own output.

Secrets arrive through --auth-header, and the cache lives under your home directory

Credentials are passed as header descriptors rather than as flags holding values. `--auth-header 'Header:env:NAME'` reads a secret out of an environment variable and `--auth-header 'Header:file:/path/token'` reads it out of a file, and both are repeatable so a service needing two headers takes two flags.

That design keeps the value out of the command line, which matters for a tool whose output is meant to be committed.

The remaining flags fall into three groups. Discovery is filtered with `--include`, `--exclude` and `--methods`. GraphQL response shaping uses `--fields` and `--selection-depth`. Output control covers `--stdin` for JSON object input plus `--pretty`, `--raw` and `--head N`.

Transport and caching are separate again. `--transport` accepts `auto`, `streamable` or `sse`, with `auto` trying Streamable HTTP and falling back to SSE, and `--base-url` overrides the server URL recorded in an OpenAPI spec. Remote specs, GraphQL introspection results and MCP tool lists are cached under `~/.cache/skill-creator`, with `SKILL_CREATOR_CACHE_DIR` to move it and `--cache-key`, `--cache-ttl` and `--refresh` to control it.

Four generation templates, and a flag set built for CI

Everything the slash command does is available directly from the shell, which is what makes the tool usable in a pipeline. The generate call takes a `--template`, and four are documented: `openapi`, `graphql`, `mcp-http` and `mcp-stdio`.

A shell generation for an OpenAPI source passes the template, a name, the spec URL, the agent and the scope. The GraphQL variant adds `--graphql` and `--graphql-schema`, and the MCP variants take either `--mcp` for an HTTP server or `--mcp-stdio` with a command string such as an npx invocation.

Seven generation flags are listed for narrowing the output: `--script` to set the script name, `--auth-header`, `--base-url`, `--description` for the skill activation text, `--force` to overwrite, `--no-test` to skip the smoke test, and `--yes` to stop prompting. Those last two exist because the same call has to work unattended.

The runtime CLI is the same package with the source passed directly, so `commands list` against a spec file will show you what a generated skill would expose before you generate anything.

Sixteen dependencies, four GraphQL loaders, and a native compiler in devDependencies

The runtime dependency list has 16 entries and a quarter of it is GraphQL loading: `@graphql-tools/load`, `@graphql-tools/url-loader`, `@graphql-tools/graphql-file-loader` and `@graphql-tools/json-file-loader`. That buys a spec or schema from a URL or from a local file without writing loaders.

The rest follows the three source types. `@modelcontextprotocol/sdk` covers MCP transport, `ajv` with `ajv-formats` validates the OpenAPI schema, `ky` is the HTTP client, `cacache` backs the on-disk cache, `string-argv` handles shell-style argument splitting, `zod` covers the CLI's own schemas, and `@apidevtools/json-schema-ref-parser` resolves references in the spec.

The development side is where the project is opinionated. Formatting and linting use `oxfmt` and `oxlint` rather than the prettier and eslint pairing, tests run under vitest with a separate `bash e2e/run.sh`, and there are two TypeScript configs with one for the build. Type checking and the build both run through `tsgo`, pinned in devDependencies to a native preview build at `7.0.0-dev.20260521.1`, which is a compiler prerelease rather than a stable release.

The published files list ships `dist`, `prompts`, `skills`, `LICENSE` and `README.md`, and the root holds 19 entries including `prompts/` and `skills/` as real directories rather than generated ones.

Editorial conclusion

Use skill-creator if your agents keep re-reading the same API documentation, and if you would rather commit a small wrapper script per service than a wall of pasted docs. Do not use it for a one-off call, where the runtime CLI does the same job without generating files. Before installing, note the Node range is three specific floors rather than a single minimum, decide between a global and a project scope, and remember that generated scripts invoke npx on every call, so the cost lands on latency rather than on your machine.

Frequently asked questions

How to install skill creator?

Run `npx @asnd/skill-creator command install --agent pi --scope global`, which writes `~/.pi/agent/prompts/skill-creator.md` and the `skill-creator-improvement` skill directory. Use `--scope project` for a repository-local install and `--no-improvement-skill` to skip the companion. Node.js must satisfy `^22.22.2 || ^24.15.0 || >=26.0.0`.

how to use skill-creator

Open your agent and run `/skill-creator` with the source you want turned into a skill, for example a spec URL, a `--graphql` endpoint with a `--graphql-schema`, an `--mcp` server or an `--mcp-stdio` command. Answer any missing install questions and the agent creates the skill, producing a SKILL.md, a wrapper script and a dated copy of the spec under `references/`.

how to use skill-creator in claude code

claude-code is one of the supported `--agent` values, alongside pi, codex, cursor, opencode, gemini-cli, github-copilot, cline and windsurf. Install it with `npx @asnd/skill-creator command install --agent claude-code --scope project`, then run the `/skill-creator` command with your spec, schema or MCP server.

how to use skill creator in github copilot

github-copilot is also a supported agent value for both install and generate. The install command is `npx @asnd/skill-creator command install --agent github-copilot`, and you can pass `--scope global` or `--scope project` to control where the prompt command and companion skill are written.

Official sources

  1. Issues
  2. License: MIT
  3. README
  4. Releases
  5. sandiiarov/skill-creator on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/sandiiarov-skill-creator.svg)](https://hysenlabs.com/projects/sandiiarov-skill-creator)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/sandiiarov-skill-creator.svg)](https://hysenlabs.com/projects/sandiiarov-skill-creator)

Was this useful?