Why is everyone talking about agent

skills? What are they really about?

Let's take a closer look. Before skills,

we placed entire guides and tool

definitions into a single massive

prompt. This approach hits the model's

context limit quickly. Models also

perform worse as instructions get

longer. They forget rules, drift from

brand voice, or hallucinate. Skills flip

this setup. Instead of carrying every

instruction all the time, the agent

keeps a small catalog of capabilities

and pulls the right skill only when a

task actually needs it. Instead of one

giant prompt, you can get a small

reusable playbooks loaded on demand. So

what is a skill? Technically, a skill is

a folder. It has a skill.md plus

optional scripts and resources. A

skill.md is a how to use this skill

guide. It contains metadata, clear

instructions, guardrails, script entry

points, and the rules for running them.

Scripts are runnable code like Python

files. They handle deterministic steps

that must behave the same way every

time, like parsing a PDF, validating a

spreadsheet, or applying a migration.

Resources are the static stuff the code

and instructions rely on, like

templates, schemas, and reference docs.

Now the important part is how skills get

used. The agent does not inject every

skill into the prompt. It starts with a

tiny index basically just a skill names

and oneline descriptions. That is enough

for the model to decide when to load a

skill. When the user asks for something,

the model decides to use a skill if

needed, then requests the full skill.md

for that one skill by emitting a tool

call. The agent runtime loads a

skill.mmd, appends it to the context,

and feeds it back to the model. This is

called progressive disclosure. Like a

well organized manual that starts with a

table of contents, then a specific

chapters, and finally a detailed

appendix, a skills let the model load

information only as needed. Let's walk

through one concrete example from a

start to finish with two skills. You

upload a Q4 budget Excel sheet and say,

"Audit this spreadsheet and draft a

short email summary. First, the agent

runtime appends the lightweight skill

index to your request and sends the

prompt to the model. The model sees only

that index, not the full skill

instructions. Next, the model decides it

needs a spreadsheet audit and it emits a

tool call asking the runtime to load a

skills a spreadsheet audit a

skills.mmd."

Then the runtime loads that skill.mmd

and appends it to the context. Now the

model has the detailed audit procedure

and knows which script to run like

audit.py.

The runtime executes the script in a

sandbox and returns a structured results

like a JSON report of formula issues and

outliers. The model reads those results

instead of guessing what's in the sheet.

Finally, the model notices the draft and

email part. Because the model can see

all available skills through the index,

it knows a style guide still is

available. It requests the style guide

skill. The agent reads the skill which

contains the formatting rules, tone

constraints, and examples. The model

uses those rules to turn the audit

findings into a clear draft email a

finance team can scheme quickly. In

short, skills make instructions portable

and versioned. You can package a

procedure once, test the script, update

it, and reuse it across teammates and

environments. You do less prompt

surgery, keep context smaller and more

relevant, and get more consistent

behavior.