Tactical Creativity, Tactical Clarity

Fifteen years ago I played in a rock band in New York. I hadn’t felt that kind of creative pull since, until I started building with AI. Ideas that would have taken me a month now take an evening, and I have more of them than I’ve had in years.

The catch showed up quickly. When an assistant can build the same idea forty different ways, you end up with forty half-built versions: a dozen browser tabs, a pile of chats that each went somewhere different, and nothing that actually shipped.

chain.sh is what came out of fixing that. It’s the home for four open-source tools for coding agents. None of them were planned as a set. Each one came from the next thing that kept going wrong.

Tactical Creativity: a plan and a memory

People worry that AI will make us lazier thinkers. It’s done the opposite for me. When writing the code stops being the slow part, you’re left with a harder question: what’s actually the best way to do this? I stopped spending my time typing and started spending it deciding.

That needs structure. An assistant that can do almost anything, with nothing telling it what matters, produces a lot of motion and very little progress. I call the habit of anchoring that energy Tactical Creativity: take the speed, but give it a direction and hold it there.

The first half of that is a plan. brainfile, which I started in late 2025, keeps tasks, plans and progress in plain Markdown files that I and my agents share. A task can carry a contract: what has to be delivered, and how we’ll check that it works. The board lives in the project, so it doesn’t drift away from the code the way a separate tracker does. It was the thing that got me out of the tabs, and I built most of brainfile using brainfile, which was the best test I could give it.

The second half is memory. A plan covers today, but every new session started from nothing, so decisions made last week got argued again this week, and the work drifted anyway. recoil, which came in May, reads the notes and docs a project already has into a memory on your own machine and keeps track of the decisions made against them. Before an agent changes something, it can check whether that was already decided and why. The next session picks up where the last one stopped.

brainfile says where we’re going. recoil remembers what we already settled on the way.

Tactical Clarity: a map and a window

A plan tells an agent what to do. It doesn’t tell it where it is.

My day job is Zero Trust security, and one rule there comes before everything else: you can’t manage what you can’t see. Visibility isn’t a feature you add at the end. It comes first.

We break that rule with coding agents all the time. Earlier this year I watched one burn through about a tenth of my monthly Claude budget trying to find a single interface implementation. The model wasn’t the problem. I’d given it text search and nothing else, so it did the only thing it could: search, read a file, search again, guess, get it wrong, start over. It was trying to rebuild a picture of the whole codebase one text match at a time.

So in March I built cymbal, the map. It indexes a codebase on your own machine and lets an agent ask structural questions: what is this, what calls it, what does it call, and what breaks if it changes. cymbal impact --graph draws the part of the code a change would touch as a diagram, trimmed so it fits in the agent’s working memory. One question replaces twenty searches.

A map only covers the code you have. Agents also guess at everything outside it: how a library works, what an API expects, how someone else solved the same problem. Guessing an API without reading its docs is the same mistake as searching a codebase blind. ketch, which I started a few days after cymbal, is the window. It searches the web, public code and documentation from one fast command-line tool, with results an agent can rely on, and it’s become my most popular project, with over six hundred stars on GitHub.

cymbal shows the agent the ground it’s standing on. ketch shows it what’s beyond it. That’s Tactical Clarity: seeing clearly before you move.

Why a chain

Each tool works on its own. You can install just cymbal and never touch the rest. But they’re better linked: plan the work, remember what you decided, see the code, look up what you don’t know.

chain.sh puts them in one place. Each tool has its own site, with the install and a manual written for people and for agents. One command, npx skills add 1broseidon/skills --skill chain, gives an agent a skill that explains all four and when to reach for each.

What I’d tell someone building with agents

1. Execution is cheap now; deciding isn’t. Spend the time you save on picking the right approach.
2. Give the agent a plan it can check itself against. Otherwise speed just produces more half-finished work.
3. Give it a map before you give it a task. Most wasted tokens are an agent trying to work out where it is.
4. Make decisions last longer than a session. If you have to repeat yourself every morning, the agent isn’t the one learning.
5. Let it read before it guesses. Docs and real examples are cheaper than a wrong answer.

The bottleneck has moved. It’s no longer how fast you can type. It’s how clearly you can see the ground before you act.