Ink and Agency

imageInk and Agency Skill Pack

An Agent Plugins 1.0.0 plugin — one installable unit, one primitive (skills), readable by any conformant host: Claude Code, OpenAI Codex, Cursor, GitHub Copilot, Kiro, VS Code.

• Ink — workflow skills: writing, sprint/Scrum, issue management, Obsidian tooling, codebase analysis, debugging, research, teaching, an end-to-end build loop (plan→spec→tickets→implement→tdd→review), and neurodivergent-friendly executive-function support, with a which-skill router over them all.
• Agency — ~138 specialist skills (language/framework experts, infra, data/AI, security, product, and more — formerly subagents), plus the clarity-council skill and its library of 46 advisory personas for multi-perspective decisions (single / multi / iterative modes).

204 skills total, one folder each directly under skills/ — the flat layout Agent Plugins fixes for skill discovery, so every host finds the same set without host-specific configuration. Each skill declares its browsing category in frontmatter; CATEGORIES.md is the index. (The pack previously shipped a separate agents/ subagent library; those were folded into skills so the whole library ships in the one bundle.)

Formerly two repositories: risadams/skills and risadams/claude-subagent. Both histories are preserved via git subtree.

Structure

ink-and-agency/
├── .claude-plugin/
│   ├── plugin.json              # Claude Code plugin manifest
│   └── marketplace.json         # Claude Code marketplace catalog
├── .agents/
│   └── plugins/
│       └── marketplace.json     # Codex marketplace catalog
├── plugin.json                  # Agent Plugins 1.0.0 manifest (GENERATED — do not edit)
├── AGENTS.md                    # Maintainer guidance (canonical; Codex auto-loads it)
├── CLAUDE.md                    # Mirror of AGENTS.md (GENERATED — do not edit)
├── skills/                      # 204 skills, flat — one folder each (shared by every host)
│   ├── <name>/SKILL.md          # canonical skill; `category:` frontmatter is the browsing bucket
│   ├── <name>/agents/openai.yaml  # Codex picker metadata (GENERATED — do not edit)
│   ├── python-pro/              #   e.g. language-specialists
│   ├── kubernetes-specialist/   #   e.g. infrastructure
│   ├── clarity-council/         # the persona council — featured skill w/ bundled personas
│   ├── persona/                 # shared council persona contracts (reference docs, not skills)
│   ├── ... (see CATEGORIES.md for all 204 grouped by category)
│   ├── CATEGORIES.md            # Browsable index of all skills by category
│   ├── FLOWS.md                 # How skills chain into flows (which-skill routes on this)
│   ├── PORTABILITY.md           # How to interpret Claude tool names on other hosts
│   └── SELF-EVOLVE.md           # The self-evolution contract every skill's footer points to
├── scripts/
│   ├── add-self-evolve.ps1      # Maintains the Self-Evolve footer in every SKILL.md
│   ├── bulk-loop-update-skills.ps1
│   ├── convert-agents-to-codex.ps1  # Regenerates GENERATED artifacts (openai.yaml, plugin.json, CLAUDE.md)
│   └── lint-skills.ps1
└── docs/
    ├── adr/                     # Architecture decision records
    └── assets/                  # Banners, skill map

Skill Map

imageSkill Map

The full inventory lives in skills/CLAUDE.md — the source of truth for the skill list and descriptions. Skills are grouped by their category: frontmatter; see skills/CATEGORIES.md for the full index.

Install

Claude Code

Add the marketplace once, then install the plugin:

/plugin marketplace add risadams/ink-and-agency
/plugin install ink-and-agency

This installs all 204 skills. Or load locally for development (no marketplace, picks up your working copy):

claude --plugin-dir /path/to/ink-and-agency

OpenAI Codex

Add the marketplace once, then install the plugin:

codex plugin marketplace add risadams/ink-and-agency
codex plugin install ink-and-agency

The plugin bundles all skills via ./skills/ — nothing to install separately. If your Codex version predates plugin marketplaces, copy the skills directly:

