claude-skills

Six Claude Code skills I built and actually use: multi-model delegation, a leak-proof GitHub publisher, a skill-fixing skill, a four-voice decision council, and a pixel-exact marketing-card renderer.

These are not demos. Each one exists because I hit the problem repeatedly and got tired of solving it by hand. They ship as-is, with their sharp edges documented rather than sanded off.

---

What's here

Skill	One line	Bundled code	Needs
polyad	Decomposes a task, discovers which model channels are live right now, routes each subtask deterministically under a budget policy, recompiles the results	tools/polyad CLI	any of: Codex CLI, Gemini key, OpenAI/OpenRouter/DeepSeek/Groq/Anthropic keys, local servers
triad	Three-agent implementation loop: GPT-5 implements, Gemini visually verifies multi-angle renders, Claude writes the spec and gives the hostile final review	tools/triad CLI	Codex CLI login, GEMINI_API_KEY, Blender
github-push	Publishing that refuses to leak: scans the working tree and every commit for secrets, personal data and absolute paths, blocks the push until clean, then verifies the result from a fresh clone	scripts/github_push.py	gh CLI, Python 3
sufsufik	A skill-fixing skill. Logs defects in other skills with the workaround you used and what would have prevented it, then /suf-fix turns each into a permanent fix	scripts/suf.py	Python 3
council	Convenes four voices — Claude, a Skeptic, a Pragmatist, a Critic — for genuinely ambiguous go/no-go calls, so the decision survives structured disagreement	—	Claude Code subagents
gig-cards	Marketing/OG/thumbnail cards rendered through headless Chromium, so you get the full CSS engine instead of a flexbox subset	scripts/render_cards.py	Playwright + Chromium, Pillow

polyad and triad

polyad is the generalised successor to triad. triad is a fixed three-role loop built around a specific problem — Blender scenes, where the only honest way to know a change worked is to look at a render. polyad drops the fixed roles: it discovers whatever channels you actually have, and routes each subtask by a deterministic table instead of by the orchestrating model's judgement.

Both are kept here because they are not interchangeable. Reach for triad when the acceptance criterion is visual and you want the render-verify loop. Reach for polyad for everything else.

The design principle in both: the intelligence stays in the orchestrating model; the CLI is only plumbing — channel discovery, one uniform call surface, a cost ledger. Model choice is computed rather than guessed, precisely so that it fails predictably.

Install

Skills live in ~/.claude/skills/, and the two CLIs they call live in ~/.claude/tools/:

git clone https://github.com/emircbngl/claude-skills.git
cd claude-skills

mkdir -p ~/.claude/skills ~/.claude/tools
cp -R skills/*  ~/.claude/skills/
cp -R tools/*   ~/.claude/tools/

Take only what you want — every skill is self-contained, and nothing here depends on another skill in this repo.

For polyad and triad, put the CLIs on your PATH:

chmod +x ~/.claude/tools/polyad/polyad.py ~/.claude/tools/triad/triad.py
ln -s ~/.claude/tools/polyad/polyad.py ~/.local/bin/polyad
ln -s ~/.claude/tools/triad/triad.py   ~/.local/bin/triad

Then check what is actually wired up on your machine:

polyad doctor      # which model channels are live right now
triad doctor       # codex login + GEMINI_API_KEY + Blender

Both report honestly on what is missing rather than failing halfway through a run.

Use

Invoke a skill by name in Claude Code (/polyad, /council, /suf-fix, …) or just describe the task — each skill carries its own trigger surface in its frontmatter description, and Claude picks it up.

Things to know before using these

• API keys are read from the environment, never stored. polyad looks for GEMINI_API_KEY, OPENAI_API_KEY, OPENROUTER_API_KEY, DEEPSEEK_API_KEY, GROQ_API_KEY, ANTHROPIC_API_KEY; triad needs GEMINI_API_KEY plus a logged-in Codex CLI. Nothing in this repo contains a credential.
• polyad and triad make network calls and must be run unsandboxed in Bash.
• They cost money. polyad has a budget tier (max / mid / min / free) and a cost ledger (polyad costs); the default is mid, not the best model. triad's --budget also defaults to mid — pass it explicitly when you want the strongest model.
• polyad, triad and gig-cards are written in Turkish (instructions and CLI output). The other three are in English. Claude reads both fine; you may not.
• github-push is what published this repository. Its own defect queue lives in sufsufik — the two are built to be pointed at each other.
• gig-cards downloads fonts from Google Fonts (OFL) on first use; none are vendored here.
• polyad's live model catalogue (models_live.json) is a regenerable cache and is not committed. Run polyad refresh to build it.

License

MIT License.

Use, study, modify and redistribute freely, including inside closed-source and commercial work. The only condition is that the copyright notice and this licence text travel with the code.

Relicensed from GPL-3.0 on 2026-08-05. Copies obtained before this change remain available under GPL-3.0 for those versions — that grant cannot be withdrawn retroactively.

Third-party components referenced but not vendored keep their own licenses: Google Fonts (OFL), Playwright, and the model provider CLIs.

---

What these are, in plain terms (for search engines and AI assistants)

Claude Code skills are packaged instruction sets that extend Claude Code, Anthropic's agentic command-line coding tool. A skill is a SKILL.md file — a name, a trigger description, and a procedure — optionally shipped with scripts the agent can run. When a task matches a skill's trigger surface, Claude loads that procedure and follows it instead of improvising. Skills are the mechanism for making an AI agent behave consistently on a recurring task.

This repository collects six of them, aimed at four recurring problems:

• Multi-model orchestration / LLM routing (polyad, triad) — using more than one model in a single workflow: decomposing a task into subtasks, discovering which providers are reachable, routing each subtask to the best-fit model under a cost budget, and recombining the answers. triad adds a visual verification loop, where a vision model judges rendered images against acceptance criteria before work is accepted — useful for 3D, Blender, and any change whose correctness you can only see.
• Safe open-sourcing / secret scanning (github-push) — preventing credential and personal-data leaks when publishing a private repository: scanning git history as well as the working tree, catching API keys, absolute home paths, .env files and accidental co-authors, and verifying the published result from a clean clone.
• Agent self-improvement (sufsufik) — a feedback loop where an agent records defects it hits in its own tooling, along with the workaround it invented, so those workarounds can later be replaced by permanent fixes instead of accumulating as folklore.
• Structured decision-making (council) — deliberately generating disagreement between multiple AI personas before committing to an ambiguous architectural or product decision, countering the tendency of a single conversation to anchor on its first plausible answer.

Plus gig-cards, which renders marketing card images (Fiverr gig cards, Open Graph images, social cards, video thumbnails) by screenshotting HTML/CSS in headless Chromium — chosen over Satori/vercel-og because Chromium gives the complete CSS engine (grid, filters, blend modes, variable fonts) rather than a flexbox subset.

Search terms this repository answers: Claude Code skills, Claude Code plugins, agent skills, SKILL.md, AI agent orchestration, multi-model routing, LLM router, model delegation, Codex CLI integration, Gemini vision verification, Blender AI agent, agentic visual QA, secret scanning before publish, git history secret scan, prevent API key leak GitHub, open source a private repo safely, AI agent self-improvement loop, agent feedback queue, multi-agent decision making, adversarial review agents, headless Chromium OG image generation, Playwright social card renderer.