#Agent Skills
Articles about Agent Skills — exploring patterns, best practices, and real-world implementations in production systems.
11 posts tagged with agent skills. ← All posts
This closing post makes everything concrete: the anatomy of a skill definition, the templates that get you started fast, and the synthesis of the series into a practical approach you can apply today. It turns the principles — scope, context discipline, specificity, reliability, operation — into a reference you can build from.
The concrete reference: the anatomy of a skill definition (the SKILL.md pattern — metadata/trigger, instructions, knowledge, resources), starter templates (general, domain, workflow, integration), and the series' synthesis — make agents reliably useful by building and tending a library of captured expertise.
The gap between a skill that works in a demo and one that works reliably in daily use is where most of the real lessons live. Skills in the wild face messy inputs, edge cases, drift, and the challenge of being maintained and shared across a team over time. This post is about what actually works when skills meet reality — the patterns that hold up, the failure modes that recur, and the operational discipline that keeps a skill library useful.
The gap between a demo skill and one that works in daily use is where the real lessons live. What makes skills succeed in the wild (the fundamentals), the failure modes that recur (drift, overlap, trigger misfires, bloat, over-trust), and operating the library as a maintained, curated, shared system.
Where general business skills capture how you do ordinary work, domain-specific skills capture deep expertise in a particular field — the specialized knowledge, rules, and judgment of law, medicine, finance, a specific codebase, a regulated process. These are the highest-value and highest-stakes skills: they let an agent operate in a specialized domain, but they demand the most rigor, because being wrong in a specialized domain is both more likely and more costly. This post is about capturing deep domain expertise as skills.
Domain-specific skills capture deep field expertise — law, finance, a specific codebase, a regulated process. The highest-value and highest-stakes skills, demanding the most rigor: grounded authoritative knowledge (not the model's hallucinations), precisely-stated rules, verification, and human oversight.
Not every agent skill is deeply technical. Some of the highest-value skills capture the ordinary, recurring work that fills an organization's days — drafting a particular kind of document, following a review process, preparing a standard analysis, handling a routine request a specific way. These "general business skills" are broadly applicable, easy to get wrong by being too generic, and quietly transformative when done right. This post is about capturing everyday business work as reliable agent skills.
The highest-value skills often capture ordinary recurring work — a standard document, a review process, a routine analysis. Their failure mode is being too generic; the value is entirely in your specifics. Why frequency-times-people makes them high-leverage, and how to find them.
A single skill makes an agent reliable at one task; the real power comes from how skills combine into patterns of work. An agent equipped with a library of well-designed skills can compose them, chain them, and apply them across a workflow — turning point capabilities into end-to-end reliable work. This post is about the patterns that emerge when skills work together, and how to think about an agent's skill library as a system rather than a pile of parts.
A single skill does one task; the power is in combination. Composition (many focused skills for one task — combinatorial leverage), chaining (skills across a workflow — reliable whole processes), and treating the skill library as a curated, compounding, shared system that mirrors your real work.
A good agent skill is a small piece of information architecture: the right scope, a clear trigger, well-structured instructions, and only the knowledge the task needs — all shaped by the context-window discipline of post 2. Building one is less about clever prompting and more about thinking like a technical writer and a software designer at once. This post is the practical craft of designing and building a skill that an agent uses reliably.
Building a skill is information architecture under a context budget. Scoping to one coherent capability, structuring it (sharp trigger, clear prescriptive instructions, curated knowledge, deferred depth), writing for the agent as a capable-but-uninformed reader, and iterating empirically while pruning ruthlessly.
The single constraint that shapes every aspect of agent skill design is the context window — the finite amount of information an agent can hold and attend to at once. A skill that ignores this constraint bloats the agent's context, degrades its focus, and defeats its own purpose. Designing for the context window — loading only what is relevant, only when relevant, as compactly as possible — is the craft at the heart of good skills. This post is about that constraint and how it drives skill design.
The context window is the constraint that shapes every aspect of skill design. Why context is finite AND precious (more context degrades focus), the master principle — load only what's relevant, only when relevant, as compactly as possible — and why this makes skills beat big prompts.
A capable AI agent with no way to carry expertise between tasks relearns everything every time. Agent skills close that gap: reusable, self-contained packages of instructions, knowledge, and procedure that an agent loads when relevant, turning a general model into one that reliably does your specific work your specific way. This series is about designing, building, and deploying agent skills — and it starts with the gap they close and why it matters.
A capable agent with no way to carry expertise between tasks relearns everything every time. Agent skills close that gap — reusable, self-contained packages of instructions, knowledge, and procedure loaded on demand — turning a general model into a reliable specialist at your specific work.
Compose three kinds of Agent Skill — code-defined, struct-based, and file-based — into a single agent through one skills context provider.
One skills ContextProvider blending three origins: in-memory volume and temperature skills plus a file-based unit-converter, unified behind one tool surface for the model.
An Agent Skill — on-demand instructions, resources, and scripts — defined entirely in Go, with no SKILL.md files on disk.
An Agent Skill built from Go closures: instructions, a static and a runtime-generated resource, and a convert script that runs in-process with no SKILL.md files.
Teach an agent a capability from a folder of files — a SKILL.md manifest, resources, and scripts — loaded on demand via progressive disclosure.
Teach an agent from a SKILL.md manifest, resources, and scripts on disk: fsskills scans the tree and a skills ContextProvider exposes load, read, and run tools.
All posts on this site are written by Pratik Dhanave, an Agentic AI Architect with 7+ years building production distributed systems, multi-agent AI platforms, and cloud-native infrastructure. About the author → Each article includes working code, architecture diagrams, and references to the specific frameworks and standards discussed. Browse all posts or explore related topics using the tag cloud above.