Skip to main content
Colin compiles agent skills from live sources. In this quickstart, you’ll build a skill from this quickstart itself. When we update these docs, your agent’s knowledge of Colin updates too.

​
Projects and Blueprints

Colin organizes work into projects. A project is a folder with a colin.toml configuration file and a models/ directory containing your source templates. When you run Colin, it reads templates from models/, resolves their dependencies, and writes compiled output. Blueprints are starter templates for projects. Instead of creating files manually, you can initialize a project from a blueprint that already has everything configured. We’ve prepared a quickstart blueprint so you can follow along without needing your editor open. Create the project: 
colin init using-colin -b quickstart
This creates a using-colin/ folder with everything you need. Move into it: 
cd using-colin

​
What’s Inside

The blueprint created this structure: 
using-colin/
├── colin.toml
└── models/
    ├── SKILL.md
    └── tips.md
The colin.toml file is minimal—just the project name. The interesting parts are in models/.

​
The Skill

Here’s models/SKILL.md, the main skill file: 
---
name: using-colin
description: How to use Colin to compile agent skills from live sources.
             Use when working with Colin projects, templates, compilation,
             or skill management.
---

# Using Colin

Compiled from live documentation.

{{ colin.github.file('PrefectHQ/colin', 'docs/getting-started/quickstart.mdx').content }}

---

{{ ref('tips.md').content }}
The top section is frontmatter—YAML metadata that tells agents when to use this skill. The name and description are what Claude Code sees when deciding which skills apply to your request. Below that is the template body. Two things are happening here:
  1. colin.github.file(...) fetches this very quickstart from GitHub and inserts its content
  2. ref('tips.md').content pulls in content from the tips.md file in your project
When Colin compiles this, it replaces those template expressions with actual content.

​
The Supporting Document

Here’s models/tips.md, a reference document that gets pulled into the main skill: 
---
colin:
  output:
    publish: false
---

## Quick Reference

**Providers** fetch from external sources:
- `colin.github.file(repo, path)` - GitHub files
- `colin.linear.issues(team=...)` - Linear issues
- `colin.notion.page(url)` - Notion pages

**References** connect documents:
- `ref('doc.md').content` - include another document's content

**LLM processing** transforms content:
- `ref('doc.md').content | llm_extract('prompt')` - extract specific information
Notice the publish: false in the frontmatter. This tells Colin to compile the document but not include it in the output. The tips content gets composed into SKILL.md via ref(), so there’s no need for a separate output file.

​
Compile the Project

Now run Colin: 
colin run
Colin reads your templates from models/, fetches the quickstart from GitHub, resolves the reference to tips.md, and writes the compiled output. By default, output goes to an output/ folder in your project. Take a look at output/SKILL.md: 
cat output/SKILL.md
You’ll see the compiled skill with all the template expressions replaced by actual content—including the quickstart you’re reading right now.

​
Incremental Builds

Here’s where Colin gets interesting. Make a change to models/tips.md—add a line about the HTTP provider. If you’d rather not open an editor, here’s a shortcut: 
echo '- `colin.http.get(url)` - HTTP endpoints' >> models/tips.md
Now run Colin again: 
colin run
Colin recompiles SKILL.md because it depends on tips.md, which changed. But notice: it didn’t re-fetch from GitHub. The GitHub content hasn’t changed since last time, so Colin used its cached version. This is the core value proposition. Colin tracks what sources went into each document and their versions. When you run again, it only refetches what’s actually changed. Your skills stay fresh without redundant work.

​
Output to Claude Code

So far, Colin has been writing to output/ in your project. To make this an actual skill that Claude Code can use, you need to configure an output target. Add the output configuration to colin.toml: 
cat >> colin.toml << 'EOF'

[project.output]
target = "claude-skill"
EOF
Run colin run again. Now instead of writing to output/, Colin writes directly to ~/.claude/skills/using-colin/. The skill is immediately available in Claude Code. Your agent now knows how to use Colin—and that knowledge will stay current every time you run colin run.

​
What You Built

You now have an agent skill that:
  • Contains the Colin quickstart, pulled live from GitHub
  • Includes your own reference notes composed via ref()
  • Rebuilds incrementally when sources change
  • Lives in Claude Code, ready to help

​
Next Steps