Understanding skills, hooks, and lifecycle automation

tech

prompt-engineering

github-copilot

concepts

Understand how Agent Skills provide portable, resource-rich capabilities and how Agent Hooks provide deterministic lifecycle automation — two complementary mechanisms that extend Copilot beyond natural language guidance.

Author

Dario Airoldi

Published

March 1, 2026

Understanding skills, hooks, and lifecycle automation

Most of Copilot’s customization stack works through natural language — you write Markdown instructions, and the model interprets them. This works well for guidance, standards, and workflows. But some situations need more.

Agent Skills bundle templates, scripts, and examples alongside instructions, creating portable capabilities that work across VS Code, CLI, and the GitHub Coding Agent. Agent Hooks run your code at lifecycle points during agent sessions, providing deterministic enforcement that doesn’t depend on model interpretation.

Together, skills and hooks fill the gap between “suggesting the model do something” and “guaranteeing it happens.” This article explains what each mechanism is, how they work conceptually, how they complement each other, and when to choose one over the other.

🎯 Beyond natural language guidance
📦 Agent Skills: portable, resource-rich capabilities
🪝 Agent Hooks: deterministic lifecycle automation
🔄 How skills and hooks complement each other
✅ Decision framework: skills vs. hooks vs. other types
⚠️ Current limitations
🎯 Conclusion
📚 References

🎯 Beyond natural language guidance

Every customization type in the Copilot stack has a fundamental limitation: it relies on the model to interpret and follow instructions. Instruction files say “use camelCase” — but the model might occasionally use snake_case anyway. Agent files say “don’t edit files” — but tool restrictions are the only hard guarantee, and even those depend on how the model reasons about tool selection.

Skills and hooks address this limitation from two different angles:

Mechanism	What it provides	Guarantee level
Skills	Rich resources (templates, scripts, examples) alongside instructions	Medium — the model still interprets, but with concrete reference material
Hooks	Shell commands that execute at lifecycle events	High — your code runs deterministically, regardless of model behavior

📦 Agent Skills: portable, resource-rich capabilities

A skill is a folder containing a SKILL.md file plus optional resources (templates, scripts, examples). Unlike instruction files that provide rules, or prompt files that provide workflows, skills provide capabilities — complete packages that include both the instructions and the materials needed to execute them.

How skills differ from other types

Aspect	Skills	Instructions	Prompts	Agents
File	`SKILL.md` in a directory	`.instructions.md`	`.prompt.md`	`.agent.md`
Activation	Automatic (description matches your prompt)	Automatic (file pattern)	On-demand (`/command`)	Agent picker
Resources	✅ Templates, scripts, examples	❌ None	❌ None	❌ None
Cross-platform	✅ VS Code, CLI, coding agent	⚠️ VS Code + GitHub.com	❌ VS Code only	❌ VS Code only
Tool control	❌ Limited	❌ None	✅ Full	✅ Full
Standard	Open (agentskills.io)	VS Code-specific	VS Code-specific	VS Code-specific

The critical differentiator is resources. A skill doesn’t just say “create a test file following our patterns.” It says “create a test file using this template” — and includes the actual template. The model doesn’t have to guess what “our patterns” look like; it has a concrete example to follow.

The progressive disclosure system

Skills use a three-level loading system to minimize context consumption:

Level 1: DISCOVERY (Always loaded)
├── name: "webapp-testing"
└── description: "Automated testing workflow for web apps..."
    (~50-100 tokens per skill)
        │
        ▼  (When your prompt matches the description)
Level 2: INSTRUCTIONS (Loaded on match)
└── SKILL.md body content
    (~500-1500 tokens)
        │
        ▼  (When Copilot references a specific resource)
Level 3: RESOURCES (Loaded on demand)
├── templates/component.test.js
├── examples/login-form-tests.js
└── scripts/setup-test-env.sh
    (Loaded only when explicitly needed)

This design means that having 20 skills in your repository costs only ~2,000 tokens at Level 1 (just names and descriptions). The full content loads only when relevant — a significant advantage over instruction files, which inject their full content into every matching request.

Skill structure

A typical skill folder:

.github/skills/webapp-testing/
├── SKILL.md                    # Required: instructions + metadata
├── templates/                  # Optional: reusable templates
│   └── component.test.js
├── examples/                   # Optional: real-world examples
│   └── login-form-tests.js
└── scripts/                    # Optional: automation scripts
    └── setup-test-env.sh

The SKILL.md file has YAML frontmatter with name and description (both required), followed by instructions in the body:

---
name: webapp-testing
description: >
  Generate test suites for React components using Jest.
  Use when writing tests, debugging failures, or setting up test infrastructure.
---

# Web Application Testing Skill

