Is AI skilled?
People learn skills by doing, AI models read them from a file, and the gap between the two shows up fast in software and in research.

“Skill” now means two different things. When I say a colleague is skilled at something, I mean they can do something really well, thanks to a lot of practice and prior experience. When I give an AI agent a skill, I mean I gave it a file!
That file is quite literal. A skill is a folder with a file called SKILL.md in it. At the top sit a name and a short description of when to use it. Below that come the instructions in plain text, sometimes with a few scripts or reference files next to it. Anthropic came up with the idea and later opened it up, and other agent tools now read the same files.
The format belongs to the tool, not the model. The agent tool finds the skill folders and puts each skill’s name and description in front of the model. The model itself only ever sees plain text. So the same skill can be handed to a Claude model, a GPT model or an open model running on your own laptop. Whether they all read it the same way is another matter. Anthropic’s own advice is to test a skill with every model you plan to use, because a smaller model may need more detail and a larger one less.
So the word skill means two very different things. One is an ability in a person’s head, the other is a text file. The differences come down to three things. How a skill is written, how it is read, and how it changes. I’ll use two areas I know, software engineering and life sciences, because the gaps show up differently in each.
How a skill is written
Most human skill is never written down. My CV says “RNA-seq analysis”, “bioinformatics”, “data science” and “agentic development workflows” among other things. Each line stands for a lot of experimentation with different methods, experience on what went wrong, samples that looked fine and weren’t, and a feel for when not all is ok with a result. None of that fits on a CV, and most of it doesn’t fit in a protocol either. And most of the time you don’t record what went wrong, you just retain it in your memory. In a way you build muscle memory.
Long before AI, philosophers noticed that much of what we know how to do can’t be written down. Gilbert Ryle separated knowing that from knowing how. You can know every rule of chess and still play badly. He also showed why rules can’t be the whole story. If every skilled act needed a rule first, you would need another rule for applying that rule, and so on without end. So the knowing how has to come first. Michael Polanyi went further and argued that we know more than we can tell. We recognise a face among thousands and can’t say how. An experienced researcher spots a bad sample the same way, before they can explain why. How do you write that down in an AI skill?
A written protocol captures the knowing-that part. A code style guide does the same in software. The knowing-how stays in people’s heads and moves between them slowly, by working side by side.
An agent skill has none of that. Whatever isn’t in the file doesn’t exist for the agent unless of course it’s built straight into the model. But writing a skill forces you to put into words things you have never had to say. That is the hard part, and it is useful even if no agent ever reads the result. When I try to write down how I do something, I usually find I understood it less clearly than I thought.
How a skill is read
A person reads documentation with everything they already know. They fill gaps, notice when something doesn’t fit, ask a colleague, and know when to break the rule. Most of the time they don’t even acknowledge that it’s a skill, it comes naturally to them.
An agent reads differently. First it decides whether to use a skill from the name and the short description alone. The rest of the file is only loaded when the description seems to match the task. A good skill with a vague description simply never gets used. And that’s the way it is with humans as well. We have a lot of skills that never ever get used, but once you need one, it is there.
Then it reads the instructions as written. Wittgenstein pointed out that a rule never fully explains how to follow it. Even a simple instruction can be read in more than one way. People settle that from experience. They know how things are done where they work, so they pick the meaning that was intended. An agent only has what the model picked up in training and other context in the session. That covers a lot, but it isn’t how your team does things.
Take a code review skill that says “check the tests”. An experienced reviewer reads that as checking that the tests would catch the bug this change could introduce. An agent can just as reasonably read it as checking that tests exist and pass, and report that all is well.
Or take a quality control step for sequencing data that says “remove low-quality samples”. Which threshold? Someone who has worked with this tissue knows that some samples always look worse and are fine, and that a whole batch looking bad points to a problem upstream, not in the samples. The skill file says none of that unless someone wrote it down or prompted it explicitly.
Neither reading is wrong. The words allow both. The difference is what the reader brings.
How a skill evolves
Here the agent wins easily. For an agent, learning is the easy part. Change out the skill file and it works the new way straight away, with no practice and no old habits to unlearn. The change sits in version control, so it can be compared, reviewed and rolled back.
People learn slowly. A skill grows through practice and feedback, over years. It also drifts without anyone noticing, and it can’t be handed over. When an experienced person leaves a team, part of how that team works leaves with them.
So the hard part moves. Learning is cheap for an agent. Knowing what to put in the file, and checking how it gets read, is not. There is one more catch. The model underneath gets upgraded every few months, and the next one can read the same file differently. A skill that worked in spring can behave differently in autumn without a word of it changing.
Update, November 2026. Since I wrote this, a paper from researchers at Google measured it. They tuned the prompts, code and tools around one model and then moved them to another. The tuned setup often did worse on the new model than the plain one they had started from. What helped was a record of every change they kept, with the problem it was meant to fix, what they expected and what actually happened. With that record, the next round could tell which changes still helped and which had only suited the old model. It is the opposite of how we keep our own experience. We remember what went wrong without writing it down. A plain agent has no memory like that, so the why has to be written down too.
What stays human
A skill file is a set of rules, and no rule fully explains how to follow it. The real skill is knowing what fills the gap between the rule and the action. That is why writing a good skill file is still very human work. It takes someone who has done the work, often for years before AI, to know which rules matter and to notice when the agent followed the words but missed the meaning. That experience is slow to build, but once it is in a file, the rest of us can copy it. We all work a little differently, so a copied skill still needs adjusting, and knowing what to adjust takes experience too.


