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.

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.

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!

I agree partly.

Skills are essentially boiling down to distributed parts of a Main Prompt. If you consider a state model you can see this pattern: Task is the state and combining the task's specifics skills defines the current prompt augmentation. When the task changes, another prompt emerges.

In the end, it is the clear guidance of the Agent that is the deciding factor.

Isn't atleast part of that GH issue something that this https://docs.boundaryml.com/guide/introduction/what-is-baml is also trying to solve? LLM inputs and outputs must be functions with defined functions. That was their starting point.

IIUC their most recent arc focuses on prompt optimization[0] where you can optimize — using DSPy and an optimization algo GEPA [1] — using relative weights on different things like errors, token usage, complexity.

[0] https://docs.boundaryml.com/guide/baml-advanced/prompt-optim... [1] https://github.com/gepa-ai/gepa?tab=readme-ov-file

> 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.

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.

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.

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.

The space is moving fast enough that everything feels provisional

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…

So like any early phase, there's risk in picking a technology to use.

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.

Why do you think they will fade out?

Extremely likely but that doesn't mean it lacks value today

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.

“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.

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.

MCP: we're uber, but for stdout

the tech industry is forever in denial that it is also actually a fashion industry.

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.

There's definitely a performative vibe to a lot of it right now

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

> full-blown JavaScript circus

It is not healthy when you have an obsession this bad, seriously. Seek help.

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.

A skill can also contain runnable code.

Many many MCPs could and should just be a skill instead.

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"?

Give this man a Turing Award

Luckily you get the "extremely confident, even when wrong" attribute for free.

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.

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

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.

> 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.

> 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

>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.

Will Skills and Code Execution replace MCPs eventually?

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

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.

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

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

I have been experimenting with these same type of factory pattern skills. Thanks for sharing.

Skills are local. MCP can be remote and has authentication.

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.