skills

My own personal agent skills, built for how I work — shared in case they are useful to you too. Nothing here is an official or supported product: expect opinionated defaults, and read a skill's README before running it. Fork it, strip out what does not fit, keep what does.

Agent skills for Claude Code and Codex CLI.

The skills run from the agent you are already using. delegate reaches across provider boundaries from that one session: stay in Claude Code while handing work to Antigravity or Codex, or stay in Codex while Claude handles a task. That means you can use the plan allowances you already have without manually moving work between IDEs or chat apps.

Built Claude-first. Claude Code is the primary target: that is where these are designed, used and tested. Codex CLI is a first-class second — the same SKILL.md loads there, every feature is expected to work, and where the two differ a skill adapts rather than degrades. delegate, for instance, routes code review to whichever vendor you are not running inside, so it is genuinely useful from either side.

What a skill is

A skill is a folder containing a SKILL.md: a description of some capability, plus instructions for using it. Your agent reads only the descriptions of installed skills. When a request matches one, it loads that skill's full instructions and follows them.

So a skill is not a plugin you call. It is knowledge the agent picks up when relevant — a workflow it should follow, a tool it should prefer, a mistake it should avoid. Claude Code and Codex CLI both read this same format from their own skill directories, so one folder serves both.

Skills

Skill	What it does
delegate	Routes work across providers without leaving your current agent, matching model strength and cost to each task. Uses Antigravity and Codex plan allowances and OpenRouter free models; also generates images.
gif	Builds small looping animated GIFs — square 16/32/64/128 px, transparent or not, up to 3s. Generates the frames through delegate on plan allowance, then assembles them locally.
svg	Builds small SVG icons — a looping CSS animation, a single still with --still, or a frame-by-frame sequence with --frames N. Asks a delegate text tier for the source, then sanitizes, resizes and re-times it locally.

Skills can build on each other. gif uses delegate for the one image call it needs, so its frames come out of a plan allowance rather than a paid image API; svg uses a delegate text tier instead, because an SVG is code rather than pixels. Install delegate alongside either to use them end to end — working on frames or source you already have needs only the skill itself.

Install

Let your agent do it

Paste this to Claude Code or Codex:

Install the skills from https://github.com/krzysztofradomski/skills — clone it, then symlink the skills into my agent skill directory and any bundled scripts onto my PATH. Show me what you linked.

The agent reads the repo and does the rest. Ask it for just one skill if you do not want all of them.

One command

curl -fsSL https://raw.githubusercontent.com/krzysztofradomski/skills/main/install.sh | bash

Piping a stranger's script into your shell is a habit worth resisting, so read it first if you prefer — it is short:

curl -fsSL https://raw.githubusercontent.com/krzysztofradomski/skills/main/install.sh -o install.sh
less install.sh && bash install.sh

It clones to ~/.local/share/agent-skills, symlinks each skill into ~/.claude/skills (and ~/.codex/skills when Codex is present), and puts bundled scripts on your PATH. Re-running it updates the clone. It never overwrites a real directory — if something is already there under that name it says so and skips. Pass names to install a subset (bash install.sh delegate), and set SKILLS_DIR, CLAUDE_DIR, CODEX_DIR or BIN_DIR to put things elsewhere.

By hand

Clone the repo wherever you keep code, then symlink the skills you want into your agent's skill directory. Symlinks rather than copies: edits and git pulls take effect immediately instead of leaving you with a stale duplicate.

git clone https://github.com/krzysztofradomski/skills.git ~/code/skills
cd ~/code/skills

mkdir -p ~/.claude/skills ~/.codex/skills
ln -s "$PWD/delegate" ~/.claude/skills/delegate    # Claude Code
ln -s "$PWD/delegate" ~/.codex/skills/delegate     # Codex CLI
ln -s "$PWD/gif" ~/.claude/skills/gif              # and the same for any other skill
ln -s "$PWD/svg" ~/.claude/skills/svg

Clone anywhere you like — $PWD keeps the commands correct whatever path you chose. Install only the skills you want; each folder is independent, and installing one directory does not pull in the rest.

From an agent skills installer

ai-skills.radomski.dev serves a .well-known/agent-skills/index.json discovery index, so any installer that reads that convention can resolve a skill directly:

npx skills add https://ai-skills.radomski.dev --skill delegate -a claude-code -g   # one skill
npx skills add https://ai-skills.radomski.dev --skill '*' -a claude-code -g        # all of them

The installer verifies the payload's sha256: digest before writing anything to disk.

Some skills ship a script. Put it on your PATH so both you and the agent can run it by name:

mkdir -p ~/.local/bin
ln -s "$PWD/delegate/scripts/delegate.sh" ~/.local/bin/delegate.sh
ln -s "$PWD/gif/scripts/gif.sh" ~/.local/bin/gif.sh
ln -s "$PWD/svg/scripts/svg.sh" ~/.local/bin/svg.sh

