skills: Composable AI Agent Skills for Real Engineering Work

Fri, 07 Aug 2026 10:00:00 +0100

Every time I opened a new project with a coding agent, the first ten minutes were the same. It would guess at the architecture from file names, wander into the wrong directory, and confidently explain a data flow that didn’t exist. I’d correct it, point it at the real entry points, and slowly walk it through how the thing actually worked.

Then I’d close the laptop, open a different repo the next day, and do it all again.

At some point I realized I wasn’t giving instructions. I was giving the same instructions, on repeat, to something that forgets between sessions. So I stopped repeating myself and started writing it down.

Introducing skills

skills is a small collection of AI agent skills for real engineering work. A skill is just a packaged set of instructions and workflows an agent can reach for when a task fits, so you’re not re-teaching the same craft every time.

The collection is deliberately small. I’d rather ship a handful of skills that each solve one real problem than a sprawling framework that tries to do everything and does none of it well.

The one that started it all

The headline skill is learn-codebase, and it exists because of those repeated ten-minute onboarding sessions.

Drop it into an unfamiliar repo and it does what I used to do by hand: detect the stack, trace the code end to end, and map the architecture, modules, data flow, conventions, and the real build/run/test commands. Then it leaves a docs/CODEBASE_OVERVIEW.md behind so the next session, human or agent, starts with a map instead of a guess.

But here’s the part I like most, and the thing I didn’t fully appreciate until I was using it:

learn-codebase gets smarter the more skills you have installed. Before it analyzes anything, it looks at which skills you already have and reaches for the ones that fit this repo’s stack. Land in a Swift project and it pulls in the Apple-focused skills. Land in a TypeScript one and it reaches elsewhere. The toolbox shapes the analysis. Your setup makes it better.

What’s in the box

Alongside learn-codebase are three focused tools, each born from a specific frustration:

apple-app-ship - Shipping an Apple app spans architecture, polish, a marketing site, App Store screenshots, and submission. Each is its own specialty. This skill orchestrates the whole workflow, checking for and delegating to the right companion skill at each phase instead of re-teaching everything.
terminal-screenshots - Hand-recorded terminal GIFs drift and look inconsistent. This uses VHS .tape scripts so your terminal demos are reproducible and re-runnable in CI. The README GIF stops being a chore.
podman-browser - A plain HTTP fetch returns empty markup on JavaScript-rendered pages. This renders the page headlessly in a Podman + Playwright container and hands back the real text or HTML.

None of them are trying to be clever. They each do one annoying thing reliably, which is exactly what I want from a tool.

Small and composable, on purpose

There’s a design decision running through all of this: these are small, composable skills, not a framework.

Skills split on one axis, who can invoke them. User-invoked skills run only when you ask for them by name; their job is usually to orchestrate. Model-invoked skills can be reached for automatically by the agent when the task fits, or triggered by you. learn-codebase and apple-app-ship are model-invoked, so you can either say “use the learn-codebase skill on this repo” or just ask for an overview and let the agent reach for it.

That composability is why the collection can stay small and still get more useful over time. Each skill is a building block. learn-codebase is the clearest example, it literally treats your other installed skills as its toolbox.

Installing it

Two ways in, two philosophies.

The Claude Code plugin installs the set as a managed bundle that updates when the repo ships. You subscribe rather than fork:

/plugin marketplace add ricardodantas/skills
/plugin install ricardodantas-skills@ricardodantas-skills

Or use skills.sh, which copies editable skill files into your project so you can hack on them and make them your own. Works with Claude Code, Codex, and other agents:

npx skills@latest add ricardodantas/skills

Then, in your agent, just mention a skill by name: “Use the learn-codebase skill to give me an overview of this repository.”

Why I published it

I’ve contributed to open source for years, but most of my agent instructions lived in scattered notes and half-remembered corrections. Packaging them forced me to be honest about what actually worked versus what I only thought worked. Writing a skill is a bit like writing documentation: you find out how well you understand something the moment you have to explain it to someone who takes you literally.

And an agent takes you very literally.

The other reason is simpler. I built these to solve my own problems, which almost certainly means someone else has the same problems. If learn-codebase saves you those repeated ten-minute onboarding sessions, or terminal-screenshots kills one more manual chore, that’s the whole point.

What’s next

I want to keep the collection small and let it grow only when a real, repeated frustration justifies a new skill, the same bar that produced these four. I have a couple of candidates already, but I’m resisting the urge to scaffold for a future that hasn’t asked for anything yet.

If you try it, I’d genuinely love your feedback. Issues, pull requests, and new skill ideas are all welcome, and if you’ve read my last post about ratatui-themes, you already know the first thoughtful issue tends to be my favorite part.

Check it out: GitHub | skills.sh

Go teach your agent something once. 🛠️

Ai on Ricardo Dantas