# Skills are the New SDKs Elvin Aghammadzada, DataRobot | AI Engineer World's Fair 2026 | 26:40 Source: https://www.youtube.com/watch?v=LC3-P7v3yoI Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks. Page: https://aietalks.com/talks/skills-are-the-new-sdks Published: 2026-07-20 Tags: agent-skills, agents, context-engineering, mcp, security ## TL;DR - Longer context windows do not guarantee better agent performance, because extra information gives the model more ways to be misled. - Skills progressively load task-specific instructions and workflows, giving agents operational knowledge without filling the context with every tool definition. - MCP and skills solve different problems, and enterprise teams need to version, evaluate, test, and verify skills before relying on them. ## Summary Elvin Aghammadzada argues that platforms need a skill layer if coding agents are going to use them reliably. APIs, SDKs, MCP tools, and human-focused documentation do not provide enough workflow knowledge for an agent. Context is also limited in practice. A model can perform worse as instructions, tool definitions, history, and retrieved data accumulate. Skills address this by exposing small metadata first, loading detailed instructions only when needed, and optionally running scripts or returning their output. A skill can encode step ordering, failure handling, security practices, and domain workflows such as training, deployment, monitoring, and prediction. Aghammadzada presents skills as a source of platform fluency, while MCP remains useful for authentication, isolation, remote execution, and access to large resources. He is also direct about the risks: generated skills can hurt performance, untrusted skills can enable prompt injection, and marketplaces lack strong verification. ## Key ideas ### Longer context windows can make agents perform worse [00:50](https://www.youtube.com/watch?v=LC3-P7v3yoI&t=50s) Aghammadzada says the promise of million-token or larger context windows encourages teams to dump documents and tool definitions into the prompt. That approach fails because every additional piece of context creates another place where the model can be misled or poisoned. He cites a paper called "Context Rot", which found that performance starts to degrade after roughly 25% of the context window is used. In a long coding session, repeated prompts, tool calls, and failures can cause an agent to repeat mistakes it made minutes earlier. A large available window does not mean all of it is useful working space. ### Documentation written for people does not teach agents a workflow [02:50](https://www.youtube.com/watch?v=LC3-P7v3yoI&t=170s) The speaker says traffic from coding agents to documentation websites rose from 10% to 50% between last year and this year. Human documentation assumes intuition, follow-up questions, and the ability to search for missing details. Models do not reliably have those abilities without a context engine around them. This creates a gap between publishing API or platform information and making that information usable by an agent. The platform needs to provide operational knowledge in a format the agent can load and apply directly. ### Skills create a fluency advantage for platforms [05:03](https://www.youtube.com/watch?v=LC3-P7v3yoI&t=303s) Aghammadzada contrasts older software advantages based on switching costs with what he calls a fluency advantage. Agents make it easier to rewrite code and move between platforms, so making departure difficult becomes less effective. A skill can improve how easily a user moves from intent to a reliable result. That experience compounds as more useful skills are added. He says teachability should join the usual platform checklist, alongside security, compliance, data governance, service guarantees, logs, tracing, and integrations. A new agent harness should be able to learn encoded operational knowledge and reach a result within seconds. ### Context engineering progressively loads only the information needed [09:29](https://www.youtube.com/watch?v=LC3-P7v3yoI&t=569s) The talk defines context engineering as reducing the information sent to the model at each moment and selecting what belongs in context now. A typical agent combines system instructions, external data, execution history, memory, and output schemas. Loading all of these together creates a difficult interaction problem. The proposed alternative is progressive loading. An agent receives a small piece of a skill when the relevant task appears, then loads more instructions or memory when required. This keeps the working context focused instead of hardcoding every possible capability into the initial prompt. ### Skills reduce the cost of exposing many capabilities [13:03](https://www.youtube.com/watch?v=LC3-P7v3yoI&t=783s) Aghammadzada compares a large MCP setup with a skills-based design. He says an agent connected to 15 MCP servers can consume more than 100,000 tokens per session from tool definitions before the conversation starts. Skills expose only metadata at first, which works like an index in a database. The detailed body can contain thousands of tokens but is loaded on demand. The speaker describes a three-level structure: front matter, a markdown body activated by the model, and scripts or extra context. Scripts may run and return only their output, or they may provide code examples for the agent to use. ### Skills let one general agent support different domains [15:07](https://www.youtube.com/watch?v=LC3-P7v3yoI&t=907s) The speaker says a general-purpose agent can remain the engine for use cases such as supply chain and manufacturing. Instead of building a separate agent for each industry, a platform team can place domain-specific skills on top of the same agent. This changes the unit of platform work from building an entire agent to building the operational packages that teach the agent how to solve a particular problem. Skills can also make it easier to move the same base agent across industries and domains. ### MCP and skills have different jobs and can work together [16:01](https://www.youtube.com/watch?v=LC3-P7v3yoI&t=961s) Aghammadzada describes MCP as a way to define actions and provide access to external execution, authentication, isolated processes, and hosted resources. Skills shape how an agent reasons about a task and can contain instructions, code, or even an MCP server. MCP remains useful when the agent needs a GPU, access to very large document stores, or data in a restricted environment that the local machine cannot reach. Skills can progressively disclose the existence and use of that remote MCP server. The two mechanisms are connected, but they address different parts of the system. ### Skill marketplaces create security and quality risks [23:03](https://www.youtube.com/watch?v=LC3-P7v3yoI&t=1383s) The talk describes an ecosystem with more than 26 supporting platforms, many published skills, and marketplaces where skills can be sold. Aghammadzada warns that generated skills can make a model use more tokens and spend more time reasoning instead of improving performance. If a model writes and executes its own skills, prompt injection becomes a serious risk. Skills also run in the agent's local environment, unlike an isolated MCP process, and marketplaces do not yet provide strong verification. He compares this to downloading packages from NPM and needing to inspect who made them and how much trust they have earned. ## Notable quotes - "The problem that skills solve is it enables a rich context access." (13:03) - "The core idea of teachability is to make that experience easy as possible whenever someone wants to use your platform for the first time or for subsequent times." (07:59) - "Context is almost like a limited resource that we need to carefully filter information." (25:58) - "A skill is only as good as the human who wrote it based on our experience." (26:17) ## Tools & references mentioned - DataRobot - MCP - Claude Code - Cursor - Codex - Gemini CLI - React - Context Rot - Open Agent - Devin Jensen - NPM ## Who should watch - You are building an enterprise platform that agents must use through APIs, MCP servers, or coding environments, and the agent keeps inventing workflow steps. - Your system prompt already contains many tools, documents, memories, and execution traces, and performance falls as sessions get longer. - You are deciding how to package domain workflows, scripts, and remote services for Claude Code, Cursor, Codex, or similar agent platforms.