llm-prompts

Cross-agent rules, workflows, skills, and agents for LLM coding assistants.

Supports Cline, GitHub Copilot, Kiro, Claude Code, and Codex.

Quick start

curl -LsSf https://raw.githubusercontent.com/alexfayers/llm-prompts/main/install.sh | sh

This installs uv (if needed), installs llm-prompts, and creates a starter config. Then:

# Edit ~/.config/llm-prompts/config.toml to add your overlay packages, then:
llm-prompts install {agent}    # kiro, cline, copilot, claude-code, codex, or all

The first install bootstraps everything: when your config has any remote (git URL) [[tools]] entries, install automatically runs setup first to install/upgrade those packages, then installs rules/workflows/skills for the target agent(s). Pass --no-update to skip the automatic setup.

From then on, keep everything current with:

llm-prompts update    # pull tool/plugin sources, refresh packages, reinstall for every agent you've set up

update re-pulls every git-based [[tools]] and [[plugins]] source, re-runs setup if any [[tools]] are remote, then reinstalls for each agent already in your manifest (i.e. every agent you've previously run install for) - no need to name agents again. Use llm-prompts update --check to see what's available without applying it.

Concepts

Rules

Rules are markdown files that steer agent behaviour. They are always active during a session - the agent reads them as part of its system prompt. Examples: coding style guidelines, git commit conventions, banned phrasing.

Rules are installed to agent-specific directories (e.g. ~/.kiro/steering/ for Kiro, ~/Documents/Cline/Rules/ for Cline, ~/.claude/rules/ for Claude Code). Codex has no rules directory, so all rules are concatenated into a single ~/.codex/AGENTS.md.

Workflows

Workflows are markdown files that define multi-step procedures the agent can follow. Unlike rules (which are always active), workflows are loaded on demand when the agent needs to perform a specific task. Examples: pre-implementation checklist, confidence scoring, oncall investigation.

Skills

Skills are directories containing a SKILL.md file that the agent reads before performing a specific action. They provide just-in-time guidance for tasks like git operations, session management, or plan refinement. Skills are installed as symlinks, so edits to the source are picked up immediately.

Agents

Agents are Claude Code custom subagent definitions - single markdown files with YAML frontmatter (name, description, model, etc.) that define a specialised subagent. They are Claude-Code-specific: only Claude Code has a ~/.claude/agents/ subagent concept, so they are installed only for the claude-code target (unlike rules, workflows, and skills, which span multiple agents). Agents are installed as symlinks, so edits to the source are picked up immediately.

Templates

Shared rules and workflows use {{VAR}} template placeholders that get substituted per agent. For example, {{RULE_FILES}} becomes "steering files" for Kiro, ".clinerules files" for Cline, and "AGENTS.md" for Codex. This allows a single source file to work across all agents. Variables are defined in each agent's vars.json.

Overlays

Overlays are separate packages that add extra rules, workflows, and skills on top of the core llm-prompts content. They are useful for organisation-specific or private rules that you don't want in the public repo.

For example, mcp-memory is an overlay that adds memory-related rules and skills. When installed alongside llm-prompts, its content is merged in during llm-prompts install. Overlay content takes priority over core content when filenames collide.

Setup config

llm-prompts setup reads ~/.config/llm-prompts/config.toml to install all your tools and overlays in one go.

[[tools]]
name = "llm-prompts"
source = "git+https://github.com/alexfayers/llm-prompts.git"

[[tools]]
name = "cline-hooks"
source = "git+https://github.com/alexfayers/cline-hooks.git"

[[tools]]
name = "mcp-memory"
source = "git+https://github.com/alexfayers/mcp-memory.git"

Each [[tools]] entry has:

Field	Description
name	Tool name
source	Local path (~/...) or git+ URL

For local-path and git URL sources, whether a package is an overlay (and which tools it targets) and whether it's standalone is inferred automatically from its own pyproject.toml (entry-point groups become overlay targets; a [project.scripts] table marks it standalone) - mcp-memory above needs no extra config because of this. Overlays are added via --with-editable (local) or --with (git) to their target tools. The installer is auto-detected (uv > pipx > pip).

To override the inference, set overlays_for (list of tools this package plugs into as an overlay) and/or standalone (true if the tool also needs its own install, e.g. it has a CLI) explicitly.

llm-prompts setup              # install all tools
llm-prompts setup mcp-memory   # install just one tool
llm-prompts setup --dry-run    # preview commands without running

setup installs or upgrades the tools/overlays in config.toml. Filter to a single tool by name, preview the commands with --dry-run, or create the starter config with --init.

Plugin sources

[[plugins]] tracks raw git repos that ship Claude Code plugin/marketplace skills (a skills/**/SKILL.md layout, no Python packaging) and fans their skills out to every agent you've installed, the same way built-in and overlay skills are:

[[plugins]]
name = "mattpocock-skills"
source = "https://github.com/mattpocock/skills.git"
ref = "main"                      # optional; branch/tag/SHA; defaults to the remote's default branch
skills = ["tdd", "code-review"]   # optional; subset by skill directory name; defaults to all

Field	Description
name	Plugin name; also its checkout directory under ~/.config/llm-prompts/plugin-sources/
source	Plain git URL (no pip/PyPI semantics)
ref	Optional branch/tag/SHA to pin to
skills	Optional list of skill names to install; installs every discovered skill if omitted

llm-prompts update refreshes each checkout (git fetch + git reset --hard, so it always lands on the upstream tip regardless of force-pushes or history rewrites) before reinstalling. A plugin skill never overwrites a built-in or overlay skill of the same name - a collision is skipped with a warning. Currently only skills are supported from external plugins; other components (commands/, agents/, hooks/, MCP/LSP servers) are ignored.

Creating an overlay

Overlay packages register via the llm_prompts entry point group:

# overlay's pyproject.toml
[project.entry-points."llm_prompts"]
my-overlay = "my_package"

The entry point value is the Python package name. Prompts are discovered by convention at <package>/prompts/:

src/my_package/prompts/
  shared/rules/         # rules for all agents
  shared/skills/        # skills for all agents
  cline/rules/          # cline-only rules
  kiro/rules/           # kiro-only rules
  claude-code/agents/   # claude-code-only subagents

Kiro agent setup

After installing rules and skills with llm-prompts install kiro, you need a Kiro agent config that references them. If you already have an agent JSON file, the installer can patch it automatically:

llm-prompts install kiro --agent-config ~/.kiro/agents/my-agent.json

This adds resources entries for the installed steering files and skills to your agent config. If cline-hooks and mcp-memory are installed (included in the default config), it also injects lifecycle hooks, the memory MCP server, and auto-approval for memory tools. If the entries already exist, they are left unchanged.

To set up a Kiro agent from scratch:

1. Run the bootstrap script (installs uv, llm-prompts, and creates a starter config):

curl -LsSf https://raw.githubusercontent.com/alexfayers/llm-prompts/main/install.sh | sh

2. Install all configured tools and overlays:

llm-prompts setup

3. Create a minimal agent config:

mkdir -p ~/.kiro/agents
cat > ~/.kiro/agents/my-agent.json << 'EOF'
{
  "name": "my-agent",
  "description": "My agent",
  "tools": ["*"]
}
EOF

4. Install rules, skills, and patch the agent config:

llm-prompts install kiro --agent-config ~/.kiro/agents/my-agent.json

3. (Optional) Set up mcp-memory for persistent memory across sessions. Add it as an MCP server in your Kiro MCP config and include the memory rules overlay in your config.toml.

mcp-memory install kiro

4. (Optional) Set up cline-hooks for lifecycle hooks (pre/post tool use, session start, etc.). Install hooks into your agent config with:

cline-hook install kiro ~/.kiro/agents/my-agent.json

CLI

llm-prompts install <agent>                    # install rules/workflows/skills
llm-prompts install kiro --agent-config PATH   # also patch agent JSON with resources
llm-prompts install <agent> --no-update        # skip auto-update
llm-prompts update                             # pull tool/plugin sources, reinstall every configured agent
llm-prompts update --check                     # report available updates without applying them
llm-prompts uninstall <agent>                  # remove installed files and config patches
llm-prompts source <agent>                     # show source file paths
llm-prompts setup                              # install all configured tools
llm-prompts setup <tool>                       # install just one tool
llm-prompts setup --dry-run                    # preview install commands without running
llm-prompts setup --init                       # create starter config

Development

To contribute or edit rules locally, clone the repos and use local paths in your config:

git clone https://github.com/alexfayers/llm-prompts.git
git clone https://github.com/alexfayers/mcp-memory.git
git clone https://github.com/alexfayers/cline-hooks.git

Then update ~/.config/llm-prompts/config.toml to use local paths:

[[tools]]
name = "llm-prompts"
source = "~/llm-prompts"

[[tools]]
name = "cline-hooks"
source = "~/cline-hooks"

[[tools]]
name = "mcp-memory"
source = "~/mcp-memory"
standalone = true
overlays_for = ["llm-prompts", "cline-hooks"]

Local paths are installed as editable, so changes to rules, workflows, and skills are picked up immediately by llm-prompts install without needing to re-run setup.

llm-prompts setup              # install all tools as editable
llm-prompts install {agent}    # install rules/workflows/skills

Linting

uv run ruff check --fix && uv run ruff format

Related

• mcp-memory - persistent memory MCP server (overlay for llm-prompts and cline-hooks)
• cline-hooks - lifecycle hooks framework for AI coding assistants