CLI creator from API docs

Builds a durable CLI from API docs, an OpenAPI spec, curls or a script: JSON output, doctor and dry-run commands, safe auth, installed on PATH and paired with a companion skill. Use when an agent keeps hitting the same service through ad hoc calls.

CodingPack: OpenAI skills160 linescli-creator
Author
Source
openai/skills/skills/.curated/cli-creator @ 49f948f
License
Apache-2.0

About this skill

What it does

The skill has the agent build a durable command-line tool from API docs, an OpenAPI spec, curl examples, an SDK, a web app or a script, so later agent sessions can call it by name from any repository.

The agent confirms the name is free with command -v, checks installed toolchains and picks one: Rust by default (clap, reqwest, serde), TypeScript/Node when an official SDK is the reason, Python for data and file work. Before coding it sketches the commands in chat: --json doctor to report config, auth source and reachability without printing tokens; discovery, resolve-to-ID, read and narrow write commands with --dry-run or drafts; bounded pagination; a raw request escape hatch. Auth comes from an environment variable or a config file; DevTools curls become sanitized notes without cookies or tokens.

The tool is installed on PATH and smoke-tested from another directory. Then the agent writes a small companion skill: which command to run first, the safe read path, what not to run without approval. references/agent-cli-patterns.md covers help text, JSON and exit codes, pagination and a companion-skill template.

When to use it, and when not

Use it when an agent keeps reaching the same service through ad hoc curl calls or a fragile script.

Skip it for a one-time task or a service that already ships a good official CLI.

How to run it

The install command below puts the whole folder in place: SKILL.md, the reference file, the Codex metadata file and the licence. You need the chosen toolchain and credentials for the target service. To call it:

  • Claude Code: /cli-creator, or ask for the skill by name.
  • Codex: $cli-creator.
  • Cursor: type / in the Agent chat and pick cli-creator.

Example: /cli-creator Build a CLI from the Buildkite REST docs: list pipelines, find failed builds, download job logs. Install it as bk-logs.

The companion skill goes to $CODEX_HOME/skills/<tool-name>/ by default; in other agents, name their skills folder. OpenAI has marked openai/skills deprecated; our copy is pinned to a commit there, and as of November 2026 openai/plugins has no newer version of this skill.

How it differs from similar skills

MCP server builder wraps an API as MCP tools for a client; this skill wraps it as shell commands with JSON output for any agent with a terminal. Bash wizard for manual steps writes a throwaway script that walks a human through steps only they can do. Skill creator with evals goes further on the companion skill if you want it tested.

Install

Run one command — it saves SKILL.md and the files it uses into your agent's skills folder. Claude Code and Codex pick up a new skill without a restart; if it does not show up, restart the agent.

Claude Code — macOS, Linux
curl -fsSL --create-dirs -o ~/.claude/skills/cli-creator/SKILL.md https://anymodel.org/en/skills/openai/cli-creator/SKILL.md -o ~/.claude/skills/cli-creator/LICENSE.txt https://anymodel.org/en/skills/openai/cli-creator/LICENSE.txt -o ~/.claude/skills/cli-creator/agents/openai.yaml https://anymodel.org/en/skills/openai/cli-creator/agents/openai.yaml -o ~/.claude/skills/cli-creator/references/agent-cli-patterns.md https://anymodel.org/en/skills/openai/cli-creator/references/agent-cli-patterns.md
Codex, Cursor — macOS, Linux
curl -fsSL --create-dirs -o ~/.agents/skills/cli-creator/SKILL.md https://anymodel.org/en/skills/openai/cli-creator/SKILL.md -o ~/.agents/skills/cli-creator/LICENSE.txt https://anymodel.org/en/skills/openai/cli-creator/LICENSE.txt -o ~/.agents/skills/cli-creator/agents/openai.yaml https://anymodel.org/en/skills/openai/cli-creator/agents/openai.yaml -o ~/.agents/skills/cli-creator/references/agent-cli-patterns.md https://anymodel.org/en/skills/openai/cli-creator/references/agent-cli-patterns.md
Claude Code — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE.txt','agents/openai.yaml','references/agent-cli-patterns.md') { $p = Join-Path "$HOME\.claude\skills\cli-creator" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/openai/cli-creator/$f" -UseBasicParsing -OutFile $p }
Codex, Cursor — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE.txt','agents/openai.yaml','references/agent-cli-patterns.md') { $p = Join-Path "$HOME\.agents\skills\cli-creator" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/openai/cli-creator/$f" -UseBasicParsing -OutFile $p }

