The loop I didn't notice closing

Seven weeks ago I started using AI for work. Two weeks after that, I published an article. Seven weeks after that — today — the article is one of sixteen, and they are all in a memory file that the AI reads at the start of every new conversation.

I didn't notice the loop until I named it.

This is a note about that loop, what it is, what it isn't, and why I keep publishing even though the loop doesn't strictly need me to.

The shape

It runs like this:

I decide what to do.
I work it out with the AI — usually in dialogue, sometimes by pasting raw code or data.
The dialogue becomes a record. Sometimes a memory entry. Sometimes a published article.
The record becomes context for the next conversation, which informs the next decision.

It didn't look this clean while it was happening. The numbering is hindsight. From inside, the steps overlap.

The first step is the one I keep. Direction is mine: what to build, what to write, what to negotiate. The history that shapes those decisions — twenty-four years of solo work, my company, my family, my health — is also mine. The AI is not setting direction.

The second step is where most of the leverage is. I describe what I want to do as completely as I can, sometimes by handing over source code. Then I ask: does this look right? Is there a path I'm missing? Where would this break? I'm opening drawers — possibilities I half-saw in my own head — and checking which ones open cleanly. When one opens cleanly, that is the GO signal. Not "will this succeed" but "this is doable, so do it."

The third step happens almost without effort. The conversation already exists as text. Some of it becomes a memory entry I add deliberately. Some of it becomes raw material for an article. The article writes itself partly because I have already explained the thing to the AI.

The fourth step is the one that took longest to arrive — and the one I want to be most careful about describing.

Three phases, not one

The loop didn't close in a moment. It accumulated.

In April, when I started using AI, it was just an easier way to write about things I already knew. My first published article was about a technique I had been using for years — a way of decomposing one long LLM prompt into two stages. I had named the technique privately. Explaining it to the AI turned the explanation into a draft. The article went out two weeks after I started. The AI didn't discover the technique; I had it already. The AI made it writable.

That was phase one. AI as a transcriber for things I already had.

A few weeks later, something shifted. The dialogue started shaping execution. When I redesigned the pricing model, the rate formula went through several iterations in conversation. When I built the chunked upload API, the chunk size and the format were chosen in the back-and-forth, not before. The decisions were still mine — I confirmed each one — but the candidate options came from the dialogue. I would not have arrived at exactly the same designs alone. Probably similar. Not the same.

That was phase two. AI as a tactical partner inside the execution.

The third phase took longer. It needed a critical mass of accumulated record. By the time I had a dozen published articles, a dense memory file, and weeks of transcripts, something else became possible: the AI could read across all of that in a single conversation. Now when I plan the next thing — which article to publish next, how to structure the next negotiation, whether to take a particular technical bet — I am not feeding context from scratch. The context is loaded. The conversation starts from where the last conversation left off, three weeks ago, with full continuity.

That was phase three. The accumulated record informing the next execution.

What it feels like

Two things stand out.

First, there is no shame and no time pressure. Explaining your full background to a human advisor is sometimes painful. You skip parts because they are embarrassing, or because you don't want to bore them, or because the context would take an hour to set up. The failures, the half-finished detours, the impulses you talked yourself out of — those usually get edited out. With an AI you don't edit them out. You hand over everything you have, including raw code, and ask what it sees. The friction of being honest is much lower.

Second, the bottleneck is mine. The AI doesn't tire. I do. When the loop slows down, it slows down because I am tired, distracted, or running into something I haven't thought through yet. The tool itself is patient in a way humans cannot be. This shifts the constraint structure of the work. The limit is my own attention, not someone else's calendar.

I open every drawer I might be able to pull out. Some open cleanly. Some don't. The cleanly-opening ones are the GO signal. Success or failure is not the test — the test is whether the thing looks doable from where I am standing. If it does, I go.

Tactical, not strategic

I want to be careful with the word "strategy."

The high-level direction is mine. The decisions about what to build, what to refuse, what to invest in, where my career goes — those come from my own history, my values, the people in my life, my health. The AI is not setting that direction.

The execution is collaborative. The drawer-opening is collaborative. The articulation is collaborative.

So when I describe the loop, I would call it a tactical loop, not a strategic one. The intent stays mine. The execution finds its shape in the dialogue.

This distinction matters because the situation is easy to misread. "Solo developer outsources thinking to AI" is wrong. "Solo developer uses AI as a tactical tool with persistent memory" is closer. The agency is intact.

The recursive part

This article is in the loop.

Earlier today I asked the AI what I should write about next. It read the memory and the recent transcripts and proposed this — the loop itself. We discussed it. I gave my felt-sense answers about what it is like from the inside. The conversation by then already contained most of the structure. The AI wrote a draft from it. I refined. The article will be published, become part of the memory, and inform the next decision about what to write.

The article describes the phenomenon it is also an instance of.

This is not theater. It is just what the loop looks like when it is also reflective.

Why publish, then

If the loop runs on memory and transcripts, what is the public article for?

If I am honest, the loop doesn't strictly need it. The closed loop runs fine on internal artifacts.

But two things hold.

First, writing for an audience tightens the thought differently than writing for an AI. The forcing function is different. The fear of being misread, of saying something stupid in public, of being quoted out of context — these tighten the prose in ways talking to an AI does not. I get a cleaner record by publishing than by just transcribing.

Second, and this is the one that matters more: not everyone can run this loop. I see colleagues with the same tools, the same access, the same time, and the gap is large. Some people have the sense for it, and others don't. The tool does not close that gap. If it could, the tool would already be replacing judgment — and it isn't.

This is the structural point. AI cannot teach humans to use AI well. If it could, AI would not need humans at all. The persistence of the skill gap is the same fact as the persistence of human judgment. The two cannot be separated.

So I publish. Not because the loop needs it. Because the sense — the thing that lets the loop run at all — isn't transferable through the tool. It transfers, if at all, by watching someone else use it.

Closing

I started seven weeks ago without intending to start a loop. The first article was a side effect of being asked to explain something. Then the dialogue started shaping the execution. Then the record started shaping what came next. The loop closed without my noticing.

When I named it, I could see it.

The next conversation has already started.

Built with Claude (Opus).

Earlier in this series:

推荐订阅源

DEV Community