AI Engineer World's Fair 2026

Skills are the New SDKs

Loading slides…

Read the talk

Skills Are the New SDKs

Agent skills package operational knowledge for selective loading, letting a general-purpose agent learn a platform without carrying every instruction and tool definition into every task.

From a talk by Elvin Aghammadzada

Before you start: Familiarity with LLM prompts, tool calls, and MCP servers will help; no prior experience authoring skills is required.

Where agent failures hide

What does an agent application expose to the model that its user never sees? The interface on screen is only one of three interfaces that must work together. Elvin Aghammadzada begins with the other two because that is where apparently mysterious agent failures often originate.

ReaderInterface
UserUI
ModelSystem prompt and tool descriptions
DataSchemas and tool-call inputs and outputs

A polished UI cannot compensate for ambiguous tool instructions or a mismatched output schema. Those defects live below the visible interaction, yet determine whether the agent can turn a request into a useful result.

0:030:22
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:03 · section reference included

A large window is not a reliable working context

Promises of million-token or even five-million-token context windows encourage an appealing shortcut: put all the documents into the prompt and let the model sort them out. The same assumption appears in tool integration: expose a hundred MCP tools and expect the model to select the right one at the right time. But every additional document or tool description introduces another opportunity for distraction, conflict, or poisoned context. Capacity is not the same as reliable use of that capacity.

Slide titled “Problem 1: Context Window Paradox,” contrasting large context promises with overloaded, distracted and conflicting contexts; presenter inset at right.Open full source frame
The context window paradox: more context does not guarantee better responses.

Aghammadzada invokes Context Rot, describing degradation after roughly 25% of a window and giving 256K tokens in a million-token window as his example. Chroma’s research supports the broader concern about increasing input length, but its results depend on the model, task, and distractors; it does not establish that percentage as a universal boundary.

The operational version is familiar: a conversation accumulates prompt-response exchanges, tool calls, and failed attempts. Aghammadzada imagines a hundred exchanges repeated across a hundred chats to convey how quickly this grows. A capable model can then behave like a much weaker one. Claude Code’s reassuring “You are absolutely right” becomes frustrating when it repeats the mistake it made five minutes earlier. Agreement has not restored the relevant working state.

0:531:09
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:53 · section reference included

From human documentation to operational fluency

Documentation creates a related mismatch. Aghammadzada reports coding agents’ share of documentation traffic rising from 10% to 50% between the previous year and the year of the talk, without identifying the measurement population. The architectural issue matters independently of that estimate: human documentation assumes readers can infer missing steps, ask follow-up questions, or search elsewhere. An agent needs those behaviors and the relevant information made available through its harness. Publishing a human-readable page does not automatically teach an agent how to operate a platform.

Historically, software businesses defended advantages that were difficult to reproduce: control of hardware, ownership of data, and integrations that made leaving a SaaS platform expensive. Aghammadzada cites reports of Claude Code translating hundreds of thousands or a million lines from Python to Rust, with switching described as taking days. These are motivation rather than a documented migration case here: the underlying proposition is that code transformation becomes less effective as a barrier when agents make it cheaper.

Skills suggest a different source of retention: operational fluency. Instead of making departure painful, make the path from intent to outcome consistently easy. Experience, in this framing, is satisfaction produced by reducing friction along that path. A skill can encode how a platform should be used so that the next interaction begins with more of that knowledge already available.

Slide titled “Skills are entirely different,” explaining how skills chain training, deployment, predictions and monitoring, with presenter inset at right.Open full source frame
Skills create a fluency moat that compounds as workflows connect.
MoatRetention mechanismProduct emphasis
FrictionSwitching is expensiveDefend existing dependencies
FluencyStaying produces reliable outcomesImprove each interaction

The distinction is defensive versus offensive. A platform can retain users because they trust the experience, not merely because they are trapped by its integrations. Skills package some of that experience as operational knowledge an agent can reuse.

3:053:21
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:05 · section reference included

Teachability joins the enterprise checklist

Enterprise buyers already ask about security, compliance, data governance and storage location, SLA guarantees, logs, tracing, integrations, and authentication connected to on-premises systems. Agent adoption adds another question: How easily can an unfamiliar agent learn to use this platform?

That is teachability. A skill encodes operational knowledge so a new harness can acquire it and apply it directly. Aghammadzada’s aspiration is a useful result within a few seconds, both on first use and on subsequent visits. Each additional skill should make another workflow easier to complete, allowing the platform’s value to compound through repeatable outcomes.

7:097:23
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

7:09 · section reference included

Spend context before and during the task

React offers an analogy for what the agent ecosystem still lacks: a widely shared approach to modularity and composition. Long-running agents do not yet have an equivalent settled development model. Context engineering is one attempt to impose order by filtering information and delivering the right material at the moment it becomes useful.