## Purpose
Generate comprehensive test suites following team conventions.

## When to use
- Writing new component tests
- Debugging test failures
- Setting up test infrastructure

## Workflow
1. Analyze the component's props and state
2. Generate test file using [test template](./templates/component.test.js)
3. Run tests to verify coverage

When to use skills

Cross-platform workflows — tasks that should work the same in VS Code, CLI, and the coding agent
Template-driven tasks — code generation, scaffolding, migration where concrete templates improve consistency
Community sharing — open standard means skills work across tools
Resource-heavy workflows — tasks that need reference files, scripts, or examples alongside instructions

🪝 Agent Hooks: deterministic lifecycle automation

Agent hooks are JSON-configured shell commands that execute at specific lifecycle points during agent sessions. Unlike every other customization type (which influences the model through natural language), hooks run your code — deterministically, with guaranteed outcomes.

Why determinism matters

Consider this scenario: your instruction file says “always run the linter after editing a file.” The model usually follows this — but sometimes it doesn’t. It forgets, or it decides the linter isn’t relevant for “just a small change,” or it runs the linter but ignores the results.

A hook configured on the PostToolUse event runs your linter script every time a file is modified. The model doesn’t choose whether to run it. Your code executes automatically.

The eight lifecycle events

Hooks fire at specific points during agent sessions:

Event	When it fires	Common use cases
`SessionStart`	First prompt of a new session	Initialize resources, inject project context
`UserPromptSubmit`	User submits a prompt	Audit requests, inject system context
`PreToolUse`	Before agent invokes any tool	Block dangerous operations, modify tool input
`PostToolUse`	After tool completes successfully	Run formatters, linters, log results
`PreCompact`	Before context compaction	Export important context, save state
`SubagentStart`	Subagent is spawned	Track nested agent usage
`SubagentStop`	Subagent completes	Aggregate results, clean up
`Stop`	Agent session ends	Generate reports, send notifications

How hooks work

Hooks receive structured JSON via stdin and can return JSON via stdout. The PreToolUse event is particularly powerful because it can block tool execution or modify tool inputs:

Agent wants to run a terminal command
        │
        ▼
┌─────────────────────────────┐
│  PreToolUse hook fires      │
│  Receives: tool name, args  │
│                             │
│  Hook script evaluates:     │
│  ├─ Contains "rm -rf"?      │
│  │   → Return: BLOCK        │
│  ├─ Contains "DROP TABLE"?  │
│  │   → Return: BLOCK        │
│  └─ Otherwise               │
│      → Return: ALLOW        │
└─────────────────────────────┘
        │
        ▼
Tool executes (or is blocked)

Hook configuration

Hooks are configured in JSON files stored in .github/hooks/:

{
  "hooks": {
    "PreToolUse": [
      {
        "type": "command",
        "command": "./scripts/validate-tool.sh",
        "timeout": 15
      }
    ],
    "PostToolUse": [
      {
        "type": "command",
        "command": "npx prettier --write \"$TOOL_INPUT_FILE_PATH\""
      }
    ]
  }
}

Hook characteristics

Aspect	Description
Deterministic	✅ Runs your code, not the model’s interpretation
Can block execution	✅ `PreToolUse` can prevent dangerous operations
Can modify input	✅ Hooks can alter tool parameters before execution
Cross-compatible	✅ Same format as Claude Code and Copilot CLI
Execution contexts	Works across local, background, and cloud agents

When to use hooks

Security enforcement — block dangerous commands, prevent file deletion, restrict access
Code quality automation — run formatters and linters automatically after edits
Audit trails — log every tool invocation for compliance and debugging
Context injection — add project metadata, environment details, or branch info at session start
Approval control — auto-approve safe operations, require confirmation for sensitive ones
Subagent governance — track and constrain nested agent usage

🔄 How skills and hooks complement each other

Skills and hooks address different aspects of the same problem: making Copilot’s behavior more reliable. They’re complementary, not competing:

Aspect	Skills provide	Hooks provide
Content	Reference material (templates, examples, scripts)	Execution automation (shell commands at lifecycle points)
Reliability	Improved accuracy through concrete examples	Guaranteed execution through deterministic code
Scope	Task-specific capabilities	Session-wide policies
Language	Markdown (interpreted by model)	Shell commands (executed by system)

When to combine them

Skills and hooks work best together in scenarios that need both guidance and enforcement:

Skill: “Generate tests using our team template”
Hook: PostToolUse runs the test suite after every file creation
Skill: “Create database migrations following our naming convention”
Hook: PreToolUse validates migration file names before write operations
Skill: “Scaffold new API endpoints using our patterns”
Hook: PostToolUse runs the linter and formatter on every created file

