Agent Skills, Explained: The Portable Format Turning Coding Agents Into Specialists

Agent skills are quickly becoming the way teams package a capability once and reuse it across every coding agent they run. In the first days of July 2026, two Show HN launches — QUALITY.md, an open spec plus agent skill plus CLI, and ctx, a tool that searches the coding-agent history already on your machine — landed alongside Simon Willison's essay Better Models: Worse Tools. Together they point at the same shift: as base models get stronger, the durable advantage moves into the skills you hand them. This guide explains what agent skills are, why portable skill formats are emerging, and how a coding agent actually uses one.

What are agent skills?

An agent skill is a self-contained, reusable unit of capability that a coding agent can load on demand — a bundle of instructions, conventions, and sometimes a companion tool or CLI that teaches the agent how to do one job well. Instead of re-explaining your standards in every prompt, you author the skill once and let any compatible agent pick it up.

The key word is portable. A well-defined agent skill is not glued to a single model or a single vendor's runtime. It travels with your project or your toolchain, so the same skill can back a review bot today and a migration agent tomorrow. That portability is exactly what a spec like QUALITY.md is chasing: a shared, machine-readable format that an agent can consume the same way regardless of which model is driving.

Why do portable agent skill formats matter now?

Willison's argument in Better Models: Worse Tools frames the tension well: model capability is climbing fast, but the tooling and scaffolding around agents can regress or fragment as everyone rebuilds it in their own way. When every team encodes its quality bar, its workflows, and its guardrails in one-off prompts, none of that work compounds. A portable skill format flips that. It turns tacit "how we do things here" knowledge into an artifact that:

• Compounds across projects — write the skill once, reuse it everywhere.
• Survives model upgrades — the skill describes the what and how; swapping the underlying model doesn't invalidate it.
• Is reviewable like code — a skill in a defined format can be versioned, diffed, and audited instead of living in someone's chat history.

That is why the QUALITY.md launch resonated: it treats a project's quality expectations as an open spec that both humans and agents can read, rather than folklore an agent has to be re-taught each session.

How does a coding agent use a skill?

At a high level, the loop is simple:

1. Discovery — the agent sees which skills are available for the current project or task.
2. Selection — based on the request, it loads the relevant skill's instructions into context.
3. Execution — it follows the skill's conventions, and where the skill ships a companion CLI, it can invoke that tool directly instead of improvising.

QUALITY.md is a clean example of the pattern because it comes as a spec and an agent skill and a CLI — the same capability expressed for humans to read, for an agent to consume, and for a command line to enforce. That three-way packaging is what lets one definition serve authoring, agent execution, and verification without drifting apart.

Where does agent history search fit in?

Skills aren't only about doing new work — they're about not losing the work you already did. ctx tackles a real day-to-day pain for anyone running coding agents: recovering past agent sessions. Your machine already holds a trail of prior runs; ctx makes that history searchable so you can find the decision, diff, or dead end from three sessions ago instead of re-deriving it.

Read as a workflow, agent-history search is the memory layer that makes skills pay off. A skill tells an agent how to work; a searchable history tells you (and, increasingly, the agent) what was already tried. Pair them and each session starts closer to where the last one ended.

What should you standardize into a skill first?

If you're adopting the pattern, start where the payoff is highest and the rules are most stable:

• Quality and review standards — the checks you apply to every change (a natural fit for a QUALITY.md-style spec).
• Repository conventions — naming, structure, and workflow rules an agent should never guess at.
• Repeatable procedures — migrations, release steps, and audits you'd otherwise paste into a prompt each time.

Skip the volatile stuff. If a rule changes weekly, it belongs in the task prompt, not a durable skill.

Frequently asked questions

Are agent skills tied to one model?

No — that's the point. A portable skill describes a capability independently of the model executing it, so it keeps working as you upgrade or switch models. Willison's essay is a useful reminder of why that independence matters: model progress shouldn't force you to rebuild your tooling from scratch.

Is an agent skill the same as a plugin?

Not quite. A plugin usually extends a specific tool; a portable agent skill is a model- and runtime-agnostic capability bundle — instructions plus optional tooling — meant to be consumed by any compatible agent.

Do I need a special format to write one?

You need a format the agent can reliably read. Emerging specs like QUALITY.md exist precisely so agents can consume a skill consistently instead of each team inventing an incompatible convention.

Takeaways for Clawvard readers

• Agent skills are where your advantage now lives. As models converge upward, the durable edge is in the reusable, portable capabilities you author around them.
• Favor open, readable formats. A skill you can version, diff, and audit compounds; a prompt buried in chat history does not.
• Pair skills with memory. Tools like ctx that make agent history searchable turn one-off sessions into accumulating knowledge.

If you're building on agentic workflows, the security side of the same story is worth reading next: see our companion piece on AI browser security and prompt injection. And if you want to put portable skills to work across your own agents, try Clawvard or follow along as we track how the agent-skills ecosystem matures.