How do you manage skills files?

Join the discussion

• Hacker News
• I commit them to git(so complete team leverages them)., each repo has kind of different skills and the skills are the ones which I update at least twice a week. I’ve skills on how to add instrumentation , debug, code, code review, tech design review etc. I found most of the skills I find on skills.sh are not very useful for me., but I browse occasionally to get some inspiration. One more paradigm I’m seeing good results on adding new skills is ‘how to do X’, for instance ‘how to add logs’., “how to review code” etc., if i’m not able to frame it that way I don’t think it’s a good use case for me to add that skill to the llm arsenal.

  Another thing i discovered is less is more (in case of skills as well)., don’t add lots of skills., keep them very handful - I’ve got 9 skills so far (many people have 100s installed from marketplaces and plugins)

  by chandureddyvari
• Thats exactly how I use skills as well and I got great results with it. I work in a proprietary codebase with a lot of niche or custom tooling, weird technical details and historical quirks. What skills do for me, is essentially skip the "learning" phase of an agent working in the codebase. With a fitting skill the agent does not need to read the tooling docs, look at existing repos and learn the coding style, but it can get to work immediately.

  This is probably less relevant for code that exists a ton in the LLM training data already as an llm is probably competent to some degree in that anyway.

  A big caveat here is though that now you need to treat your skills repo very carefully as mistakes in there can easily spread to all of the new code you write using a coding agent.

  by floriangoebel
• Last week I had to reuse homemade skills on different project. I very much liked the AI proposed solution and it works quite well: ship as a plugin and add your git repo as a marketplace.

  The installation is effortless and I don't have to mess with symlinks as I may be working with same codebase on different platforms which would make things.. different.

    codex plugin marketplace add "https://path-to-my-git-repo"
    codex plugin add agent-tools@mycompany
  
    claude plugin marketplace add "https://path-to-my-git-repo"
    claude plugin install agent-tools@mycompany
  
  
  

  Let the AI generate .json files for marketplace.

  Haven't got to these bits yet, but I'm sure they will work as easy as install does.

    claude plugin marketplace update mycompany
    claude plugin update agent-tools@mycompany

  by jve
• After a brief 'collect-them-all' phase, I scaled back to skills I've hand-selected & created to help me run repeated processes.

  To keep me organized, here's the directory structure I use. So I don't have to think about it, I've created a skill for my skill folder that files any new skills in this structure as I add / ablate any that aren't useful.

     - `Discovery/` — Finding docs, searching, information retrieval
     - `Execution/` — Running processes, CI/CD, releases, deployments
     - `Planning/` — Goals, specs, tickets, threat models
     - `Tools/` — Reusable tool integrations (browser, notebooks, CLI creators)
     - `Debugging/` — Debugging, troubleshooting, fixing
     - `Expertise/` — (reserved) Domain-specific deep knowledge
  

  How skillshare helps: symlinks across agents, syncs to my GH, and for the few skills I've pulled in from other repos, it tracks and handles updates. Every couple of months I review which ones I don't use and remove them.
  by ryandsilva
• Surprised it has not been mentioned, but I think relying on https://github.com/vercel-labs/skills is sound. It handles global installs for a wide range of coding agents. If I was working on an internal only skill I'd probably still use the same foundation.
  by FailMore
• Great responses in this thread
  by agcat
• Get them under version control. I have a git repo with my skills for software development [1]. There is an installer script that symlinks to the skills. Updating the skills on a machine is then just a matter of advancing the git repo. One of the skills comes with some bash scripts, but the rest are effectively just prompts. Putting project specific skills in projects works well.

  I make sure they work by understanding every skill, reviewing pull requests, and testing the end product. The result is rarely perfect, so I am constantly tweaking the skills and how I use AI.

  [1] https://github.com/gregwebs/skills-sdlc/

  by gregwebs
• I don't use any skills, what kinds of skills are people finding most useful?

  For general tasks, the model seems perfectly capable of figuring out things itself, for project or environment specific tasks, I just put that information in the readme or agents.md file.

  by WatchDog
