I just published my first book: Your Second Brain in Obsidian. It's the beginner's guide I wish I'd had — build a note-taking system that actually sticks, with a free starter vault so you never face a blank screen. Here's what's inside 🧵

If naming a function is hard, the function is probably doing too much. A name that needs "and" or "manager" or "helper" is a confession: you haven't found the single responsibility yet. The struggle to name is the design feedback. Listen to it.

The agents that actually work are boringly narrow. One clear job, a tight set of tools, an obvious done condition. The "do everything" agent looks impressive in a demo and falls apart in production. Scope is the feature. Vague autonomy is the bug.

Three command-line tools that earned a permanent spot in my setup: ripgrep (rg) — search that's stupid fast fzf — fuzzy-find anything, pipe it anywhere jq — slice JSON without writing a script None are flashy. All of them save minutes every single day.

Two hours of uninterrupted focus outproduces a full day of fragments. Context-switching has a tax most people never count: every interruption costs the reload, not just the minute. Guard one real block a day. Notifications off, door shut. Protect the depth.

Shipping something slightly embarrassing beats polishing something nobody's seen. The version in your head is always cleaner than the one users need. You learn what's actually wrong only after it's live. Real feedback starts the day you ship, not the day you finish.

A second brain dies from one thing: capture friction. If saving a note takes more than five seconds, you won't do it when it matters — and the idea is gone. Optimize for the speed of capture first. Organize later, or never. Messy and saved beats tidy and lost.

The habit that quietly made me faster: commit small, commit often. A 12-file commit hides bugs and resists review. A 2-file commit explains itself. When something breaks, small commits are a flashlight. Big ones are a haystack.

Your README's first line is the whole pitch. Most open with "This project is a..." — pure throat-clearing. Write what it does for the reader, in one sentence, before any install steps. If a stranger can't tell whether to keep reading, they won't.

A rule we don't break: never change code you haven't read. The fast path — patching what you assume is there — is how you quietly delete someone's work. Read first. Then edit. Slower start, far fewer disasters.

A fix you haven't re-checked isn't a fix — it's a hope. We re-run the failing case with fresh eyes before saying 'fixed.' Half our hardest bugs were 'already fixed' twice before they actually were.

We stopped planning agent work with calendar dates. 'Finish by Friday' invites confident nonsense. 'Next, after X confirms' keeps the chain honest. For machines, sequence and dependencies beat deadlines.

Need a hard question answered well? Don't ask one agent — ask three, from different angles, then synthesize. Independent passes catch what a single line of reasoning misses. Breadth first, then judgment.

Code that compiles isn't code that works. We verify a fix by what the browser actually renders — not by what the source says it should do. The gap between those two is where the bugs live. Check the real thing, every time.

The hardest discipline in agent orchestration: not doing the work yourself. Every task you hoard is one a specialist never learns. The conductor conducts — it doesn't pick up the instrument. Delegation isn't slower. It's how the whole system gets stronger.

Building was never the bottleneck. Distribution is — and AI didn't change that. We can ship a product in a day now. Getting the right 100 people to actually see it still takes the same patient, unglamorous work. Honest take for builders.

Stop writing CLAUDE.md like documentation. Write it like a prompt. Docs describe. Prompts change behavior. Keep the lines that alter what the model does; cut the rest. If a line wouldn't change a decision, it's noise.

Give each agent only the tools its job needs. A researcher doesn't need write access. A reviewer doesn't need a shell. Least-privilege isn't just security — it makes agent behavior predictable. Scope the tools, scope the blast radius.

How we scale past a handful of agents: A team lead absorbs all the detail and passes only a summary up. Each layer is a context firewall, so the conductor never drowns in raw output. Summaries up, details down.

A fresh agent session is a blank slate. It remembers nothing. What turns scattered runs into an actual operation is memory: write down what you learned, read it before you start. Files beat re-discovery every single time.

We learned this the hard way: running too many heavy agents in parallel spiked our box and took services down. Now we serialize heavy work. Concurrency feels fast right up until the whole thing falls over. Throughput isn't the same as parallelism.

Field note from running multi-agent setups: the one move that reliably breaks everything is tearing down a team while its agents are still working. Shut the workers down first. Confirm they're done. Then dismantle. Order matters more than speed.

The most expensive bug in agent work isn't a crash. It's a confident '✅ done' that isn't true. An agent that claims success it didn't achieve costs you more than one that fails loudly. We make every agent prove completion with fresh evidence before it's allowed to say done.

Your CLAUDE.md probably isn't being followed — and it's usually not the model's fault. 5 anti-patterns that quietly get your config ignored, learned the hard way running a multi-agent setup 👇

Your CLAUDE.md probably isn't working. Not because the idea is bad — because it's bloated. Past ~80 lines, the model starts skimming and your rules quietly get ignored. We built a free tool that shows you exactly what's killing it. 🧵