How I work with AI
Producing is the easy part. Accumulating is what compounds.
“. . . in most things (relationships, work, even in learning) what you’re trying to do is find the thing you can go all-in on to earn compound interest.” — Naval Ravikant, The Almanack of Naval Ravikant
A friend asked me to show him how I actually work with AI. So I did. He got genuinely, unexpectedly excited. Not politely impressed, the way people usually are when you walk them through a setup. Excited enough to keep pulling the thread, and excited enough that I noticed.
That reaction told me the way I work now is worth showing directly. Not a clever prompt or a slick trick — the system underneath it.
Here’s the thing I’d been missing for years. There are two engines in how anyone works with AI. One produces. One accumulates. Almost everybody builds the first and lets the second go to seed, and the second is the only one that compounds.
AI didn’t invent the habit I’m about to describe. It poured fuel on one I already had. The first thing AI hands you is speed: a post in minutes, a summary in seconds, a draft of nearly anything on demand. So you produce. You generate, you ship, you generate again, and the whole time it feels enormously productive.
Then a month goes by and you look back at a pile of outputs that just weren’t that good, with no learning behind them. No deepened understanding. No body of work that builds on itself. Just a longer and longer list of things you made once and have already half-forgotten. The volume went up. Nothing compounded.
The two engines
It took me an embarrassingly long time to see why, and the answer turned out to be simple: I was only running one of them.
The production engine is the one everyone notices. It turns out the posts, the drafts, the analyses, the finished things that go into the world. Its output is visible, so it feels like progress. The accumulation engine is quieter and slower. It’s the notes I keep, the half-thoughts I catch before they evaporate, the reviews I run at the end of a week, the thickening record of what I’ve thought and learned and gotten wrong. It ships nothing. All it does is get richer.
For years, long before AI, I ran only the first one, and it never once felt like a mistake. That’s the trap. The production engine has something to show for itself, so neglecting the other never feels like neglect. It feels like focus.
But run production alone and every piece of work starts from zero. Blank page. Cold start. Nothing to draw on but whatever you can summon on the spot, which most days isn’t much.
When the accumulation engine is running, the texture of the work changes. I don’t sit down to a blank page anymore. I sit down to one that’s already half-full: notes I left myself, ideas I’ve already chewed over, connections I made weeks ago and forgot I’d made. The producing becomes almost a byproduct, because the hard part, the thinking, already happened upstream, a little at a time, when no deadline was breathing on it. That’s what my friend was watching across the table, even though neither of us had the words for it. The output he found impressive was just the accumulation engine, quietly paying out.
One idea, from capture to publish
Watched from outside, the way my friend watched it, the system looks like a magic trick. Followed from the inside it’s almost mundane, which is the point. So here’s the honest trail of this exact piece, from the first scrap to the words you’re reading now.
It started in a weekly review. The coffee conversation had stuck with me, so when I sat down to sweep the week, I dropped it into a seed note, barely more than a spark and a few angle bullets. The line itself read: “Coffee with a friend recently — showed him the current setup and he got genuinely excited. That reaction is the signal: the way I work with AI now is worth showing, not just describing.”
That’s capture, the least impressive step in the system and easily the most important. I wasn’t writing a piece. I was making sure the thought couldn’t get away. Nothing downstream can compound if nothing upstream gets written down.
Then it got developed the way any idea does: by being argued with. The next day I sat down with the agent torn between two pieces: a reflective one about why I’d stopped publishing, and this practical one about how I work. We worked the decision out loud. At one point we killed an opening I was fond of, a neat “the pause itself is the proof” hook, because it leaned on a claim neither of us could actually verify. That’s the part people miss about working this way: nothing was being written for me. The thinking stayed mine, and the agent’s job was to keep me honest and keep me moving, right down to talking me out of a good-sounding line that wasn’t true.
Only once the idea was clear did the writing start, and it didn’t start with writing. It started with framing questions: who is this actually for, what’s the real claim, what would make it land. (The answer to the first one, since you’re here, is you.) That order is the whole game, and it’s the lesson that took me longest to learn. AI makes generation cheap, and cheap generation is the trap, because the machine multiplies whatever you feed it. Hand it muddy thinking and it hands back beautifully written mud. The cleaner the prose, the longer it takes you to notice.
So the framing got pinned down first. Then, and only then, the machine did what it’s actually good at: an outline, then a draft built a section at a time, then a pass to scrub out the tells that give machine-writing away. Every step had a gate, and at each one I was the one who decided. It never ran ahead of me.
Look at the shape of that. The drafting, the part everyone pictures when they hear “using AI,” was a single step near the end, and the smallest one. Everything ahead of it was catching the thought, sharpening it, and framing it. People assume working well with AI is about better prompts. Nearly all of it is what you do before you ever write one.
Why it’s built this way
Pull back for a moment, because how the system is built matters as much as what it does. Three ideas hold it up.
The first: a written-down workflow beats a clever conversation. A chat is gone the instant you close the window. You can’t reread it, and you certainly can’t improve on it. Everything in my system is a structured, inspectable procedure instead, so I can read exactly what it does, argue with it, version it, and hand it to someone else whole. If you can’t see what a workflow does, you can’t trust it, and you can’t make it better.
The second: the tools are temporary and the structure underneath them isn’t. I build on the flat assumption that every product I lean on today will be gone or surpassed within a year or two, and the last few years have proven me right more often than I’d like. So nothing load-bearing is tied to any particular app. It’s built against roles and contracts instead: a thinking agent, a data agent, a shared memory they both read from and write to, and the rules that govern how those roles work together. A workflow says “write this to the daily note.” It never says “call this company’s API.” The furniture gets replaced all the time. The floor plan stays put.
The third is the one I’ve come to value most: a failure you write down is worth more than a success you don’t. A lot of my workflows carry a small scar, a line that records how that exact step broke last time, so it can’t break the same way twice. Over months those scars add up. The ideas accumulate, but so does the record of what went wrong and what each failure taught me. That’s the real compounding: a library of thoughts that keeps getting bigger, and underneath it a slowly building immunity to my own past mistakes.
What I dropped, and what stuck
None of this arrived fully formed. It’s the residue of a couple of years of building things, trying them, and quietly killing most of them. What I cut says as much about the system as what I kept.
I dropped the heavy overnight automation first — elaborate machinery that was supposed to reorganize and distill my memory while I slept, and in practice only made my own memory harder to trust: an opaque process rewriting my notes in the dark, where I couldn’t see what it was doing or why. I dropped a drawer of agents I’d spun up because I could, well past the point the work clearly needed them. And I dropped a stack of review steps that had never once changed a decision I made. It was ceremony wearing the costume of discipline. Cutting it felt like loss right up until it started feeling like relief.
What survived every round of cutting is a short list, and the shortness is the point. Plain-text notes under version control, the foundation the whole thing rests on. Agents that propose before they act, so I approve a change before it’s ever written. A steady rhythm of daily and weekly reviews, the heartbeat that keeps the rest alive. The tools that implement those three things have changed many times over. The three things themselves never have.
What’s genuinely new mostly comes down to drawing cleaner lines: the split between prose work and data work, now a boundary I keep on purpose where it used to be an accident of how things grew, partly so the more sensitive work stays where it belongs. The newest piece is a layer whose only job is to audit the system itself. Every few weeks it walks the workflows and asks each one a blunt question: is this still earning its place, or has it quietly curdled into the same ceremony I spent a year cutting out? That’s the part I’m proudest of, because it turns pruning from something I have to remember into something the system does to itself. A system that can’t notice its own dead weight will collect it.
This showcase is one of those new things too: the whole system, versioned out in the open, so it can be looked at directly instead of merely described.
The system is here
Here’s the honest state of all of it: the system will keep moving. That’s the design, not a disclaimer. A system that can’t change is one that’s already dying, and the fact that mine is permanently unfinished is a property I’d defend. I’d much rather show you something alive and visibly half-built than something polished, finished, and quietly embalmed.
If you’d rather see the real thing than read my description of it, it’s out in the open. The workflows live in a repository you can read on GitHub, kn0wsnothing/agentic-ai-skills-and-tools, and a running snapshot of how I work sits at knowsnothing.org/ai. I’m not selling a method, and there’s no course at the end of this. I’m just opening the hood.
Because the part worth copying was never the tools sitting on top. Those will keep changing, and that’s fine. What gathers underneath them, slowly and almost invisibly, is the part that’s actually mine: every note I kept, every failure I wrote down, every workflow I sharpened, so the next piece of work starts a little further along than the last.
That’s the only part that compounds, and the only part that’s yours to build. The question worth sitting with isn’t which tools I use. It’s whether you’ve built that quiet engine underneath, the one that keeps accumulating long after the conversation closes.
This was written with the assistance of AI. The ideas, experiences, and arguments are mine; the AI helped with structure, pacing, and iterative drafting.