Skip to main content
Agent skills are an open standard for giving AI agents domain-specific expertise. Tools like Claude Code, Cursor, Codex, and Gemini CLI can discover and load skills dynamically to perform better at specific tasks. Colin compiles skills from live sources. Instead of static markdown files that go stale, write templates that pull from your actual infrastructure: GitHub repos, incident history, internal APIs. When those sources change, Colin recompiles. Skills stay fresh automatically.

​
Why Colin?

Skills drift from reality. The deployment process changes, environments get renamed, approval flows update. The skill becomes wrong. Agents give bad advice. Colin keeps skills fresh by compiling them from live sources: 
---
name: deployment-process
description: How to deploy to staging and production
---

# Deployment

{{ ref('infrastructure/environments').content }}

## Steps

{{ colin.github.file('acme/platform', 'docs/DEPLOY.md').content }}

## Recent Issues

{{ colin.mcp.pagerduty.resource('incidents/deploy-related/last-30d') | llm_extract('what went wrong and how it was fixed') }}
Run colin run. The skill compiles from your infrastructure doc, the latest deployment guide from GitHub, and recent incidents from PagerDuty. When the deployment guide changes, Colin detects it and recompiles.

​
Migrating Existing Skills

Static skills can become Colin templates incrementally. Keep existing content, wrap dynamic parts in refs: 
# Deployment

## Environments

{{ colin.github.file('acme/infra', 'docs/ENVIRONMENTS.md').content }}

## Manual Steps

1. Create a PR against main
2. Wait for CI to pass
3. Get approval from a code owner
4. Merge to main

[Your existing static content stays here unchanged]
The static parts pass through unchanged. The dynamic parts recompile when sources change. Start with one dynamic section and expand from there.

​
The Standard

A skill is a folder containing markdown files with YAML frontmatter. The standard uses progressive disclosure: agents load just enough information to decide what to do, then reveal more details as needed. 
my-skill/
├── SKILL.md          # Loaded first: name, description, overview
├── deploying.md      # Loaded when relevant
└── troubleshooting.md
The SKILL.md frontmatter tells agents when to use the skill: 
---
name: deployment-process
description: How to deploy code to staging and production
---
At startup, agents pre-load skill names and descriptions. This metadata is enough to know when each skill applies. The body loads only when the skill is invoked.

​
Output to Skills Directories

Configure Colin to write directly to your agent’s skills folder:
colin.toml
[project.output]
target = "claude-skill"
scope = "user"
With scope = "user", skills write to ~/.claude/skills/ and become available in all Claude Code sessions. With scope = "project", they write to .claude/skills/ relative to your project. Other agents use different locations. Target any path:
colin.toml
[project.output]
target = "skill"
path = "~/.codex/skills/"
The skill target uses per-subdirectory manifests, so multiple skill projects can coexist without interfering.

​
Generating Skills from MCP Servers

The mcp-guide blueprint generates complete skill sets from any MCP server automatically. 
colin init my-skills -b mcp-guide
cd my-skills
colin mcp add source "npx -y @your-org/mcp-server"
colin run
Colin connects to the server, discovers its tools, and generates: 
server-name/
├── SKILL.md           # Server overview with tool list
├── greet.md           # Tool documentation
├── calculate.md       # Tool documentation
└── scripts/
    ├── greet.py       # Executable wrapper
    └── calculate.py
Each tool gets its own documentation file with parameter schemas and usage instructions. The LLM writes concise descriptions automatically. To customize:
colin.toml
[vars]
mcp_provider_name = "custom-name"   # Override folder name
generate_scripts = false            # Disable script generation

​
Writing Skills Manually

For skills not generated from MCP servers, create templates that compile to proper skill format. A minimal skill:
models/my-skill/SKILL.md
---
name: code-review
description: Guidelines for reviewing pull requests
---

# Code Review Process

{{ ref('engineering/review-checklist').content }}

## Style Guide

{{ colin.github.file('acme/platform', 'STYLE.md').content }}
For skills with multiple files, use {% file %} blocks:
models/skill-generator.md
---
colin:
  output:
    publish: false
---

{% file "my-skill/SKILL.md" publish=true %}
---
name: onboarding
description: New engineer onboarding checklist
---

# Onboarding

{{ ref('hr/onboarding-steps').content }}
{% endfile %}

{% file "my-skill/first-week.md" publish=true %}
# First Week

{{ colin.mcp.notion.resource('pages/first-week-guide').content }}
{% endfile %}

​
Keeping Skills Fresh

Colin tracks dependencies automatically. When ref() or MCP fetches execute, Colin records the version. On the next run, it checks if versions changed and recompiles affected skills. For time-sensitive content, set expiration: 
---
colin:
  cache:
    expires: 1d
---
This forces recompilation daily, even if sources haven’t changed. Useful for skills that should always reflect the latest data.

​
Example: Team Context Skill

A skill that keeps agents informed about your team:
models/team/SKILL.md
---
name: team-context
description: Information about the engineering team, current projects, and how we work
---

# Engineering Team

{{ ref('company/engineering-org').content }}

## Current Sprint

{{ colin.mcp.linear.resource('team/engineering/current-sprint') | llm_extract('active projects and blockers') }}

## On-Call

{{ colin.mcp.pagerduty.resource('schedules/engineering') | llm_extract('who is on call this week') }}

## Recent Decisions

{{ colin.mcp.notion.resource('databases/engineering-decisions?last=30d') | llm_extract('key decisions and rationale') }}
Configure to write to Claude Code:
colin.toml
[project]
name = "team-context"

[project.output]
target = "claude-skill"
scope = "user"

[[providers.mcp]]
name = "linear"
command = "npx"
args = ["-y", "@linear/mcp-server"]

[[providers.mcp]]
name = "pagerduty"
command = "npx"
args = ["@pagerduty/mcp-server"]

[[providers.mcp]]
name = "notion"
command = "npx"
args = ["@anthropic/mcp-server-notion"]
Run colin run and the skill appears in Claude Code immediately.

​
Updating Skills

The colin skills update command refreshes all Colin-managed skills: 
colin skills update
Colin scans ~/.claude/skills/ (or another specified directory), finds all subdirectories with Colin manifests, and updates them in parallel. Each manifest stores its source project location, so Colin knows where to find the original templates. Specify a different skills directory: 
colin skills update ~/.codex/skills/
Automate with cron to keep skills fresh: 
# Update skills every hour
0 * * * * colin skills update -q
This enables a workflow where skills are “installed” once and updated automatically as their sources change. Developers can maintain skill projects centrally while agents receive updates wherever they run.