Simple wins. Always. Because it is very composable, fun to work with, and organically evolves.
LLMs are great at language and text, but they don’t know how to do anything, so they rely on something running (e.g. a server) and listening to their output. If the output is formatted in a certain way, say:
sum(41, 1) |
the server / listener can convert it to code, call a “sum” function and return 42:
In this particular case we would say that LLM has a “sum” tool. And the LLM would have a prompt similar to this one where it would identify that two numbers need to be added from the user’s prompt, and would “call a tool” with “sum(41, 1)“.
But that was a few years ago, where we would beg LLMs to call a tool and return the response in JSON pretty please. And sometimes it would even work, and sometimes it would not.
Fast forward to now, we have Tools, MCP, Agents, LSP, + many more acronyms. Plus LLMs are much better at following our “please JSON” begging.
However, one capability, one discovery and innovation in this field stands out: Skills. The reason it stands out is because, compared to all the hype and acronyms, Skills are… simple.
Just a Directory
A Skill is effectively a directory. That’s it.
It doesn’t require a complex registration process or a heavy framework. It requires a folder, a markdown file, and maybe a script or two. It relies on a standard structure that the Agent (current fancy name for a “piece of code that calls LLM”) knows how to traverse.
This simplicity lowers the barrier to entry significantly. The best way to learn something is to do it, hence I needed a problem to solve.
The “Dad” Problem
My kids are navigating the ways of middle/high school: one is deep in ionic bonding in Chemistry, another one is grappling with graphing sine waves in Pre-Calculus.
I can explain these concepts to them with words, or I can scribble on a napkin (which I love doing), but some concepts just need to move. They need to be visualized. I could write a Python program or a D3.js visualization for every single problem, but that takes too long, even when done directly with “the big 4“.
I needed a way to say: “Show me a covalent bond in H₂O” and have the visualization write itself, test itself, run itself, and show me that interactive covalent bond moving step by step.
Great fit for a “Skill” I thought and built salvador that can do this:
> /visualize a covalent bond in H₂O |
Salvador… Who?
Salvador is an Anthropic Skill (but I hear others are adopting skills as well) that lives in my terminal. Its job is to visualize physics, math, or any other Universe concepts on demand.
The beauty is in the organization and progressive disclosure. The Agent doesn’t load the entire “visualization knowledge base” into its context window at once, like it did with MCP. It discovers the skill via metadata and only loads the heavy instructions when I actually ask for a visualization.
Here is what it looks like on disk:
salvador/ ├── SKILL.md <-- the brain ├── scripts/ <-- the hands │ ├── inspect.js │ └── setup.sh └── templates/ <-- the scaffolding └── visualization.html |
The Brain (SKILL.md)
This is the core. It uses a markdown format with YAML frontmatter. But inside, it’s not code – it’s a codified intent. It defines the flow: analyze the ask, divide and conquer, plan the steps / structure, code the solution, verify the result, go back if needed, etc.
The Hands (scripts/)
An agent without tools is just a chatbot. For salvador to work, it needs to “see” what it created.
A small script, inspect.js, that lives inside, spins up a headless browser. When the Agent generates a visualization, it doesn’t “hope” it works. It runs inspect.js to capture console errors and take screenshots.
If the screen, or a sequence of screens, are not what they should be, whether the laws of Physics are off, or a text overlay is misplaced, the Agent catches it, understands the problem, and rewrites the code.
The Loop
This is where the “agent” part becomes real. It’s not the usual “text in, code out.”, it’s a loop:
Idea -> Code -> Inspect -> Fix (as many times as needed) -> Render
Now, when we work on grokking a Physics problem at the kitchen table, I have a lot more than a napkin drawing: me and Salvador are cooking:
$ claude > /visualize the difference between gravity on Earth vs Mars using a bouncing ball |
Salvador picks up the intent, writes the physics simulation, tests it, fixes the gravity constant if it got it wrong, and pops open a browser window:
Humans today create and “conduct” code with or without LLMs. But complementing it with a Skill unlocks learning The Universe quark by quark, lepton by lepton.
Composable. And very open for evolution, because it is.. Simple. and Simple Wins. Always.