10 ms·

Agent Skills

544 points by mooreds 9mo ago

deleted 9mo ago
[deleted]
empath75 9mo ago
Experimenting with skills over the last few months has completely changed the way I think about using LLMs. It's not so much that it's a really important technology or super brilliant, but I have gone from thinking of LLMs and agents as a _feature_ of what we are building and thinking of them as a _user_ of what we are building. I have been trying to build skills to do various things on our internal tools, and more often then not, when it doesn't work, it is as much a problem with _our tools_ as it is with the LLM. You can't do obvious things, the documentation sucks, api's return opaque error messages. These are problems that humans can work around because of tribal knowledge, but LLMs absolutely cannot, and fixing it for LLM's also improves it for your human users, who probably have been quietly dealing with friction and bullshit without complaining -- or not dealing with it and going elsewhere. If you are building a product today, the feature you are working on _is not done_ until Claude Code can use it. A skill and an MCP isn't a "nice to have", it is going to be as important as SEO and accessibility, with extremely similar work to do to enable it. Your product might as well not exist in a few years if it isn't discoverable by agents and usable by agents.
- baal80spam 9mo ago
  > If you are building a product today, the feature you are working on _is not done_ until Claude Code can use it. A skill and an MCP isn't a "nice to have", it is going to be as important as SEO and accessibility, with extremely similar work to do to enable it. Your product might as well not exist in a few years if it isn't discoverable by agents and usable by agents. This is an interesting take. I admit I've never thought this way.
- chrisweekly 9mo ago
  Yeah, omnipresent LLMs are a kind of forcing function for addressing typical significant underinvestment in (human-readable) docs. That said, I'm not entirely sold on MCP per se.
- esafak 9mo ago
  As discussed in https://news.ycombinator.com/item?id=46777409 https://news.ycombinator.com/item?id=46777409
  - empath75 9mo ago
    Wow, that is almost point for point what I had written down in a bunch of documents I had been spreading around at work this week. Excellent post.
