Skills are the new JavaScript frameworks. It is no coincidence that yesterday’s hype sellers now ship a new agent skill every week, it’s the same dynamic behind the new-framework-every-day meme we’ve all laughed and suffered from for years.
If you haven’t met them yet, a skill is just a file of instructions an AI agent loads to do a certain kind of task. You can write your own or install someone else’s, and lately the second option looks like the default. I think it’s a mistake.
Let’s be very pragmatic and look at a real one, I’m cherry-picking of course, but it’s for the sake of brining a point.
Matt Pocock, one of the most famous skills sellers, has a skill in the engineering section of his public repo for “Real Engineering” called /implement.
This is the whole thing (as of November 2026):
Implement the work described by the user in the spec or tickets.
If the user passes a ticket reference, fetch it from the issue tracker and state its title before starting. If the reference is ambiguous, ask.
Call the Skill tool with “tdd” where possible, at pre-agreed seams.
Run typechecking regularly, single test files regularly, and the full test suite once at the end.
Once done, call the Skill tool with “code-review” to review the work.
Commit your work to the current branch.
“Implement the work described by the user”. This is the most obvious thing your agent knows it has to do, it’s there just for that, it’s literally INSTRUCTED for that. Telling it again only adds cost and guarantees nothing.
TDD, typechecking, tests. These are things that must ONLY be done deterministically, every time, without wasting a single token asking for that, and newer model know that already: if there are tests to be run, they run them.
“Call the Skill tool with code-review”. When to run a code review MUST be your choice, not something hidden in someone else’s skill. If you want to iterate fast, you’re wasting time and tokens on an LLM review at every loop (if the model interprets it like that, of course).
The worst one: “Commit your work to the current branch”. What? Which branch? Why should such an action be part of someone else’s imported skill?
This is what you bring into your workflow out of the laziness of not just thinking, talking to your agents, and creating your own workflow, skills and commands at your need.
These are your engineering tools nowadays. I think that, if this is the default, we haven’t learned anything: especially now, with the power of these models, we’re still blindly adopting other people’s solutions. This is not “Real Engineering”, this is slop and loss of control. You get the look of a process, not a correct result.
Also: imported skills age badly. Models catch up with the harness: through RLHF, RLAIF and general progress, they absorb what used to need extra scaffolding, and they do it better. Don’t take my word for it though. In July 2026 Thariq Shihipar from the Claude Code team published The new rules of context engineering for Claude 5 generation models, and they built the model, so it’s worth listening:
“We found that we were overconstraining Claude Code, both through our system prompt and in our CLAUDE.md files and skills”. They removed over 80% of Claude Code’s system prompt for the newest models, with no measurable loss on their coding evaluations.
“Avoid stating ‘the obvious’ things Claude should know by looking at your file system or your repo”. Sounds familiar? (point 1 above)
“Think of skills as lightweight guides” and “avoid making them overconstrained, except in highly important areas”.
They moved code review into its own skill, one Claude calls selectively. (point 3)
“Across your system prompt, skills, and CLAUDE.md files, you may need to simplify just like we did”.
If the people who make the model are deleting instructions, the files you copied from a stranger last spring are probably due for the same treatment.
Blind imports also cost you grasp, and fun. If you don’t know what a skill says, you don’t know why the model behaves the way it does. Borrow only where you are not the expert: if you’re strong in distributed systems, it makes sense to lean on other people’s knowledge of design systems and UI. Even then, read it before you use it, and even better: talk to your agent, iterate, and if you’re satisfied with your work, make your own and polish it over time, to the point of deleting it, if the model doesn’t need it anymore.
I’m not saying shared skills are useless. In a company or a project it is useful to have a set of skills, or guidelines in AGENTS.md, that are vertical on the team or the project itself. But they must be reviewed over time, as harnesses and models improve, and that is part of the engineering we have to pursue now. It’s engineering common sense: control of the ideas, keeping the brain turned on, and being critical about how we talk to our agents. We cannot delegate our judgement to a set of files, especially if not written by us, and let them rot.
So what do I do instead? I try to think like the model, putting myself in its place and ask: if I had to do this job, what would I need to do it well? Then I ask what the model is missing, and how I can give it that. It’s a creative exercise, and honestly more fun than installing someone else’s work. Most of the time I do the work first, by hand, find a good way to do it, and only then turn it into something repeatable, like a /command.
But, I don’t feel the need to give my skills/commands to others. What’s useful, if anything, is the workflow and the idea behind the little improvements you can freely steal.
So, I don’t care about your /skills, and you shouldn’t care about mine. The value is in writing your own and sharing the ideas.
Have fun.

