agent-skills

59 agent skills and 9 autonomous agents. Polyglot dev, web3, ZK, genomics, UI/UX, systems programming. Default host is the Raxol agent; Claude Code also works.

How skill loading works

Skills are portable SKILL.md files -- the agentskills.io format: YAML frontmatter (a name, a short trigger description) plus a markdown body. Any compatible host loads the same files. Two are documented here.

Raxol agent (default). Raxol.Agent.Skills.Store scans ~/.agents/skills/**/SKILL.md on boot and holds them as read-only procedural memory. Skills are pull-based: the agent sees only each skill's name and description (via the skills_list tool) and reads a full body on demand (skill_view) when it judges one relevant -- the trigger clause in the description guides that choice. Nothing but the list metadata sits in context until the agent pulls a skill, so all 59 cost almost nothing until used.

Claude Code (secondary). Lazy in a different way: Claude Code reads the trigger clause from each frontmatter and auto-injects the full skill content when the trigger matches your conversation. Sub-files (examples, checklists, reference tables) stay out of context until they're needed.

Either way, 59 skills don't bloat your sessions. The noir ZK skill isn't eating tokens while you're reviewing a PR.

Skills

Each skill lives in skills/<name>/ with a SKILL.md entry point.

Domain

Skill What it does
claude-api Anthropic SDK reference (Python, TS, Go, Elixir, Rust, Lua, cURL)
droo-stack Polyglot patterns (Elixir, TS, Go, Rust, C, Zig, Python, Lua, Shell, Noir, Chezmoi)
raxol Elixir TUI/agent framework (TEA agents, MCP, headless sessions)
noir ZK circuit design, Aztec contracts, constraint optimization
solidity-auditor Solidity dev standards, vulnerability taxonomy, Foundry-first audit
zk-x-ray Pre-audit briefing for ZK + EVM hybrids (Noir + Solidity), public-input parity check
ethskills Ethereum tooling, framework selection, EIP/ERC standards
nix Nix language, flakes, NixOS, Home Manager, packaging
native-code NIF development (C/Rust/Rustler), SIMD (Zig), BEAM native boundary
ffmpeg-asm ffmpeg upstream + integration: x86inc.asm, NEON + Apple M4 SME, HBD templating, dispatch, checkasm, upstream patch workflow
coingecko CoinGecko/GeckoTerminal API: prices, markets, DEX pools, trending tokens
blockscout Blockscout MCP: 16 tools for on-chain data across 8+ chains
signoz SigNoz MCP: ~41 tools for OTel metrics/traces/logs, alerts, and regen correlation
web-asset-generator Favicon, app icon, OG image, devicon generation and optimization
cancer-predisposition-variant-analyst Ultra-rare variant interpretation, mechanistic paradox resolution, ACMG/ClinGen evidence

Workflow

Skill What it does
tdd Test-driven development: vertical slices, mutation testing, polyglot
code-review PR review: blast radius, security scan, SOLID checks, 40-item checklist
prd-to-plan PRD -> phased tracer-bullet vertical slices (and optionally GitHub issues)
focused-fix 5-phase bug fix: SCOPE -> TRACE -> DIAGNOSE -> FIX -> VERIFY
release Conventional commits, semver bumping, changelog, readiness checks
qa Bug triage and issue creation; interactive QA with background explorer
interface-designer "Design It Twice" -- parallel sub-agents with divergent constraints
ubiquitous-language DDD glossary extraction, canonical terms
design-ux UI/UX design patterns, design tokens, accessibility, TUI aesthetics
property-testing Generative/property-based testing (Hypothesis, proptest, StreamData, fast-check)
refactoring-strategy Strangler fig, large renames, safe restructuring for polyglot codebases

Infrastructure

Skill What it does
mcp-server-builder OpenAPI -> MCP server scaffolding (Python FastMCP + TypeScript)
ci-cd-pipeline-builder Stack detection -> GitHub Actions/GitLab CI generation
dependency-auditor Multi-language vuln scanning + license compliance
observability-designer SLO/SLI design, burn rate alerting, dashboard generation
database-designer Schema analysis, ERD generation, index optimization
performance-profiler Polyglot profiling (Node/Python/Go/Elixir/Rust)
git-guardrails PreToolUse hooks to block dangerous git operations
git-worktree-manager Parallel dev with deterministic port allocation
env-secrets-manager Leak detection, rotation, pre-commit setup
tech-debt-tracker Debt scanning, cost-of-delay prioritization
security-auditor Security vulnerability scanning and compliance assessment
playwright Browser automation and e2e testing tooling (Python + TS)
prepper Pre-session project briefings (git, GitHub, CI, deps, recall)

Meta

