Four skills we reach for every week
A skill is a folder of instructions an agent loads when a job matches.
There are a lot of them now. These are the four that come off the shelf every week in our own work, across video projects, client sites, and the code behind them. None of them are exotic. Each one changes what the assistant does on the first try.
Graphify: a map of the codebase
Big projects with a lot of media and data attached get hard to hold in your head, and harder for an agent to search.
Grep finds a word. It does not tell you what calls what, or how a request travels across twelve files before it becomes a render. Graphify builds that map once: the architecture, the call flow, the places a function is actually used. Questions get answered from the map instead of from a pile of search hits.
It keeps its work in a graphify-out/ folder inside the project. The next time you open the repo, query that folder first. The map is already there.
Reach for it when you are onboarding to an unfamiliar or large repository, when the question is "where does this get used," and before any refactor that touches more than one file. The habit that makes it pay off: run it before you ask, not after the agent has guessed wrong twice.
Ponytail: the laziest solution that works
Agents like to build. Left alone on a small task, one will add a configuration layer, a helper module, and a dependency you did not ask for.
Ponytail is a discipline skill for any coding task. It holds the agent to the laziest solution that works: you are not going to need it, the standard library or something already installed before new code, the shortest diff that fixes the thing, and as little prose as possible around it.
It is probably useful for most people, not only developers. The same instinct that over-builds code over-builds spreadsheets, scripts, and automations. Reach for it on every coding task, and especially the moment an agent starts proposing architecture for a bug fix.
Frontend-design: choices, not defaults
Ask an assistant for a website and you get the website everyone gets.
The same hero, the same three cards, the same gradient. Frontend-design is the skill we use whenever we build new interface or reshape an existing one. It pushes for a real aesthetic direction, deliberate typography, and decisions that belong to the project instead of to the template.
We use it for client websites, and for something fewer people think about: a website as a presentation. A breakdown for a client or a new marketing strategy can live in one responsive, animated HTML file you send ahead or pull up in a browser and walk through in the room. That idea gets its own breakdown: a website as a presentation.
The habit: give it the real content and the real audience before it draws anything. Design made for placeholder text comes out looking like placeholder text.
Deep research: an afternoon of reading in one brief
This one is simple, and most casual users never turn it on.
The output is only as good as the brief. Tell it the scope, the sources to prefer or avoid, and the decision the research feeds. A brief we actually use:
Research: local video generation on a single workstation, October 2026.
Scope: open models that run on one GPU with 24 GB or less.
Prefer: model cards, official repos, benchmark write-ups with methods.
Avoid: launch-day demos, posts without sources.
Decision it feeds: whether we add a local step to our shot pipeline
this quarter, or keep generation in the cloud.
Deliver: one page, trade-offs first, sources inline.| Skill | What it gives you | Reach for it when |
|---|---|---|
| Graphify | A map of the code: architecture, call flow, where things are used | A large or unfamiliar repo, before a refactor |
| Ponytail | The smallest change that works, no new dependencies | Every coding task, especially when an agent over-builds |
| Frontend-design | A direction, typography, and choices that fit the project | New interface, a site, a web presentation |
| Deep research | A sourced report from many sources at once | Anything that would take an afternoon of reading |
Research mode takes a question, fans out across many sources with several subagents working at once, and comes back with a sourced narrative report instead of a list of links. Anything you would otherwise spend an afternoon reading about belongs here: a new tool category, a market, a technical decision with real trade-offs.
The fifth habit: ask for a handoff
Not a skill, a request, and the one power users lean on most.
When a conversation gets long or needs to move to another chat, another tool, or another machine, ask for a handoff: a document the project writes and keeps updated for itself, so the next thread starts with everything and none of the junk. It has its own breakdown: asking for a handoff.
Where these come from
All four ship as skills in Claude's skill catalog, written in the open Agent Skills format, the same SKILL.md folder a growing list of agents can read.
You can study the public examples, adapt them, or write your own for a process you repeat.
Do this today
Pick the one closest to your work.
If you write code, turn on ponytail for a week and watch the diffs shrink. If you build anything visual, run frontend-design on your next page with the real copy in hand. If you are deciding something, write a research brief in the shape above and let it run while you make coffee.
Resources
Every link this breakdown leans on, in one place.