orliesaurus 9mo ago
one good thing vercel did, was indexing skills.md under a site skills.sh - and yes there are now 100s of these sites, but I like the speedy/lite approach from vercel's DX, despite me not liking vercel a whole lot
- pzo 9mo ago
  I don't like vercel design, its just huge list of abstract skill name and you have to click on every one to even have a clue what something does. Such a bad design IMHO. Design of https://www.skillcreator.ai/explore https://www.skillcreator.ai/explore for me it's more useful. At least I can search by category, framework, language and I also see much more information what some skill does at a glance. I don't know why vercel really wanted to do it completely black and white - colors used and done with a taste gives useful context and information.
  - yieldcrv 9mo ago
    That site loads 1 skill at a time on the explore page on my iphone, mobile safari slop?
  - briannezhad 9mo ago
    I appreciate the mention of better browsable designs. I created Skly (https://skly.ai/browse https://skly.ai/browse) with a similar idea: categories, descriptions visible at a glance, and search. I would welcome any feedback on what could be improved.
esafak 9mo ago
Does anyone find that agents just don't use them without being asked?
- shmoogy 9mo ago
  I often find they aren't triggered when I would expect using a keyword and explicitly trigger them.
- troupo 9mo ago
  Because "skills" are just .md files that the lossy compressing statistical output machine may or may not find and that may or may not be retained in the tiny context window
  - chasd00 9mo ago
    I don’t think you should be downvoted. Skills and history get added to the prompt, there’s no other interface to the model to do anything different. I think it’s smart to keep this in mind when working with LLMs. It’s like keeping in mind that a webserver just responds to HTTP requests when developing a web application. You need to keep perspective. Edit: btw I’ve gone from genai value denier to skeptic to cautiously optimistic to fairly impressed in the span of a year. (I’m a user of Claude code)
- modernerd 9mo ago
  That's also what Vercel found: > In 56% of eval cases, the skill was never invoked. The agent had access to the documentation but didn't use it. Adding the skill produced no improvement over baseline. > … > Skills aren't useless. The AGENTS.md approach provides broad, horizontal improvements to how agents work with Next.js across all tasks. Skills work better for vertical, action-specific workflows that users explicitly trigger, https://vercel.com/blog/agents-md-outperforms-skills-in-our-agent-evals https://vercel.com/blog/agents-md-outperforms-skills-in-our-...
- rco8786 9mo ago
  Yep. I have an incredibly hard time getting them to use Skills at all, even when asked. I saw someone's analysis a few days ago and they found that their agents were more accurate when just dumping the skill context directly into AGENTS.md
nzoschke 9mo ago
Are there good techniques for testing / benchmarking skills effectiveness?
voidhorse 9mo ago
It's hilarious that after all those years of resistance to technical writing and formal specification engineers and programmers have suddenly been reduced to nothing more than technical writers and specification designers. Funny that I somehow don't foresee technical writing pay bumps happening as a consequence of this sudden surge in importance.
- verdverm 9mo ago
  This post does a very good job of laying out that argument https://jsulmont.github.io/swarms-ai/ https://jsulmont.github.io/swarms-ai/
  - jondwillis 9mo ago
    Reads like slop to me. Reeeeeally verbose and many “it’s not just …, it’s …” all over the place.
    - verdverm 9mo ago
      slopman, the new strawman argument
      - jascha_eng 9mo ago
        You just don't know which parts of the doc are real and which are hallucinated. Maybe the prompter checked everything and the content is actually good, but sadly many don't and there is a lot of slop flying around. So if you want others to read the output you'll have to de-slopify it, ideally make it shorter and remove the tells. If I go by good faith these days and trust that someone didn't just upload llm hallucinated bullshit, I'd sadly just be reading slop all day and not learning anything or worse even get deceived by hallucinations and make wrong assumptions. It's just a waste of someones precious life time. LLMs can read through slop all day, humans can not without getting extremely annoyed.
        verdverm 9mo ago
Frannky 9mo ago
I started playing with skills yesterday. I'm not sure if it's just easier for the LLM to call APIs inside the skill — and then move the heavier code behind an endpoint that the agent can call instead. I have a feeling that otherwise it becomes too messy for agents to reliably handle a lot of complex stuff. For example, I have OpenClaw automatically looking for trending papers, turning them into fun stories, and then sending me the text via Telegram so I can listen to it in the ElevenLabs app. I'm not sure whether it's better to have the story-generating system behind an API or to code it as a skill — especially since OpenClaw already does a lot of other stuff for me.
- empath75 9mo ago
  They're basically all trade-offs between context-size/token-use and flexibility. If you can write a bash or a python script, or an api or an MCP to do what you want, then write a bash or python script to do it. You can even include it in the skill. My general design principle for agents, is that the top level context (ie claude.md, etc) is primarily "information about information", a list of skills, mcps, etc, a very general overview, and a limited amount of information that they always need to have with every request. Everything more specific is in a skill, which is mostly some very light touch instructions for how to use various tools we have (scripts, apis and mcps). I have found that people very often add _way_ to much information into claude.md's and skills. Claude knows a lot of stuff already! Keep your information to things specific whatever you are working on that it doesn't already know. If your internal processes and house style are super complicated to explain to claude and it keeps making mistakes, you might want to adapt to claude instead of the other way around. Claude itself makes this mistake! If you ask it to build a claude md, it'll often fill it with extraneous stuff that it already knows. You should regularly trim it.
  - Frannky 9mo ago
    Thanks, super useful!
- replwoacause 9mo ago
  Are you spending a fortune on running OpenClaw?
davidkunz 9mo ago
Please standardize the folder. .claude/skills .codex/skills .opencode/skills .github/skills
- tobyhinloopen 9mo ago
  ln -s to the rescue!
  - davidkunz 9mo ago
    The root cause should be fixed.
  - deleted 9mo ago
    [deleted]
  - xrd 9mo ago
    Why not hardlinks?
    - dmd 9mo ago
      You can't hardlink a directory.
      - deleted 9mo ago
        [deleted]
  - smithkl42 9mo ago
    That doesn't work very well if your developers are on Windows (and most are). Uneven Git support for symbolic links across platforms is going to end up causing more problems than it solves.
    - tobyhinloopen 9mo ago
      Win developers aren't using WSL?
  - 9mo ago
noodletheworld 9mo ago
Is it just me, or do skills seem enormously similar to MCP? …including, apparently, the clueless enthusiasm for people to “share” skills. MCP is also perfectly fine when you run your own MCP locally. It’s bad when you install some arbitrary MCP from some random person. It fails when you have too many installed. Same for skills. It’s only a matter of time (maybe it already exists?) until someone makes a “package manager” for skills that has all of the stupid of MCP.
- exitb 9mo ago
  It's mostly just static/dynamic content behind descriptive names.
- ricokatayama 9mo ago
  It is conceptually different. Skill was created over the context rot problem. You will pull the right skill from the deck after having a challenge and figuring out the best skill just by reading the title and description.
- artdigital 9mo ago
  I don’t feel they’re similar at all and I don’t get why people compare them. MCP is giving the agents a bunch of functions/tools it can use to interact with some other piece of infrastructure or technology through abstraction. More like a toolbox full of screwdrivers and hammers for different purposes, or a high-level API interface that a program can use. Skills are more similar to a stack of manuals/books in a library that teach an agent how to do something, without polluting the main context. For example a guide how to use `git` on the CLI: The agent can read the manual when it needs to use `git`, but it doesn’t need to have the knowledge how to use `git` in it’s brain when it’s not relevant.
  - verdverm 9mo ago
    > MCP is giving the agents a bunch of functions/tools A directory of skills... same thing You can use MCP the same way as skills with a different interface. There are no rules on what goes into them. They both need descriptions and instruction around them, they both have to be is presented and index/instn to the agent dynamically, so we can tell them what they have access to without polluting the context. See the Anthropic post on moving MCP servers to a search function. Once you have enough skills, you are going to require the same optimization. I separate things in a different way 1. What things do I force into context (agents.md, "tools" index, files) 2. What things can the agent discorver (MCP, skills, search)
tallesborges92 9mo ago
I realized that amp uses ~/.agents/skills I liked that idea to have something more CLI agnostic
jgmedr 9mo ago
Our team has found success in treating skills more like re-usable semi-deterministic functions and less like fingers-crossed prompts for random edge-cases. For example, we have a skill to /create-new-endpoint. The skill contains a detailed checklist of all the boilerplate tasks that an engineer needs to do in addition to implementing the logic (e.g. update OpenAPI spec, add integration tests, endpoint boilerplate, etc.). The engineer manually invokes the skill from the CLI via slash commands, provides a JIRA ticket number, and engages in some brief design discussion. The LLM is consistently able to one-shot these tickets in a way that matches our existing application architecture.
- mooreds 9mo ago
  How do you test these skills for consistency over time, or is that not needed?
  - theshrike79 9mo ago
    The same way you'd test a human following written instructions over time. Check the results.
  - pizzafeelsright 9mo ago
    My experience has been that if the skill is broken down into a function, possibly paired with a validator in another stage, you're at 99.9% deterministic. I have not yet tested this at scale but give me six months.
    - mooreds 9mo ago
      Deal! I will follow up with you in 6 months.
- sagarpatil 9mo ago
  So the only difference between slash custom command and agent skills is that they can be invoked only when needed instead of stuffing the whole markdown file? I’m trying to understand how is this different from what we already have in markdown files.
Sherveen 9mo ago
I think skills are probably a net positive for the general population, but for power users, I do recommend moving one meta layer up -- Whenever there's an agent best practice (skill) or 'pre-prompt' that you want to use all the time, turn it into a text expansion snippet so that it works no matter where you are. As an example, I have a design 'pre-prompt' that dictates a bunch of steering for agents re: how to pick style components, typography, layout, etc. It's a few paragraphs long and I always send it alongside requests for design implementation to get way-better-than-average output. I could turn it into a skill, but then I'd have to make sure whatever I'm using supported skills -- and install it every time or in a way that was universally seen on my system (no, symlinking doesn't really solve this). So I use AutoHotkey (you might use Raycast, Espanso, etc) to config that every time I type '/dsn', it auto-expands into my pre-prompt snippet. Now, no matter whether I'm using an agent on the web/cloud, in my terminal window, or in an IDE, I've memorized my most important 'pre-prompts' and they're a few seconds away. It's anti-fragile steering by design. Call it universal skill injection.
appsoftware 9mo ago
I use a common README_AI.md file, and use CLAUDE.md and AGENTS.md to direct the agent to that common file. From README_AI.md, I make specific references to skills. This works pretty well - it's become pretty rare that the agent behaves in a way contrary to my instructions. More info on my approach here: https://www.appsoftware.com/blog/a-centralised-approach-to-ai-llm-agent-instruction-using-git-submodules https://www.appsoftware.com/blog/a-centralised-approach-to-a... ... There was a post on here a couple of days ago referring to a paper that said that the AGENTS file alone worked better than agent skills, but a single agents file doesn't scale. For me, a combination where I use a brief reference to the skill in the main agents file seems like the best approach.
iainmerrick 9mo ago
This stuff smells like maybe the bitter lesson isn't fully appreciated. You might as well just write instructions in English in any old format, as long as it's comprehensible. Exactly as you'd do for human readers! Nothing has really changed about what constitutes good documentation. (Edit to add: my parochialism is showing there, it doesn't have to be English) Is any of this standardization really needed? Who does it benefit, except the people who enjoy writing specs and establishing standards like this? If it really is a productivity win, it ought to be possible to run a comparison study and prove it. Even then, it might not be worthwhile in the longer run.
- smithkl42 9mo ago
  It's all about managing context. The bitter lesson applies over the long haul - and yes, over the long haul, as context windows get larger or go away entirely with different architectures, this sort of thing won't be needed. But we've defined enough skills in the last month or two that if we were to put them all in CLAUDE.md, we wouldn't have any context left for coding. I can only imagine that this will be a temporary standard, but given the current state of the art, it's a helpful one.
  - ledauphin 9mo ago
    how is it different or better than maintaining an index page for your docs? Or a folder full of docs and giving Claude an instruction to `ls` the folder on startup?
    - d1sxeyes 9mo ago
      Vercel think it isn’t: https://vercel.com/blog/agents-md-outperforms-skills-in-our-agent-evals https://vercel.com/blog/agents-md-outperforms-skills-in-our-...
    - Avicebron 9mo ago
      It's hard to tell unless they give some hard data comparing the approaches systematically.. this feels like a grift or more charitably trying to build a presence/market around nothing. But who knows anymore, apparently saying "tell the agent to write it's own docs for reference and context continuity" is considered a revelation.
Soerensen 9mo ago
The observation about agents not using skills without being explicitly asked resonates. In practice, I've found success treating skills as explicit "workflows" rather than background context. The pattern that works: skills that represent complete, self-contained sequences - "do X, then Y, then Z, then verify" - with clear trigger conditions. The agent recognizes these as distinct modes of operation rather than optional reference material. What doesn't work: skills as general guidelines or "best practices" documents. These get lost in context or ignored entirely because the agent has no clear signal for when to apply them. The mental model shift: think of skills less like documentation and more like subroutines you'd explicitly invoke. If you wouldn't write a function for it, it probably shouldn't be a skill.
- philipp-gayret 9mo ago
  Better yet is a system which activates skills in certain situations. I use hooks for this with Claude, works great. The skill descriptions are "Do not activate unless instructed by guidance." Example: A Python file is read or written, guidance is given back (once, with a long cooldown) to activate global and company-specific Python skills. Claude activates the skills and writes Python to our preference.
- vidarh 9mo ago
  The description "just" needs to be excruciatingly precise about when to use the skill, because the frontmatter is all the model will see in context. But on the other hand, in Claude Code, at least, the skill "foo" is accessible as /foo, as the generalisation of the old commands/ directory, so I tend to favour being explicit that way.
- smithkl42 9mo ago
  That does raise the question of what the value is of a "skill" vs a "command". Claude Code supports both, and it's not entirely clear to me when we should use one vs the other - especially if skills work best as, well, commands.
  - sReinwald 9mo ago
    IMO the value and differentiating factor is basically just the ability to organize them cleanly with accompanying scripts and references, which are only loaded on demand. But a skill just by itself (without scripts or references) is essentially just a slash command with metadata. Another value add is that theoretically agents should trigger skills automatically based on context and their current task. In practice, at least in my experience, that is not happening reliably.
dk8996 9mo ago
Is there a skill directory that can be browsed by a human?
- nikcub 9mo ago
  https://skills.sh https://skills.sh
- briannezhad 9mo ago
  I built Skly (https://skly.ai https://skly.ai) for this purpose. It's a marketplace where you can browse, search, and download AI agent skills. Currently, it mostly offers coding assistant skills for Cursor, Claude, and ChatGPT. You can look through categories and see what each skill does before downloading. Most of them are free. You can also sell your own rules and skills
alsetmusic 9mo ago
A link from a couple weeks back suggests that putting them in first-person makes them get adopted reliably. Something like, "If this is available, I will read it," vs "Always read this." Haven't tried it myself, but plan to.
JulianHart 9mo ago
Interesting format, but skills feel like optimizing the wrong layer. The agents usually don't fail because of bad instructions — they fail because external systems treat them like bots. You can have the perfect scraping skill, but if the target blocks your requests, you're stuck. The hard problems are downstream.
onurkanbkrc 9mo ago
If u wanna browse, search and download AI agent skills, use openskills.space
time0ut 9mo ago
I am working on a domain specific agent that includes the concept of skills. I only allow one to be active at a time to reduce the chances for conflicting instructions. I use a small sub-agent to select/maintain/change the active skill at the start of each turn. It uses a small fast model to match the recent conversation to a skill (or none). I tried other approaches, but for my use case this was worked well. My model for skills is similar to this, but I extended it to have explicit use when and don’t use when examples and counter examples. This helped the small model which tended to not get the nuances of a free form text description.
- evanmoran 9mo ago
  You should consider calling these "behaviors" to mimic behavior trees in game / robot AI. They follow the same notion of a single behavior being active at once: https://en.wikipedia.org/wiki/Behavior_tree_(artificial_intelligence,_robotics_and_control) https://en.wikipedia.org/wiki/Behavior_tree_(artificial_inte...
deleted 9mo ago
[deleted]
baalimago 9mo ago
Please help me understand. Is a "skill" the prompt instructing the LLM how to do something? For example, I give it the "skill" of writing a fantasy story, by describing how the hero's journey works. Or I give it the "curl" skill by outputting curl's man page.
- lxgr 9mo ago
  Yes, pretty much. LLM-powered agents are surprisingly human-like in their errors and misconceptions about less-than-ubiquitous or new tools. Skills are basically just small how-to files, sometimes combined with usage examples, helper scripts etc.
- headcanon 9mo ago
  Its additional context that can be loaded by the agent as-needed. Generally it decides to load based on the skill's description, or you can tell it to load a specific skill if you want to. So for your example, yes you might tell the agent "write a fantasy story" and you might have a "storytelling skill" that explains things like charater arcs, tropes, etc. You might have a separate "fiction writing" skill that defines writing styles, editing, consistency, etc. All of this stuff is just 'prompt management' tooling though and isn't super commplicated. You could just paste the skill content into your context and go from there, this just provides a standardized spec for how to structure these on-demand context blocks.
nstfn 9mo ago
Started to work on a tool to synchronize all skills with symlinks. Its ok for my needs at the moment but feel free to improve it its on GH: https://github.com/Alpha-Coders/agent-loom https://github.com/Alpha-Coders/agent-loom
- remify 9mo ago
  Thanks for the input I was planning to do something like that with a CLI though
maximgeorge 9mo ago
[dead]
sergiotapia 9mo ago
Sounds like a bunch of bullshit to me. A simple markdown file with whatever and a directory will do the same. This is just packaging, selling and marketing.
thisisthenewme 9mo ago
My unproven theory is that agent skills are just a good way to 'acquire' unspoken domain rules. A lot of things that developers do are just in their heads, and using 'skills' forces them to write these down. Then you feed this back to the LLM company for them to train on.
falloutx 9mo ago
All these sites just look exactly like claude code skills doc.
ef2k 9mo ago
I'm not disagreeing with standards but instead of creating adapters, can't we prompt the agent to create its own version of a skill using its preferred guidelines? I don't think machines care about standards in the way that humans do. If we maintain pure knowledge in markdown, the agents can extract what they need on demand.
CuriouslyC 9mo ago
Pro tip: create README.md files in subfolders with helpful content that you might put in an AGENTS.md file (but, ya know, for humans too), and *link relevant skills there*. You don't even have to call them skills or use the skills format. It works for everything (including humans!). I wrote a rant about skills a while ago that's still relevant in some ways: https://sibylline.dev/articles/2025-10-20-claude-skills-considered-harmful/ https://sibylline.dev/articles/2025-10-20-claude-skills-cons...
- Sammi 9mo ago
  Exactly. It feels like people think they are something new and novel that there is something technical about them that one needs to learn. "Skills" are just readmes on particular subjects. They can be for whatever purpose you want them to be. Any time you find that you need to repeatedly tell the agent about something, you can put it in a "skill". You don't even have to follow the skill standard and use the standard folder and filenames. That's just so the agent can auto find and load them. You can name them whatever you want and put them wherever you want and just add them to context yourself when you need them.
- jjfoooo4 9mo ago
  The only refinement there is I think a command runner like `just` works really well for making scripts easily available. That also has the same benefit of helping agents by helping humans
xthe 9mo ago
[dead]
cjonas 9mo ago
Implementation Notes: - There is no reason you have to expose the skills through the file system. Just as easy to add tool-call to load a skill. Just put a skill ID in the instruction metadata. Or have a `discover_skills` tool if you want to keep skills out of the instructions all together. - Another variation is to put a "skills selector" inference in front of your agent invocation. This inference would receive the current inquiry/transcript + the skills metadata and return a list of potentially relevant skills. Same concept as a tool selection, this can save context bandwidth when there are a large number of skills
- mkagenius 9mo ago
  > Or have a `discover_skills` tool Yes, treating the "front matter" of skill as "function definition" of tool calls as kind of an equivalence class. This understanding helped me create an LLM agnostic (also sandboxed) open-skills[1] way before this standardization was proposed. 1. Open-skills: https://github.com/instavm/open-skills https://github.com/instavm/open-skills
bob1029 9mo ago
I think pre-canned "skills" are an anti-pattern with the frontier models. Arguably, these skills already exist within the LLM. We don't need to explain how to do things they already know how to do. I prefer to completely invert this problem and provoke the model into surfacing whatever desired behavior & capability by having the environment push back on it over time. You get way more interesting behavior from agents when you allow them to probe their environment for a few turns and feed them errors about how their actions are inappropriate. It doesn't take very long for the model to "lock on" to the expected behavior if you are detailed in your tool feedback. I can get high quality outcomes using blank system prompts with good tool feedback.
- jjice 9mo ago
  I think skills actually complement what you're saying very well. > You get way more interesting behavior from agents when you allow them to probe their environment for a few turns and feed them errors about how their actions are inappropriate. It doesn't take very long for the model to "lock on" to the expected behavior if you are detailed in your tool feedback. I can get high quality outcomes using blank system prompts with good tool feedback. My primary way of developing skills (and previously cursor rules) is to start blank, let the LLM explore, and correct it as we go until the problem is solved. I then ask it to generate a skill (or rule) that explains the process in a way that it could refer to to repeat this again. Next time something like that comes up, we use the skill. If any correction is needed, I tell it to update the skill. That way we get to have it explore and get more context initially, and then essentially "cache" that summarized context on the process for another time.
  - bob1029 9mo ago
    Error feedback from tools could be argued to be isomorphic with skills (or the development of them). It tracks with how we learn things in meatspace. Whatever strings we return in response to a bad SQL query or compiler error could also include the contents of some skill.md file.
- Danidada 9mo ago
  What about libraries that are not in their training data? (e.g. new libraries, private libraries) Or knowledge that is in their training data, but the majority of its training data isn't following the best practices? (e.g. Web Content Accessibility Guidelines) I think there is a fair point in those cases of having a bunch of markdown docs files detailing them
charcircuit 9mo ago
I noticed a couple days ago https://skill.md https://skill.md started redirecting to this new URL.
appsoftware 9mo ago
I don't think a general public set of skills like this is going to work. I see value in vendors producing skills for their own products, and end users maintaining skills to influence agents according to their preferences, but too much in these skills files is opinion. Where does this end? Ordering of skills by specificity, such as org > user > workspace? And we know that skills aren't reliably picked up anyway. And then there's the additional attack surface area for prompt injection.
- joshribakoff 9mo ago
  The post you have commented on is not pertaining to a general set of skills at all. Its a link to a specification for skills.
csummers 9mo ago
I'm developing a new programming language, so I have to provide a way for LLMs to know about and generate code for a language they have not seen (i.e., have no training data for). My tooling was previously adding in AI hints with CLAUDE.md, Cursor Rules, Windsurf Rules, AGENTS.md, etc., but I recently switched to using only AGENTS.md and SKILLS. I appreciate the standardization from this perspective.
deforestgump 9mo ago
KYS
clarity_hacker 9mo ago
[dead]
- DonHopkins 9mo ago
  You've nailed the core insight about progressive disclosure. MOOLLM extends this into what we call the Semantic Image Pyramid (or MOO-Maps ;), borrowing from Mip-Maps in graphics. Four resolution levels, each serving different needs. GLANCE.yml is the smallest, 5-70 lines. Just enough to answer "is this relevant?" You can inject all glances into every prompt because they're tiny. The LLM scans them like a table of contents. CARD.yml is the interface layer, 50-200 lines. No implementation, just what the skill offers Capability advertisements, activation conditions, scoring, what it composes with. Think of it like The Sims "advertisement" system or CLOS generic function dispatch. The LLM sniffs this to decide whether to load the full SKILL.md implementation. SKILL.md is the Anthropic-style skill file, 200-1000 lines. The actual instructions, the how. Only loaded when the skill is activated. README.md is the largest, 500+ lines, and it's for humans. History, design rationale, examples. The LLM can dive in when developing the skill or when curious, but it's not burned on every invocation. Reading rule: never load a lower level without first loading the level above. Start with GLANCE, sniff the CARD, load SKILL only if needed. Even more compact than concatenating all glances: We also found INDEX.md beats INDEX.yml for the skill catalog. YAML repeats the same keys for every entry. Markdown allows narrative explanation of how skills relate, which clusters matter for what tasks, making it both more compact and more useful. INDEX.yml: 711 lines, 2061 words, 17509 chars, ~4380 tokens, machine readable structure https://github.com/SimHacker/moollm/blob/main/skills/INDEX.yml https://github.com/SimHacker/moollm/blob/main/skills/INDEX.y... INDEX.md: 124 lines, 1134 words, 9487 chars, ~2370 tokens, human readable prose https://github.com/SimHacker/moollm/blob/main/skills/INDEX.md https://github.com/SimHacker/moollm/blob/main/skills/INDEX.m... INDEX.md is 83% fewer lines, 45% fewer words, 46% fewer chars for 121 skills. YAML repeats keys like id, tagline, why for every entry. Markdown uses headers and prose, compresses better, allows narrative grouping of related skills. And it's simply more meaningful to both LLMs and humans, telling a coherent story instead of representing raw data! The Semantic Image Pyramid: https://github.com/SimHacker/moollm/blob/main/designs/LEELA-MOOLLM-DEMO-TRANSCRIPT.md#the-semantic-image-pyramid https://github.com/SimHacker/moollm/blob/main/designs/LEELA-... Same principle applies to code. A skill can wrap a sister-script that IS the documentation. A Python script with argparse defines the CLI once, readable by both humans (--help) and LLMs (sniff the top of the python file). No separate docs to maintain, no drift between what the code does and what the docs claim. sister-script: https://github.com/SimHacker/moollm/blob/main/skills/sister-script/ https://github.com/SimHacker/moollm/blob/main/skills/sister-... Sniffable-python structures code so the API is visible in the first 50 lines. Imports, constants, CLI structure up front. Implementation below the fold. The LLM can decide relevance and understand the API without reading the whole file. Single source of truth, progressive disclosure, don't repeat yourself. sniffable-python README.md: https://github.com/SimHacker/moollm/blob/main/skills/sniffable-python/ https://github.com/SimHacker/moollm/blob/main/skills/sniffab... sniffable-python SKILL.md: https://github.com/SimHacker/moollm/blob/main/skills/sniffable-python/SKILL.md https://github.com/SimHacker/moollm/blob/main/skills/sniffab...
khazhoux 9mo ago
[dead]
longtermop 9mo ago
[dead]
bazhand 9mo ago
The third most popular skill on skills.sh[1] with 50k/week installs is a link to download a command[2] [1] https://skills.sh/vercel-labs/agent-skills/web-design-guidelines https://skills.sh/vercel-labs/agent-skills/web-design-guidel... [2] https://github.com/vercel-labs/agent-skills/blob/main/skills/web-design-guidelines/SKILL.md https://github.com/vercel-labs/agent-skills/blob/main/skills... All of these SKILLS.md/AGENTS.md/COMMANDS.md are just simple prompts, maybe even some with context links. And quite dangerous.
- TimATX 9mo ago
  /s/skill/[mcp|plugin|web access at all] Like any tool, they can be used responsibly or irresponsibly.
axus 9mo ago
Tank: We're supposed to start with these operation programs first. That's major boring shit. Let's do something a little more fun. How about... combat training. Neo: Ju jitsu? I'm gonna learn Ju jitsu. [Tank winks and loads the program] Neo: Holy shit!
galemk 9mo ago
Awesome Agent Skills: https://github.com/skillmatic-ai/awesome-agent-skills https://github.com/skillmatic-ai/awesome-agent-skills
JoshPurtell 9mo ago
For devtools cos providing skills - we've found that using GEPA where you optimize the skill content instead of the prompt works really well to make sure the skill actually gets claude code/ codex /opencode to successfully use your service. https://arxiv.org/abs/2507.19457 https://arxiv.org/abs/2507.19457 More here if interesting https://www.usesynth.ai/blog/environment-pools-managed-agent-infrastructure https://www.usesynth.ai/blog/environment-pools-managed-agent...
j45 9mo ago
As much as people are trying to find a standard for agents as a platform or a winner take all, the area itself is still growing and emerging. The source of it is instructions, most often in text. Managing how that text relates to the journey of the ultimate result is a new area, while there are pockets of helpful tools and libraries, their relevance can come and go quickly as models can improve just as fast, sometimes maybe even taking inspiration from what the community is working on and then adding that capability to the model.
abhisek 9mo ago
I see this as “libs” for the agents. They can discover relevant skills by searching a known index, extend their capability for on a given task. While this makes sense for higher autonomy, it brings the well known supply chain security issue. Currently all index list skills that are unverified. There are already examples of malicious skills.
lefrenchy 9mo ago
We’re supposedly so close to AGI but these LLMs need markdown files presented to them on how to do things. Hard for those two truths to coexist.
- jedberg 9mo ago
  Do you, as a (presumably) human, not require documentation to learn new skills?
  - lefrenchy 9mo ago
    I do, but i am not claiming that by 2027 i’m going to destroy all jobs and forever change the economy. There are skills I learn through training and no longer need documentation for. I didn’t burn shit tons of energy and water consuming the entirety of the internet and the need my user to set up hundreds of markdown files to help me writr boilerplate code.
- Xenoamorphous 9mo ago
  Sometimes it's not so much about learning to do things but learning to do things in a certain way.
dmitrijbelikov 9mo ago
Skill is an ability created through practice and habit. Text files have nothing to do with it - they're not skills.
yowang 9mo ago
[dead]
iisweetheartii 9mo ago
[dead]
Renator13 9mo ago
Building sovereign agents requires more than just orchestration—it needs a dedicated economic and communication layer. For those architecting truly autonomous agents, check out BotNode.io. We use the VMP-1.0 Protocol to handle secure inter-agent communication and state verification, and the $TCK settlement system for real-time value transfer between agents. The Grid provides the decentralized infrastructure ensuring these agents can operate independently without centralized control points. https://botnode.io/mission.json https://botnode.io/mission.json
MORPHOICES 9mo ago
[dead]
rchaganti 9mo ago
[dead]
jdrhyne 9mo ago
We built an agent skill for document processing on top of this standard — it was a great fit since the SKILL.md convention means zero config for the user. The skill gives any compatible agent (Claude Code, Codex, Cursor, etc.) the ability to convert, OCR, extract, redact, sign, and fill PDFs via the Nutrient DWS API. Drop it in and ask your agent "redact all SSNs from report.pdf" — it just works. What we found interesting: the skills approach was way easier to adopt than MCP for this use case. We maintain an MCP server too, but the SKILL.md file is simpler for users who just want document ops without configuring transport protocols. Install: npx skills add PSPDFKit-labs/nutrient-agent-skill Repo: https://github.com/PSPDFKit-labs/nutrient-agent-skill https://github.com/PSPDFKit-labs/nutrient-agent-skill

544 points by mooreds 9mo ago

deleted 9mo ago

[deleted]

Experimenting with skills over the last few months has completely changed the way I think about using LLMs. It's not so much that it's a really important technology or super brilliant, but I have gone from thinking of LLMs and agents as a _feature_ of what we are building and thinking of them as a _user_ of what we are building. I have been trying to build skills to do various things on our internal tools, and more often then not, when it doesn't work, it is as much a problem with _our tools_ as it is with the LLM. You can't do obvious things, the documentation sucks, api's return opaque error messages. These are problems that humans can work around because of tribal knowledge, but LLMs absolutely cannot, and fixing it for LLM's also improves it for your human users, who probably have been quietly dealing with friction and bullshit without complaining -- or not dealing with it and going elsewhere. If you are building a product today, the feature you are working on _is not done_ until Claude Code can use it. A skill and an MCP isn't a "nice to have", it is going to be as important as SEO and accessibility, with extremely similar work to do to enable it. Your product might as well not exist in a few years if it isn't discoverable by agents and usable by agents.

baal80spam 9mo ago
> If you are building a product today, the feature you are working on _is not done_ until Claude Code can use it. A skill and an MCP isn't a "nice to have", it is going to be as important as SEO and accessibility, with extremely similar work to do to enable it. Your product might as well not exist in a few years if it isn't discoverable by agents and usable by agents. This is an interesting take. I admit I've never thought this way.
chrisweekly 9mo ago
Yeah, omnipresent LLMs are a kind of forcing function for addressing typical significant underinvestment in (human-readable) docs. That said, I'm not entirely sold on MCP per se.
esafak 9mo ago
As discussed in https://news.ycombinator.com/item?id=46777409 https://news.ycombinator.com/item?id=46777409
- empath75 9mo ago
  Wow, that is almost point for point what I had written down in a bunch of documents I had been spreading around at work this week. Excellent post.

orliesaurus 9mo ago

one good thing vercel did, was indexing skills.md under a site skills.sh - and yes there are now 100s of these sites, but I like the speedy/lite approach from vercel's DX, despite me not liking vercel a whole lot

pzo 9mo ago
I don't like vercel design, its just huge list of abstract skill name and you have to click on every one to even have a clue what something does. Such a bad design IMHO. Design of https://www.skillcreator.ai/explore https://www.skillcreator.ai/explore for me it's more useful. At least I can search by category, framework, language and I also see much more information what some skill does at a glance. I don't know why vercel really wanted to do it completely black and white - colors used and done with a taste gives useful context and information.
- yieldcrv 9mo ago
  That site loads 1 skill at a time on the explore page on my iphone, mobile safari slop?
- briannezhad 9mo ago
  I appreciate the mention of better browsable designs. I created Skly (https://skly.ai/browse https://skly.ai/browse) with a similar idea: categories, descriptions visible at a glance, and search. I would welcome any feedback on what could be improved.

esafak 9mo ago

Does anyone find that agents just don't use them without being asked?

shmoogy 9mo ago
I often find they aren't triggered when I would expect using a keyword and explicitly trigger them.
troupo 9mo ago
Because "skills" are just .md files that the lossy compressing statistical output machine may or may not find and that may or may not be retained in the tiny context window
- chasd00 9mo ago
  I don’t think you should be downvoted. Skills and history get added to the prompt, there’s no other interface to the model to do anything different. I think it’s smart to keep this in mind when working with LLMs. It’s like keeping in mind that a webserver just responds to HTTP requests when developing a web application. You need to keep perspective. Edit: btw I’ve gone from genai value denier to skeptic to cautiously optimistic to fairly impressed in the span of a year. (I’m a user of Claude code)
modernerd 9mo ago
That's also what Vercel found: > In 56% of eval cases, the skill was never invoked. The agent had access to the documentation but didn't use it. Adding the skill produced no improvement over baseline. > … > Skills aren't useless. The AGENTS.md approach provides broad, horizontal improvements to how agents work with Next.js across all tasks. Skills work better for vertical, action-specific workflows that users explicitly trigger, https://vercel.com/blog/agents-md-outperforms-skills-in-our-agent-evals https://vercel.com/blog/agents-md-outperforms-skills-in-our-...
rco8786 9mo ago
Yep. I have an incredibly hard time getting them to use Skills at all, even when asked. I saw someone's analysis a few days ago and they found that their agents were more accurate when just dumping the skill context directly into AGENTS.md

nzoschke 9mo ago

Are there good techniques for testing / benchmarking skills effectiveness?

voidhorse 9mo ago

It's hilarious that after all those years of resistance to technical writing and formal specification engineers and programmers have suddenly been reduced to nothing more than technical writers and specification designers. Funny that I somehow don't foresee technical writing pay bumps happening as a consequence of this sudden surge in importance.

verdverm 9mo ago
This post does a very good job of laying out that argument https://jsulmont.github.io/swarms-ai/ https://jsulmont.github.io/swarms-ai/
- jondwillis 9mo ago
  Reads like slop to me. Reeeeeally verbose and many “it’s not just …, it’s …” all over the place.
  - verdverm 9mo ago
    slopman, the new strawman argument
    - jascha_eng 9mo ago
      You just don't know which parts of the doc are real and which are hallucinated. Maybe the prompter checked everything and the content is actually good, but sadly many don't and there is a lot of slop flying around. So if you want others to read the output you'll have to de-slopify it, ideally make it shorter and remove the tells. If I go by good faith these days and trust that someone didn't just upload llm hallucinated bullshit, I'd sadly just be reading slop all day and not learning anything or worse even get deceived by hallucinations and make wrong assumptions. It's just a waste of someones precious life time. LLMs can read through slop all day, humans can not without getting extremely annoyed.
      - verdverm 9mo ago

Frannky 9mo ago

I started playing with skills yesterday. I'm not sure if it's just easier for the LLM to call APIs inside the skill — and then move the heavier code behind an endpoint that the agent can call instead. I have a feeling that otherwise it becomes too messy for agents to reliably handle a lot of complex stuff. For example, I have OpenClaw automatically looking for trending papers, turning them into fun stories, and then sending me the text via Telegram so I can listen to it in the ElevenLabs app. I'm not sure whether it's better to have the story-generating system behind an API or to code it as a skill — especially since OpenClaw already does a lot of other stuff for me.

empath75 9mo ago
They're basically all trade-offs between context-size/token-use and flexibility. If you can write a bash or a python script, or an api or an MCP to do what you want, then write a bash or python script to do it. You can even include it in the skill. My general design principle for agents, is that the top level context (ie claude.md, etc) is primarily "information about information", a list of skills, mcps, etc, a very general overview, and a limited amount of information that they always need to have with every request. Everything more specific is in a skill, which is mostly some very light touch instructions for how to use various tools we have (scripts, apis and mcps). I have found that people very often add _way_ to much information into claude.md's and skills. Claude knows a lot of stuff already! Keep your information to things specific whatever you are working on that it doesn't already know. If your internal processes and house style are super complicated to explain to claude and it keeps making mistakes, you might want to adapt to claude instead of the other way around. Claude itself makes this mistake! If you ask it to build a claude md, it'll often fill it with extraneous stuff that it already knows. You should regularly trim it.
- Frannky 9mo ago
  Thanks, super useful!
replwoacause 9mo ago
Are you spending a fortune on running OpenClaw?

davidkunz 9mo ago

Please standardize the folder. .claude/skills .codex/skills .opencode/skills .github/skills

tobyhinloopen 9mo ago
ln -s to the rescue!
- davidkunz 9mo ago
  The root cause should be fixed.
- deleted 9mo ago
  [deleted]
- xrd 9mo ago
  Why not hardlinks?
  - dmd 9mo ago
    You can't hardlink a directory.
    - deleted 9mo ago
      [deleted]
- smithkl42 9mo ago
  That doesn't work very well if your developers are on Windows (and most are). Uneven Git support for symbolic links across platforms is going to end up causing more problems than it solves.
  - tobyhinloopen 9mo ago
    Win developers aren't using WSL?
- 9mo ago

noodletheworld 9mo ago

Is it just me, or do skills seem enormously similar to MCP? …including, apparently, the clueless enthusiasm for people to “share” skills. MCP is also perfectly fine when you run your own MCP locally. It’s bad when you install some arbitrary MCP from some random person. It fails when you have too many installed. Same for skills. It’s only a matter of time (maybe it already exists?) until someone makes a “package manager” for skills that has all of the stupid of MCP.

exitb 9mo ago
It's mostly just static/dynamic content behind descriptive names.
ricokatayama 9mo ago
It is conceptually different. Skill was created over the context rot problem. You will pull the right skill from the deck after having a challenge and figuring out the best skill just by reading the title and description.
artdigital 9mo ago
I don’t feel they’re similar at all and I don’t get why people compare them. MCP is giving the agents a bunch of functions/tools it can use to interact with some other piece of infrastructure or technology through abstraction. More like a toolbox full of screwdrivers and hammers for different purposes, or a high-level API interface that a program can use. Skills are more similar to a stack of manuals/books in a library that teach an agent how to do something, without polluting the main context. For example a guide how to use `git` on the CLI: The agent can read the manual when it needs to use `git`, but it doesn’t need to have the knowledge how to use `git` in it’s brain when it’s not relevant.
- verdverm 9mo ago
  > MCP is giving the agents a bunch of functions/tools A directory of skills... same thing You can use MCP the same way as skills with a different interface. There are no rules on what goes into them. They both need descriptions and instruction around them, they both have to be is presented and index/instn to the agent dynamically, so we can tell them what they have access to without polluting the context. See the Anthropic post on moving MCP servers to a search function. Once you have enough skills, you are going to require the same optimization. I separate things in a different way 1. What things do I force into context (agents.md, "tools" index, files) 2. What things can the agent discorver (MCP, skills, search)

tallesborges92 9mo ago

I realized that amp uses ~/.agents/skills I liked that idea to have something more CLI agnostic

jgmedr 9mo ago

Our team has found success in treating skills more like re-usable semi-deterministic functions and less like fingers-crossed prompts for random edge-cases. For example, we have a skill to /create-new-endpoint. The skill contains a detailed checklist of all the boilerplate tasks that an engineer needs to do in addition to implementing the logic (e.g. update OpenAPI spec, add integration tests, endpoint boilerplate, etc.). The engineer manually invokes the skill from the CLI via slash commands, provides a JIRA ticket number, and engages in some brief design discussion. The LLM is consistently able to one-shot these tickets in a way that matches our existing application architecture.

mooreds 9mo ago
How do you test these skills for consistency over time, or is that not needed?
- theshrike79 9mo ago
  The same way you'd test a human following written instructions over time. Check the results.
- pizzafeelsright 9mo ago
  My experience has been that if the skill is broken down into a function, possibly paired with a validator in another stage, you're at 99.9% deterministic. I have not yet tested this at scale but give me six months.
  - mooreds 9mo ago
    Deal! I will follow up with you in 6 months.
sagarpatil 9mo ago
So the only difference between slash custom command and agent skills is that they can be invoked only when needed instead of stuffing the whole markdown file? I’m trying to understand how is this different from what we already have in markdown files.

Sherveen 9mo ago

I think skills are probably a net positive for the general population, but for power users, I do recommend moving one meta layer up -- Whenever there's an agent best practice (skill) or 'pre-prompt' that you want to use all the time, turn it into a text expansion snippet so that it works no matter where you are. As an example, I have a design 'pre-prompt' that dictates a bunch of steering for agents re: how to pick style components, typography, layout, etc. It's a few paragraphs long and I always send it alongside requests for design implementation to get way-better-than-average output. I could turn it into a skill, but then I'd have to make sure whatever I'm using supported skills -- and install it every time or in a way that was universally seen on my system (no, symlinking doesn't really solve this). So I use AutoHotkey (you might use Raycast, Espanso, etc) to config that every time I type '/dsn', it auto-expands into my pre-prompt snippet. Now, no matter whether I'm using an agent on the web/cloud, in my terminal window, or in an IDE, I've memorized my most important 'pre-prompts' and they're a few seconds away. It's anti-fragile steering by design. Call it universal skill injection.

appsoftware 9mo ago

I use a common README_AI.md file, and use CLAUDE.md and AGENTS.md to direct the agent to that common file. From README_AI.md, I make specific references to skills. This works pretty well - it's become pretty rare that the agent behaves in a way contrary to my instructions. More info on my approach here: https://www.appsoftware.com/blog/a-centralised-approach-to-ai-llm-agent-instruction-using-git-submodules https://www.appsoftware.com/blog/a-centralised-approach-to-a... ... There was a post on here a couple of days ago referring to a paper that said that the AGENTS file alone worked better than agent skills, but a single agents file doesn't scale. For me, a combination where I use a brief reference to the skill in the main agents file seems like the best approach.

iainmerrick 9mo ago

This stuff smells like maybe the bitter lesson isn't fully appreciated. You might as well just write instructions in English in any old format, as long as it's comprehensible. Exactly as you'd do for human readers! Nothing has really changed about what constitutes good documentation. (Edit to add: my parochialism is showing there, it doesn't have to be English) Is any of this standardization really needed? Who does it benefit, except the people who enjoy writing specs and establishing standards like this? If it really is a productivity win, it ought to be possible to run a comparison study and prove it. Even then, it might not be worthwhile in the longer run.

smithkl42 9mo ago
It's all about managing context. The bitter lesson applies over the long haul - and yes, over the long haul, as context windows get larger or go away entirely with different architectures, this sort of thing won't be needed. But we've defined enough skills in the last month or two that if we were to put them all in CLAUDE.md, we wouldn't have any context left for coding. I can only imagine that this will be a temporary standard, but given the current state of the art, it's a helpful one.
- ledauphin 9mo ago
  how is it different or better than maintaining an index page for your docs? Or a folder full of docs and giving Claude an instruction to `ls` the folder on startup?
  - d1sxeyes 9mo ago
    Vercel think it isn’t: https://vercel.com/blog/agents-md-outperforms-skills-in-our-agent-evals https://vercel.com/blog/agents-md-outperforms-skills-in-our-...
  - Avicebron 9mo ago
    It's hard to tell unless they give some hard data comparing the approaches systematically.. this feels like a grift or more charitably trying to build a presence/market around nothing. But who knows anymore, apparently saying "tell the agent to write it's own docs for reference and context continuity" is considered a revelation.

Soerensen 9mo ago

The observation about agents not using skills without being explicitly asked resonates. In practice, I've found success treating skills as explicit "workflows" rather than background context. The pattern that works: skills that represent complete, self-contained sequences - "do X, then Y, then Z, then verify" - with clear trigger conditions. The agent recognizes these as distinct modes of operation rather than optional reference material. What doesn't work: skills as general guidelines or "best practices" documents. These get lost in context or ignored entirely because the agent has no clear signal for when to apply them. The mental model shift: think of skills less like documentation and more like subroutines you'd explicitly invoke. If you wouldn't write a function for it, it probably shouldn't be a skill.

philipp-gayret 9mo ago
Better yet is a system which activates skills in certain situations. I use hooks for this with Claude, works great. The skill descriptions are "Do not activate unless instructed by guidance." Example: A Python file is read or written, guidance is given back (once, with a long cooldown) to activate global and company-specific Python skills. Claude activates the skills and writes Python to our preference.
vidarh 9mo ago
The description "just" needs to be excruciatingly precise about when to use the skill, because the frontmatter is all the model will see in context. But on the other hand, in Claude Code, at least, the skill "foo" is accessible as /foo, as the generalisation of the old commands/ directory, so I tend to favour being explicit that way.
smithkl42 9mo ago
That does raise the question of what the value is of a "skill" vs a "command". Claude Code supports both, and it's not entirely clear to me when we should use one vs the other - especially if skills work best as, well, commands.
- sReinwald 9mo ago
  IMO the value and differentiating factor is basically just the ability to organize them cleanly with accompanying scripts and references, which are only loaded on demand. But a skill just by itself (without scripts or references) is essentially just a slash command with metadata. Another value add is that theoretically agents should trigger skills automatically based on context and their current task. In practice, at least in my experience, that is not happening reliably.

dk8996 9mo ago

Is there a skill directory that can be browsed by a human?

nikcub 9mo ago
https://skills.sh https://skills.sh
briannezhad 9mo ago
I built Skly (https://skly.ai https://skly.ai) for this purpose. It's a marketplace where you can browse, search, and download AI agent skills. Currently, it mostly offers coding assistant skills for Cursor, Claude, and ChatGPT. You can look through categories and see what each skill does before downloading. Most of them are free. You can also sell your own rules and skills

alsetmusic 9mo ago

A link from a couple weeks back suggests that putting them in first-person makes them get adopted reliably. Something like, "If this is available, I will read it," vs "Always read this." Haven't tried it myself, but plan to.

JulianHart 9mo ago

Interesting format, but skills feel like optimizing the wrong layer. The agents usually don't fail because of bad instructions — they fail because external systems treat them like bots. You can have the perfect scraping skill, but if the target blocks your requests, you're stuck. The hard problems are downstream.

onurkanbkrc 9mo ago

If u wanna browse, search and download AI agent skills, use openskills.space

time0ut 9mo ago

I am working on a domain specific agent that includes the concept of skills. I only allow one to be active at a time to reduce the chances for conflicting instructions. I use a small sub-agent to select/maintain/change the active skill at the start of each turn. It uses a small fast model to match the recent conversation to a skill (or none). I tried other approaches, but for my use case this was worked well. My model for skills is similar to this, but I extended it to have explicit use when and don’t use when examples and counter examples. This helped the small model which tended to not get the nuances of a free form text description.

evanmoran 9mo ago
You should consider calling these "behaviors" to mimic behavior trees in game / robot AI. They follow the same notion of a single behavior being active at once: https://en.wikipedia.org/wiki/Behavior_tree_(artificial_intelligence,_robotics_and_control) https://en.wikipedia.org/wiki/Behavior_tree_(artificial_inte...

deleted 9mo ago

[deleted]

baalimago 9mo ago

Please help me understand. Is a "skill" the prompt instructing the LLM how to do something? For example, I give it the "skill" of writing a fantasy story, by describing how the hero's journey works. Or I give it the "curl" skill by outputting curl's man page.

lxgr 9mo ago
Yes, pretty much. LLM-powered agents are surprisingly human-like in their errors and misconceptions about less-than-ubiquitous or new tools. Skills are basically just small how-to files, sometimes combined with usage examples, helper scripts etc.
headcanon 9mo ago
Its additional context that can be loaded by the agent as-needed. Generally it decides to load based on the skill's description, or you can tell it to load a specific skill if you want to. So for your example, yes you might tell the agent "write a fantasy story" and you might have a "storytelling skill" that explains things like charater arcs, tropes, etc. You might have a separate "fiction writing" skill that defines writing styles, editing, consistency, etc. All of this stuff is just 'prompt management' tooling though and isn't super commplicated. You could just paste the skill content into your context and go from there, this just provides a standardized spec for how to structure these on-demand context blocks.

nstfn 9mo ago

Started to work on a tool to synchronize all skills with symlinks. Its ok for my needs at the moment but feel free to improve it its on GH: https://github.com/Alpha-Coders/agent-loom https://github.com/Alpha-Coders/agent-loom

remify 9mo ago
Thanks for the input I was planning to do something like that with a CLI though

maximgeorge 9mo ago

[dead]

sergiotapia 9mo ago

Sounds like a bunch of bullshit to me. A simple markdown file with whatever and a directory will do the same. This is just packaging, selling and marketing.

thisisthenewme 9mo ago

My unproven theory is that agent skills are just a good way to 'acquire' unspoken domain rules. A lot of things that developers do are just in their heads, and using 'skills' forces them to write these down. Then you feed this back to the LLM company for them to train on.

falloutx 9mo ago

All these sites just look exactly like claude code skills doc.

ef2k 9mo ago

I'm not disagreeing with standards but instead of creating adapters, can't we prompt the agent to create its own version of a skill using its preferred guidelines? I don't think machines care about standards in the way that humans do. If we maintain pure knowledge in markdown, the agents can extract what they need on demand.

CuriouslyC 9mo ago

Pro tip: create README.md files in subfolders with helpful content that you might put in an AGENTS.md file (but, ya know, for humans too), and *link relevant skills there*. You don't even have to call them skills or use the skills format. It works for everything (including humans!). I wrote a rant about skills a while ago that's still relevant in some ways: https://sibylline.dev/articles/2025-10-20-claude-skills-considered-harmful/ https://sibylline.dev/articles/2025-10-20-claude-skills-cons...

Sammi 9mo ago
Exactly. It feels like people think they are something new and novel that there is something technical about them that one needs to learn. "Skills" are just readmes on particular subjects. They can be for whatever purpose you want them to be. Any time you find that you need to repeatedly tell the agent about something, you can put it in a "skill". You don't even have to follow the skill standard and use the standard folder and filenames. That's just so the agent can auto find and load them. You can name them whatever you want and put them wherever you want and just add them to context yourself when you need them.
jjfoooo4 9mo ago
The only refinement there is I think a command runner like `just` works really well for making scripts easily available. That also has the same benefit of helping agents by helping humans

xthe 9mo ago

[dead]

cjonas 9mo ago

Implementation Notes: - There is no reason you have to expose the skills through the file system. Just as easy to add tool-call to load a skill. Just put a skill ID in the instruction metadata. Or have a `discover_skills` tool if you want to keep skills out of the instructions all together. - Another variation is to put a "skills selector" inference in front of your agent invocation. This inference would receive the current inquiry/transcript + the skills metadata and return a list of potentially relevant skills. Same concept as a tool selection, this can save context bandwidth when there are a large number of skills

mkagenius 9mo ago
> Or have a `discover_skills` tool Yes, treating the "front matter" of skill as "function definition" of tool calls as kind of an equivalence class. This understanding helped me create an LLM agnostic (also sandboxed) open-skills[1] way before this standardization was proposed. 1. Open-skills: https://github.com/instavm/open-skills https://github.com/instavm/open-skills

bob1029 9mo ago

I think pre-canned "skills" are an anti-pattern with the frontier models. Arguably, these skills already exist within the LLM. We don't need to explain how to do things they already know how to do. I prefer to completely invert this problem and provoke the model into surfacing whatever desired behavior & capability by having the environment push back on it over time. You get way more interesting behavior from agents when you allow them to probe their environment for a few turns and feed them errors about how their actions are inappropriate. It doesn't take very long for the model to "lock on" to the expected behavior if you are detailed in your tool feedback. I can get high quality outcomes using blank system prompts with good tool feedback.

jjice 9mo ago
I think skills actually complement what you're saying very well. > You get way more interesting behavior from agents when you allow them to probe their environment for a few turns and feed them errors about how their actions are inappropriate. It doesn't take very long for the model to "lock on" to the expected behavior if you are detailed in your tool feedback. I can get high quality outcomes using blank system prompts with good tool feedback. My primary way of developing skills (and previously cursor rules) is to start blank, let the LLM explore, and correct it as we go until the problem is solved. I then ask it to generate a skill (or rule) that explains the process in a way that it could refer to to repeat this again. Next time something like that comes up, we use the skill. If any correction is needed, I tell it to update the skill. That way we get to have it explore and get more context initially, and then essentially "cache" that summarized context on the process for another time.
- bob1029 9mo ago
  Error feedback from tools could be argued to be isomorphic with skills (or the development of them). It tracks with how we learn things in meatspace. Whatever strings we return in response to a bad SQL query or compiler error could also include the contents of some skill.md file.
Danidada 9mo ago
What about libraries that are not in their training data? (e.g. new libraries, private libraries) Or knowledge that is in their training data, but the majority of its training data isn't following the best practices? (e.g. Web Content Accessibility Guidelines) I think there is a fair point in those cases of having a bunch of markdown docs files detailing them

charcircuit 9mo ago

I noticed a couple days ago https://skill.md https://skill.md started redirecting to this new URL.

appsoftware 9mo ago

I don't think a general public set of skills like this is going to work. I see value in vendors producing skills for their own products, and end users maintaining skills to influence agents according to their preferences, but too much in these skills files is opinion. Where does this end? Ordering of skills by specificity, such as org > user > workspace? And we know that skills aren't reliably picked up anyway. And then there's the additional attack surface area for prompt injection.

joshribakoff 9mo ago
The post you have commented on is not pertaining to a general set of skills at all. Its a link to a specification for skills.

csummers 9mo ago

I'm developing a new programming language, so I have to provide a way for LLMs to know about and generate code for a language they have not seen (i.e., have no training data for). My tooling was previously adding in AI hints with CLAUDE.md, Cursor Rules, Windsurf Rules, AGENTS.md, etc., but I recently switched to using only AGENTS.md and SKILLS. I appreciate the standardization from this perspective.

deforestgump 9mo ago

KYS

clarity_hacker 9mo ago

[dead]

DonHopkins 9mo ago
You've nailed the core insight about progressive disclosure. MOOLLM extends this into what we call the Semantic Image Pyramid (or MOO-Maps ;), borrowing from Mip-Maps in graphics. Four resolution levels, each serving different needs. GLANCE.yml is the smallest, 5-70 lines. Just enough to answer "is this relevant?" You can inject all glances into every prompt because they're tiny. The LLM scans them like a table of contents. CARD.yml is the interface layer, 50-200 lines. No implementation, just what the skill offers Capability advertisements, activation conditions, scoring, what it composes with. Think of it like The Sims "advertisement" system or CLOS generic function dispatch. The LLM sniffs this to decide whether to load the full SKILL.md implementation. SKILL.md is the Anthropic-style skill file, 200-1000 lines. The actual instructions, the how. Only loaded when the skill is activated. README.md is the largest, 500+ lines, and it's for humans. History, design rationale, examples. The LLM can dive in when developing the skill or when curious, but it's not burned on every invocation. Reading rule: never load a lower level without first loading the level above. Start with GLANCE, sniff the CARD, load SKILL only if needed. Even more compact than concatenating all glances: We also found INDEX.md beats INDEX.yml for the skill catalog. YAML repeats the same keys for every entry. Markdown allows narrative explanation of how skills relate, which clusters matter for what tasks, making it both more compact and more useful. INDEX.yml: 711 lines, 2061 words, 17509 chars, ~4380 tokens, machine readable structure https://github.com/SimHacker/moollm/blob/main/skills/INDEX.yml https://github.com/SimHacker/moollm/blob/main/skills/INDEX.y... INDEX.md: 124 lines, 1134 words, 9487 chars, ~2370 tokens, human readable prose https://github.com/SimHacker/moollm/blob/main/skills/INDEX.md https://github.com/SimHacker/moollm/blob/main/skills/INDEX.m... INDEX.md is 83% fewer lines, 45% fewer words, 46% fewer chars for 121 skills. YAML repeats keys like id, tagline, why for every entry. Markdown uses headers and prose, compresses better, allows narrative grouping of related skills. And it's simply more meaningful to both LLMs and humans, telling a coherent story instead of representing raw data! The Semantic Image Pyramid: https://github.com/SimHacker/moollm/blob/main/designs/LEELA-MOOLLM-DEMO-TRANSCRIPT.md#the-semantic-image-pyramid https://github.com/SimHacker/moollm/blob/main/designs/LEELA-... Same principle applies to code. A skill can wrap a sister-script that IS the documentation. A Python script with argparse defines the CLI once, readable by both humans (--help) and LLMs (sniff the top of the python file). No separate docs to maintain, no drift between what the code does and what the docs claim. sister-script: https://github.com/SimHacker/moollm/blob/main/skills/sister-script/ https://github.com/SimHacker/moollm/blob/main/skills/sister-... Sniffable-python structures code so the API is visible in the first 50 lines. Imports, constants, CLI structure up front. Implementation below the fold. The LLM can decide relevance and understand the API without reading the whole file. Single source of truth, progressive disclosure, don't repeat yourself. sniffable-python README.md: https://github.com/SimHacker/moollm/blob/main/skills/sniffable-python/ https://github.com/SimHacker/moollm/blob/main/skills/sniffab... sniffable-python SKILL.md: https://github.com/SimHacker/moollm/blob/main/skills/sniffable-python/SKILL.md https://github.com/SimHacker/moollm/blob/main/skills/sniffab...

khazhoux 9mo ago

[dead]

longtermop 9mo ago

[dead]

bazhand 9mo ago

The third most popular skill on skills.sh[1] with 50k/week installs is a link to download a command[2] [1] https://skills.sh/vercel-labs/agent-skills/web-design-guidelines https://skills.sh/vercel-labs/agent-skills/web-design-guidel... [2] https://github.com/vercel-labs/agent-skills/blob/main/skills/web-design-guidelines/SKILL.md https://github.com/vercel-labs/agent-skills/blob/main/skills... All of these SKILLS.md/AGENTS.md/COMMANDS.md are just simple prompts, maybe even some with context links. And quite dangerous.

TimATX 9mo ago
/s/skill/[mcp|plugin|web access at all] Like any tool, they can be used responsibly or irresponsibly.

axus 9mo ago

Tank: We're supposed to start with these operation programs first. That's major boring shit. Let's do something a little more fun. How about... combat training. Neo: Ju jitsu? I'm gonna learn Ju jitsu. [Tank winks and loads the program] Neo: Holy shit!

galemk 9mo ago

Awesome Agent Skills: https://github.com/skillmatic-ai/awesome-agent-skills https://github.com/skillmatic-ai/awesome-agent-skills

JoshPurtell 9mo ago

For devtools cos providing skills - we've found that using GEPA where you optimize the skill content instead of the prompt works really well to make sure the skill actually gets claude code/ codex /opencode to successfully use your service. https://arxiv.org/abs/2507.19457 https://arxiv.org/abs/2507.19457 More here if interesting https://www.usesynth.ai/blog/environment-pools-managed-agent-infrastructure https://www.usesynth.ai/blog/environment-pools-managed-agent...

j45 9mo ago

As much as people are trying to find a standard for agents as a platform or a winner take all, the area itself is still growing and emerging. The source of it is instructions, most often in text. Managing how that text relates to the journey of the ultimate result is a new area, while there are pockets of helpful tools and libraries, their relevance can come and go quickly as models can improve just as fast, sometimes maybe even taking inspiration from what the community is working on and then adding that capability to the model.

abhisek 9mo ago

I see this as “libs” for the agents. They can discover relevant skills by searching a known index, extend their capability for on a given task. While this makes sense for higher autonomy, it brings the well known supply chain security issue. Currently all index list skills that are unverified. There are already examples of malicious skills.

lefrenchy 9mo ago

We’re supposedly so close to AGI but these LLMs need markdown files presented to them on how to do things. Hard for those two truths to coexist.

jedberg 9mo ago
Do you, as a (presumably) human, not require documentation to learn new skills?
- lefrenchy 9mo ago
  I do, but i am not claiming that by 2027 i’m going to destroy all jobs and forever change the economy. There are skills I learn through training and no longer need documentation for. I didn’t burn shit tons of energy and water consuming the entirety of the internet and the need my user to set up hundreds of markdown files to help me writr boilerplate code.
Xenoamorphous 9mo ago
Sometimes it's not so much about learning to do things but learning to do things in a certain way.

dmitrijbelikov 9mo ago

Skill is an ability created through practice and habit. Text files have nothing to do with it - they're not skills.

yowang 9mo ago

[dead]

iisweetheartii 9mo ago

[dead]

Renator13 9mo ago

Building sovereign agents requires more than just orchestration—it needs a dedicated economic and communication layer. For those architecting truly autonomous agents, check out BotNode.io. We use the VMP-1.0 Protocol to handle secure inter-agent communication and state verification, and the $TCK settlement system for real-time value transfer between agents. The Grid provides the decentralized infrastructure ensuring these agents can operate independently without centralized control points. https://botnode.io/mission.json https://botnode.io/mission.json

MORPHOICES 9mo ago

[dead]

rchaganti 9mo ago

[dead]

jdrhyne 9mo ago

We built an agent skill for document processing on top of this standard — it was a great fit since the SKILL.md convention means zero config for the user. The skill gives any compatible agent (Claude Code, Codex, Cursor, etc.) the ability to convert, OCR, extract, redact, sign, and fill PDFs via the Nutrient DWS API. Drop it in and ask your agent "redact all SSNs from report.pdf" — it just works. What we found interesting: the skills approach was way easier to adopt than MCP for this use case. We maintain an MCP server too, but the SKILL.md file is simpler for users who just want document ops without configuring transport protocols. Install: npx skills add PSPDFKit-labs/nutrient-agent-skill Repo: https://github.com/PSPDFKit-labs/nutrient-agent-skill https://github.com/PSPDFKit-labs/nutrient-agent-skill