DEV Community

Cover image for Introducing skillc: The Development Kit for Agent Skills
Gabriel Wu
Gabriel Wu

Posted on

Introducing skillc: The Development Kit for Agent Skills

#skill #agents #compiler #tracing

TL;DR: skillc helps you create, validate, and optimize reusable knowledge packages that make AI coding agents smarter. Whether you're building skills or consuming them, skillc gives you the tools to work confidently.

The Problem: AI Agents Forget Everything

You've probably noticed this pattern:

  1. You explain a complex workflow to your AI coding agent
  2. It helps you perfectly... this one time
  3. Next session, you explain it all over again

AI agents are stateless. They don't remember your team's conventions, your favorite libraries, or that obscure API you've mastered. Every conversation starts from zero.

Agent Skills: Persistent Knowledge for AI Agents

Agent Skills solve this by giving agents persistent, structured knowledge they can reference across sessions. A skill is just a directory with a SKILL.md file:

rust-skill/
├── SKILL.md          # Metadata + instructions
└── docs/
    ├── patterns.md   # Your coding patterns
    └── gotchas.md    # Common pitfalls
Enter fullscreen mode Exit fullscreen mode

The agent reads your skill and applies that knowledge contextually. No more repeating yourself.

Enter skillc: The Development Kit

skillc is the CLI toolkit for working with Agent Skills. It handles two distinct workflows:

For Skill Authors: Build with Confidence

Creating a skill that actually helps agents requires validation. skillc provides the full authoring pipeline:

skc init  →  skc lint  →  skc build  →  skc stats  →  git push
    ↓            ↓            ↓             ↓             ↓
scaffold    validate    test locally   trace usage    publish
Enter fullscreen mode Exit fullscreen mode 
# Create a new skill
skc init rust-patterns

# Validate structure, links, and quality
skc lint rust-patterns

# Build locally and test with your agent
skc build rust-patterns

# See how agents actually use your skill
skc stats rust-patterns --group-by sections

# Publish when ready
git push origin main
Enter fullscreen mode Exit fullscreen mode

The skc stats command is particularly powerful — it shows you which sections agents access most:

$ skc stats rust-patterns --group-by sections

Skill: rust-patterns
Path: /Users/dev/.skillc/skills/rust-patterns
Query: Sections
Filters: since=<none>, until=<none>, projects=<none>
Period: start=2026-01-15T09:12:33+00:00, end=2026-01-30T16:45:21+00:00
23      SKILL.md        Error Handling
18      SKILL.md        Iteration
12      SKILL.md        Lifetimes
9       references/async.md     Tokio Patterns
7       references/async.md     Channel Selection
5       references/testing.md   Mocking Strategies
3       references/testing.md   Property Testing
Enter fullscreen mode Exit fullscreen mode

Now you know: agents need more content on error handling and iteration. This data helps you optimize for real usage patterns.

For Power Users: Unlock Search and Analytics

Even if you're just using skills, skillc adds superpowers:

skc build  →  skc search  →  skc stats
     ↓             ↓              ↓
  indexing    find content   track usage
Enter fullscreen mode Exit fullscreen mode 
# Install any skill
npx skills add username/awesome-skill

# Compile it to enable indexing
skc build awesome-skill

# Full-text search across all content
skc search awesome-skill "error handling"

# Track what your agents are actually reading
skc stats awesome-skill
Enter fullscreen mode Exit fullscreen mode

Building a skill creates a search index, so you can quickly find relevant content without reading everything manually.

Real-World Example: A Rust Skill

Here's a minimal but useful skill for Rust development. First, the SKILL.md frontmatter:

---
name: rust-patterns
description: "Idiomatic Rust patterns and common gotchas"
---
Enter fullscreen mode Exit fullscreen mode

Then the content with practical patterns:

Error Handling section:

Always use thiserror for library errors and anyhow for applications:

// Library code
#[derive(thiserror::Error, Debug)]
pub enum MyError {
    #[error("invalid input: {0}")]
    InvalidInput(String),
}

// Application code
use anyhow::{Context, Result};

fn main() -> Result<()> {
    do_thing().context("failed to do thing")?;
    Ok(())
}
Enter fullscreen mode Exit fullscreen mode

Iteration section:

Prefer iterators over manual loops:

// ❌ Avoid
let mut results = Vec::new();
for item in items {
    results.push(transform(item));
}

// ✅ Prefer
let results: Vec<_> = items.iter().map(transform).collect();
Enter fullscreen mode Exit fullscreen mode

After publishing, any agent with this skill installed will apply these patterns automatically.

MCP Integration: Direct Agent Access

skillc includes an MCP (Model Context Protocol) server, so agents can query skills directly. Add it to your agent's MCP configuration:

For example, in Cursor (.cursor/mcp.json):

{
  "mcpServers": {
    "skillc": {
      "command": "skc",
      "args": ["mcp"]
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

This exposes tools like skc_search, skc_show, skc_outline, and skc_stats that agents can call programmatically — no CLI needed.

Getting Started 

# Install
cargo install skillc

# Create your first skill
skc init my-first-skill --global

# Edit SKILL.md with your knowledge
# Then validate and test
skc lint my-first-skill
skc build my-first-skill
Enter fullscreen mode Exit fullscreen mode

What Will You Teach Your Agent?

The best skills come from real expertise:

  • Framework patterns you've learned the hard way
  • API quirks that aren't in the docs
  • Team conventions that keep code consistent
  • Debugging techniques for specific tools

Your knowledge, captured once, applied forever.

Links:

What skill would you create first? Drop a comment below!

Top comments (0)