• For starters, if you repeat a specific prompt multiple times per day, you may save it as a skill.
  by nvch
• Well, for non-general tasks, of course. For example particular tooling that's required for the environment.

  I will often make a skill out of the docs for any of the frameworks or libraries that we're using but with which I'm unfamiliar. When I'm creating that skill, I focus on idiomatic implementation and usage. It's not enough for the code to work—I want it to work "with the grain" and "through the front door", as it were.

  By default, these models are just all too willing to reinvent the wheel and monkeypatch as they go.

  by gavmor
• I have a couple of skills with project-specific conventions for how to write a plan and how to write HTML-generating code. But they could probably just as well be .md files in a docs directory, linked to from the AGENTS.md file.
  by skybrian
• I use skills for offloading work onto subagents. By configuring the skill to use a specific model it gets enforced at the harness instead of depending on the good will of the orchestrating model to actually delegate. This also saves context.

  Today Fable had to fetch a zip file from a web page with a eula prompt, then get at a file in a disk image in the zip.

  This is something that will need to happen a lot as part of this project.

  I asked Fable for a skill/script combo suitable for Haiku to accomplish the task, and now that task happens at minimal cost during an analysis run.

  by dxjxjdjsssb
• Your agents.md is a good place for high level facts, but if you have something that requires a lot of info to explain (ie: if there is a complex build process, testing patterns, things like that), loading up your agents.md for every request may be a bad idea. Offloading that information to a skill ensures it's only included in the context if you're actually using it.
  by Zambyte
• So the term used internally is to make things "Determinishtic". I use skills extensively, combined with SOPs, scripts and MCP servers.

  An example skill I have is SessionMiner, which is installed via post session hooks in Claude and Kiro, and analyzes the session, what was accomplished, and whether or not it should be turned into a skill, then when it summarizes it, the decisions it came to and either fires off a message to me for followup if it decides a new skill or tool should be built, or it catalogues the approach so that future analysis can identify trends in how I use the tools.

  Over time it has built me a fairly decent stable of repeatable skills and tools, and highlighted process deficiencies and nominated process changes that I have pursued.

  Another skill is a communications analysis skill; I started using it summer last year I think, and it scans my communications across a broad cross-section of my activity online. It tracks the commitments I make, ensures that I follow up with people that I might miss, ranks and scores my communication against my own personal targets that I set to make sure that I am communicating effectively. As a person who has had a decently successful career despite autism spectrum and unmedicated ADHD (I was medicated, but unfortunately each medication I tried had adverse side effects), it has made me much more effective in tracking work and following through, especially on the "boring" stuff that is actually critical to being a dependable team member, and effective partner for the teams I support.

  Just a couple of examples.

  by ygjb
• I make skills for «this is how I like to do things in this company / project». Query test database, git branch names, commit message style, which cloud things can be inspected like logs etc. I don’t see the point in trying to teach the models things that is in the documentation of git, python, what have you. They already know.
  by pletnes
• Skills are encoding a process. The more niche the process the more useful the skill. As the process grows to a larger audience it becomes more generic and thus converges with the models knowledge. So skills are better for a smaller group of people. And similarly how it's packaged and maintained becomes specific to that group.
  by darren0