git clone https://github.com/risadams/ink-and-agency
cp -r ink-and-agency/skills/* ~/.agents/skills/

Update

Releases are cut with semantic versioning and published as GitHub Releases (see CHANGELOG.md). To move to the latest version:

Updating on Claude Code

/plugin marketplace update ink-and-agency   # refresh the catalog
/plugin update ink-and-agency               # pull the new version

For a local dev checkout, just git pull — --plugin-dir always reflects the working tree.

Updating on OpenAI Codex

codex plugin marketplace update ink-and-agency
codex plugin update ink-and-agency

Invoking skills

Everything is a skill — a prompt-driven capability. Specialist skills (former subagents like python-pro, security-auditor) run inline like any other skill.

Invoking on Claude Code

Not sure which skill fits? Run /ink-and-agency:which-skill — it routes over the whole pack and hands you the exact invocation.

Invoking on OpenAI Codex

A skill's invocation mode is identical on both hosts — it's authored once in SKILL.md frontmatter and projected to each host, so a skill that's user-invoked in Claude Code is user-invoked in Codex too.

How skills compose

This pack is skills-only — one primitive covering both quick workflow techniques and deep domain specialists (the latter, like backend-developer and security-auditor, were formerly subagents).

Two kinds of skill

Common patterns

Pattern 1: workflow skill invokes a specialist

implement skill
  → writes the API
  → code-review skill → validated diff

Pattern 2: a flow chains skills

grill → work-plan → plan-to-spec → plan-to-tickets → implement (tdd + code-review)

Skills declare workflow neighbours in the related-skills frontmatter field. For the full model, see skills/INTEGRATION.md; for named end-to-end flows, see skills/FLOWS.md.

Self-evolution

Every skill in the pack learns across invocations. Each SKILL.md ends with a short Self-Evolve footer pointing at the shared contract, skills/SELF-EVOLVE.md. The loop it runs:

1. Start — the skill reads its learnings journal, if one exists, and applies what's relevant (standing guidance always; past entries when they match the situation).
2. End — the skill silently evaluates how the run went, from observable signals: corrections, retries, things that misfired, things that clicked.
3. Optional feedback — it may ask you one short question, and only when the session is interactive and the run had visible friction. Ignoring or declining costs nothing; it never asks during /loop runs, in subagents, or in non-interactive sessions.
4. Capture — only signal-bearing runs get a journal entry (the test: would this change the next invocation?). Routine clean runs write nothing.
5. Route improvements — when a learning suggests the skill itself should change, not just your context, it's routed by tier (see below).

Where learnings live — always on your machine. One markdown journal per skill: ~/.ink-and-agency/learnings/<skill-name>.md (user-global, follows you across projects), falling back to .ink-and-agency/learnings/<skill-name>.md at the workspace root on hosts whose sandbox confines writes to the workspace (Codex's default). Journals are plain markdown you can read, edit, or delete; nothing is ever sent anywhere.

How the skill itself improves. If the canonical checkout of this repo is present — you're working inside it, or ~/.ink-and-agency/config.md names its path — the skill proposes a concrete edit and, with your confirmation, applies it to the checkout (uncommitted, generated artifacts re-synced). Otherwise it records the idea under Suggested skill improvements in the journal and, only with your consent, offers to file it as an issue on this repo. A skill never edits its running copy in a plugin cache — caches are wiped on update and diverge from source.

For contributors: the footer is machine-maintained by pwsh ./scripts/add-self-evolve.ps1 (idempotent — run it after adding a skill; lint fails on a missing footer). A skill where end-of-run evaluation makes no sense can opt out with self-evolve: false in its frontmatter.

Conventions

• Skills cross-reference each other via the related-skills frontmatter field.
• Cross-component file paths are written relative to the referencing file (or described as "under the plugin root"), so they resolve on any host. Claude Code additionally exposes the plugin root as ${CLAUDE_PLUGIN_ROOT}.
• Skill bodies use Claude Code tool vocabulary; skills/PORTABILITY.md defines how other hosts map those names by intent.
• The markdown under skills/, plus AGENTS.md, are the single source of truth. Everything Codex-facing is generated from them by pwsh ./scripts/convert-agents-to-codex.ps1: skills/*/agents/openai.yaml (per-skill Codex picker metadata + invocation policy), the root plugin.json, and the root CLAUDE.md (mirror of AGENTS.md). After editing any source, re-run the script and commit the output; CI fails if they drift.
• One skill, both hosts: a skill's invocation mode lives once in its SKILL.md frontmatter (disable-model-invocation: true = user-invoked only) and is projected to Codex as policy.allow_implicit_invocation: false. Never hand-edit openai.yaml. See AGENTS.md.
• The persona council is the clarity-council skill (three inline modes), not a set of subagents — so it ships in the skills bundle on both hosts. Personas are reference documents in the shared skills/persona/ category (not skills — they have no SKILL.md), read by the council.
• The Self-Evolve footer at the bottom of every SKILL.md is machine-maintained (between <!-- self-evolve:start/end --> markers) by pwsh ./scripts/add-self-evolve.ps1 — change the template in that script and re-run it, never the footer itself. See Self-evolution.
• On Claude Code, skill names are namespaced by the plugin at install time (ink-and-agency:skill-name), so local project skills won't collide.

License

MIT