From For-L∞ps to Feedback L∞ps

Every programmer learns l∞ps in the first week.

for (let i = 0; i < 10; i++)—do this thing ten times. It’s the first real power you feel as a beginner. You tell the machine to repeat, and it repeats. Tirelessly, perfectly, without complaint. You’ve just discovered leverage.

But here’s the thing about a for-l∞p: you have to know everything upfront. You know the start. You know the end. You know the step size. The l∞p doesn’t learn anything. It doesn’t adapt. Iteration ten is identical to iteration one, just with a bigger counter. It’s repetition without evolution.

For decades, this was the dominant metaphor for how we thought about computation. Define the procedure. Execute the procedure. Repeat the procedure. The programmer’s job was to think clearly enough upfront that the l∞p could run without supervision. Intelligence was front-loaded. Execution was mechanical.

AI broke this model.

When you work with a language model, you’re not writing a for-l∞p. You’re running a while-l∞p with no predetermined exit condition. You iterate until something feels right. Each pass through the l∞p produces different output. Each output changes what you feed in next time. The l∞p learns. Or rather, you learn, and the l∞p is the mechanism through which your learning gets expressed.

This is the fundamental shift: from l∞ps that execute to l∞ps that explore.

A for-l∞p is a hammer. You know exactly where the nail is. You’re just driving it in. A feedback l∞p is a flashlight in a dark room. You don’t know where anything is. Each sweep of light reveals a little more, and what you see determines where you point the light next.

Consider how a traditional programmer works: they think about the problem, design a solution in their head, write the code, test it, debug it. The thinking happens before the l∞p. The l∞p is just verification.

Now consider how someone builds with AI: they start with a rough idea, describe it to the model, look at what comes back, notice something unexpected, adjust their description, look again, realize the problem is different than they thought, redesign on the fly, iterate, iterate, iterate. The thinking happens inside the l∞p. The l∞p is the thinking.

This is deeply weird if you come from traditional programming. You’re used to l∞ps being the dumb part—the part where the machine does exactly what you told it, over and over. Now the l∞p is the smart part. The l∞p is where discovery happens. The l∞p is the whole point.

And it goes deeper. In traditional code, you optimize l∞ps by reducing iterations. Fewer passes, less work, faster program. The ideal l∞p runs once and gets it right. In AI work, you optimize l∞ps by increasing their quality, not reducing their count. More iterations often means more learning, which means better output. The ideal isn’t fewer l∞ps. It’s richer l∞ps.

There’s a beautiful irony in this. Programming gave us l∞ps as a way to automate repetition—to take the human out of the cycle. Do it once, then let the machine do it ten thousand times. But the most important l∞p in AI puts the human back in. Every iteration requires a human judgment call. The machine generates. You evaluate. The machine adjusts. You evaluate again. It’s the opposite of automation. It’s collaboration at the speed of thought.

The for-l∞p said: “I know what I want. Do it many times.” The feedback l∞p says: “I don’t know what I want yet. Help me figure it out.”

Both are l∞ps. Both involve repetition. But they’re as different as marching and dancing. One follows a predetermined path. The other finds its path by moving.

The programmers who thrive in the AI era will be the ones who internalize this shift. Who stop thinking of l∞ps as mechanisms for execution and start thinking of them as mechanisms for understanding. Who realize that the most powerful l∞p isn’t running inside the computer at all.

It’s running between you and the machine. And every iteration makes both of you smarter.