Agent Skill Creator

Turn any workflow into reusable AI agent software that installs on 17 platforms — no spec writing, no prompt engineering, no coding required.

▶ watch the 15-second terminal demo

What you get: describe a workflow in plain English (or hand over a PDF, a link, a script) → a complete, validated and security-scanned agent skill, with functional code, its own eval spec, and a cross-platform installer → the same skill running on Claude Code, Cursor, Copilot, Gemini, Windsurf, and 12 more with one command.

---

Quick start

# macOS / Linux — paste into Terminal
curl -fsSL https://raw.githubusercontent.com/FrancyJGLisboa/agent-skill-creator/main/scripts/bootstrap.sh | sh

Then open your AI tool and describe what you do:

/agent-skill-creator Every Friday I clean the CRM export, calculate regional
totals, and email a PDF sales report.

…and watch it build the skill end to end:

▸ Phase 1  Discovery     ▸ Phase 4  Detection
▸ Phase 2  Design+evals   ▸ Phase 5  Build · validate · security-scan
▸ Phase 3  Architecture

✓ weekly-crm-report-skill  (12 files, evals, installer)
  installed on Claude Code, Cursor, Gemini CLI

Use it:  /weekly-crm-report-skill data/crm-export.csv
  → report.pdf   → dashboard.html

No clone, no pip, no API key to get started — just git and any one of 17 supported tools. Windows one-liners and single-tool installs are in Advanced Install.

---

Why this vs. the alternatives

	Agent Skill Creator	Hand-writing a SKILL.md	Anthropic's skill-creator
Time to a working skill	~minutes, one prompt	hours of spec + iteration	minutes (interactive Q&A)
Coding required	none — it writes the code	yes	some
Cross-platform install	17 platforms, auto-detected + format adapters	one tool, by hand	Claude-focused
Built-in validation + security scan	yes (hard gates)	manual	partial
Ships an eval spec (regression metric)	yes, per skill	no	no
Optimizable (autoresearch handoff)	yes	no	no
Input you can hand it	prose, PDF, URL, code, transcript	you write it from scratch	guided prompts

Anthropic's skill-creator is excellent for authoring a Claude skill interactively. This is for turning whatever you already have into a validated skill that installs everywhere, with the testing and security gates wired in.

---

Examples

Three runnable example skills ship in references/examples/. Each one passes the same gates the creator applies to your skills — validate.py, check_pipeline.py, and its own bundled eval spec (run_evals.py --rollout):

Skill	You'd say…	It produces
weekly-crm-report	"clean this CRM export and total sales by region"	a deduped regional-totals JSON summary
pr-blocker-summarizer	"summarize my open PRs, blockers first"	a standup digest: blocked vs. ready, one-line count
stock-analyzer	"analyze AAPL with RSI and MACD"	indicators + a buy/sell/hold signal with reasoning

Try one without installing anything:

git clone https://github.com/FrancyJGLisboa/agent-skill-creator
cd agent-skill-creator/references/examples/weekly-crm-report
python3 scripts/run_pipeline.py --input evals/golden/case-1/input.csv --output /tmp/summary.json
python3 scripts/run_evals.py --rollout      # runs the skill on its golden inputs and scores them

---

The Problem

Every AI coding tool — Claude Code, GitHub Copilot, Cursor, Windsurf, Codex, Gemini, Kiro, and more — starts from zero. It doesn't know your company's processes, data sources, or compliance requirements. So every person re-explains the same workflows in every conversation. Knowledge stays in individual chat histories. New hires start from scratch.

Agent skills fix this. A skill is structured knowledge your agent loads automatically — like installing an app. Once installed, anyone on your team can invoke it and get consistent results, every time, on any platform.

The catch: building a proper skill requires understanding the spec format, writing clear prompt instructions, designing how information loads progressively, writing functional code, and getting activation keywords right. Even simple skills take multiple rounds of iteration to get right.

Agent Skill Creator removes that barrier entirely. You pass in whatever you have — messy docs, links, code, PDFs, transcripts, vague descriptions — and it produces a validated, security-scanned skill ready to install on 17 platforms and share with your team. You describe what you do; it builds the software.

---

Install & first skill — in detail

1. Install

The macOS/Linux one-liner is in Quick start above. Windows:

Windows (PowerShell):

irm https://raw.githubusercontent.com/FrancyJGLisboa/agent-skill-creator/main/scripts/bootstrap.ps1 | iex

Windows (Command Prompt):

powershell -ExecutionPolicy Bypass -Command "irm https://raw.githubusercontent.com/FrancyJGLisboa/agent-skill-creator/main/scripts/bootstrap.ps1 | iex"

The installer clones to ~/.agents/skills/agent-skill-creator and links to every detected platform (Claude Code, Copilot, Gemini CLI, Kiro, Cline, Roo Code, Kilo Code, Factory Droid, Cursor, Goose, OpenCode). To update later, run cd ~/.agents/skills/agent-skill-creator && git pull.

Advanced: Want to install to a single tool, or already have a local clone? See Advanced Install below.

2. Use it

Open your agent and type /agent-skill-creator followed by whatever you have:

/agent-skill-creator Every week I pull sales data from our CRM, clean
duplicate entries, calculate regional totals, and generate a PDF report.

You can pass anything — plain English, documentation links, existing code, API docs, PDFs, database schemas, transcripts. Combine multiple sources in one message. The more context, the better the result.

