A new generation of coders who can't code.

2.7 million views for telling engineers to stop writing code and start "designing loops that prompt your agents."

Wait, so now we write code not with prompts but loops? 

Great. Let's follow that logic all the way to the end.

The post came from Peter Steinberger, the man behind OpenClaw, the fastest-growing open-source AI agent on GitHub, about which plenty has already been said.

Interestingly for me, he is also the guy The Pragmatic Engineer interviewed under the title "I Ship Code I Don't Read," and as of February, he works at OpenAI. Hold that last detail, we will come back to it. The pitch, in his own words:

“You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents.”

The idea behind it is that you no longer even prompt. You describe the problem, build a loop around the agent, and let it figure out the rest on its own. No more typing instructions. 

You become the architect of a machine that types the instructions for you.

So, here is where I see things and why this is problematic and has a real-world impact. 

First problem: nobody actually knows what a "loop" is

The audience cheering this on can't even agree on what is being sold. Under the viral post, you get (ironic, I guess) replies like the one below, asking, in all seriousness, whether these are even Python loops, then following up that "in his post, it sounds like there is no prompting at all."

There are some honest questions like "How are people using loops?" and even what are these agent loops, how is that different from just prompting, and are we really so lazy that typing a prompt is now too much? 

When the people building and boosting this stuff are asking each other what the thing is, you are not looking at a methodology. You are looking at a vibe.

My favorite take on the whole genre came from Daksh Gupta, who nailed the San Francisco hype cycle perfectly: Boris Cherny goes on a podcast every few months, says something like "I've stopped breathing now I just wrote a breath.md," and the next day everyone in SF stops breathing. 😊

An unclear phrase or sometimes just a screenshot from the right person is just enough, and suddenly, a few thousand people reorganize their entire workflow around a tweet.

And, of course, the vendors are already “shipping” vibe-coded solutions. 

But let’s continue because there is a real argument underneath these slogans.

This is nothing new.

Ok, before we dive in, I feel like I have to say this.

This is not a new idea.

Yes!

All of this is the same "run the agent in a loop" idea that was the Ralph Wiggum loop a few months back, now wearing a new hat:

The technique didn't change - the title did. I am starting to think that AI influencing is itself a while-loop: same idea, new buzzword, post, repeat. 

From Prompting to Looping to NOT writing code? 

The loop argument quietly assumes one thing: that a whole generation of engineers will spend the next few years clicking “Accept” in Claude Code without really understanding what the code does. And that's fine, the argument goes, as long as one condition holds. 

AI keeps getting smarter than the people who used to write that code.

This is a bet. A big one.

The bet is that within a few years, these systems will beat the best system engineers and architects at their own job. Not faster versions of what already exists on GitHub. Actual novel design, new patterns, new architectures, new programming languages, new frameworks. 

Pretty much - PROGRESS.

Yes, coming up with “new stuff”, which has been the one issue that even the big labs agree LLMs are bad at.  

If that happens, great. The humans were just training wheels, and we can either throw them out of the equation or let them write poetry. 

But what if it doesn't? 

What I see today is that these models are excellent at extrapolating known solutions. Give them a problem that looks like a million other problems, and they nail it. Give them something genuinely new, and they confidently produce something that looks right and isn't. I made this point in more detail when I wrote about why rapid enterprise adoption of generative AI is questionable, and nothing in the last two years has changed my mind. The models are pattern machines. They are spectacular at the average case and quietly dangerous at the edge case.

Teams are Already Looping

The loop is not a thought experiment. It is already running in companies worldwide. 

There is a post going around r/cscareerquestions titled "My senior engineers have stopped thinking for themselves." 2.1K upvotes, almost 600 comments. The author describes a tech lead who used to whiteboard system designs for hours and now ships a PR labeled "refactored auth flow based on ChatGPT output." When asked to walk through the changes, the answer was "just paste it into ChatGPT and ask it to explain."

It gets better. Another senior on the same team approves PRs in three minutes flat by pasting the diff into a chat and using AI to evaluate it. 

AI writes, AI evaluates.  

That habit let a race condition into production. When it was flagged, the response was "well the AI said it was thread safe."

