Canopy Skills for VS Code

Write Claude Code / GitHub Copilot skills as executable code, not prose.

IntelliSense, semantic diagnostics, and go-to-definition for Canopy skills — the declarative, tree-structured execution framework for AI agents. Tracks framework v0.22.0.

Available on the VS Code Marketplace under the canopy-ai publisher — search for Canopy Skills in the Extensions panel, or install via code --install-extension canopy-ai.canopy-skills. Pre-Marketplace .vsix artifacts are still attached to each GitHub Release for offline installs.

What is Canopy?

Canopy is a framework for writing AI skills as structured, executable code rather than freeform prose. Instead of describing what an AI agent should do in plain text, you define skills as a tree of named operations with explicit control flow, inputs, and outputs — then run them through Claude Code or GitHub Copilot.

A Canopy skill looks like this:

---
name: review-pr
description: Review a pull request for correctness and style
---

## Tree

* FETCH_PR << PR_URL
* IF << changes_are_large >>
  * SPLIT_INTO_SECTIONS
* ELSE
  * REVIEW_IN_ONE_PASS
* SHOW_PLAN >> review_summary

Key ideas:

• Skills (SKILL.md) define behavior as a tree of operation calls.
• Ops (ops.md) define reusable named operations local to a skill or shared across skills.
• Framework primitives (IF, ELSE_IF, ELSE, SWITCH, CASE, DEFAULT, FOR_EACH, BREAK, END, ASK, SHOW_PLAN, VERIFY_EXPECTED, EXPLORE) are built-in control-flow + interaction + execution ops provided by the framework.
• Resources (constants, policies, templates, schemas, verify checklists, command scripts, references) are supporting files co-located with each skill.
• Skills install at one of three roots — .agents/skills/ (cross-client, gh skill 2.91+ default), .claude/skills/ (Claude Code), or .github/skills/ (Copilot). canopy-runtime resolves <skills-root> automatically.

Canopy turns AI instructions into something you can read, review, version-control, lint, and refactor — like real code.

Installation

The extension is distributed as a .vsix on GitHub Releases until the Marketplace listing is live.

1. Download the latest canopy-skills-<version>.vsix from the Releases page.
2. Install from the command line:

   code --install-extension canopy-skills-<version>.vsix
   

   Or in VS Code: Extensions panel → … menu → Install from VSIX… → pick the file.

Quick Start

Open your project, then run these from the Command Palette (Ctrl+Shift+P / Cmd+Shift+P):

1. Canopy Install: Install...
   • Pick an install method: script / gh skill / Claude Code plugin
   • Pick a target: Claude Code, Copilot, Both, or Cross-client (.agents/skills/)
   • Installs the three framework skills. The marker block self-writes on first agent load — install scripts also write it eagerly.
2. Create your first skill (requires claude or gh copilot on PATH)
   • Canopy Skill: Create Skill — describe it in plain English; the agent scaffolds and validates
   • Canopy Template: New Skill — drop a blank SKILL.md + ops.md and hand-author
3. Edit the generated SKILL.md — these activate automatically:
   • Autocomplete for primitives and custom ops
   • Hover docs on every ALL_CAPS identifier
   • F12 go-to-definition
   • Real-time diagnostics with Quick Fixes
4. Run the skill from your AI agent
   • Claude Code auto-discovers .claude/skills/
   • Copilot loads .github/skills/
   • Iterate with Canopy Skill: Modify / Validate / Improve Skill

What this extension does

Turns Canopy skill files into a first-class editor experience: live semantic validation with Quick Fixes, autocomplete for every primitive and custom op, inline hover docs, and go-to-definition across the skill → project → framework op lookup chain. Tracks the framework's evolving feature surface — subagent dispatch markers (v0.20+), per-skill metadata.canopy-features slice manifest with drift detection (v0.21+), and universal op contracts with static type-flow analysis through the binding graph (v0.22+). Ships scaffolding commands for every resource type plus direct integration with the Canopy AI agent via claude or gh copilot suggest.

In action

Autocomplete for primitives and custom ops

Type a tree-node prefix and get completions for every IF, ELSE, ASK, SHOW_PLAN, VERIFY_EXPECTED, and any custom op defined in the current skill, the project, or the framework.

Semantic diagnostics with Quick Fixes

Real-time validation catches primitive signature violations, missing frontmatter, wrong <</>> usage, and broken resource references — before you run the skill.

Inline documentation for every primitive

Hover any ALL_CAPS identifier to see its signature, description, and how it flows with << / >> — no context switching to the framework docs.

Commands

All commands are accessible via the Command Palette (Ctrl+Shift+P / Cmd+Shift+P). Commands are grouped into three categories that sort alphabetically in the palette to give you a natural workflow order: Canopy Install → Canopy Skill → Canopy Template.

Install (Canopy Install category)

Install the Canopy framework into your project. Each command shows a Quick Pick of the three skills (canopy, canopy-runtime, canopy-debug) — all checked by default.

✨ Skill — describe it, let AI write it (Canopy Skill category)

Start here. No deep framework knowledge required — describe what you want in plain English and the Canopy AI agent writes, validates, and refines the skill for you. Auto-detects the installed AI target (Claude Code under .claude/ or GitHub Copilot under .github/) and invokes claude "<prompt>" or gh copilot suggest "<prompt>".

Scaffold — manual authoring (Canopy Template category)

For authors who know the framework and prefer to hand-write skills and resources. Each command drops a correctly-structured blank file at the right path — you fill in the content.

Features

Syntax highlighting

Five language IDs cover all Canopy file types:

All patterns cover all three skills roots: .agents/ (cross-client), .claude/ (Claude Code), and .github/ (Copilot). The agentskills.io standard layout (assets/, scripts/, references/) and the legacy flat layout (category dirs at the skill root) are both recognised.

IntelliSense

Completions in SKILL.md and ops.md:

Hover documentation

Hovering over a framework primitive or a custom op shows its description, expected << input and >> output, and a usage example.

Go-to-definition

Press F12 (or right-click → Go to Definition) on any ALL_CAPS identifier. The extension resolves through:

1. Current skill's ops.md
2. Consumer-defined cross-skill ops (if any)
3. Framework primitives (statically defined in the extension; canonical source is canopy's skills/canopy-runtime/references/ops.md index plus per-feature slice files under skills/canopy-runtime/references/ops/<slice>.md)

Semantic diagnostics

Real-time squiggles for:

Requirements

• VS Code 1.85 or later
• For Install (via install script): git in PATH
• For Install as Agent Skill (gh skill): gh CLI v2.90.0+ in PATH (the skill subcommand)
• For Canopy Skill commands targeting Claude: claude CLI in PATH (each command surfaces an "open download" link if missing)

Settings

Building from source

npm install
npm run compile      # one-shot TypeScript compile
npm run watch        # watch mode
npm run package      # produces canopy-skills-<version>.vsix

Press F5 in VS Code to open an Extension Development Host with the extension loaded.

Links

• Canopy framework
• Extension source
• Changelog