/agent-skill-creator Based on our deployment runbook: https://wiki.internal/deploy-process

/agent-skill-creator See scripts/invoice_processor.py — turn it into a reusable skill

3. What comes out

A complete skill, automatically installed on your platform:

Skill installed successfully.

To use it, open a new session and type:

  /sales-report-skill Generate the weekly report for the West region

Installed at: ~/.claude/skills/sales-report-skill

The agent detects your platform, installs the skill to the right location, and tells you exactly how to invoke it. No manual steps.

The generated skill includes a cross-platform installer (install.sh) that auto-detects all 17 supported platforms, generates format adapters for Cursor (.mdc), Windsurf (.md rules), and Junie (guidelines.md) automatically, and creates a universal ~/.agents/skills/ symlink so the skill is discoverable by multiple tools at once.

sales-report-skill/
├── SKILL.md          # Skill definition (activates with /sales-report-skill)
├── AGENTS.md         # Companion file (read by many tools for cross-tool reach)
├── scripts/          # Functional Python code
├── references/       # Detailed documentation
├── assets/           # Templates, configs
├── install.sh        # Cross-platform installer (17 platforms, format adapters, --all flag)
└── README.md         # Installation instructions

Your team installs it the same way — one git clone to their tool's path — and invokes it with /sales-report-skill.

---

What's new

v6 — Artifacts. Skills can emit interactive React artifacts in Claude Code (and Claude.ai). When output is visualizable — time series, comparisons, KPIs, tables — Phase 2 inlines one of four bundled React templates plus the artifact protocol into the generated SKILL.md; you write no React. In hosts that don't render artifacts (Cursor, Cline, Codex CLI, Gemini CLI) the source appears as fenced code and the markdown analysis is unchanged — honest degradation. Suppress with --no-artifact; force a template with --artifact <line-chart|bar-chart|kpi-cards|data-table>. (design notes)

Every skill ships its own metric. Each generated skill carries an eval spec (evals/<name>.eval.md) plus a scripts/run_evals.py runner. In Phase 2 the creator derives 3–6 binary checks and ≥3 golden cases (seeded from your own files); you give a one-word thumbs-up. It's an instant regression test — python3 scripts/run_evals.py exits non-zero on failure, so it drops into CI. With a declared run command, run_evals.py --rollout executes the skill on each golden input and scores the real output (--rollout --promote captures the first passing baseline). The spec is consumable by autoresearch-universal for optimization with no reformatting. Honest limits: --rollout is opt-in (it runs arbitrary skill code), and llm-judge checks print as a checklist rather than being auto-graded. On by default; skip with --no-eval.

---

How It Works

You don't need to understand any of this to use it. But if you're curious:

The agent doesn't just follow your description literally. Humans describe what they do, not what they need. "I pull sales data and make a report" hides a dozen implicit requirements — who reads the report, what format, what happens when data is missing. The agent reads all your material, uncovers these implicit requirements, and generates its own internal specification before writing any code. It builds from that deeper understanding, not from your surface description.

UNDERSTAND    Read all material → uncover real intent → generate internal spec
BUILD         Structure directory → write code and docs → craft activation keywords
VERIFY        Spec validation → security scan → block delivery if either fails

Every skill is automatically validated (correct structure, naming, metadata) and security-scanned (no hardcoded keys, no credential exposure, no injection risks) before delivery. Skills that fail these checks are blocked.

---

Share Skills Across Your Team

After the agent builds and installs your skill, it asks:

Want to share this skill with your team so they can install it too?

Say yes. The agent detects whether your team uses GitHub or GitLab, creates a repo, pushes the skill, and gives you a one-liner to share:

Shared! Your colleagues can install it by pasting this in their terminal:

  git clone https://github.com/your-org/sales-report-skill.git ~/.agents/skills/sales-report-skill

One git clone to ~/.agents/skills/ makes it available on Codex CLI, Gemini CLI, Kiro, and Antigravity simultaneously. For Claude Code users: ~/.claude/skills/sales-report-skill. For Cursor: .cursor/rules/sales-report-skill.

Send that line to your colleague on Slack or Teams. They paste it. Done. They can now type /sales-report-skill in their agent.

No registry commands, no publishing steps, no terminal knowledge beyond paste. The agent handles the repo creation, the push, and generates install commands for every platform.

The result over time

Each team member creates skills from their own domain and shares them. Over months the organization accumulates a library of reusable skills:

• Sales team shares /sales-report-skill
• Engineering shares /deploy-checklist-skill
• Legal shares /quarterly-compliance-skill
• Data science shares /customer-churn-skill
• SRE shares /incident-runbook-skill

Any colleague installs any skill with one git clone. Any agent on any platform can invoke it. Knowledge compounds instead of evaporating.

For teams and consultants: the skill registry

When an organization has more than a few skills, the agent offers to set up a team skill registry — a shared git repo where all team members publish their skills and anyone can browse and install them.

The consultant (or team lead) sets it up once:

python3 scripts/skill_registry.py init --name "Acme Corp Skills"

Then every team member can:

```bash

Publish a skill they created

python3 scripts/skill_registry.py publish ./sales-report-skill/ --tags sales,reports

Browse what's available

python3 scripts/skill_registry.py list

Search for a specific skill

python3 scripts/skill_registry.py search "sales"

Install a colleague's skill (auto-detects platform)

python3 scripts/skill_registry.py install sales-rep