Context Engineering 103 - Agent Skills

In the last article, we covered Write, Select, Compress, and Isolate as the four pillars of context engineering. That framework works beautifully when you're managing context at runtime.

But there's a different approach. Instead of asking "how do I manage all this context?", it asks "what if the agent could grab exactly what it needs, exactly when it needs it?"

That's the core idea behind Agent Skills.

The Problem with Static Context

When you need an agent to be an expert at a particular task, you typically have three options:

1. Subagents - Handoff the task to a subagent with selected context. This works most of the time, but the tricky part is context handoff. What context do you pass? What do you take back? These decisions need considerable iteration to get right.

2. RAG - Store expertise in documents, retrieve relevant chunks on every query. Cosine similarity fetches top results, but those chunks don't always make sense together.

3. System Prompt - Feed everything upfront. Brand guidelines, procedures, documentation. All sitting there from the start, whether the current task needs it or not.

Most of the time you're either managing subagent handoffs or fighting system prompt bloat.

When we built the supervisor-subagent architecture at Chromatic for video production, managing those handoffs took weeks of iteration and considerable token cost to reach acceptable accuracy.

Skills as Progressive Disclosure

Agent Skills take a different approach. Instead of loading everything upfront, they use progressive disclosure.

At startup, the agent loads only the metadata of available skills, just the name and a short description, which comes to around 50 tokens per skill. When a request matches a skill's description, only then does the agent read the full SKILL.md into context. If that skill references additional files, the agent can choose to read those too, or skip them if the current task doesn't need that depth.

Think of it like a well-organized manual where you start with the table of contents, flip to the relevant chapter when needed, and only dive into the appendix if the situation calls for it.

What's Inside a Skill

A skill is a folder containing:

SKILL.md (mandatory): YAML frontmatter with name and description, followed by instructions
Reference files (optional): Additional documentation for specific use cases
Scripts (optional): Python scripts, shell commands, validation logic

The YAML frontmatter gets loaded at startup for discovery, while the instructions below contain the actual guidelines, examples, and common mistakes to avoid. Think of it as the onboarding document you'd give a new team member who needs to get up to speed on a specific workflow.

When the skill gets more complex, you split it into multiple files. For a Nano Banana prompt generator skill, you might have separate reference files for character creation, outdoor scenes, art style rendering, text generation, and diagram creation. When generating a character, the outdoor scene context never enters the window.

Scripts are particularly useful because they run without loading the code itself into context. The agent executes them and only sees the output, keeping the window clean while still leveraging deterministic operations.

How This Connects to Context Engineering

The core insight is simple: load context only when you need it.

Instead of stuffing everything into the system prompt from the start, skills let you inject expertise at the moment it becomes relevant. The context window stays clean until the task actually requires that knowledge.

This is context engineering at the architectural level. You're designing the system so context enters and exits based on what's happening right now.

Building Skills That Actually Work

After working with skills for a while, some patterns become clear.

Description field matters for discovery. It should contain a brief overview of what the skill does, along with trigger words that match how users naturally phrase requests. If your skill generates Nano Banana prompts for characters, the description should contain terms like "character creation", "generate character", "Nano Banana character".

SKILL.md structure should stay focused on the common case. Move edge cases into separate reference files that get loaded only when needed.

Code in skills should handle deterministic operations: sorting lists, parsing structured data, validating formats. These are better executed than generated.

What This Means for Building Agents

Till now, specialization in agents meant one of three things: subagents with careful context handoffs, tool configurations for specific capabilities, or bloated system prompts trying to cover every scenario. Each approach has its tradeoffs, and mixing them adds complexity.

Skills offer a fourth path where you package expertise into discoverable folders, and the agent loads what it needs when it needs it, without context bloating and complex handoff logic. Instead of redesigning architecture for each new capability, you simply add a skill folder.

How We Use Skills at Chromatic Labs

We use skills to structure different parts of our video production pipeline, including script writing skills that adapt per use case, video prompt generation skills, image prompt skills, camera action reference skills, and BGM prompt generation skills. Each skill handles one aspect of the workflow, and the agent loads what it needs based on what's being created.

The result is a system where expertise stays modular and the context window stays clean.

References

Context engineering isn't just theory at Chromatic Labs. Agent Skills is how we keep our video generation pipeline modular and efficient. Each skill knows its domain, the agent picks what's relevant, and the context stays clean across every frame we generate.