If you ran ls ~/.claude/skills on my Mac right now, you would count 35 folders. That number is the problem, not the flex. I have installed, written, and abandoned enough Claude skills over the past year, including the 53 I built and documented for my own agent skills marketplace, to know that most skill collections are junk drawers. The skills that survive are not the cleverest ones. They are the ones that hand work to each other.
That is my actual thesis after a year of this: a skill on its own is a saved prompt. A skill that receives output from one skill and produces input for another is a workflow. Nine of my 35 earn their place that way. This post is the nine, in the order work actually flows through them.
Why Most Skill Stacks Fail Within a Month
Every listicle tells you to install ten skills. Almost nobody tells you the failure mode: you install ten skills, use three once, and within a month you cannot remember which ones exist. The skill triggers on the wrong prompts, or never triggers, and you quietly go back to raw prompting.
The fix is structural. A skill earns permanent residence in my ~/.claude/skills directory only if it satisfies one of two conditions:
- It sits on a seam in my workflow, where one kind of work becomes another kind of work (an idea becomes a spec, a spec becomes issues, a diff becomes a review).
- It writes something down that a future session will read.
Everything else gets deleted at the end of the month. That rule took me from a junk drawer to a pipeline.
The Interrogation Layer: Skills That Refuse to Start Coding
1. grill-me
The single highest-leverage file in my entire setup is 12 lines long. grill-me interviews me relentlessly about a plan before any code exists, one question at a time, walking down each branch of the decision tree. The line in the skill file that does the real work is this one:
If a question can be answered by exploring the codebase, explore the codebase instead.
That sentence is the difference between an AI that quizzes you and an AI that does homework before asking. Half of my "requirements" turn out to be things the repo already answers. The other half are decisions I had not realized I was avoiding.
2. to-prd
When the grilling ends, to-prd converts the conversation into a PRD without asking me anything else. The skill explicitly forbids further interviewing: it synthesizes what the session already knows, sketches the modules to build, and pushes for deep modules, meaning a lot of functionality behind a simple, stable interface. Then it publishes the PRD to my issue tracker with a ready-for-agent label so any future session, or any parallel agent, can pick it up cold.
3. to-issues
to-issues slices the PRD into vertical slices, thin end-to-end paths through the feature rather than horizontal layers. This matters more with agents than with humans, because an agent given "build the database layer" will invent an API contract that the real UI never asked for. An agent given "a user can archive one post and see it disappear" cannot drift far.
The Build Layer: Skills That Touch Code
4. tdd
My tdd skill enforces red-green-refactor, and its most valuable content is a prohibition, written in bold in the skill file: do not write all tests first, then all implementation. That is horizontal slicing wearing a TDD costume, and it is exactly what a model does when left alone, because generating 30 tests in one breath feels productive. The skill also encodes a test philosophy I had to learn the expensive way: test behavior through public interfaces, never implementation. If a rename breaks your tests but behavior did not change, the tests were testing the wrong thing.
5. improve-codebase-architecture
This is the skill I run when the pipeline loops back on itself, usually after three or four features have accreted in one area. It hunts for shallow modules and proposes consolidations. Models are strangely reluctant to refactor their own output without an explicit mandate; this skill is the mandate. I wrote up the full pipeline these five skills form in the 5-skill engineering pipeline I run if you want the end-to-end version with timings and failure modes.
The Continuity Layer: Skills That Fight Amnesia
6. handoff
Long features do not fit in one session. handoff writes a structured summary of state, decisions, and next steps before I close a session, so the next session starts warm instead of re-reading the repo from scratch. It is the cheapest fix I know for context bloat, and it pairs with the memory pattern in skill nine.
7. skill-creator
The meta-skill. skill-creator does not just scaffold new skills, it evaluates them: you write test prompts, run Claude-with-the-skill against them, and benchmark whether the skill actually triggers and actually helps. Building 53 marketplace skills taught me that the description field is 80 percent of a skill's quality, because a skill that does not trigger might as well not exist. I documented my testing routine separately in how I test Claude skills before they break my workflow.
The Domain Layer: Where Skills Meet Your Actual Job
8. The seo-* suite
Thirteen of my 35 folders sit in the seo family: audit, content, schema, hreflang, sitemap, technical, programmatic, and more. I am not suggesting you install an SEO suite. I am suggesting you look at whatever the 13-folder cluster would be in your work, the domain where you repeat judgment calls weekly, and encode it. This site runs on Laravel with six locales and eight sitemaps; the suite exists because I got tired of re-explaining my own stack every session. Your version might be contracts-* or etl-*. The pattern is the point.
The Pattern That Makes All Eight Compound
9. learnings.md
The ninth item is not a skill file. It is a habit the other eight feed: every time a session teaches me something non-obvious, a gotcha, a command that behaves unexpectedly, a wrong assumption, it gets appended to a markdown memory file the next session will read. Mine records things like "composer test runs PHPStan here, not PHPUnit" and "cache config after every .env edit on prod." None of those are in any documentation. All of them cost me real time once, and only once.
This is the compounding mechanism. Skills without memory give you the same good session forever. Skills plus a learnings file give you a system that is measurably better in month three than in month one. It is also the seed of something bigger; when I scaled the same idea up to routines, dashboards, and scheduled agents, it became a full AI operating system.
How the Nine Connect on a Real Week
A feature idea enters through grill-me on Monday. to-prd and to-issues turn it into five vertical slices by lunch. tdd builds them across the week, with handoff bridging sessions. improve-codebase-architecture runs when the diff gets ugly. The seo-* suite handles the publishing side of my week. skill-creator maintains all of the above. And learnings.md quietly collects the tuition I already paid so I never pay it twice.
Notice what is missing: no "summarize this article" skill, no novelty. Boring seams, reliably connected, beat clever one-offs every time. If you are earlier in the journey, start with the plan-first strategy before installing anything, because skills amplify a workflow; they cannot substitute for one.
Where to Get the Skills Themselves
Several of the nine are my own builds and several came from the community, then got edited until they matched how I work, which is the step everyone skips. I publish the skills I build, with install instructions and the SKILL.md source, in my agent skills marketplace. Browse the 53 that are live, steal the ones that sit on your seams, and delete the rest at the end of the month. That last part is not a joke. It is the whole system.