Any other agent: save the file into its skills folder, or give it the link to the file: https://anymodel.org/en/skills/openai/cli-creator/SKILL.md

SKILL.md

Raw

CLI Creator

Create a real CLI that future Codex threads can run by command name from any working directory.

This skill is for durable tools, not one-off scripts. If a short script in the current repo solves the task, write the script there instead.

Start

Name the target tool, its source, and the first real jobs it should do:

  • Source: API docs, OpenAPI JSON, SDK docs, curl examples, browser app, existing internal script, article, or working shell history.
  • Jobs: literal reads/writes such as list drafts, download failed job logs, search messages, upload media, read queue schedule.
  • Install name: a short binary name such as ci-logs, slack-cli, sentry-cli, or buildkite-logs.

Prefer a new folder under ~/code/clis/<tool-name> when the user wants a personal tool and has not named a repo.

Before scaffolding, check whether the proposed command already exists:

command -v <tool-name> || true

If it exists, choose a clearer install name or ask the user.

Choose the Runtime

Before choosing, inspect the user's machine and source material:

command -v cargo rustc node pnpm npm python3 uv || true

Then choose the least surprising toolchain:

  • Default to Rust for a durable CLI Codex should run from any repo: one fast binary, strong argument parsing, good JSON handling, easy copy/install into ~/.local/bin.
  • Use TypeScript/Node when the official SDK, auth helper, browser automation library, or existing repo tooling is the reason the CLI can be better.
  • Use Python when the source is data science, local file transforms, notebooks, SQLite/CSV/JSON analysis, or Python-heavy admin tooling that can still be installed as a durable command.

Do not pick a language that adds setup friction unless it materially improves the CLI. If the best language is not installed, either install the missing toolchain with the user's approval or choose the next-best installed option.

State the choice in one sentence before scaffolding, including the reason and the installed toolchain you found.

Command Contract

Sketch the command surface in chat before coding. Include the binary name, discovery commands, resolve or ID-lookup commands, read commands, write commands, raw escape hatch, auth/config choice, and PATH/install command.

When designing the command surface, read references/agent-cli-patterns.md for the expected composable CLI shape.

Build toward this surface:

  • tool-name --help shows every major capability.
  • tool-name --json doctor verifies config, auth, version, endpoint reachability, and missing setup.
  • tool-name init ... stores local config when env-only auth is painful.
  • Discovery commands find accounts, projects, workspaces, teams, queues, channels, repos, dashboards, or other top-level containers.
  • Resolve commands turn names, URLs, slugs, permalinks, customer input, or build links into stable IDs so future commands do not repeat broad searches.
  • Read commands fetch exact objects and list/search collections. Paginated lists support a bounded --limit, cursor, offset, or clearly documented default.
  • Write commands do one named action each: create, update, delete, upload, schedule, retry, comment, draft. They accept the narrowest stable resource ID, support --dry-run, draft, or preview first when the service allows it, and do not hide writes inside broad commands such as fix, debug, or auto.
  • --json returns stable machine-readable output.
  • A raw escape hatch exists: request, tool-call, api, or the nearest honest name.

Do not expose only a generic request command. Give Codex high-level verbs for the repeated jobs.

Document the JSON policy in the CLI README or equivalent: API pass-through versus CLI envelope, success shape, error shape, and one example for each command family. Under --json, errors must be machine-readable and must not contain credentials.

Auth and Config

Support the boring paths first, in this precedence order:

  1. Environment variable using the service's standard name, such as GITHUB_TOKEN.
  2. User config under ~/.<tool-name>/config.toml or another simple documented path.
  3. --api-key or a tool-specific token flag only for explicit one-off tests. Prefer env/config for normal use because flags can leak into shell history or process listings.

Never print full tokens. doctor --json should say whether a token is available, the auth source category (flag, env, config, provider default, or missing), and what setup step is missing.

If the CLI can run without network or auth, make that explicit in doctor --json: report fixture/offline mode, whether fixture data was found, and whether auth is not required for that mode.

For internal web apps sourced from DevTools curls, create sanitized endpoint notes before implementing: resource name, method/path, required headers, auth mechanism, CSRF behavior, request body, response ID fields, pagination, errors, and one redacted sample response. Never commit copied cookies, bearer tokens, customer secrets, or full production payloads.

Use screenshots to infer workflow, UI vocabulary, fields, and confirmation points. Do not treat screenshots as API evidence unless they are paired with a network request, export, docs page, or fixture.