Skill What it does
polymath Split-brain research: three-tier roster, polymath persona composition
architect ADR workflows, dependency classification, pattern detection
agent-designer Multi-agent architecture patterns, tool schemas, guardrails
adversarial-reviewer Three-persona devil's advocate review
self-improving-agent Auto-memory curation, pattern promotion lifecycle
codebase-onboarding Auto-generate onboarding docs, audience-aware
rag-architect RAG pipeline design: chunking, embedding, retrieval, evaluation
llm-cost-optimizer 7 optimization techniques in priority order
digest Multi-platform activity digest (18 sources + differential mode)
recall Knowledge base: query past decisions, patterns, gotchas
autoresearch Check experiment status, run iterations, view dashboards
watchdog Scan repos for stale PRs, failing CI, security advisories
sentinel Monitor on-chain contracts for anomalous transactions
regen Read Fluidify Regen incidents, extract SigNoz correlation keys
patchbot Scan and update outdated dependencies across ecosystems
writing-voice Writing voice calibration from studied authors, combinatorial blending
humanizer Strip AI-isms and add real voice; de-slop AI-generated prose
skill-creator Scaffold new skills with frontmatter, triggers, and sub-files

Agents

Nine standalone tools, each with a Typer CLI, pydantic models, and a FastMCP server. They run independently of the skill system -- install them separately, talk to them over MCP.

Agent What it does MCP tools
digest Multi-platform activity digest (18 sources, differential, structured views) 7
recall Knowledge capture and retrieval (SQLite + FTS5) 8
scribe Session insight extractor (writes to recall) 3
autoresearch Autonomous experiment runner (ML, Noir, Solidity) 3
watchdog Repo health monitor (PRs, CI, deps, advisories) 2
prepper Pre-session context builder (git, GitHub, deps, recall, sentinel) 3
sentinel On-chain contract monitor via Blockscout (11 chains) 2
patchbot Polyglot dependency updater (Elixir, Rust, Node, Go, Python) 3
regen Incident reader + SigNoz OTel correlation (Fluidify Regen) 7

MCP integration

Each agent doubles as an MCP server. Add to ~/.mcp.json:

{
  "mcpServers": {
    "digest": { "command": "digest", "args": ["serve"] },
    "recall": { "command": "recall", "args": ["serve"] },
    "scribe": { "command": "scribe", "args": ["serve"] },
    "autoresearch": { "command": "autoresearch", "args": ["serve"] },
    "watchdog": { "command": "watchdog", "args": ["serve"] },
    "prepper": { "command": "prepper", "args": ["serve"] },
    "sentinel": { "command": "sentinel", "args": ["serve"] },
    "patchbot": { "command": "patchbot", "args": ["serve"] },
    "regen": { "command": "regen", "args": ["serve"] },
    "coingecko": { "url": "https://mcp.api.coingecko.com/mcp" }
  }
}

See TODO.md for the roadmap.

Install

Skills live at ~/.agents/skills/<name>/SKILL.md. Get them on disk once (below), then point your host at that directory -- the Raxol agent reads it natively.

Raxol agent (default)

~/.agents/skills is already the Raxol agent's default external skills dir. Enable the provider:

# config/config.exs (or runtime.exs)
config :raxol_agent, skills_provider: Raxol.Agent.Skills.Store

That supervises Raxol.Agent.Skills.Store (which scans ~/.agents/skills/**/SKILL.md on boot) and exposes the skills_list, skill_view, and skill_manage tools to the agent. Verify:

length(Raxol.Agent.Skills.Store.list())  # => 59

To load skills straight from a repo checkout instead, add its path:

config :raxol_agent, skills_external_dirs: ["~/.agents/skills", "~/CODE/agent-skills/skills"]

Get the skills on disk

npx -- pick individual skills or grab everything:

npx skills@latest add DROOdotFOO/agent-skills/tdd
npx skills@latest add DROOdotFOO/agent-skills

chezmoi (recommended -- this is how the skills are kept fresh) -- add the external, then a single chezmoi apply pulls the whole collection to ~/.agents/skills:

# ~/.chezmoiexternal.toml
[".agents/skills"]
    type = "archive"
    url = "https://github.com/DROOdotFOO/agent-skills/archive/main.tar.gz"
    stripComponents = 2
    include = ["*/skills/**"]
    refreshPeriod = "168h"

Apply to install, and force a refresh whenever you want the latest before the 168h window elapses:

chezmoi apply                      # install / update (auto-refreshes every 168h)
chezmoi apply --refresh-externals  # force-pull the newest skills right now

The Raxol agent reads ~/.agents/skills directly after apply -- no further step. To add a new skill: push it to agent-skills main, then chezmoi apply --refresh-externals. For the full reproducible rig (this external plus the repo clone for the MCP agent CLIs and the ~/.claude/skills symlinks), see DROOdotFOO/dotfiles -- chezmoi apply --refresh-externals is the one command that applies or refreshes everything.

Manual -- clone and symlink:

git clone https://github.com/DROOdotFOO/agent-skills.git ~/.agents/skills-repo
ln -s ~/.agents/skills-repo/skills ~/.agents/skills

Claude Code (secondary)

Self-contained plugin (no ~/.agents/skills needed):

/plugin install agent-skills@DROOdotFOO/agent-skills
# or add the marketplace first:
/plugin marketplace add DROOdotFOO/agent-skills

Already installed to ~/.agents/skills via the methods above? Symlink them into Claude Code:

mkdir -p ~/.claude/skills
for d in ~/.agents/skills/*/; do
    ln -sf "../../.agents/skills/$(basename "$d")" ~/.claude/skills/
done

Agents

Each agent installs independently:

cd agents/<name> && pip install -e .

Lint

./scripts/skills-lint.sh

Checks frontmatter, trigger clauses, file references, and cross-skill links.

License

MIT