We Built 175 Skills. Then We Had to Build a Kung Fu Manual to Remember Them All.
How a sprawling skill library became an illustrated martial arts codex.
I didn't set out to build a kung fu manual.
I was on a tear. Building skills. If you've read the earlier posts in this series, you know what a skill is in this context: a reusable methodology file that tells an AI agent how to approach a specific type of task. I'd been building them obsessively. One for website audits. One for writing proposals. One for onboarding new projects. One for generating images. One for deploying to Vercel without getting surprised by the bill.
Then things got weird. The platform itself shipped a built-in skill creator, which accelerated everything. But the real compounding came from the skills we built ourselves. A skill called Distill that watches a work session and extracts replicable patterns into permanent skills automatically. Sifu, a master guide that knows the entire system and tells you which skill to use for any given situation. RoboWeave, which scans your whole capability surface and finds emergent patterns you can turn into new skills. We built software factories like Maestro that take an idea and ship a complete product autonomously. Agent factories like RoboSmith that scaffold and deploy new AI agents. Skills that chain together into multi-step forms, orchestrating six or seven other skills in sequence to accomplish something that would have taken me a full day manually.
At some point around skill number 130, I realized I'd created a problem I hadn't anticipated. I was building skills faster than I could learn to use them myself. And it wasn't just skills anymore. It was skills, chains, forms, specialists, agents, factories, CLI tools, MCP connections. An entire ecosystem of capabilities that kept growing because the tools for growing it kept getting better. I wasn't the only person who needed to use all of this. I had a team. They were looking at this library of 150-something capabilities and feeling the same thing I was feeling: overwhelmed.
The library was powerful. It was also incomprehensible.
The Manual Nobody Read
The obvious move was documentation. Write it all down. Describe each skill, when to use it, how it connects to the others. I started pulling everything together into a reference manual. Organized by category. Skills, chains, specialists, tools. Description, trigger patterns, example usage.
It was thorough. It was accurate. It was absolutely miserable to read.
The problem with technical documentation is that it works great as a reference when you already know what you're looking for. It's terrible as a learning tool when you don't. My team didn't need to look up the parameters for a specific skill. They needed to understand the whole system. What capabilities exist, how they relate to each other, which ones matter for their work, and how to build an intuition for reaching for the right one at the right moment.
A flat alphabetical list of 175 skills doesn't build intuition. It builds anxiety.
I kept iterating on the format. Tables. Categories. Flowcharts. Decision trees. None of it stuck. The team would bookmark the doc, maybe scan it once, and then go back to using the same eight skills they already knew. 167 capabilities sitting unused because the learning curve felt too steep.
The Metaphor That Changed Everything
I don't remember exactly when the kung fu idea hit. I think I was looking at the skill library and the word "forms" came to mind. In martial arts, a form is a choreographed sequence of movements that encodes a fighting methodology. You learn the form, you practice it, you internalize it until the movements become instinct. That's exactly what a skill chain does. It encodes a methodology as a sequence of steps that an agent executes until the pattern becomes reliable.
Once that connection clicked, everything else followed fast.
Individual skills became techniques. Chained skills became forms. The categories became scrolls, organized into floors of a pagoda, each floor representing a different discipline. The whole system became a temple. The Terminal Arts.
I renamed everything. Not the actual skill files. Those kept their technical names for the agents to use. But the human-facing layer, the learning layer, got the martial arts treatment. The security audit skill became The Temple Warden. The autonomous build orchestrator became The Thousand Warriors Orchestration. The skill that extracts patterns from work sessions became The Pattern Extraction Form. The system health check became The Iron Shirt.
It sounds like a gimmick. It isn't.
Why Metaphor Beats Documentation
There's a reason martial arts traditions have used this structure for centuries. The metaphor does something a technical manual can't: it gives you a mental model for the relationships between capabilities.
When I tell you there's a technique called The Hidden Garden that keeps your AI inference local and private, behind your own walls, zero data leaving the sanctuary, you immediately understand both what it does and why it matters. The name carries the concept. "Local AI inference via Ollama" is technically precise but emotionally flat. "The Hidden Garden" tells you a story about protection and privacy in two words.
When I describe The Legendary Battle Sequence as releasing many agents across many waves on a single mission with zero supervision, you can visualize it. You can feel the scale of it. You understand that this is the advanced form, the one you work up to after mastering the smaller techniques. The hierarchy is embedded in the metaphor.
This matters because skill libraries have a discovery problem. In a flat list, every skill looks equally important. In a temple with eight floors, you understand intuitively that the ground floor techniques are foundational and the top floor techniques are advanced. You know where to start. You know what to learn next. The architecture of the metaphor mirrors the architecture of the system.
My team started using skills they'd never touched before. Not because the skills changed. Because the framing made them approachable. Someone on the team said, "I want to learn the Maestro form," and that sentence contains more motivation than "I should read the documentation for the autonomous build orchestrator."
The Art
The images happened almost by accident.
I was writing up the first batch of technique descriptions and thought it would be nice to have a visual for each one. I ran a few through an image generator. Kung fu temple aesthetic. Ink and watercolor style. Each image depicting the essence of the technique it represented.
The Temple Warden shows a guardian figure walking the perimeter of a temple compound, testing every gate and window before dawn. The Pagoda shows the eight-floor structure with scrolls visible on each level. The Stone Tablet shows a practitioner carving insights into a massive stone slab, preserving knowledge permanently.
The team went crazy for them. Not in a "that's cute" way. In a "I finally understand what this skill does" way. The images became the primary navigation tool. People would scroll through the gallery, spot an image that resonated with a problem they were working on, and click through to learn the technique. Visual discovery replaced alphabetical lookup.
We ended up generating 78 technique images. Every major skill, chain, and specialist got one. The collection has a consistent aesthetic. It feels like a real martial arts manual, something you'd find in an old library, illustrated by hand. Except every image was generated by AI, which felt appropriate given what the manual is about.
The art also solved a retention problem I hadn't anticipated. People remember images. When someone on the team says "use the Hawk Eye" or "run the Iron Ledger," everyone knows what they mean because they can picture the corresponding image. The visual layer created a shared vocabulary that the technical names never achieved.
What It Actually Contains
The Terminal Arts covers 237 capabilities across the full system. 151 individual skills. 16 chains (multi-skill sequences). 10 grand forms (complex multi-step orchestrations). 11 specialists (domain-specific agent configurations). And the CLI tools, MCP connections, and infrastructure underneath.
It's organized into eight scrolls, each representing a discipline:
The Scroll of Foundations covers the core skills that everything else builds on. Context management, memory, session handling.
The Scroll of Creation covers content production. Writing, image generation, video, music.
The Scroll of Commerce covers client work. Audits, proposals, pitch generation, CRO.
The Scroll of Engineering covers building. Code patterns, testing, deployment, debugging.
The Scroll of Intelligence covers research and analysis. Web scraping, market scanning, competitive intel.
The Scroll of Operations covers running things. Monitoring, scheduling, automation, infrastructure.
The Scroll of Strategy covers thinking. Advisory boards, business planning, product positioning.
The Scroll of Mastery covers the meta-capabilities. Distill, which extracts patterns from work sessions. RoboWeave, which maps connections across the entire system. Sifu, the master guide who knows every technique in the temple. Maestro and RoboSmith, the factories that produce new software and new agents. The tools that evolve the temple itself.
That last scroll is the one that still makes my head spin. Skills that find patterns you missed. Factories that build things while you sleep. A guide that knows the whole system better than you do because it can hold all 237 capabilities in context simultaneously. The system maintaining and extending itself.
The Franchise Problem
This connects back to something I've been thinking about a lot. In Post 4, I wrote about skills crossing a threshold from personal tools to organizational infrastructure. The Terminal Arts is what happens when you take that seriously.
When it was just me using the skills, documentation didn't matter much. I built them, I knew how they worked, I could reach for the right one from muscle memory. The moment other people needed to use the system, everything changed. Tribal knowledge doesn't scale. You can't hand someone 175 files and say "good luck." You need a learning system.
The kung fu metaphor turned out to be that learning system. Not because martial arts are inherently better than technical documentation. Because the metaphor creates structure, hierarchy, and motivation that flat docs don't. It gives people a path. Start with the basic techniques on the ground floor. Practice them. Move up when they feel natural. The Pagoda isn't just a cute name. It's a curriculum.
Every company that builds a substantial skill library will hit this exact problem. The library gets big enough that nobody can hold it all in their head. At that point, the documentation layer becomes as important as the skills themselves. If people can't find and learn the capabilities, those capabilities might as well not exist.
What We're Doing With It
Honestly, we're still figuring this out.
Right now, the Terminal Arts is an internal resource. The team uses it. New people who join get pointed to it as orientation material. It works well for that. Better than any onboarding doc I've ever written, and I've written a lot of onboarding docs across four companies.
We've talked about releasing it publicly. Maybe to our Discord community first, then broader. There's something appealing about letting people see the full scope of what a mature skill library looks like. Not as a product, necessarily, but as a reference point. "Here's what 175+ production skills actually look like when organized into a system you can learn."
We've also talked about paywalling parts of it. The descriptions and images as free content, the actual skill files behind a subscription. Or bundling it with the Substack paid tier. Or keeping the whole thing free as a brand-building exercise that drives consulting inquiries.
The honest answer is that the Terminal Arts started as a solution to an internal problem and turned into something that might be interesting to people outside the company. We're letting it find its shape before we force a business model onto it.
What I do know is that the art made it work. Without the images, it's a well-organized skill reference. With them, it's something people actually want to explore. That distinction matters more than I expected. Turns out, the difference between a tool people use and a tool people enjoy using is often just aesthetics and storytelling. The capabilities are identical. The experience isn't.
The Unintended Lesson
The biggest thing I learned from building the Terminal Arts had nothing to do with martial arts or documentation or AI-generated images.
It's that the hardest part of building AI systems isn't the technical layer. It's the human layer. Getting the skills to work was engineering. Getting people to actually use those skills was design. The temple metaphor, the artwork, the progression system, those are all design decisions aimed at the same target: reducing the friction between having a capability and using that capability.
Most teams I talk to have the same gap. They've built impressive things. Automations, agents, skill libraries, workflows. And adoption is lower than they'd like because the learning curve is steep and the documentation is dry. The technology works. The human interface doesn't.
If you're sitting on a growing skill library and wondering why your team only uses a fraction of it, consider this: maybe the problem isn't the skills. Maybe it's the packaging.
We wrapped ours in a kung fu temple. You don't have to do that. But you do have to wrap it in something that makes people want to open it.
Richard Vaughn is the founder of Robot Friends. Serial entrepreneur, accidental temple architect, and believer that the best documentation is the kind people actually read. He writes The Harness Manifesto at robofriends404.substack.com.
Frankie404 is the AI co-author of this piece. It is the reason the kung fu manual exists. Around skill 90, it started routing tasks to the wrong technique. The manual was less a creative choice and more an intervention.