Consider an agent that starts with system instructions, CLAUDE.md, built-in tools, and MCP connections. User messages arrive on top of that baseline. Aghammadzada uses 40% window occupancy as a practical budgeting heuristic, labeling the region below it the smart zone and the region above it the dumb zone. This is separate from his earlier 25% example, rather than a second experimentally established cutoff.

The revealing failure happens before the first prompt. Add one MCP integration, then another internet-connected service, then web search. Their definitions can consume the proposed working budget before the user has asked anything. The agent starts its first task with a crowded context instead of earning that complexity through relevant work.

Several distinct kinds of information compete for the same space:

  • Instructions: System-level guidance for the agent.
  • External data: Uploaded PDFs, retrieved documents, and other task evidence.
  • Execution history: Prior tool results and the current session state.
  • Memory: Information retained across conversations.
  • Output schema: The structure the final response must satisfy.

Keeping every component connected at every moment creates what Aghammadzada calls an “n times n” problem—a metaphor for interacting complexity. The alternative is progressive loading: retain access to the knowledge, but introduce the relevant piece only when the task needs it.

8:428:58
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:42 · section reference included

Discover capabilities without loading their manuals

With skills, a capability such as web search can live outside the active context while remaining discoverable. The agent does not need its complete instructions permanently present. Aghammadzada estimates that 15 MCP servers can consume more than 100,000 tokens in tool definitions before conversation begins, and that skills can make this overhead at least ten times smaller. No measured server configuration or controlled comparison accompanies the estimate; it illustrates the cost of eager loading.

Skill metadata behaves like a database index. A short entry tells the agent what is available and when it might be relevant. The full instructions may contain thousands of tokens, but discovery requires only the compact description at the top of the file. Detailed content enters context on demand. Discoverability and instruction loading become separate operations.

That separation also changes what developers build. Claude Code and Codex can serve as general-purpose engines rather than merely coding products. For a supply-chain or manufacturing customer, the domain-specific work can live in skills layered over that engine. Switching industries then means changing the operational knowledge supplied to the agent, rather than rebuilding the agent loop for each customer.

13:0013:16
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:00 · section reference included

Skills and MCP can compose

Skills and MCP, both introduced by Anthropic, address different parts of the system. MCP exposes callable operations. Skills supply instructions that shape how an agent approaches a problem and uses its capabilities. A writable skill can also be revised after experience, whereas an agent calling a separately hosted MCP server ordinarily cannot edit that server’s implementation.

The discussion of Joji’s question makes this boundary more interesting. A SKILL.md can direct an agent to an MCP server. A skill can also package tool implementations directly or contain instructions and code for creating a server. The relationship can run in both directions: an MCP tool can itself invoke an agent that loads skills, while memory, caching, and customization can reproduce some of the adaptation attributed to skills.

“Skills vs. MCP” slide with kitchen analogy bullets, a file-and-tool illustration on yellow, and a participant labeled Carson Gee in a video inset.Open full source frame
MCP provides the kitchen; skills provide the recipes.

Skills can therefore package more than advice. They can template code, execute it, build and run MCP servers, and introduce those servers into the parent agent’s available context. The discussion culminates in the deliberately expansive observation, “Copilot could be a skill”: a substantial agent capability can be packaged for another agent to acquire.

15:5616:07
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

15:56 · section reference included

Remote resources still need a service boundary

NeedUseful mechanism
Procedural reasoningSkill instructions
Authentication and restricted accessA service with appropriate credentials
Heavy computationHosted execution
Selective discovery of a remote toolA skill introducing an MCP server

Aghammadzada recommends skills when the hard part is knowing how to approach the work, and MCP when the hard part involves access or computational horsepower. A separately hosted server can isolate resource-intensive execution from the agent’s machine. That boundary depends on deployment and permissions; MCP alone does not guarantee isolation, and a skill does not inherently require unrestricted local execution.

The interleaved discussion characterizes MCP as an older standard still adapting, and cites 85,000 skills to convey how quickly the newer ecosystem has grown. But packaging knowledge cannot conjure remote infrastructure. The examples are intentionally large: semantic search over 400 TB of documents, a 500 TB disk, or access to 75 GPUs. A skill can disclose the relevant MCP server when needed, while that server supplies the resources. Restricted medical records make the same point about access: the agent’s personal computer may have neither the data nor permission to retrieve it directly.

There is still room to reduce unnecessary tool surfaces. Aghammadzada points to Codex and Claude Code as systems with a handful of core tools rather than hundreds of bespoke operations. Given a strong reasoning model, capability folders and scripts can replace some separately exposed tools. That argument applies where the agent already has the necessary execution environment; it does not remove the remote resource and access requirements just described.

18:2018:36
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

18:20 · section reference included

The three loading levels of a skill