Build Workflow

  1. Read the source just enough to inventory resources, auth, pagination, IDs, media/file flows, rate limits, and dangerous write actions. If the docs expose OpenAPI, download or inspect it before naming commands.
  2. Sketch the command list in chat. Keep names short and shell-friendly.
  3. Scaffold the CLI with a README or equivalent repo-facing instructions.
  4. Implement doctor, discovery, resolve, read commands, one narrow draft or dry-run write path if requested, and the raw escape hatch.
  5. Install the CLI on PATH so tool-name ... works outside the source folder.
  6. Smoke test from another repo or /tmp, not only with cargo run or package-manager wrappers. Run command -v <tool-name>, <tool-name> --help, and <tool-name> --json doctor.
  7. Run format, typecheck/build, unit tests for request builders, pagination/request-body builders, no-auth doctor, help output, and at least one fixture, dry-run, or live read-only API call.

If a live write is needed for confidence, ask first and make it reversible or draft-only.

When the source is an existing script or shell history, split the working invocation into real phases: setup, discovery, download/export, transform/index, draft, upload, poll, live write. Preserve the flags, paths, and environment variables the user already relies on, then wrap the repeatable phases with stable IDs, bounded JSON, and file outputs.

For raw escape hatches, support read-only calls first. Do not run raw non-GET/HEAD requests against a live service unless the user asked for that specific write.

For media, artifact, or presigned upload flows, test each phase separately: create upload, transfer bytes, poll/read processing status, then attach or reference the resulting ID.

For fixture-backed prototypes, keep fixtures in a predictable project path and make the CLI locate them after installation. Smoke-test from /tmp to catch binaries that only work inside the source folder.

For log-oriented CLIs, keep deterministic snippet extraction separate from model interpretation. Prefer a command that emits filenames, line numbers or byte ranges, matched rules, and short excerpts.

Rust Defaults

When building in Rust, use established crates instead of custom parsers:

  • clap for commands and help
  • reqwest for HTTP
  • serde / serde_json for payloads
  • toml for small config files
  • anyhow for CLI-shaped error context

Add a Makefile target such as make install-local that builds release and installs the binary into ~/.local/bin.

TypeScript/Node Defaults

When building in TypeScript/Node, keep the CLI installable as a normal command:

  • commander or cac for commands and help
  • native fetch, the official SDK, or the user's existing HTTP helper for API calls
  • zod only where external payload validation prevents real breakage
  • package.json bin entry for the installed command
  • tsup, tsx, or tsc using the repo's existing convention

Add an install path such as pnpm install, pnpm build, and pnpm link --global, or a Makefile target that installs a small wrapper into ~/.local/bin.

Python Defaults

When building in Python, prefer boring standard-library pieces unless the workflow needs more:

  • argparse for commands and help, or typer when subcommands would otherwise get messy
  • urllib.request / urllib.parse, requests, or httpx for HTTP, matching what is already installed or already used nearby
  • json, csv, sqlite3, pathlib, and subprocess for local files, exports, databases, and existing scripts
  • pyproject.toml console script or a small executable wrapper for the installed command
  • uv or a virtualenv only when dependencies are actually needed

Add a Makefile target such as make install-local that installs the command on PATH and document whether it depends on uv, a virtualenv, or only system Python.

Companion Skill

After the CLI works, create or update a small skill for it. Use $skill-creator when it is available. Use $CODEX_HOME/skills/<tool-name>/SKILL.md for a personal companion skill unless the user names a repo-local .codex/skills/... path or another skill repo.

Write the companion skill in the order a future Codex thread should use the CLI, not as a tour of every feature. Explain:

  • How to verify the installed command exists.
  • Which command to run first.
  • How auth is configured.
  • Which discovery command finds the common ID.
  • The safe read path.
  • The intended draft/write path.
  • The raw escape hatch.
  • What not to do without explicit user approval.
  • Three copy-pasteable command examples.

Keep API reference details in the CLI docs or a skill reference file. Keep the skill focused on ordering, safety, and examples future Codex threads should actually run.

Connect through AnyModel API

This skill runs on whatever model your agent uses. Point Claude Code, Codex or Cursor at AnyModel to run it on Claude, GPT, Gemini and more with one key — pay per token, no subscription.

More from the pack OpenAI skills

ASP.NET Core apps

Guides the agent through current ASP.NET Core practice: choosing Blazor, Razor Pages, MVC or Minimal APIs, Program.cs and middleware order, auth, EF Core, tests and upgrades to .NET 10. Use when building, reviewing or upgrading an ASP.NET Core app.

ChatGPT Apps SDK

