Loop Engineering: What It Means for Southeast Asian Developers

A few weeks ago, the most important skill in agentic coding didn’t have a name. Now it does.

In early June 2026, Peter Steinberger posted a single line that racked up over six million views: “You shouldn’t be prompting coding agents anymore. You should be designing loops that prompt your agents.” Within days the term loop engineering had a guide, a five-part framework from Addy Osmani, and an unusually blunt endorsement from Boris Cherny, the lead on Claude Code, who described his own job now as — simply — “writing loops.”

When the people building the most advanced coding agents on earth tell you the work has moved from prompting to writing loops, that’s not a hype cycle. That’s the job changing under your feet. And for a company literally named Inference Loops, advising developers across Southeast Asia, it’s the topic we’ve been circling for every post this year. So let’s name it plainly and map it out.

What loop engineering actually is

Loop engineering is the shift from prompting an agent to designing the system that prompts the agent.

In the prompting era — which is to say, last year — you sat inside the loop. You typed an instruction, read the output, typed a correction, read again. You were the feedback mechanism. Every iteration ran through your keyboard and your attention.

Loop engineering moves you out of that seat. Instead of being the feedback loop, you design it: you decide what triggers the agent, what tools it has, what counts as success, and when it’s allowed to stop. Then you let it run. As SmartScope’s write-up on the trend puts it, the human moves from inside the loop to above it — from operator to architect. You stop steering each turn and start engineering the thing that steers itself.

This is the same arc we traced in our post on the inference loop: coding becoming a loop, not a keystroke. Loop engineering is the discipline that arc produces — the named skill of building those loops well.

The two things every loop needs

Strip a working agent loop to its essentials and you find two non-negotiable parts, well captured in Matthew Berman’s framing of the trend:

1. A trigger. Something kicks the loop off — a human command, a schedule (run every night), or an event (a pull request opened, a test failing). The trigger is what turns a one-shot tool into a standing system.
2. A verifiable goal. The loop needs to know, mechanically, whether it has succeeded — a unit test passing, CI going green, a spec matching output. Without a checkable goal, the loop either stops too early or never stops at all.

That second requirement is the whole game, and it’s worth dwelling on. Loop engineering has an almost exact analogy in reinforcement learning: both need a verifiable reward. An RL agent with no reward signal learns nothing; a coding loop with no verifiable goal drifts forever or declares false victory. This is why the hard problems in loop engineering aren’t the loop itself — they’re verification and stopping conditions. Writing the while loop is trivial. Knowing whether the work is actually done, and getting the agent to stop at exactly the right moment, is the part that separates a demo from a system you can trust overnight.

We made the engineering version of this point in the agent loop pattern post: the quality of your verification phase caps the quality of your agent. Loop engineering is that principle promoted to a job title.

The three-layer model: Harness → Loop → Orchestration

The most useful framework to come out of this month is a clean separation of the agentic stack into three layers. Get these straight and most of the confusion around agents dissolves.

Layer 1 — The Harness. This is the runtime scaffolding around a single model call: tool dispatch, context management, safety, persistence. It’s the non-model machinery that turns a raw LLM into something that can read a file, run a command, and remember what it did. We dissected this layer in detail in the agent loop pattern post. The harness is infrastructure — mostly something you adopt (Claude Code, Cursor, an Agents SDK) rather than build from scratch.

Layer 2 — The Loop. This is where loop engineering lives. Given a harness, the loop is the feedback cycle you design on top of it: the trigger, the tools you expose, the verifiable goal, the stopping condition, the memory the agent carries between turns. This is the layer that’s your craft and your differentiation. Two teams using the identical harness will get wildly different results depending on how well they engineer the loop.

Layer 3 — Orchestration. This is the coordination of multiple loops and agents: running them in parallel, in pipelines, on schedules; one loop reviewing pull requests while another compares specs to implementations nightly; sub-agents fanning out and reporting back. Orchestration is where individual loops become a system that does sustained work without a human babysitting each one.

The progression matters: you adopt a harness, you engineer the loop, you scale with orchestration. Most teams over-invest in chasing the newest harness (or the newest model inside it) and under-invest in the middle layer — the loop — which is exactly where the leverage and the durable skill actually are.

Why this is Southeast Asia’s bet to make

Here’s where it gets specific for the region, and why we think loop engineering is the single best skill bet a Southeast Asian developer can make right now.

Start with the market. Southeast Asia’s AI opportunity is projected to add on the order of a trillion dollars to regional GDP by 2030 — a 13–18% boost. Singapore launched the world’s first Agentic AI Framework in January 2026 and runs a national supercomputing centre with serious dedicated AI compute; Indonesia reports worker generative-AI usage north of 90%; the regional data-centre build-out is enormous. The demand for people who can build reliable agent systems is not coming — it’s here, and it’s regional.

Now layer on the thesis from our post on the developer’s evolving role: agents are squeezing the old junior-implementation work that much of the region’s tech on-ramp was built on. Loop engineering is the answer to that squeeze, not a victim of it. Why?

Because loop engineering is a skill, not a headcount. It doesn’t require a frontier lab, a massive team, or expensive infrastructure — the harnesses are commoditizing fast and available to anyone. What it requires is judgment: the ability to design a verifiable goal, build a good feedback loop, and know when the work is genuinely done. That’s learnable, it’s portable, and it multiplies one developer’s output enormously. A loop engineer in Phnom Penh or Jakarta, running the same Claude Code or Cursor harness as one in San Francisco, competes on the layer where talent and judgment matter — not on the layer where capital and headcount do.

This is the leapfrog made concrete. The region doesn’t need to out-spend anyone on models or data centres to win here. It needs to produce developers who are excellent at the middle layer — the loop — and orchestration on top of it. That is a far more level playing field than the region has ever had in software.

What Inference Loops is doing about it

We didn’t pick our name by accident, and we didn’t pick this moment by accident either. The whole arc of our writing this year — the inference loop, the anatomy of the harness, the developer-as-orchestrator, and now loop engineering — has been building toward a single, unfashionable claim: the loop is the unit of value in agentic software, and Southeast Asia can own that layer.

So that’s what we build around. We design and audit agent loops and harnesses for teams that need them to work in production. And through how we hire and train, we’re betting on exactly the people this moment rewards — engineers, including early-career ones, who can be taught to think in triggers, verifiable goals, and stopping conditions rather than in keystrokes.

Conclusion

Loop engineering got its name in June 2026, but the shift it describes has been underway for the whole agentic era: the developer’s job is moving from typing prompts to designing the loops that prompt agents — from inside the loop to above it. The three-layer model makes the work legible: adopt a harness, engineer the loop, scale with orchestration, and pour your effort into the middle layer where the leverage lives.

For Southeast Asia, this is the most encouraging development in years. The hottest skill in software right now is one that rewards judgment over capital, and judgment is something the region can build at a cost structure the expensive markets can’t match. The loop is the opportunity. We intend to help the region own it.

If your team is learning to engineer loops — or wants engineers who already can — let’s talk.