Zero to Agent in 30 Minutes: From Prompting to Loop Engineering with Ofer Mendelevitch

Michelle Smith · rss · 2026-08-18 source ↗ Reader 🖥️

Agentic Loop Coding Agents Loop Engineering Multi-Agent Orchestration Verifiability (as the Quality Bar)

Moving a coding-agent workflow from fully human-prompted toward autonomous happens in two escalating steps -- replace a sequence of individual prompts with one verifiable goal the agent can check itself against, then add a second agent as an independent reviewer of the first -- and doing both reduces required human intervention while raising code quality.

practical · expository — A short O'Reilly Radar write-up previewing/recapping a live webinar episode. It argues for a specific practice (how to move a coding-agent workflow toward autonomy) via a single worked example, rather than building a sustained theoretical case. Genuinely thin: 404 words, no direct quotations from the speaker, a numbered how-to list plus a one-paragraph frame and conclusion. Extracted as-is rather than padded to look like a fuller piece.

Structure

Part	Role
Opening frame: Ofer Mendelevitch used a package-version-resolver example to compare step-by-step prompting, loop engineering, and multi-agent collaboration.	context
Step 1 -- start with explicit prompts in every step (baseline).	premise/starting point
Step 2 -- define a verifiable goal so the agent iterates on its own (loop engineering).	core claim
Step 3 -- add a second agent as reviewer, then generalize to a larger team of specialized agents.	extension of the core claim
Closing paragraph restating the benefit (less human intervention, higher quality).	conclusion
"Coming next week" teaser for a different episode (voice-first workflow with OpenAI Codex, hosted by Craig Hewitt).	unrelated promotional material, not part of the argument

Key terms

loop engineering Loop Engineering
Replacing a sequence of individual human prompts with a single end-result the agent can check for itself -- the agent inspects code, adds tests, runs them, fixes failures, and verifies packaging, continuing until a defined goal is met, without a human prompting after each step.
verifiable goal
A task framing (e.g. 'implement the resolver and be ready to ship with packaging') specific enough that the agent itself can determine whether it has been met, as opposed to a goal only a human can judge.
reviewer (agent)
A second coding agent assigned to examine the first agent's work against the specification, give feedback, and run additional checks including adversarial probes -- distinct from the agent that writes the code.

Propositions

explicitCoding-agent workflows can be arranged along a spectrum of increasing autonomy: fully human-prompted (step-by-step), then loop-driven (single agent, verifiable goal), then multi-agent (coder plus reviewer, potentially a larger specialized team).conf: high
supportsZero to Agent in 30 Minutes: Build a Workflow Agent with John Berryman · p10 — Same 'add complexity only incrementally, prove each simpler layer first' principle from a sibling episode of the same webinar series, applied here to prompting -> loop -> multi-agent-review instead of that episode's app-plumbing -> stub -> agent -> toolkit -> skill build order.
explicitReplacing step-by-step prompting with one verifiable goal lets an agent inspect its own code, add and run tests, fix failures, and verify packaging, iterating until the goal is met without waiting for another human prompt after each step.conf: high
supportsLoop Engineering · p2 — Restates the same core loop-engineering move -- swap step-by-step prompts for one end-state the agent checks itself against -- using a concrete coding example (a package resolver) rather than Osmani's general definition.
supportsWhat is “loop engineering?” · p5 — Matches the claim that a well-engineered loop is judged mainly by whether it reaches a verifiable completion state (tests passing, etc.).
explicitcontestedAdding a second agent as an independent reviewer -- examining the specification, giving feedback, and running additional checks including adversarial probes -- can further reduce human intervention and raise code quality beyond what a single looping agent achieves.conf: high
supportsLoop Engineering · p7 — A concrete two-agent (Jam) instantiation of the structural element Osmani names as the single most useful loop primitive: separating the sub-agent that drafts from the sub-agent that checks.
contradictsArticle: Multi-Agent AI for Production Security Operations: An A2A and MCP Architecture in a 5G Core · p3 — The production-security piece insists a reviewer agent's safety logic must be codified as version-controlled, deterministic policy rather than reasoned about by an LLM at runtime -- directly at odds with this article's LLM-reviewer-agent pattern (examine spec, give feedback, run adversarial probes) for coding review.
explicitcontestedThe two-agent coder/reviewer pattern generalizes to a larger team of specialized agents covering security, compliance, testing, frontend, backend, and DevOps.conf: high
contradicts ←No Vibes Allowed: Solving Hard Problems in Complex Codebases – Dex Horthy, HumanLayer · p6 — That source argues the two-agent coder/reviewer pattern generalizes into larger teams of named-role specialist agents (security, compliance, frontend, backend); this talk explicitly argues against exactly that anthropomorphized-role pattern, saying sub-agents exist for context isolation, not role specialization.
implicitPairing different underlying coding-agent models so that one model can challenge work produced by another improves the rigor of review, beyond what same-model self-review would provide.conf: medium
implicitFraming coding work as a definable, machine-checkable goal -- rather than as a sequence of prompts -- is the pivotal shift that unlocks the further autonomy gains of loop engineering and multi-agent review.conf: medium

Arguments

Defining a verifiable goal, rather than prompting step by step, lets an agent work through a coding task with less human intervention. strength: medium

Explicit premises:

A verifiable goal lets the agent inspect code, add tests, run them, fix failures, and verify packaging on its own
In the demoed example, the agent worked through the resolver task to completion this way

Implicit premises:

A goal can be reliably operationalized as something machine-checkable (tests passing, packaging succeeding) such that 'checks pass' is a trustworthy proxy for 'the task is actually done correctly'
The agent's self-assessment of having met the goal can be trusted without independent (human) confirmation

Inferences:

If the verification step itself is weak or gameable, the loop could converge on a state that passes its own checks without meeting the intended spec -- a possibility the article never raises

Adding a second agent as reviewer improves code quality and further reduces required human intervention beyond a single looping agent. strength: low