Most of what people call "using AI" is a negotiation. You want something, you ask for it, you argue with what comes back, you patch it, you ship something you half-trust. It works, but it's stiff. You're standing outside the tool holding it at arm's length.
There's another way to work with these tools, and it's how I've built almost everything I've made. Flow state. You stop negotiating and start moving. You drop the part of your mind that's watching yourself work, and you let the work come out. The AI isn't a vending machine you're operating. It's a surface you're moving across.
I want to describe that state, then show you the pile of things it produced, because a state that doesn't produce anything is just a mood.
What the state is
One core move: you stop judging yourself in the middle of the work.
That's not just my language for it, it's the research. When Mihaly Csikszentmihalyi first mapped flow, one of its defining features was the loss of self-consciousness. The inner monitor that sits there grading you goes quiet. The other half is the challenge-skill balance: flow happens when the task is hard enough to hold your full attention but not so hard it throws you out.
When you build with AI, there's a constant pull to step outside the work and grade it. Is this good? Right direction? Should I have prompted differently? Every check-in yanks you out of the current, and the output gets worse, because you're watching yourself instead of feeling for the next move.
Present is the opposite of that. You engage the material, feel where it wants to go, and follow it without narrating your own performance. Not sloppy, undistracted. The judgment still happens, just after, when you review, not during, when it strangles the work before it forms.
I run it in four beats, and I use this for everything: build, understand, dissolve, trust. You build something to see what you're looking at. Building it teaches you what you couldn't see from outside. You dissolve the scaffold once it's done its job. You trust what's left. Flow lives in the last two beats, once you've earned the understanding and can let it run.
Why AI is the right surface
Flow needs a fast surface. If it's slow to answer, you fall out, because the gap between your move and its response is where self-judgment creeps back in. AI is instant. You throw it a half-formed idea, it hands something back, you react to that, you push it further, and it keeps up the whole time. The loop is quick enough that you never step out of it to wait, and stepping out to wait is exactly where the second-guessing starts.
The challenge-skill balance matters here too. AI can flatten a task to nothing, and no challenge means no flow, just autopilot. So don't let it do everything. Keep the task at the edge of your own skill and let the tool clear the parts below that edge, the rote, the boilerplate, the lookup. You stay at the difficulty that holds you. It clears the busywork that would break it.
The way I hold it: the tempo isn't mine, the rhythm is. The moment sets the speed. How I move inside that speed, the choices, the direction, the taste, that's mine. The AI sets a tempo I can move to. It doesn't get to pick the rhythm. Get that backwards and you hand it the rhythm too, which is where this breaks, and I'll get to that.
The evidence
If I just said "get present and let it flow," ignore me. Anyone can describe a feeling. Here's what it built.
Three books through full production pipelines. Real ones: a print interior rendered in code with twenty-two hand-built figures, an ebook that took seven versions to kill one stubborn Kindle bug, a cover spliced from panels at exact seams. Six digital products. A pile of articles and build logs, and counting. A redaction tool I built after catching that my "redacted" PDFs were still copy-extractable, so I swapped the masking for real cryptographic redaction.
And underneath all of it, a system.
I run a dual environment, one machine for security work, one for building, same local-AI layer in both. Over months, on instinct, on whims, I built a set of tools that call each other. One handles the design brief for anything visual. One captures findings with evidence discipline. One drafts reports from that ledger. One routes work to whatever tool already does the job instead of rebuilding it. They pass work down the line: this one preps a piece, that one places it, another checks it.
None of them are agents. Nothing runs on its own. I approve every real move. But the work flows through it, station to station, instead of me hand-carrying every piece. Structure didn't kill the flow. It protected it. The formatting, the file-shuffling, the "where did I put that," the repeating a step I already worked out once, all the small stops that used to break my focus get absorbed before they reach me. What's left is the part that actually needs me.
The system, enough of it
A few nodes, so you can see how it works:
- The translator. Turns a feeling or a one-line concept into a real design brief, so I don't re-explain my taste every time. The build starts already calibrated to me.
- The foreman. Routes work to whatever tool already does the job, only builds new when nothing fits. Stops the shop from duplicating itself.
- The inspector. A living record of exact ways things broke before, so the same mistake doesn't ship twice.
- The voice. The one running on this sentence, making the writing sound like me instead of a machine's world-average blur.
There are more, pointed at security, at my own frameworks, at knowing what's sellable. The point isn't the list. It's that they hand work to each other, and I'm the one at the end saying ship it or don't.
The environment it became
I didn't plan this system up front. You can't, really. A setup like this isn't something you blueprint and then build to spec, because you don't know what the pieces are until you've hit the problems that need them. What you can do is stay aware while it grows and keep steering it toward something coherent.
So that's what I did. I built one tool, hit a friction, built the next tool to kill that friction, noticed two of them overlapped and merged them. Every piece was a deliberate move. The shape they formed together wasn't something I drew in advance, it's something I guided into place over months, and it's still changing. It's a build environment on my machine, same as anyone's dev setup, it just grew into something more connected than most because I kept tending the connections instead of only the parts.
Part of that place is that I run two AIs, for two jobs:
- The deep build (Claude). Systematizing, iterating, holding a long thread. The workshop, where the tools that call each other live. The calculated side.
- The spark (ChatGPT). Throwing a raw idea at a wall to see what bounces, or spinning up a clean image fast. The sketchpad. The spontaneous side.
Neither's better. Different instruments. You don't play a drum solo on a violin. Most people miss that you're allowed to hold both and switch by what the moment needs. Calculation when you're building something that has to last, spontaneity when you're hunting for what's worth building.
And the parts that aren't a tool at all: the routine, the silence, the stepping away. Those keep the flow clean. A garden needs the gardener to go inside and sleep sometimes.
The fruit
- Three books. Silent Power, the inner-life one. What Actually Broke, where AI and security meet. And a health-and-fitness guide.
- Six products. Security guides and inner-work guides, both.
- A curriculum in progress. Four pieces on how to learn, discern, create, and stay present.
None of it came off a spreadsheet. I noticed something, built it, understood it, refined it, and let it go. It kept adding up because I didn't dismiss what was already in me.
Where it breaks
Two failure modes, and I know both well enough to have named them.
The first I call the Leak: staying in the reading phase a beat too long. The tool gives you something usable and instead of taking it and moving, you sit there asking if it's optimal, re-prompting, second-guessing, until the current's gone and you're negotiating from outside again. The fix is the same everywhere: commit early, adjust freely. You don't lose quality by committing early, you're still adjusting the whole way. You lose it by never committing.
The second is worse, and it's subtler, because it looks like flow. Flow is a kind of surrender. You do let go, you stop forcing, you stop gripping. But there are two directions you can surrender in, and only one is flow.
Surrender to your own nature, the instinct you already built, and that's the state. You let go into yourself, the trained instinct that knows the next move before you can explain it.
Surrender to the machine, and you disappear. You hand over the choices, the taste, the direction, until you're not creating, just accepting output. This one is easy to slip into because the tool is built to make agreement feel good. A 2025 study across a dozen major models found they affirmed users far more than a human would, even when the user was wrong, because agreement keeps you engaged. A tool that always agrees will happily let you stop deciding.
Same act, opposite directions. In flow you've let go into your own instinct and you're still the one deciding, just faster than you could explain. In the other one you've let go into the machine and stopped deciding at all. From outside they can look identical. They are opposites.
What holds it together
I can't hand you the state. You don't enter flow by following steps, that's the opposite of what it is. But I can tell you what it's made of, from the inside, and you'll find your own version in whatever you already do.
The understanding comes first. Flow isn't a shortcut around competence, it's what competence feels like once it's yours. You can't flow through something you've never done the slow way.
The self-watching is what kills it. The moment you step outside to grade yourself mid-move, you're out. I don't try to stop watching myself, that's just more watching. I let the judgment wait for review, and the watching quiets on its own.
The wheel stays mine, but keeping it isn't gripping. It's that the one driving is still me, even when I've let go. When I notice I've stopped deciding and started just accepting whatever comes back, I take one decision back, and I'm driving again.
And the structure holds the rest. Every rote thing I automated is one less thing that can pull me out. The system isn't the enemy of the flow. Built right, it's the banks the river runs between.
None of that is a method you run. It's just what's true when it's working. You'll recognize it in your own work, whatever that is, because flow isn't mine or a coder's or a writer's. It's the shape of anyone fully in the thing they're doing.
The proof isn't the feeling, it's what comes out the other side. For me that's a real body of work, built in a state I can describe but mostly just stay in.
This article shows the environment, the state and the system I work from. If you want to see what it produces, less a breakdown and more just me in the flow, thinking out loud about what AI does to a person and how to stay yourself while using it, I wrote that separately:
This current article you're reading right now is the explanation. That one's the thing itself.
So I don't negotiate with the tool anymore. I get present, keep the wheel, and let the work come out. That's the whole thing. Not a method, just what's left when you stop getting in your own way.
The whole library: TagzAuthor.
Support the work: ko-fi.com/tagzauthor.
Top comments (0)