skills 0.1.2

CLI that installs AI agent skills from your Dart and Flutter package dependencies into your IDE, so Antigravity, Cursor, Claude, and other assistants know how to use your stack.

Skills

A CLI that brings AI agent skills from your Dart and Flutter package dependencies directly into your IDE.

Note: The Dart team is working on a similar solution based on Dart's MCP server. When that is released, we will provide scripts to convert your skills to Dart's new format. This package will then either adopt the Dart MCP standard for delivering skills or be deprecated (assuming the MCP solution is equally capable).

Dart packages can ship a skills/ directory containing Agent Skills, structured instructions that teach AI coding assistants how to use the package effectively. The skills CLI finds those skills in your dependency tree and installs them into your IDE so your AI assistant better understands your stack.

The problem

When you add a Dart package to your project, your AI coding assistant has no idea how to use it properly. It guesses APIs, invents patterns, and hallucinates methods that don't exist. You end up copy-pasting documentation into chat, writing custom rules, or correcting the AI over and over.

The solution

Package authors ship skills alongside their code. You run one command, and your AI assistant knows how to work with every package in your project.

skills get

That's it. Your AI assistant now has context-aware instructions for every dependency that provides skills.

Installation

Activate the CLI globally:

dart pub global activate skills

Make sure ~/.pub-cache/bin is on your PATH (instructions).

Quick start

Navigate to the root of your Dart or Flutter project and run:

# Install skills from all dependencies
skills get

# Install skills from a specific package
skills get serverpod

# List installed skills
skills list

# Remove all managed skills
skills remove

# Remove skills from one package
skills remove serverpod

The CLI will automatically run pub get if needed, scan your dependency packages for skills/ directories, and install them in the right location for your IDE. If you are using a monorepo, skills will locate your different packages and get the skills for all of them.

Supported IDEs

The CLI auto-detects your IDE from project directory markers. If multiple IDEs are detected, it installs to all of them. You can also pass --ide explicitly or set the SKILLS_IDE environment variable to target a single IDE.

IDE	Flag	Install location	Format
Antigravity	--ide antigravity	.agent/skills/	Agent Skills (full directory)
Cursor	--ide cursor	.cursor/skills/	Agent Skills (full directory)
Claude Code	--ide claude	.claude/rules/	Markdown rule file
GitHub Copilot	--ide copilot	.github/instructions/	.instructions.md file
Cline	--ide cline	.clinerules/	Markdown rule file

Note that you need to install skills for GitHub Copilot using the --ide copilot flag. It will not be automatically added.

IDE format differences

Cursor and Antigravity support the full Agent Skills standard. The entire skill directory is copied as-is, including scripts/, references/, and assets/ subdirectories.

Claude Code, GitHub Copilot, and Cline use their own rules/instructions format. For these IDEs, only the markdown body from SKILL.md is extracted and written as a single rule file. The scripts/, references/, and assets/ directories are not installed for these IDEs.

If your package needs to support all IDEs, make sure the essential instructions are self-contained in the SKILL.md body and don't depend on supporting files.

For package maintainers

Ship AI skills with your package so every user's coding assistant understands your APIs, conventions, and best practices.

Adding skills to your package

Create a skills/ directory at the root of your package (next to lib/). Each skill is a subdirectory containing a SKILL.md file following the Agent Skills specification:

my_package/
  lib/
  skills/
    my_package-code-gen/
      SKILL.md
      scripts/       # optional helper scripts
      references/    # optional reference docs
      assets/        # optional static resources
    my_package-testing/
      SKILL.md

Naming convention

Every skill directory name must start with your package name followed by a hyphen. The CLI verifies this on installation and silently skips any skills that don't follow the convention.

For a package named serverpod:

Directory name	Valid?
serverpod-code-generation	Yes
serverpod-api-design	Yes
code-generation	No -- missing package prefix
other_pkg-code-generation	No -- wrong prefix

This convention ensures skill names are globally unique and self-documenting. When a user sees serverpod-code-generation in their IDE, they know exactly where it came from.

Writing a skill

The name field in SKILL.md should match the directory name. Here is an example of a skill:

---
name: my_package-my-skill
description: Use when the user is working with MyPackage APIs to ensure correct patterns and error handling.
---

# My Skill

## Guidelines

- Always use `MyPackage.initialize()` before calling other methods.
- Prefer the builder pattern for configuration.
- Handle `MyPackageException` explicitly rather than catching generic exceptions.

## Examples

...

The description tells the AI when to activate the skill -- make it specific and action-oriented.

Supporting all IDEs

Cursor and Antigravity receive the full skill directory, including scripts/, references/, and assets/. Claude Code, GitHub Copilot, and Cline only receive the markdown body from SKILL.md.

To maximize compatibility:

• Put all essential instructions directly in SKILL.md. This is the only content that reaches every IDE.
• Use scripts/, references/, and assets/ for supplementary material that enhances the skill on IDEs that support it, but don't make the skill depend on them.

Best practices

• Keep skills focused. One skill per major feature area. Don't dump everything into a single skill.
• Write for the AI, not the human. Skills are instructions for the coding assistant. Be direct and prescriptive.
• Include examples. Show correct usage patterns. The AI learns best from concrete examples.
• Keep SKILL.md under 500 lines. Move detailed reference material into references/ files for IDEs that support them.
• Version your skills with your package. When you change APIs, update the skills to match.

What happens when users run skills get

1. The CLI resolves your package's location on disk from package_config.json.
2. It finds your skills/ directory and each skill subdirectory with a SKILL.md.
3. It validates that each skill name starts with your package name.
4. Skills are installed into the user's IDE-specific location.
5. A .dart_skills/skills_config.json tracking file records which skills were installed from which package and IDE.

Users can update skills by running skills get again. Existing skills from your package are replaced with the latest versions.

The .dart_skills/skills_config.json file tracks managed skills so skills remove knows what to clean up without touching skills you created manually.