Builds ChatGPT apps on the Apps SDK: reads current OpenAI docs first, picks an app archetype, plans MCP tools, adapts an official example or scaffolds a Node server and widget, then tests in Developer Mode. Use when building or fixing an app inside ChatGPT.

Define a measurable goal

Turns a fuzzy intention into one measurable goal with a validator, scope and stop condition, then registers it via get_goal and create_goal. Use before goal-backed or long-running agent work, when "done" needs a number or a check.

Address GitHub PR comments

Fetches all comments, reviews and inline threads on the current branch's GitHub PR with a gh GraphQL script, numbers them and fixes only the ones you pick. Use when a PR has review comments to work through and you want to choose which get changed.

Fix failing GitHub Actions checks

Finds failing GitHub Actions checks on a PR with gh, pulls the logs, extracts the failure snippet and drafts a fix plan, changing code only after approval. Use when a PR's CI is red and you want the cause and a plan before any edit.

Jupyter notebooks

Creates and tidies Jupyter notebooks for experiments or tutorials from bundled templates via a stdlib script, with structure patterns and a run-top-to-bottom checklist. Use when starting a notebook or turning a messy one into something others can rerun.

Linear issues and projects

Works with Linear issues, projects and cycles through Linear's MCP server in a fixed order: setup, scope, read, then write, with sample workflows for triage, sprints and releases. Use when an agent should read or update Linear as part of a task.

Deploy to Netlify

Deploys the current project to Netlify with `npx netlify`: checks the login, links the folder to a site by Git remote or creates one, builds locally and returns a preview or production URL. Use when you want to publish a site to Netlify from your machine.

Browser automation with Playwright CLI

Drives a real browser from the terminal with playwright-cli: snapshots give element refs for clicks and typing, plus screenshots, console, network and traces, with no test files written. Use when a task needs a browser clicked through step by step.

Deploy to Render

Deploys an app to Render from a Git repo: writes and validates a render.yaml Blueprint with services, databases and secrets, or creates one service through the Render MCP server, then checks status and logs. Use when an app needs hosting on Render.

Security best-practice review

Checks Python, JavaScript/TypeScript and Go code against bundled security specs for ten frameworks, writes a report by severity with line numbers and fixes one finding at a time. Use when you explicitly ask for a security best-practice review.

Repository threat model

Writes a repository-grounded threat model: trust boundaries, assets, attacker capabilities and ranked abuse paths with mitigations, asking you to confirm key assumptions before the final file. Use when you explicitly ask to threat model a codebase.

Sentry issues and events

Reads Sentry issues and events through the sentry CLI without changing anything: recent production errors, issue and event details, AI root-cause summaries, with PII redacted. Use when you ask what is failing in production according to Sentry.

Deploy to Vercel

Deploys a project to Vercel, as a preview unless told otherwise, through the Vercel CLI or, without an account, a bundled script that uploads the folder and returns a preview link and a claim link. Use when you want a shareable deployment link fast.

Figma MCP design context

Reads Figma frames through the Figma MCP server in a fixed order (design context, metadata, screenshot) and rebuilds them with the project's components and tokens; also covers server setup in Codex. Use when connecting Figma MCP or coding from a frame link.

Figma use_figma prerequisite

Sets the rules an agent must load before every use_figma call that runs Plugin API JavaScript in a Figma file: return values, page resets, colours, fonts, node IDs, small validated steps. Use when creating or editing anything inside a Figma file.

Implement a Figma design in code

Implements a Figma frame or component as code in your repo with 1:1 visual parity: fetches context and a screenshot, maps the output to project tokens and components, then runs a validation checklist. Use when a Figma link must become production UI.

Generate a Figma design from an app

Builds or updates a full screen in Figma from code or a description, section by section, using the file's published components, variables and styles instead of hardcoded values. Use when a page from your app should exist as a Figma screen.

Figma design system from a codebase

Builds a Figma design system library from a codebase in five supervised phases: discovery, variables and styles, page structure, components one by one, QA. Use when a product needs a Figma library that matches its code tokens and components.

Figma Code Connect components

Links published Figma components to the code components that implement them via Code Connect: finds unmapped ones, matches them in the codebase, maps only what the user approves. Use when a Figma library and its code both exist but are not linked.

Figma design system rules

Writes project rules for turning Figma designs into code into CLAUDE.md, AGENTS.md or a Cursor rules file, based on Figma's rule template and an analysis of the codebase. Use when setting up an agent for regular Figma-to-code work in a repo.

Create a new Figma file

Creates a blank Figma design file or FigJam board in your drafts, resolving the plan through whoami, and returns the file key and URL. Use when the next Figma step needs a fresh file to write into.