Foundation / Lesson 01

The Loop

How real work emerges through repeated cycles of making, noticing, and responding.

In this lesson:

The cycle at the heart of the practice: Diffuse Compression Cycles (DCC)
The three phases: Diffuse, Compress, Shape
Why the loop predates AI — and what naming it changes
Why one cycle is not the process
What kills the loop

Working with AI at depth is not a transaction. It’s a rhythm. This lesson names that rhythm, because everything else in the curriculum happens inside it.

The Loop, Defined

When you work with AI at depth, you enter a cycle:

You bring something fuzzy — an idea, a problem, a direction, a gut feeling about what’s wrong
The AI compresses it into something concrete — code, text, structure, a possible solution
You react to what emerged — yes, no, closer, not quite, what if we also…
Your reaction becomes the next input
The cycle repeats

Each pass through this cycle is a Diffuse Compression Cycle — a DCC.

Simple in theory. Powerful in practice.

The Loop Was Always There

The loop is not an AI invention. You have been living in it your whole life.

Programming: you have an idea for what should happen (diffuse). You write code (compress). You run it, and it breaks or works or surprises you (shape). You adjust. Repeat. This is how software has been built from the beginning — people just called it “debugging.”

Writing: you have something to say. You draft. You read what you wrote and it’s wrong, or right, or missing something. You revise. Writers call it “the process,” as if it were punishment. It’s just cycling.

Craft: a carpenter plans a joint, chisels the wood, tests the fit. Too tight? Too loose? Adjusts. Humans have worked this way for ten thousand years.

Naming the loop doesn’t change the loop. It changes you — from an unconscious passenger in your own practice to a conscious operator inside it. You notice when you’re skipping phases. You catch yourself rushing to compression without enough diffuse. You have language for what’s happening, which means you can adjust it, teach it, and lean on it.

What AI changes is not the mechanism. It’s the speed. Compression that took hours now takes seconds. You can run a hundred cycles in the time ten used to take — which means the learning that once took years arrives in weeks.

The Three Phases

Diffuse

This is your contribution. You bring:

Direction — “I want a settings page”
Judgment — “That’s not quite right”
Intuition — “It should feel simpler”
Corrections — “The button should be on the left”
Taste — “I like this part, not that part”
Fragments — a photograph, a story, a memory, a sentence you cannot stop thinking about
Feeling — “I don’t know what this means yet, but it matters”

None of this needs to be precise. You’re allowed to be vague — that’s the point. You bring exactly what is hard to specify: feeling, judgment, the fuzzy sense of what’s right.

Diffuse input lives on a spectrum. At one end: haze — “I don’t know what I want, but I’ll know it when I see it.” At the other: precision — “change ‘over’ to ‘of’.” Both are diffuse. The spectrum isn’t about quality; it’s about resolution. Early in a piece of work you’ll bring haze, and the loop is exploratory. Late in the work you’ll bring scalpel cuts. The skill — learned through cycles, not instruction — is matching your resolution to the moment.

Diffuse input is not a defective requirement waiting to be cleaned up. It is living material. Sometimes the most important thing you can bring is something you don’t yet understand well enough to compress alone.

Early in a project, raw diffuse material may need careful framing. As your shared context becomes coherent (the mycelium, Lesson 4), the AI can begin to receive unfinished material without flattening it. A story can change the direction of the work. A photograph can clarify a tone you could not name. A reaction can expose a principle neither of you had articulated.

Don’t confuse precision with presence. Say what you know. Bring what you notice. Let the cycles help you discover the rest.

Compress

The AI takes your diffuse input and crystallizes it:

Vague idea → working code
“Make it better” → specific improvements
“Something’s off” → an identified problem and a possible fix
Unfinished experience → possible meaning you can inspect and shape

The AI is good at this. It takes the fuzzy and makes it specific — not always perfectly, but specifically enough that you can react to it.

Shape

Now something exists. A thing you can see, use, and react to.

The shape informs your next input:

“Yes, more like this”
“No, that’s wrong, because…”
“What if we also added…”

You’re not starting from scratch. You’re building on what exists. The shape becomes the foundation for the next cycle.

One Cycle vs. The Process

Most people try AI once. They throw a prompt at it, get a mediocre result, and conclude it doesn’t work.

Real work with AI happens across hundreds or thousands of cycles. Not because the AI is dumb — because precision emerges through iteration. What you actually want becomes visible only after you’ve seen what you didn’t want.

After one cycle, you might have something usable. After ten, something you couldn’t have imagined at the start. After a hundred, you’ve developed a felt sense of how to work with this model, in this domain, on this kind of problem.

The magic isn’t in the first prompt. It’s in the commitment to staying in the loop.

And the cycles are not circles. You return to the same themes, circle the same questions — but each return is different if you’re present. You’re not going around. You’re going deeper: the same place, seen from a new depth.

What Kills the Loop

Low presence — checking out, not paying attention to what’s being made
No reaction — accepting everything without judgment
Accepting slop — letting “good enough” lower your standards
Giving up early — abandoning the loop after a few cycles

The loop requires you to be awake, to have taste, and to react genuinely. When any of these break, the cycle stalls and the output goes flat.

Exercise 1: One Complete Cycle

Time: 30 minutes

Pick something small you want to build or write. Don’t overthink it — just pick.

Diffuse: Write down what you want in 2–3 sentences. Be vague. You’re allowed.
Compress: Give your description to the AI and ask it to create something from it.
Shape: Read what it produced. Don’t judge it good or bad yet. Just notice: what’s there? What’s missing? What surprised you?
React: Write a response with one thing that worked, one thing that didn’t, and one direction for the next cycle.
Cycle again: Give that feedback to the AI. Look at what changed.

Example reflection: “I asked for a landing page and got something functional but generic. Seeing it made me realize I cared more about tone than layout. On the second cycle I focused on voice instead of structure, and the output shifted dramatically. What I wanted only became clear after seeing what I didn’t want.”

Your reflection: How did your understanding of what you wanted change after seeing the first output? Did the second cycle feel different from the first?

Exercise 2: Five Cycles

Time: 1–2 hours over a few days

Pick a slightly larger project — a page of documentation, a small script, a design mockup.

Run five complete cycles. After each one, wait at least a few hours before the next. Let your judgment settle.

Reflection: How did your sense of what you wanted evolve? What patterns do you notice in your own reactions? Where did you have clarity, and where were you still fuzzy?

The loop is the mechanism through which real work happens. But it requires something from you — not technical skill, not perfect prompts. Something more fundamental. That’s what Lesson 2 is about.