Developers are increasingly faced with multiple options for the same task, which makes it harder to choose the right agent skill. More and more Agent Skills pop up, and they all have a great story on why you should use them. And honestly, most of the ones that I used worked great, but what if I find multiple ones with the same purpose?
I’m quite skilled in Agent Skills: I released multiple myself, and I’m actively creating an AI Fundamentals course. I know pretty well what to look at when evaluating new skills, but I also realize that this is a cumbersome process that needs guidance. That’s why I’m here to share you my process.
New Agent Skills arrive everyday
You open up your social feeds, and you get flooded with release messages on new Agent Skills. It might be my algorithm ;-), but it’s simply a fact. Agent Skills are still relatively new; not everybody knows how to use them, let alone how to build one yourself.
I’m personally active in the Swift development ecosystem and monitoring the skills there. Last week, we got a new SwiftUI Pro Agent Skill by Paul Hudson, and an iOS Accessibility Agent Skill by Daniel. In the related thread on X, Daniel mentioned two other accessibility agent skills worth checking out. Simultaneously, I was also asked whether Paul’s SwiftUI Agent Skill is complementary to mine. It made it clear to me that we need to educate ourselves on how to choose the right Agent Skill.
Why you should not just install every skill you encounter
Every Agent Skill you find looks like a little present. You can enhance your agents and become an expert on everything you want!
The reality is that it’s worth being thoughtful about which Agent Skills you install:
- What if the Agent Skill is not well maintained?
- What if the knowledge in the Agent Skill is wrong?
- What if you have multiple Agent Skills of the same type?
Some skills are complementary, but many can also bite each other. Agents are smart, but they could load multiple skills for the same purpose into your context, resulting in mixed expertise and wasted tokens. You could also end up with agents loading a skill for every task, even when the skill might not add much value for that specific task.
Altogether, I believe we need to consciously choose the skills we want to use and guard their quality as if we were hiring new employees on our team.
A 9-Step Framework for Choosing the Right Agent Skill
Altogether, I want to give you a step-by-step guide that should help you build a collection of personal favorite skills to become more productive in agentic development.
1. Start with the task you want help with
You might unexpectedly run into Agent Skills on socials, but sometimes you’re also purposely looking for a specific skill. If your task is building apps in Swift, you want to build a collection of skills related to Swift development. If you’re mostly doing web development, you’ll be looking for web-specific skills.
I like to start my journey by searching on skills.sh. For example, if you search for Swift Concurrency, you’ll find one of my skills. The detail page shows how valuable this first impression can be in your journey of choosing the right Agent Skill:
Before explaining each point, I want to emphasize that weekly installs and popularity says nothing about the quality of a skill (more on that later). However, they do give you a first checkpoint to decide whether or not you should dive deeper. We simply don’t have the time to evaluate all skills available, do we?
- Weekly installs shows whether the skill is used at all. It can indirectly tell you that it’s a well-known author, a skill that went viral, or just a first-mover advantage.
- The repository link will help us in future steps, to further analyze the details of the skill itself
- GitHub stars are overrated (no pun intended), but once again, it’s very unlikely low-quality skills will get high stars. Yet, high quality skills can also never be noticed, leaving them with little stars at moment of evaluation. Therefore, in my opinion, overrated. Don’t look blindly on these.
- When was the skill first released? Mostly just interesting information, you could argue that newer skills might even be better because of the latest knowledge. Nothing deal-breaking here.
- Security Audits are where you want to be critical. If these don’t pass, I would simply skip the skill right away. No time to waste on that!
Once these first signals look good for further exploration, you can click on the link at point 2 and continue your journey.
2. Understand opinionated vs non-opinionated skills
Agent Skills guide your agents into an outcome that follows the skill’s best practices. When skills are opinionated, you might suddenly end up with architecture decisions like MVVM, while you might believe we should stay away from view models completely.
It’s a common example, but my point is that you should be aware of the opinions in the Agent Skill. For example, the Composable Architecture by Point-Free is quite popular in the Swift development community. They’ve released their own Agent Skills to support this, but you only want to use these if you want to apply that architecture to your apps as well.
That’s why I always look carefully into the README of a skill, as well as the structure and reference files (more on that later).
3. Popularity does not guarantee quality
Picking an Agent Skill reminds me of picking a 3rd-party package for my apps. It’s tempting to look at a repository’s GitHub stars, and it’s true: they tell something. However, the repo could simply have been built by someone with a lot of reach; it could be an old repository, or it could have been a first-mover advantage. With the latter, I mean that a repo could go viral when there’s simply no alternative yet. At the moment of evaluation, it does not mean it’s the best pick for your task.
On the flip side, a repo could be of high quality, but the author simply isn’t good at marketing. Therefore, you should only look at the stars as guidance in your journey, but not as a deal breaker.
4. Look at the author and expertise
Even though many Agent Skills are likely built with or even by AI, it’s important to know who the author of the skill is. If they have matching expertise and high standards, they are more likely to produce high-quality work.
For example, I liked this section of the Marketing Skills:
Even though this is very much marketing itself, Corey did not hide himself. It shows that he’s active in the marketing ecosystem, that he offers complementary services, and that he educates on marketing elsewhere. This has been a clear green signal for me when I first encountered (and installed) this skill. Oh, and, this has been one of my favorite skills so far.
5. Inspect the structure of the skill
At this point, you’ve probably found a skill that’s either popular, well-structured on the surface-level, or built by someone you respect. You can decide to go all in and install it, but there are more steps to take.
A skill is built from an entry SKILLS.md file, which guides agents to specific reference files for the task at hand. For example, our SwiftUI SKILLS.md file includes a clear decision tree and reference files for specifics like Liquid Glass or SwiftUI Performance. The quality of these files impact how well your agents perform.
For example, if an Agent Skill’s SKILLS.md isn’t properly structured or bloated with unrelated context, it can fill your agent’s context with unnecessary details. If all the knowledge is placed inside the skills file, it’s also likely to give your agent unrelated knowledge for the task at hand.
You need to understand that you want to give your agents the minimum required knowledge to get the best possible outcome for the task at hand. Anything unnecessary will fill your task context and increases chances of an outcome that does not match your standards.
6. Evaluate reference files and context usage
Related to this are so-called reference files. The SKILLS.md guides an agent into a specific reference file. In the above example, it could be that I prompt my agent:
Use the /swiftui-agent-skill to improve the performance of
@SideWindowView.swift
What will happen:
- The agent explores the Agent Skill
- It reads the
SKILLS.mdand finds guidance on SwiftUI performance - It finds out that a dedicated reference file exists for performance and uses that for best practices
It only reads into that performance reference file, or at least, in most cases. Some skills require loading a specific reference file every time, regardless of the task. Or, it could guide you to skip reading into any reference file. For example, my Swift-Concurrency skill comes with a Quick Fix Mode.
My point is that you want to verify whether the Agent Skill is properly structured with single-responsibility reference files. If so, you’re good to continue.
7. Maintenance matters most
Just like with 3rd-party dependencies, you want to make sure a repo is well-maintained. If you see many open issues, PRs without attention, and no releases available, you could argue that it’s better to look for a project with better maintenance.
If there are no issues or PRs open, it says nothing. An Agent Skill could either be evergreen, not requiring much maintenance, or it could just be a skill that’s already at a high quality level.
8. Test skills individually
You could end up with multiple high-quality skills for the same task. At that point, I’d recommend testing each one and picking your personal preference. Monitor each skill’s repo over the coming weeks and see if there’s a clear winner that matches your preference.
I personally try to install one Agent Skill per domain, since you don’t want an Agent picking up multiple skills for the same job. It will fill your context with duplicate knowledge, and might only confuse your agents. Instead, I install one skill at a time, test it out, and eventually make sure I only have one of the two/three/four/etc. installed.
9. Judge the results, even after picking a winner
This is the point where I see many go wrong. They install the skill and never look back. Updating Agent Skills is often a manual job, but it’s way less visible than project dependencies. At the same time, it’s also important to keep validating the quality of your skills. It could be that a project was well-maintained and up to date at the time of installation, but if it’s not updated with the latest best practices, you will push your agents to use old-style best practices.
So even after picking a winner, it’s important to revisit your skills. Just like you would periodically review the quality of your employees 😉
Conclusion
Agent Skills are a true blessing for all who work with agents. Choosing the right Agent Skill is difficult, but with the steps from this article, you should be able to guard the quality of your personal collection of skills. The great thing about Agent Skills is that they’re built by people across the community, each bringing their own expertise and perspective. Exploring different approaches is often the best way to learn what works best for your workflow.
Picking Agent Skills is part of AI Fundamentals, and I’d love to welcome you to my dedicated course: Agentic coding fundamentals for developers.
See you there?