A skill has two immediate readers. The runtime reads its front matter to advertise the capability; the model reads the Markdown body when the skill is activated. The file’s front matter is YAML. The small XML representation described in the talk is how a runtime can present that metadata to the model, not the syntax of the front matter itself.

LevelWhen it is neededContent
MetadataBefore activationName and discovery description
InstructionsOn activationMarkdown procedure
Supporting filesDuring the procedureScripts, examples, or additional context

Aghammadzada describes metadata as typically under 100 tokens and an activated body as typically under 5,000 tokens. These are sizing guidance, not enforced limits. The useful distinction is which material must be visible to select a capability and which can wait until execution.

The third level can avoid loading implementation code altogether. In the talk’s example, Claude Code or the Claude SDK executes get_deployment_features.py and places only its output into context. The model needs the resulting deployment information, not necessarily the source code that retrieved it.

For a small Python illustration of that output boundary, suppose a local deployment record contains both feature metadata and other deployment details. A helper can emit just the feature names needed for the next step:

python

import json
import sys


def feature_names(deployment: dict) -> list[str]:
    return [feature["name"] for feature in deployment["features"]]


if __name__ == "__main__":
    deployment = json.load(sys.stdin)
    json.dump({"features": feature_names(deployment)}, sys.stdout)
    sys.stdout.write("\n")

For input {"id":"demo","features":[{"name":"age"},{"name":"income"}]}, the output is {"features": ["age", "income"]}. This illustrates the same mechanism: execute a helper, then return a focused result instead of adding its implementation and every source field to the prompt.

Execution support is a harness capability. Other platforms may use supporting code as examples for the model to read rather than as directly executable scripts. The package still has three levels—metadata, instructions, and supporting material—but the host determines how the last level is consumed.

20:4621:04
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

20:46 · section reference included

A reusable engine that can extend itself

The talk describes support across more than 26 platforms and roughly 100,000 available skills, including use in Claude Code, Codex, Copilot, and Gemini CLI. Alongside paid marketplaces, Aghammadzada mentions ClawHub as a registry and his organization’s open-source skills repository. These figures describe the ecosystem as he presents it, rather than a current census.

OpenClaw becomes the architectural example. Aghammadzada claims it had surpassed Linux and React in repository stars, but the more useful observation is how it organizes context across applications and chat interfaces. Subagents can keep individual working contexts focused, while self-evolving skills can revise behavior after experience or add a capability by writing a new skill. That opens the possibility of self-repair as well as extension.

Slide titled “Openclaw uses Skills,” describing a compact XML skill list and self-extension through newly written SKILL.md files; presenter inset at right.Open full source frame
OpenClaw uses progressive disclosure and can draft new skills for future sessions.

Aghammadzada describes OpenClaw as a coding agent with about ten underlying tools. The proposed enterprise architecture follows directly: build one capable base agent, then put customer and domain knowledge into skills. The breadth comes from what the engine can learn to do with its tools, not simply from the size of its initial tool catalog.

22:4323:00
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

22:43 · section reference included

Skills need a software lifecycle

If an agent can write skills, why not let it write all of them? Aghammadzada cites unnamed research reporting that generated skills increased token use and reasoning time rather than improving performance. The study and its experimental conditions are not identified in the talk. His practical conclusion is narrower and experience-based: useful skills usually need human operational knowledge, not just additional model-generated instructions.

Self-extension also crosses a trust boundary. A publicly distributed skill can carry prompt injection; an agent that writes and executes its own skills can turn a bad instruction into an action. Aghammadzada refers to OpenClaw security incidents without detailing cases, then warns about execution in the same environment as the agent and weak marketplace verification. His npm comparison is a reminder to examine who produced a package before installing it. Popularity and authorship can inform that decision, but they do not contain execution.

Context is a budget. An irrelevant file, web search, or error message spends part of it without helping the task. Skills provide a way to make operational knowledge available selectively, while MCP remains useful for the services and resources that knowledge directs an agent to use.

That makes a skill a maintained software artifact. Aghammadzada notes that good skills can take weeks to build, and emphasizes the quality of their human authors. Version them, evaluate whether they improve outcomes, and test their behavior. The package is small enough to look like documentation, but its instructions participate in execution—and deserve the same care as the software they guide.

24:3424:55
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

24:34 · section reference included

Resources

From the talk

  • Context RotPaper1:58

    Controlled experiments showing how input length, distractors, and retrieval conditions affect performance across 18 language models.

  • Installable skills and helper scripts for DataRobot training, deployment, predictions, monitoring, and agent workflows.

  • The SKILL.md format, metadata requirements, supporting files, and three levels of progressive disclosure.

  • A request-level analysis of agent and browser traffic across Mintlify-hosted documentation, including measurement limitations.

  • SkillsBenchPaper

    A benchmark for evaluating procedural skills through paired agent runs and task verifiers. The paper has multiple revisions.

Updates since the talk

Transcript download
Full transcript

Loading transcript…