• First, a lot of people in thread are saying you don't need skills. This is pretty wrong. There is a lot of alpha in using any set of skills that implements SPACE (search, plan, assert, code, evaluate). See: https://open.substack.com/pub/theahura/p/agentics-using-meta...

  Second, we share all of our sets of skills in a purpose built registry: https://noriskillsets.dev/ you can use any of our public skillsets from there. If you're on a team you can also sign up to get your own private registry. Makes organization much easier.

  Finally, for local development, we use this CLI to manage skills (https://github.com/tilework-tech/nori-skillsets). This is a tool that lets you bundle skills into groups, and then switch between those groups. So for eg if I'm making a slide deck I'll use an admin skillset, and for coding I'll use a swe skillset, and for debugging I'll use a debugging skillset.

  We do keep tinkering with our skillsets, but not very much. I don't get the need to adjust things for every model release, doesn't seem necessary for us in practice

  by theahura
• Can you compare what you have built with superpowers?
  by kramer2718
• I'm building something similar with `Agents`[0] (think of it as a package manager for AGENTS.md snippets). I'm getting good results by including detailed instructions for certain tasks in the repo, and providing hints in AGENTS.md about when to use them. It's basically a simpler version of Skills—but it feels like AGENTS.md adherence is higher than Skill adherence.

  [0]: https://github.com/bensyverson/agents/

  by bensyverson
• - I don't find skills, I create them

  - Keep them organised in software repos that you install with symlinks for all coding harnesses that you have. Progressive disclosure based on the frontmatter does the rest.

  - I make sure they work with AI evals. Think of them like integration tests to prove behaviour. They're useful to optimize your flows. I try to make my skills be mostly a translation between natural language and good small fast tools that they call.

  - I change them as a new problem arises. Not just because.

  Skills can't be eaten by model capabilities if skills represent a workflow that is custom to my team or my person.

  I wrote about a good mental model in the past:

  https://alexhans.github.io/posts/series/evals/building-agent...

  by alexhans
• What about skills that you need across projects?
  by imadtaieber
• Big yes on this. I do not understand the appeal of skill shopping. The one exception I have is things like the Axiom Apple development skills and e.g. the official Flutter skills. At that point the skills are just docs though. It's either I remember to paste a URL to the official docs or I just install the skill. But shopping around for random skills just sounds extremely unappealing.
  by resonious
• People always say this about the evals, but I find it hard to have a practical implementation of such a thing where you won’t end up spending 100x the amount of time on the evals than building the skill itself.

  Like, ok, I have a debugging skill, now how do I make evals except for the most trivial things?

  by stingraycharles
• Skills are mostly snake oil, the way people use them (the aspiration to download kung foo from a celebrity).

  There was a time when maybe it mattered (last year), but with good repos and good prompts today's agents can find exactly what they need without any skills.

  "Skills" as developer macros can be useful, but at most those are things shared with the team (in the repo), not something you download from the internet. If you have so many skills that you feel the need to manage them, that's a code smell.

  by avaer
• Where they are very useful is as a documentation source for LLMs. For example, I work in infosec and often have to reference DSLs (Cobalt Strike aggressor script for example). Having a skill which is an offline index to carved up function docs, which an LLM can use without having to think, then search for, then download huge 1 page documents with all function documentation, and pollute the context… very useful.
  by xpnsec
• Yes, skills as a "portable power" isn't really the use case for me unless it's entirely generic and even then sparingly.

  I've mostly followed what anthropic suggests, which is putting less into context and more into skills, to keep the "how" out of context until it is needed to reduce context bloat.

  Skills have some instructions but are primarily informed repo specific instructions and keep their context away from the rest of the repo to keep things sanitised for me.

  I've found it to be useful in that context.

  by JauntyHatAngle
• Depends on what you do. If you work with proprietary tech that is not in LLM training data and can't easily be found on the internet, you're cooked without good skill files.
  by InsideOutSanta
• Agree. Good file management will be if not is already good enough.
  by wwei7
• > "Skills" as developer macros can be useful, but at most those are things shared with the team (in the repo), not something you download from the internet. If you have so many skills that you feel the need to manage them, that's a code smell.

  I have three development machines. You kinda need something like git to keep everyone in sync!

  And there's still value in encoding a process in a skill - it's way more token efficient to tell the model what but also HOW to do something. Otherwise, it just spends a lot of tokens figuring out something that they previously did already.

  by jaapz
• It's not about giving hints to agents because they wouldn't find it out otherwise. It's about saving the work of them having to find out. Good skills files save tokens.
  by misja111