✅ Decision framework: skills vs. hooks vs. other types

What are you trying to accomplsh?
│
├─ "I need the model to follow a workflow with templates"
│   └─ → Skill (SKILL.md + resources)
│
├─ "I need to guarantee something happens at a lifecycle point"
│   └─ → Hook (.github/hooks/*.json)
│
├─ "I need persistent coding standards"
│   └─ → Instruction file (.instructions.md)
│
├─ "I need a specialized AI persona with tool restrictions"
│   └─ → Agent (.agent.md)
│
├─ "I need a one-time reusable workflow"
│   └─ → Prompt file (.prompt.md)
│
└─ "I need both guidance AND enforcement"
    └─ → Skill + Hook (combine both)

Quick comparison table

Need	Best mechanism	Why
Block dangerous commands	Hook (`PreToolUse`)	Deterministic — can’t be bypassed
Auto-format after edits	Hook (`PostToolUse`)	Guaranteed execution, not model judgment
Generate tests from template	Skill	Provides the actual template, not just instructions
Enforce naming conventions	Instruction file	Pattern-based, always active for matching files
Define a security reviewer persona	Agent	Identity override with tool restrictions
Run a code review workflow	Prompt file	On-demand task with tool control
Cross-platform scaffolding	Skill	Works across VS Code, CLI, and coding agent
Audit all tool invocations	Hook (`PreToolUse` + `PostToolUse`)	Captures every operation deterministically

⚠️ Current limitations

Skills limitations

Preview feature — APIs and behaviors may change in future releases
No tool control — skills can’t restrict which tools the model uses (unlike agents and prompts)
No handoffs — skills can’t orchestrate multi-step workflows between agents
Description-based activation — if the description doesn’t match the user’s prompt, the skill won’t activate
Requires chat.useAgentSkills: true setting in VS Code

Hooks limitations

Preview feature — configuration format may change
Shell commands only — hooks run shell scripts, not native code
Timeout constraints — hooks must complete within their timeout (default varies by event)
No model influence — hooks can’t change how the model reasons; they only control execution
Organization policies — your organization might have disabled hooks for security reasons

🎯 Conclusion

Skills and hooks extend GitHub Copilot’s customization stack beyond natural language guidance into concrete resources and deterministic automation. Skills package templates, scripts, and examples into portable capabilities that improve the model’s accuracy through reference material. Hooks guarantee that specific code runs at lifecycle events, regardless of model behavior.

Key takeaways

Skills are portable capabilities with resources (templates, scripts, examples) that work across VS Code, CLI, and the coding agent
Hooks are deterministic shell commands that fire at eight lifecycle events during agent sessions
Skills improve accuracy through concrete reference material; hooks provide guaranteed execution
The progressive disclosure system means skills consume minimal tokens until activated
PreToolUse hooks can block dangerous operations — the most powerful enforcement mechanism in the stack
Skills and hooks are complementary — combine them when you need both guidance and enforcement

Next steps

How to structure content for Copilot skills — practical guide to writing SKILL.md files
How to use agent hooks for lifecycle automation — complete coverage of all eight lifecycle events
Understanding MCP and the tool ecosystem — the protocol for extending Copilot with external tools

📚 References

VS Code Agent Hooks Documentation [📘 Official] Official VS Code documentation for agent hooks. Covers all eight lifecycle events, JSON configuration format, input/output schemas, permission decisions in PreToolUse, and cross-platform compatibility with Claude Code and Copilot CLI.

VS Code Copilot Customization Overview [📘 Official] Microsoft’s comprehensive guide to customizing Copilot, including coverage of Agent Skills — file structure, progressive disclosure, cross-platform support, and enabling the preview feature.

Agent Skills Open Standard (agentskills.io) [📘 Official] The open standard defining the skill file format, progressive disclosure system, and cross-platform compatibility requirements.

VS Code v1.107 Release Notes [📘 Official] December 2024 release introducing Agent Skills as a preview feature, alongside Agent HQ and enhanced lifecycle management.

Understanding skills, hooks, and lifecycle automation

Table of contents

🎯 Beyond natural language guidance

📦 Agent Skills: portable, resource-rich capabilities

How skills differ from other types

The progressive disclosure system

Skill structure

When to use skills

🪝 Agent Hooks: deterministic lifecycle automation

Why determinism matters

The eight lifecycle events

How hooks work

Hook configuration

Hook characteristics

When to use hooks

🔄 How skills and hooks complement each other

When to combine them

✅ Decision framework: skills vs. hooks vs. other types

Quick comparison table

⚠️ Current limitations

Skills limitations

Hooks limitations

🎯 Conclusion

Key takeaways

Next steps

📚 References