That is the loop. That is the finished product of "stop prompting, start designing loops." Nobody on that team is reading the code that goes to production. The AI thinks the codebase is a fresh greenfield project with no legacy constraints, and the humans have stopped checking. 

And that is where both slogans hit hard. 

Version one - New world - “This is an upgrade, stop thinking, start building”

The Reddit post reframes it as what it actually is: a team that has lost the ability to reason about its own systems.

You can call that one Reddit thread an outlier. The problem is that there is no data behind it, and it comes from an AI lab. In January, Anthropic published a randomized controlled trial that put developers through a coding task with and without AI help, then quizzed them on what they had just built. The AI group scored 50%. The hand-coding group scored 67%. 

Guess the biggest gap? 

It was on debugging questions, which is to say the single skill you need most to catch when AI-generated code is quietly wrong. There is a footnote worth reading twice: the study used a simple sidebar assistant, and the authors expect the effect to be more pronounced with agentic coding products. The loop does not soften this. It is the strongest version of it.

To be fair, the study also found that how you use AI matters. The people who asked the model to explain its output, who used it to build understanding rather than skip it, held on to far more. Which is the same line I keep coming back to in this industry: using AI to inform a human is a completely different thing from using it to replace the human. 

So yeah, the gap between the tweet and the comment section is the whole story.

Who writes the next pattern?

If most engineers forget how the machine actually works, and the machine never learns to invent, who maintains the critical systems? Who does the research that creates the next pattern for the agent to copy?

The models learned to code by ingesting code that humans wrote and explained. They are good at Ruby on Rails auth flows because there are a million Ruby on Rails auth flows in the training data, written and debugged and argued over by people who understood them. Remove those people, and you don't just lose the maintainers. You lose the source of the next generation of training data. The agent gets very, very good at imitating 2025 and has no idea what 2030 looks like, because nobody is inventing 2030 anymore.

We are betting there is no gap between "good enough to replace the engineer" and "good enough to replace the researcher."

That is the entire bet, compressed and again, it is a good one. 

Because today, we have Mythos released and the “mindblowing” examples are again using AI to build already existing stuff - Mindcraft clones, for example. 

But wait, I am not done yet. 

Why the labs are very happy about this

It is in the direct commercial interest of the AI labs that you stop understanding your own code. The productivity-influencer crowd never mentions this part.

Think it through. If your engineers can read, reason about, and fix the systems they run, you have leverage. You can switch tools, bring work back in-house, negotiate. The model is a helper. But if your team has spent three years clicking Accept and nobody left can explain the auth flow, then the only entity on earth capable of fixing your codebase is the lab that produced it (and the next, more expensive model it sells you). Dependence is not a side effect of the loop. For the vendor, it is the product.

To be clear, I am not saying every lab is running this play on purpose. But the structural incentive does not care about anyone's intentions. A market where customers cannot maintain their own systems is a better market for whoever sells the maintenance, and that is true whether the vendor is rooting for it or not.

I am not the only one who sees this. Under the same wave of loop posts, Duca asked whether anyone is actually using loops, and answered his own question: it sounds like an effective way to funnel money out of your pocket and into the AI labs. Blunt, and basically correct.

And now back to that detail I asked you to hold. The man who told 2.7 million people to stop prompting and start designing loops, who built his reputation on shipping code he does not read, took a job at OpenAI in February. I am not saying that is a conspiracy. I am saying incentives are incentives, and the person selling you on giving up a capability now collects a paycheck from the company that sells you the replacement. 

Read the pitch again with that in mind.

I have written before about taking vendor AI narratives at face value, in the Klarna case, where a year of "we replaced 700 people with AI" quietly turned into "we are hiring humans again." The lesson there is the lesson here. 

When someone with a commercial incentive tells you to give up a capability, ask who is holding the capability afterwards. In the Klarna story it was the headline. In the loop story it is your ability to understand the thing your business runs on.

Where I land

I am not anti-agent. I use these tools every day, and for the average case they are excellent. If you are scaffolding a CRUD app or refactoring something that has been written ten thousand times before, design your loop and go to lunch.

But "stop prompting" is not a workflow tip. It is a wager that the model will cross from imitation into invention before your team forgets how the machine works. Maybe it will. The people pushing the bet certainly talk like it is already settled.

I personally wouldn't make that bet.