If ~/.local/bin is not already on your PATH, add it to your shell profile:

echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc

Verify it worked. Start a new agent session — skills load at startup, so an already-running one will not see it — and type /delegate in Claude Code, or ask the agent to list its skills. To update later, git pull in the clone; the symlinks pick it up with nothing to reinstall.

Requirements and configuration differ per skill. Read that skill's own README before first use — delegate, for example, wants API keys for its optional providers and can spend money if you opt in with a flag.

API keys

Nothing here needs an API key to be useful. Antigravity and Codex authenticate through their own CLIs — install them, sign in once, and delegate.sh providers will show them. Keys only add the two optional providers below.

OpenRouter — unlocks free frontier models for one-shot text (delegate.sh or), and acts as the last-resort paid image provider. Get a key at openrouter.ai/keys:

mkdir -p ~/.config/openrouter
printf 'OpenRouter key: '; read -rs k; echo
printf '%s' "$k" > ~/.config/openrouter/key; chmod 600 ~/.config/openrouter/key; unset k

Google AI Studio — tried first for images. Get a key at aistudio.google.com/apikey:

mkdir -p ~/.config/google-ai
printf 'AI Studio key: '; read -rs k; echo
printf '%s' "$k" > ~/.config/google-ai/key; chmod 600 ~/.config/google-ai/key; unset k

Worth knowing before you bother: AI Studio's free tier grants zero image quota. Every image model returns RESOURCE_EXHAUSTED with limit: 0 until billing is enabled on the Google project, so in practice this key changes nothing for images and the chain falls through to the free paths. Its free-tier text does work, but Antigravity already covers text better and on plan allowance. Set it if you have billing enabled or want it ready; skip it otherwise.

Both keys are read from files rather than passed as arguments, so they never land in your shell history or in ps output. $OPENROUTER_API_KEY and $GEMINI_API_KEY work too if you prefer environment variables. Check what actually works:

delegate.sh providers --check

That validates the OpenRouter key against the API and exits nonzero if it is rejected — a key file existing proves nothing.

Using a skill

You do not need to invoke a skill by name. Describe what you want, and the agent loads the skill whose description matches — "delegate this to a cheaper model" pulls in delegate on its own. Name it explicitly (/delegate) when you want to be certain, or when the phrasing is ambiguous.

Tests

bash tests/run.sh

Five default suites, 227 assertions, no test framework and no provider calls: delegate's own tests fake agy, codex and openrouter to check provider detection, tier routing, the write-verification guard, the free-before-paid image order, and the timeout guard that kills a hung provider (and its children) instead of hanging forever. Generation for the gif/svg skills is exercised against a fake delegate.sh that replays canned model replies and records the prompts it was handed, so the retry loop and the prompt contents are tested without spending quota. The browser suite (Playwright) checks that the SVG output actually animates, holds still under prefers-reduced-motion, and steps one frame per slot; it skips cleanly when Playwright is not installed. A sixth, opt-in suite (bash tests/run.sh real) runs the same generation paths against a real agy/codex provider to catch regressions the fakes can't, at the cost of real plan allowance. See tests/ for what each suite covers and for the three real bugs they have already caught.

Site

site/ is a single self-contained index.html: a landing page built around a real delegate session against a prepared demo repo — reading a file, writing a fix, catching a bug in that fix through cross-vendor review, and generating an image, all on plan allowance. The transcript plays out line by line, and a tab bar switches between skills; both are CSS-only, so there is no JavaScript on the page at all. No build step and no dependencies beyond Google Fonts — drop the folder into Cloudflare Pages (or any static host) as-is.

Writing a skill

skill-name/
├── SKILL.md        # required: YAML frontmatter (name, description) + instructions
├── REFERENCE.md    # optional: detail the agent loads only when it needs it
├── README.md       # optional: for humans — install, requirements, limitations
└── scripts/        # optional: deterministic work better done in code than re-derived

Drop a new folder in and install.sh picks it up — it treats any directory containing a SKILL.md as installable, with no manifest to update.

After adding or changing a skill, regenerate the discovery index before deploying site/:

scripts/build-agent-skills-index.sh

It re-hashes each skill (single-file skills as their bare SKILL.md, multi-file skills as a flat <name>.tar.gz) into site/agent-skills/ and writes site/.well-known/agent-skills/index.json with a sha256: digest per skill, so the digest served always matches the bytes served.

The description is the only thing the agent sees when deciding whether to load the skill, so it has to say both what the skill does and when to reach for it. Keep SKILL.md short and push detail into REFERENCE.md; everything in SKILL.md costs context on every load.

Two things worth stealing from delegate: put a guard in code rather than documenting a rule and hoping the model follows it, and never let a skill spend money without an explicit flag.

License

MIT — see LICENSE.