There's a pattern I keep seeing: LLMs used to replace things we already know how to do deterministically. Parsing a known HTML structure, transforming a table, running a financial simulation. It works, but it's like using a helicopter to cross the street: expensive, slow, and not guaranteed to land exactly where you intended.
The real opportunity with Agent Skills isn't just packaging prompts. It's providing a mechanism that enables a clean split: LLM as the control plane (planning, choosing tools, handling ambiguous steps) and code or sub-agents as the data/execution plane (fetching, parsing, transforming, simulating, or executing NL steps in a separate context).
This requires well-defined input/output contracts and a composition model. I opened a discussion on whether Agent Skills should support this kind of composability:
I've recently been doing some work with Autodesk. It would be great for an LLM to be as comfortable with the "vocabulary" of these applications as they are with code. Maybe part of this involves creating a language for CAD design in the first place. But the principle that we need to build out vocabularies and subsequently generate and expose "sentences" (workflows) for LLM's to train on seems like a promising direction.
Of course this requires substantial buy in from application owners - create the vocabulary - and users - agree to expose and share the sentences they generate - but the results would be worth it.
The same applies to context vs a database. If a reasoning model makes a decision about something, it should be put off to the side and stored as a value/variable/entry somewhere. Instead of using pages and pages of context, it makes sense for some tasks to "press" decisions that become more permanent to the conversation. You can somewhat accomplish that with notebooklm, by turning results into notes into sources, but notebooklm is insular and doesnt have the research and imaging features of gemini.
And also, in writing, writing from top to bottom has its disadvantages. It makes sense to emulate human writing process and have passes, as you flesh out, and conversely summarize writing.
Current LLMs can brute force these things through emulation/observation/mimicry but they arent as good as doing it the right way. Not only would I like to see "skills" but also "processes" where you create a well defined order that tasks are accomplished in sequence. Repeatable templates. This would essentially include variables in the templates, set for replacement.
Additionally, I can't even get claude or codex to reliable use the prompt and simple rules (use this command to compile) in an agents.md or whatever required markdown file is needed. Why would I assume they will reliably handle skills prompts spread about a codebase?
I've even seen tool usage deteriorate while it's thinking and self commanding through its output to say.. read code from a file. Sometimes it uses tail while other times it gets confused on the output and then writes a basic python program to parse lines and strings from the same file to effectively get what was the same output as before. How bizarre!
> Parsing a known HTML structure, transforming a table, running a financial simulation.
Transforming an arbitrary table is still hard, especially a table on a webpage or in a document. Sometimes I even struggle to find the right library. The effort does not seem worth it for one-off need of such transformation too. LLM can be a great tool for doing the tasks.
How likely are we to look back on Agent/MCP/Skills as some early Netscape peculiarity? I would dive into adoption if I didn't think some new thing would beat the paradigm in a fortnight.
I've built a number of MCP servers, including an MCP wrapper. I'd generally recommend you skip it unless you know you need it. Conversely, I'd generally recommend you write up a couple skills ASAP to get a feel for them. It will take you 20 minutes to write and test some.
MCP does three things conceptually: it lets you build a bridge between an agent and <something else>, it specifies a UI+API layer between the bridge and the LLM, and it formalizes the description of that bridge in a tool-calling format.
It's that UI+API layer that's the biggest pain in the ass, in my opinion. Sometimes you need it; for instance, if you wanted an agent to access your emails, a high quality MCP server that can't destroy your life through enthusiastic tool calling makes sense.
If, however, you have, say a CLI tool or simple API that's reasonably self documenting and you're willing to have it run, and/or if you need specific behavior with a different context setting, then a skill can just be a markdown file that explains what, how, why.
Agreed. I use only one MCP server regularly and it’s a custom one integrated into my QT desktop app. It has tools for inspecting the widget tree, using selectors to click/type/etc, and take screenshots. Functionality that would otherwise be hard or impossible to reliably implement using CLI calls but gives Claude a closed feedback loop.
All public MCP server I’ve seen have been a disaster with too many tools and tokens polluting the context. It’s really most useful when you need tight integration with some other environment and can write a little custom wrapper to provide it.
Agent/MCP/Skills might be "Netscape-y" in the sense that today's formats will evolve fast. But Netscape still mattered: it lost the market, not the ideas. The patterns survived (JavaScript, cookies, SSL/TLS, progressive rendering) and became best practices we take for granted.
The durable pattern here isn't a specific file format. It's on-demand capability discovery: a small index with concise metadata so the model can find what's available, then pull details only when needed. That's a real improvement over tool calling and MCP's "preload all tools up front" approach, and it mirrors how humans work. Even as models bake more know-how into their weights, novel capabilities will always be created faster than retraining cycles. And even if context becomes unlimited, preloading everything up front remains wasteful when most of it is irrelevant to the task at hand.
So even if "Skills" gets replaced, discoverability and progressive disclosure likely survive.
Yes this 100%. Every person i speak with who is excited about MCP is some LinkedIn Guru or product expert. I'm yet to encounter a seriously technical person excited by any of this.
The problem isn’t having a standard way for agents to branch out. The problem is that AI is the new Javascript web framework: there’s nothing wrong with frameworks, but when everyone and their son are writing a new framework and half those frameworks barely work, you end up with a buggy, fragmented ecosystem.
I get why this happens. Startups want VC money, established companies then want to appear relevant, and then software engineers and students feel pressured to prove they’re hireable. And you end up with one giant pissing contest where half the players likely see the ridiculousness of the situation but have little choice other than to join party.
I have found MCPs to be very useful (albeit with some severe and problematic limitations in the protocol's design). You can bundle them and configure them with a desktop LLM client and distribute them to an organization via something like Jamf. In the context I work in (biotech) I've found it a pretty high-ROI way to give lots of different types of researchers access to a variety of tools and data very cheaply.
I have found MCPs helpful. Recently, I used one to migrate a site from WordPress to Sanity. I pasted in the markdown from the original site and told it to create documents that matched my schemas. This was much quicker and more flexible than whipping up a singular migration tool. The Sanity MCP uses oAuth so I also didn’t need to do anything in order to connect to my protected dataset. Just log in. I’ll definitely be using this method in the future for different migrations.
I use only one MCP, but I use it a lot: it's chrome devtools. I get Claude Code to test in the browser, which makes a huge difference when I want it to fix a bug I found in the browser - or if I just want it to do a real world test on something it just built.
Skills are just prompt conventions; the exact form may change but the substance is reasonable. MCP, eh, it’s pretty bad, I can see it vanishing.
The agent loop architectural pattern (and that’s the relevant bit) is going to continue to matter. There will be new patterns for sure, but tool calling plus while loop (which is all an “agent” is) is powerful and highly general.
How likely is it to even remember “the AI stuff” 2-3 years from now? What we’re trying to do with LLMs today is extremely unsustainable. NVidia/openai will run out of silly investors eventually…
Frontier models will eventually eat all the tedious tailored add-ons as just part of something they can do.
Right now models have roughly all of the written knowledge available to mankind, minus some obscure held out private archives and so on. They have excellent skills and general abilities to construct plausible sequences of actions to accomplish work, but we need to hold their hands to really get decent performance across a wide range of activities. Skills and agent frameworks and MCP carve out different domains of that problem, with successful solutions providing training data for future models that might be able to be either generalized, or they'll be able to create a vast mountain of synthetic data following successful patterns, and make the next generation of models incredibly useful for a huge number of tasks, by default.
It might also be possible that by studying the problem, identifying where mode collapses and issues with training prevent the right sort of generalization, they might tweak the architecture and be able to solve the deficiency through normal training runs, and thereby discard the need for all the bespoke artisanal agent specifications.
“inserted at the start of any query” feels like a bit of a misunderstanding to me. It plops the skill text into the context when it needs it or when you tell it to. It’s basically like pasting in text or telling it to read a file, except for the bit where it can decide on its own to do it. I’m not sure start, middle, or end of query is meaningful here.
It's basically just a way for the LLM to lazy-load curated information, tools, and scripts into context. The benefit of making it a "standard" is that future generations of LLMs will be trained on this pattern specifically, and will get quite good at it.
It's the description that gets inserted into the context, and then if that sounds useful, the agent can opt to use the skill. I believe (but I'm not sure) that the agent chooses what context to pass into the subagent, which gets that context along with the skill's context (the stuff in the Markdown file and the rest of the files in the FS).
This may all be very wrong, though, as it's mostly conjecture from the little I've worked with skills.
BUT what makes them powerful is that you can include code with the skill package.
Like I have a skill that uses a Go program to traverse the AST of a Go project to find different issues in it.
You COULD just prompt it but then the LLM would have to dig around using find and grep. Now it runs a single executable which outputs an LLM optimised clump of text for processing.
The agentic development scene has slowly turned into a full-blown JavaScript circus—bright lights, loud chatter, and endless acts that all look suspiciously familiar. We keep wrapping the same old problems in shiny new packages, parading them around as if they’re groundbreaking innovations. How long before the crowd grows tired of yet another round of “RFC” performances?
It’s a fast moving field. People aren’t coming up with new ideas to be performative. They see issues with the state of the art and make something that may or may not advance things forward. MCP is huge for getting agents to do things in the “real world”. However, it’s costly! Skills is a cheap way to fill that gap for many cases. People are finding immediate value in both of these. Try not to be so pessimistic.
It's not pessimism, but actual compatibility issues
like deno vs npm package ecosystems that didn't work together for many years
There are multiple AGENTS vs CLAUDE vs .github/instructions; skills vs commands; ... intermixed and inconsistent concepts, all out in the wild
When I work on a project, do all the files align? If I work in an org, where developers have agent choice, how many of these instructions and skills "distros" do I need to put (pollute?) my repo with?
Well, these agentic / AI companies don't even know what an RFC is, let alone how to write one. The last time they attempted to create a "standard" (MCP) it was not only premature, but it was a complete security mess.
Apart from Google Inc., I have not seen a single "AI company" propose an RFC that was reviewed by the IETF and became a proper internet standard. [0]
"MCP" was one of the worst so-called "standards" ever built since the JWT was proposed. So I do not take Anthropic seriously when they create so-called "open standards" especially when the reference implementation is in Javascript or TypeScript.
Why does this need to be a standard in the first place. This isn't DDR5 lol, it's literally just politely asking the model to remember some short descriptions and read a corresponding file when it thinks appropriate. I feel like these abstractions are supposed to make Claude sound more sophisticated because WOW now we can give the guy new skills! But really they're just obfuscating the "data as code" aspect of LLMs which is their true power (and vulnerability ofc).
I have no idea why I’m about to defend OpenAI here. BUT OpenAI have released some open weight models like gpt-oss and whisper. But sure open weight not open source. And yeah I really don’t like OpenAI as a company to be clear.
They have but it does feel like they are developing a closed platform aka Apple.
Apple has shortcuts, but they haven’t propped it up like a standard that other people can use.
To contrast this is something you can use even if you have nothing to do with Claude, and your tools created will be compatible with the wider ecosystem.
I feel inspired and would like to donate my standard for Agent Personas to the community. A persona can be defined by a markdown file with the following frontmatter:
---
persona: hacker
description: logical, talks about computers a lot, enjoys coffee, somewhat snarky and arrogant
---
<more details here>
1. For an experienced Claude Code user, you can already build such an agent persona quite trivially by using the /agents settings.
2. It doesn't actually replace agents. Most people I know use pre-defined agents for some tasks, but they still want the ability to create ad-hoc agents for specific needs. Your standard, by requiring them to write markdown files does not solve this ad-hoc issue.
3. It does not seem very "viral" or income-generating. I know this is premature at this point, but without charging users for the standard, is it reasonable to expect to make money off of this?
All the talk about "open" standards from AI companies feels like VC-backed public LLM experiments. Even if these standards fade, they help researchers create and validate new tools. I see this especially with local models. The rise of CLI-based LLM coding tools lets me use models like GPT OSS 20B to build apps locally and offline.
Skills are a pretty awkward abstraction. They emerged to patch a real problem, generic models require fine-tuning via context, which quickly leads to bloated context files and context dilution (ie more hallucinations)
But skills dont really solve the problem. Turning that workaround into a standard feels strange. Standardizing a patch isn’t something I’d expect from Anthropic, it’s unclear what is their endgame here
Skills don’t solve the problem if you think an llm should know everything. But if you see LLMs mostly as a text plan-do-check-act machine that can process input text, generate output text, and can create plans how to create more knowledge and validate the output, without knowing everything upfront, skills are perfectly fine solution.
The value of standardizing skills is that the skills you define work with any agentic tool. Doesn't matter how simple they are, if they dont work easily, they have no use.
You need a practical and efficient way to give the llm your context. Just like every organization has its own standards, best practices, architectures that should be documented, as new developers do not know this upfront, LLMs also need your context.
An llm is not an all knowing brain, but it’s a plan-do-check-act text processing machine.
How would you solve the same problem? Skills seem to be just a pattern (before this spec) that lets the LLMs choose what information they need to "load". It's not that different from a person looking up the literature before they do a certain job, rather than just reading every book every time in case it comes in handy one day. Whatever you do you will end up with the same kind of solution, there's no way to just add all useful context to the LLM beforehand.
> Standardizing a patch isn’t something I’d expect from Anthropic
This is not the first time, perhaps expectation adjustment is in order. This is also the same company that has an exec telling people in his Discord (15m of fame recently) Claude has emotions
Marketing. That defines pretty much everything Anthropic does beyond frontier model training. They're the same people producing sensationalized research headlines about LLMs trying to blackmail folks in order to prevent being deleted.
I'd love to see way more interest, rigor, tooling, etc in the industry regarding Skills, I really think they have solved the biggest problems that killed Expert Systems back in the day. I'd love to see the same enthusiasm as MCPs for these, I think in the long term they will be much more important than MCPs (still complementary).
I wish agentic skills were something other than a system prompt or a series of step-by-step instructions. feels like anthropicide and opportunity here to do something truly groundbreaking but ended up with prompt engineering.
Could one make a copyleft type license such that the generated code must be licensed free and open and under the same license? How enforceable are licenses on these skills anyway, if one can take in the whole skill with an agent and generate a legally distinct but functionally close variant?
Interesting move. One thing I’m curious about is how opinionated the standard is supposed to be.
In practice, agent “skills” tend to blur the line between capabilities, tools, and workflows, especially once statefulness and retries enter the picture.
Is the goal here mostly interoperability between agent frameworks, or do you see this evolving into something closer to a contract for agent behavior over time?
I can imagine standardization helping a lot, but only if it stays flexible enough to avoid freezing today’s agent design assumptions.
I doubt that. MCPs are broader. You can serve a Skill via a MCP but the reverse may not be always true.
For example, you can't have a directory named "Stripe-Skills" which will give you a breakdown of last week's revenue (unless you write in the skills how to connect to stripe and get that information). So, most of the remote, existing services are better used as MCPs (essentially APIs).
I have been switching between OpenCode and Claude - one thing I like about OpenCode is the ability to define custom agents. These can be ones tailored to specific workflows like PR reviews or writing change logs. I haven't yet attempted the equivalent of this with skills in Claude.
These two solutions look feel and smell like the same thing. Are they the same thing?
Any OpenCode users out there have any hot or nuanced takes?
Claude Code has subagents as well. I created a workflow with multiple agents to build iOS apps, including agents for orchestration, design, build, and QA.
I had developed a tool for Roo Code, and have moved over to anti-gravity with no problem, that basically gives playwright the ability to develop and test user scripts in an automated fashion.
It is functionally a skill. I suppose once anti-gravity supports skills, I will make it one officially.
Love seeing this become an open standard.
We just shipped the first universal skill installer built on it:
npx ai-agent-skills install frontend-design
20 of the most starred Claude skills ever, now open across Claude Code, Cursor, Amp, VS Cod : anywhere that supports the spec. Would love some feedback on it
In a way yes, you can reduce context usage by a non-negligible amount approaching it this way. I'm investigate this on my skill validation/analysis/bidirectional MCP server project and hope to have it as a released feature soon: https://github.com/athola/skrills
Or if we wrote these things in a language with real imports and modules?
I'm authoring equivalent in CUE, and assimilating "standard" provider ones into CUE on the fly so my agent can work with all the shenanigans out there.
I noticed a similar optimization path with skills, where I now have subagents to analyze the performance of a previous skill/command/hook execution, triggered by a command. I've pushed this to my plugin marketplace https://github.com/athola/claude-night-market
“Agent skills” seems more like a pattern than something that needs a standard. It’s like announcing you’ve created a standard for “singletons” or “monads”
This is the right direction but this implementation is playdough and this needs to be a stone mansion. I’m working on a non-LLM AI model that will blow this out of the water.
Claude's skills thing just leveled up from personal toy to full enterprise push - org admins shoving Notion/Figma/Atlassian workflows straight into the model? That's basically turning Claude into your company's AI front door. The open standard bit is smart though, means every partner skill keeps funneling tokens back their way. But good luck when every PM wants their custom agent snowflake and your infra bill triples overnight.
That's not what this is. MCP is still around and useful- skills are tailored prompt frameworks for specific tasks or contexts. They're useful for specialization, and in conjunction with post-training after some good data is acquired, will allow the next generation of models to be a lot better at whatever jobs produce good data for training.
Local tools/skills/function definitions can already invoke any API.
There's no real benefit to the MCP protocol over a regular API with a published "client" a local LLM can invoke. The only downside is you'd have to pull this client prior.
I am using local "skill" as reference to an executable function, not specifically Claude Skills.
If the LLM/Agent executes tools via code in a sandbox (which is what things are moving towards), all LLM tools can be simply defined as regular functions that have the flexibility to do anything.
I seriously doubt MCP will exist in any form a few years from now
I have seen ~10 IQ points drop with each MCP I added. I have replaced them all with either skill-like instructions or curl calls in AGENTS.md with much better "tool-calling" rate.
It isn't particularly useful. It uses a lot of context without a lot of value. Claude has written a blog post saying as much. Skills keep the context out unless it's needed.
There's a pattern I keep seeing: LLMs used to replace things we already know how to do deterministically. Parsing a known HTML structure, transforming a table, running a financial simulation. It works, but it's like using a helicopter to cross the street: expensive, slow, and not guaranteed to land exactly where you intended.
The real opportunity with Agent Skills isn't just packaging prompts. It's providing a mechanism that enables a clean split: LLM as the control plane (planning, choosing tools, handling ambiguous steps) and code or sub-agents as the data/execution plane (fetching, parsing, transforming, simulating, or executing NL steps in a separate context).
This requires well-defined input/output contracts and a composition model. I opened a discussion on whether Agent Skills should support this kind of composability:
https://github.com/agentskills/agentskills/issues/11
I've recently been doing some work with Autodesk. It would be great for an LLM to be as comfortable with the "vocabulary" of these applications as they are with code. Maybe part of this involves creating a language for CAD design in the first place. But the principle that we need to build out vocabularies and subsequently generate and expose "sentences" (workflows) for LLM's to train on seems like a promising direction.
Of course this requires substantial buy in from application owners - create the vocabulary - and users - agree to expose and share the sentences they generate - but the results would be worth it.
The same applies to context vs a database. If a reasoning model makes a decision about something, it should be put off to the side and stored as a value/variable/entry somewhere. Instead of using pages and pages of context, it makes sense for some tasks to "press" decisions that become more permanent to the conversation. You can somewhat accomplish that with notebooklm, by turning results into notes into sources, but notebooklm is insular and doesnt have the research and imaging features of gemini.
And also, in writing, writing from top to bottom has its disadvantages. It makes sense to emulate human writing process and have passes, as you flesh out, and conversely summarize writing.
Current LLMs can brute force these things through emulation/observation/mimicry but they arent as good as doing it the right way. Not only would I like to see "skills" but also "processes" where you create a well defined order that tasks are accomplished in sequence. Repeatable templates. This would essentially include variables in the templates, set for replacement.
100%
Additionally, I can't even get claude or codex to reliable use the prompt and simple rules (use this command to compile) in an agents.md or whatever required markdown file is needed. Why would I assume they will reliably handle skills prompts spread about a codebase?
I've even seen tool usage deteriorate while it's thinking and self commanding through its output to say.. read code from a file. Sometimes it uses tail while other times it gets confused on the output and then writes a basic python program to parse lines and strings from the same file to effectively get what was the same output as before. How bizarre!
> Parsing a known HTML structure, transforming a table, running a financial simulation.
Transforming an arbitrary table is still hard, especially a table on a webpage or in a document. Sometimes I even struggle to find the right library. The effort does not seem worth it for one-off need of such transformation too. LLM can be a great tool for doing the tasks.
How likely are we to look back on Agent/MCP/Skills as some early Netscape peculiarity? I would dive into adoption if I didn't think some new thing would beat the paradigm in a fortnight.
I've built a number of MCP servers, including an MCP wrapper. I'd generally recommend you skip it unless you know you need it. Conversely, I'd generally recommend you write up a couple skills ASAP to get a feel for them. It will take you 20 minutes to write and test some.
MCP does three things conceptually: it lets you build a bridge between an agent and <something else>, it specifies a UI+API layer between the bridge and the LLM, and it formalizes the description of that bridge in a tool-calling format.
It's that UI+API layer that's the biggest pain in the ass, in my opinion. Sometimes you need it; for instance, if you wanted an agent to access your emails, a high quality MCP server that can't destroy your life through enthusiastic tool calling makes sense.
If, however, you have, say a CLI tool or simple API that's reasonably self documenting and you're willing to have it run, and/or if you need specific behavior with a different context setting, then a skill can just be a markdown file that explains what, how, why.
Agreed. I use only one MCP server regularly and it’s a custom one integrated into my QT desktop app. It has tools for inspecting the widget tree, using selectors to click/type/etc, and take screenshots. Functionality that would otherwise be hard or impossible to reliably implement using CLI calls but gives Claude a closed feedback loop.
All public MCP server I’ve seen have been a disaster with too many tools and tokens polluting the context. It’s really most useful when you need tight integration with some other environment and can write a little custom wrapper to provide it.
Agent/MCP/Skills might be "Netscape-y" in the sense that today's formats will evolve fast. But Netscape still mattered: it lost the market, not the ideas. The patterns survived (JavaScript, cookies, SSL/TLS, progressive rendering) and became best practices we take for granted.
The durable pattern here isn't a specific file format. It's on-demand capability discovery: a small index with concise metadata so the model can find what's available, then pull details only when needed. That's a real improvement over tool calling and MCP's "preload all tools up front" approach, and it mirrors how humans work. Even as models bake more know-how into their weights, novel capabilities will always be created faster than retraining cycles. And even if context becomes unlimited, preloading everything up front remains wasteful when most of it is irrelevant to the task at hand.
So even if "Skills" gets replaced, discoverability and progressive disclosure likely survive.
Yes this 100%. Every person i speak with who is excited about MCP is some LinkedIn Guru or product expert. I'm yet to encounter a seriously technical person excited by any of this.
MCP, as a concept, is a great idea.
The problem isn’t having a standard way for agents to branch out. The problem is that AI is the new Javascript web framework: there’s nothing wrong with frameworks, but when everyone and their son are writing a new framework and half those frameworks barely work, you end up with a buggy, fragmented ecosystem.
I get why this happens. Startups want VC money, established companies then want to appear relevant, and then software engineers and students feel pressured to prove they’re hireable. And you end up with one giant pissing contest where half the players likely see the ridiculousness of the situation but have little choice other than to join party.
I have found MCPs to be very useful (albeit with some severe and problematic limitations in the protocol's design). You can bundle them and configure them with a desktop LLM client and distribute them to an organization via something like Jamf. In the context I work in (biotech) I've found it a pretty high-ROI way to give lots of different types of researchers access to a variety of tools and data very cheaply.
I have found MCPs helpful. Recently, I used one to migrate a site from WordPress to Sanity. I pasted in the markdown from the original site and told it to create documents that matched my schemas. This was much quicker and more flexible than whipping up a singular migration tool. The Sanity MCP uses oAuth so I also didn’t need to do anything in order to connect to my protected dataset. Just log in. I’ll definitely be using this method in the future for different migrations.
I use only one MCP, but I use it a lot: it's chrome devtools. I get Claude Code to test in the browser, which makes a huge difference when I want it to fix a bug I found in the browser - or if I just want it to do a real world test on something it just built.
Don't forget A2A: https://developers.googleblog.com/en/a2a-a-new-era-of-agent-...
We'll see how many of these are around in a few years.
I'm yet to come across applications implementing A2A in real life.
Skills are just prompt conventions; the exact form may change but the substance is reasonable. MCP, eh, it’s pretty bad, I can see it vanishing.
The agent loop architectural pattern (and that’s the relevant bit) is going to continue to matter. There will be new patterns for sure, but tool calling plus while loop (which is all an “agent” is) is powerful and highly general.
So like any early phase, there's risk in picking a technology to use.
How likely is it to even remember “the AI stuff” 2-3 years from now? What we’re trying to do with LLMs today is extremely unsustainable. NVidia/openai will run out of silly investors eventually…
Why do you think they will fade out?
Frontier models will eventually eat all the tedious tailored add-ons as just part of something they can do.
Right now models have roughly all of the written knowledge available to mankind, minus some obscure held out private archives and so on. They have excellent skills and general abilities to construct plausible sequences of actions to accomplish work, but we need to hold their hands to really get decent performance across a wide range of activities. Skills and agent frameworks and MCP carve out different domains of that problem, with successful solutions providing training data for future models that might be able to be either generalized, or they'll be able to create a vast mountain of synthetic data following successful patterns, and make the next generation of models incredibly useful for a huge number of tasks, by default.
It might also be possible that by studying the problem, identifying where mode collapses and issues with training prevent the right sort of generalization, they might tweak the architecture and be able to solve the deficiency through normal training runs, and thereby discard the need for all the bespoke artisanal agent specifications.
His point, I believe, was that it is early in the innovation cycle and they very well be replaced quickely with different solutions/paradigms.
Adoption on most of these has been weak, except MCP (and whatever flavor of markdown file you like to add to your agent context)
Extremely likely but that doesn't mean it lacks value today
Is a skill essentially a reusable prompt that is inserted at the start of any query? The marketing of Agents/MCP/skills/etc is very confusing to me.
“inserted at the start of any query” feels like a bit of a misunderstanding to me. It plops the skill text into the context when it needs it or when you tell it to. It’s basically like pasting in text or telling it to read a file, except for the bit where it can decide on its own to do it. I’m not sure start, middle, or end of query is meaningful here.
It's basically just a way for the LLM to lazy-load curated information, tools, and scripts into context. The benefit of making it a "standard" is that future generations of LLMs will be trained on this pattern specifically, and will get quite good at it.
Does it persist the loaded information for the remainder of the conversation or does it intelligently cull the context when it's not needed?
It's the description that gets inserted into the context, and then if that sounds useful, the agent can opt to use the skill. I believe (but I'm not sure) that the agent chooses what context to pass into the subagent, which gets that context along with the skill's context (the stuff in the Markdown file and the rest of the files in the FS).
This may all be very wrong, though, as it's mostly conjecture from the little I've worked with skills.
Its part of managing the context. It's a bit of prepared context that can be lazy-loaded in as the need arises.
Inversely, you can persist/summarize a larger bit of context into a skill, so a new agent session can easily pull it in.
So yes, it's just turtles, sorry, prompts all the way down.
Skills can be just instructions how to do things.
BUT what makes them powerful is that you can include code with the skill package.
Like I have a skill that uses a Go program to traverse the AST of a Go project to find different issues in it.
You COULD just prompt it but then the LLM would have to dig around using find and grep. Now it runs a single executable which outputs an LLM optimised clump of text for processing.
It also has (Python/Ruby/bash) scripts which Claude Code can execute.
The agentic development scene has slowly turned into a full-blown JavaScript circus—bright lights, loud chatter, and endless acts that all look suspiciously familiar. We keep wrapping the same old problems in shiny new packages, parading them around as if they’re groundbreaking innovations. How long before the crowd grows tired of yet another round of “RFC” performances?
MCP: we're uber, but for stdout
Good job, reading this sentence physically hurts my eyes.
the tech industry is forever in denial that it is also actually a fashion industry.
That's only true for companies that make most of their money from investment instead of customers. Those exist too.
Beyond assembly everything is window dressing.
It’s a fast moving field. People aren’t coming up with new ideas to be performative. They see issues with the state of the art and make something that may or may not advance things forward. MCP is huge for getting agents to do things in the “real world”. However, it’s costly! Skills is a cheap way to fill that gap for many cases. People are finding immediate value in both of these. Try not to be so pessimistic.
It's not pessimism, but actual compatibility issues
like deno vs npm package ecosystems that didn't work together for many years
There are multiple AGENTS vs CLAUDE vs .github/instructions; skills vs commands; ... intermixed and inconsistent concepts, all out in the wild
When I work on a project, do all the files align? If I work in an org, where developers have agent choice, how many of these instructions and skills "distros" do I need to put (pollute?) my repo with?
When the AI investment dollars run out. "As long as the music is playing, you've got to get up and dance." (Chuck Prince, Citigroup)
Well, these agentic / AI companies don't even know what an RFC is, let alone how to write one. The last time they attempted to create a "standard" (MCP) it was not only premature, but it was a complete security mess.
Apart from Google Inc., I have not seen a single "AI company" propose an RFC that was reviewed by the IETF and became a proper internet standard. [0]
"MCP" was one of the worst so-called "standards" ever built since the JWT was proposed. So I do not take Anthropic seriously when they create so-called "open standards" especially when the reference implementation is in Javascript or TypeScript.
[0] https://www.rfc-editor.org/standards
To be fair, security wasn’t even a consideration until RFCs were well into triple digits. We’re still very early, as they say.
> I have not seen a single "AI company" propose an RFC that was reviewed by the IETF and became a proper internet standard.
Why would the IETF have anything to do with LLM/agent standards? This seems like a category error. They also don’t ratify web standards, for example.
> full-blown JavaScript circus
It is not healthy when you have an obsession this bad, seriously. Seek help.
Why does this need to be a standard in the first place. This isn't DDR5 lol, it's literally just politely asking the model to remember some short descriptions and read a corresponding file when it thinks appropriate. I feel like these abstractions are supposed to make Claude sound more sophisticated because WOW now we can give the guy new skills! But really they're just obfuscating the "data as code" aspect of LLMs which is their true power (and vulnerability ofc).
i like how Anthropic has positioned themselves as the true AI research company and donating “standards” like that.
Although Skills are just md files but it’s good to see them “donate” it.
There goal seems to be simple: Focus on coding and improving it. They’ve found a great niche and hopefully revenue generating business there.
OpenAI on the other hand doesn’t give me same vibes, they don’t seem very oriented. They’re playing catchup with both Google models and Anthropic
I have no idea why I’m about to defend OpenAI here. BUT OpenAI have released some open weight models like gpt-oss and whisper. But sure open weight not open source. And yeah I really don’t like OpenAI as a company to be clear.
They have but it does feel like they are developing a closed platform aka Apple.
Apple has shortcuts, but they haven’t propped it up like a standard that other people can use.
To contrast this is something you can use even if you have nothing to do with Claude, and your tools created will be compatible with the wider ecosystem.
A skill can also contain runnable code.
Many many MCPs could and should just be a skill instead.
I feel inspired and would like to donate my standard for Agent Personas to the community. A persona can be defined by a markdown file with the following frontmatter:
This isn’t just a standard—this is a templating system that could offer us a straight shot to AGI!
Please consider donating this to the Linux Foundation so they can drive this inspiring innovation forward.
I have a few qualms about this standard:
1. For an experienced Claude Code user, you can already build such an agent persona quite trivially by using the /agents settings.
2. It doesn't actually replace agents. Most people I know use pre-defined agents for some tasks, but they still want the ability to create ad-hoc agents for specific needs. Your standard, by requiring them to write markdown files does not solve this ad-hoc issue.
3. It does not seem very "viral" or income-generating. I know this is premature at this point, but without charging users for the standard, is it reasonable to expect to make money off of this?
Have you considered publishing this with a few charts about vague levels of "correctness"?
What is "correctness?"... wait hang on let me think...
"you're absolutely right!"
Give this man a Turing Award
Luckily you get the "extremely confident, even when wrong" attribute for free.
But always willing to admit the opposite is true and go with that on a whim.
As groundbreaking as this is, it will never get traction without a LICENSE.md.
announcing md2ai spec
absolutely revolutionary! ;)
> logical
Please tell us how REALLY feel about JavaScript.
It was just a few months ago that the MCP spec added a concept called "prompts" which are really similar to skills.
And of course Claude Code has custom slash commands which are also very similar.
Getting a lot of whiplash from all these specifications that are hastily put together and then quickly forgotten.
My understanding is, that MCP Prompts and Slash Commands are "user triggered" whereas Skills (and MCP Tools) are "model triggered".
Other than that it appears MCP prompts end up as slash commands provided by an MCP Server (instead of client side command definitions).
But the actual knowledge that is encoded in skills/commands/mcp prompts is very similar.
It's a "standard" though! /s
They published a specification, that doesn’t yet make it a standard.
All the talk about "open" standards from AI companies feels like VC-backed public LLM experiments. Even if these standards fade, they help researchers create and validate new tools. I see this especially with local models. The rise of CLI-based LLM coding tools lets me use models like GPT OSS 20B to build apps locally and offline.
Skills are a pretty awkward abstraction. They emerged to patch a real problem, generic models require fine-tuning via context, which quickly leads to bloated context files and context dilution (ie more hallucinations)
But skills dont really solve the problem. Turning that workaround into a standard feels strange. Standardizing a patch isn’t something I’d expect from Anthropic, it’s unclear what is their endgame here
Skills don’t solve the problem if you think an llm should know everything. But if you see LLMs mostly as a text plan-do-check-act machine that can process input text, generate output text, and can create plans how to create more knowledge and validate the output, without knowing everything upfront, skills are perfectly fine solution.
The value of standardizing skills is that the skills you define work with any agentic tool. Doesn't matter how simple they are, if they dont work easily, they have no use.
You need a practical and efficient way to give the llm your context. Just like every organization has its own standards, best practices, architectures that should be documented, as new developers do not know this upfront, LLMs also need your context.
An llm is not an all knowing brain, but it’s a plan-do-check-act text processing machine.
How would you solve the same problem? Skills seem to be just a pattern (before this spec) that lets the LLMs choose what information they need to "load". It's not that different from a person looking up the literature before they do a certain job, rather than just reading every book every time in case it comes in handy one day. Whatever you do you will end up with the same kind of solution, there's no way to just add all useful context to the LLM beforehand.
> Standardizing a patch isn’t something I’d expect from Anthropic
This is not the first time, perhaps expectation adjustment is in order. This is also the same company that has an exec telling people in his Discord (15m of fame recently) Claude has emotions
> it’s unclear what is their endgame here
Marketing. That defines pretty much everything Anthropic does beyond frontier model training. They're the same people producing sensationalized research headlines about LLMs trying to blackmail folks in order to prevent being deleted.
>But skills dont really solve the problem.
I think that they often do solve the problem, just maybe they have some other side effects/trade offs.
They’re not a perfect solution, but they are a good one.
The best one we have thought of so far.
I'd love to see way more interest, rigor, tooling, etc in the industry regarding Skills, I really think they have solved the biggest problems that killed Expert Systems back in the day. I'd love to see the same enthusiasm as MCPs for these, I think in the long term they will be much more important than MCPs (still complementary).
I wish agentic skills were something other than a system prompt or a series of step-by-step instructions. feels like anthropicide and opportunity here to do something truly groundbreaking but ended up with prompt engineering.
I'm curious about the `license` field in the specification: https://agentskills.io/specification.
Could one make a copyleft type license such that the generated code must be licensed free and open and under the same license? How enforceable are licenses on these skills anyway, if one can take in the whole skill with an agent and generate a legally distinct but functionally close variant?
Interesting move. One thing I’m curious about is how opinionated the standard is supposed to be. In practice, agent “skills” tend to blur the line between capabilities, tools, and workflows, especially once statefulness and retries enter the picture. Is the goal here mostly interoperability between agent frameworks, or do you see this evolving into something closer to a contract for agent behavior over time? I can imagine standardization helping a lot, but only if it stays flexible enough to avoid freezing today’s agent design assumptions.
If anyone wants to use Skills in Gemini CLI or any other llm tool - check out something I have created, open-skills https://github.com/BandarLabs/open-skills
It does code execution in an apple container if your Skill requires any code execution.
It also proves the point that Skills are basically repackaged MCPs (if you look into my code).
Will Skills and Code Execution replace MCPs eventually?
I doubt that. MCPs are broader. You can serve a Skill via a MCP but the reverse may not be always true.
For example, you can't have a directory named "Stripe-Skills" which will give you a breakdown of last week's revenue (unless you write in the skills how to connect to stripe and get that information). So, most of the remote, existing services are better used as MCPs (essentially APIs).
I have been switching between OpenCode and Claude - one thing I like about OpenCode is the ability to define custom agents. These can be ones tailored to specific workflows like PR reviews or writing change logs. I haven't yet attempted the equivalent of this with skills in Claude.
These two solutions look feel and smell like the same thing. Are they the same thing?
Any OpenCode users out there have any hot or nuanced takes?
Claude Code has subagents as well. I created a workflow with multiple agents to build iOS apps, including agents for orchestration, design, build, and QA.
The skills can be specific to a repository but the agents are global, right?
Claude code simply supports agents also
They really do love standards
I had developed a tool for Roo Code, and have moved over to anti-gravity with no problem, that basically gives playwright the ability to develop and test user scripts in an automated fashion.
It is functionally a skill. I suppose once anti-gravity supports skills, I will make it one officially.
Finally I can share this beauty with a wider world:
https://github.com/alganet/skills/blob/main/skills/left-padd...
Amazing. It's just missing an order for the chatbot to say "I know left-pad" before actually doing any work.
This is hilarious
Is that intentionally designed to completely occupy the full context window of the earlier GPT models?
Either way, that’s hilarious. Well done.
I asked a model to write for me following the style and tone of other skills!
<conspiracy_mode> maybe all of them were designed to occupy the full context window of earlier GPT models </conspiracy_mode>
Love seeing this become an open standard. We just shipped the first universal skill installer built on it:
npx ai-agent-skills install frontend-design
20 of the most starred Claude skills ever, now open across Claude Code, Cursor, Amp, VS Cod : anywhere that supports the spec. Would love some feedback on it
github.com/skillcreatorai/Ai-Agent-Skills
Is it possible to provide a llm a skill through the mcp resource feature?
In a way yes, you can reduce context usage by a non-negligible amount approaching it this way. I'm investigate this on my skill validation/analysis/bidirectional MCP server project and hope to have it as a released feature soon: https://github.com/athola/skrills
It’s also possible to implement an MCP as a skill
Still can’t symlink skills from Claude code to codex tho :/
My company has a plugin marketplace in a git repo where we host our shared skills. It would be nice if we could plug that into the web interface.
Or if we wrote these things in a language with real imports and modules?
I'm authoring equivalent in CUE, and assimilating "standard" provider ones into CUE on the fly so my agent can work with all the shenanigans out there.
Our lab has been experimenting with “meta skills” that allow creation of skills to use later after a particular workflow.
Paper & applications published here: https://earthpilot.ai/metaskills/
I noticed a similar optimization path with skills, where I now have subagents to analyze the performance of a previous skill/command/hook execution, triggered by a command. I've pushed this to my plugin marketplace https://github.com/athola/claude-night-market
I have been experimenting with these same type of factory pattern skills. Thanks for sharing.
After a session with Claude Code I just tell it "turn this into a skill, incorporate what we've learned in this session".
Argh word creep.
It has been published as an open specification.
Whether it is a standard isn't for them to declare.
Is codex working well with python notebooks?
Tired of having to learn the Next New Thing (tm) that'll be replaced in a month.
“Agent skills” seems more like a pattern than something that needs a standard. It’s like announcing you’ve created a standard for “singletons” or “monads”
how are skills and mcp different?
Skills are local. MCP can be remote and has authentication.
It still sounds the same to me.
This is the right direction but this implementation is playdough and this needs to be a stone mansion. I’m working on a non-LLM AI model that will blow this out of the water.
What is the difference between 3rd party skills and connectors? How do you access/install 3rd party skills in claude code?
Claude's skills thing just leveled up from personal toy to full enterprise push - org admins shoving Notion/Figma/Atlassian workflows straight into the model? That's basically turning Claude into your company's AI front door. The open standard bit is smart though, means every partner skill keeps funneling tokens back their way. But good luck when every PM wants their custom agent snowflake and your infra bill triples overnight.
Might add this to the next https://hackernewsai.com/ newsletter.
Good riddance MCP.
That's not what this is. MCP is still around and useful- skills are tailored prompt frameworks for specific tasks or contexts. They're useful for specialization, and in conjunction with post-training after some good data is acquired, will allow the next generation of models to be a lot better at whatever jobs produce good data for training.
Local tools/skills/function definitions can already invoke any API.
There's no real benefit to the MCP protocol over a regular API with a published "client" a local LLM can invoke. The only downside is you'd have to pull this client prior.
I am using local "skill" as reference to an executable function, not specifically Claude Skills.
If the LLM/Agent executes tools via code in a sandbox (which is what things are moving towards), all LLM tools can be simply defined as regular functions that have the flexibility to do anything.
I seriously doubt MCP will exist in any form a few years from now
I have seen ~10 IQ points drop with each MCP I added. I have replaced them all with either skill-like instructions or curl calls in AGENTS.md with much better "tool-calling" rate.
It isn't particularly useful. It uses a lot of context without a lot of value. Claude has written a blog post saying as much. Skills keep the context out unless it's needed.
It's a much better system in my experience.