← All editions
newsPublished 2026-07-03

Cold Open — AIEWF signs off with the great loops debate

The AI Engineer World's Fair closed Friday with a debate that cut to the heart of how agents actually work — are 'loops' the right architectural primitive at all? Plus: Simon Willison and the Claude Code team share a judgment-based approach to model delegation that is quietly becoming a production pattern, and course creators report 50%+ revenue drops as AI reshapes developer education.

▶ video
Cold Open — AIEWF signs off with the great loops debate
— views

Friday, July 3, 2026. We ran 21 sources today; three stories made the cut — one of them the closing chapter of a week-long conference that changed the vocabulary of AI engineering.

Listen to today's episode on the Cold Open podcast page.

The lead · AIEWF closes with the great loops debate

AIEWF closing day — the great loops debate on agent architecture

The AI Engineer World's Fair ended Thursday, and the closing sessions surfaced the week's most fundamental disagreement: is the loop the right way to think about autonomous agents at all?

Two camps. On one side: practitioners who say the loop — an agent that checks, acts, checks, acts until done — is the natural atomic unit of autonomous work. It is simple, composable, and easy to explain. On the other: practitioners who argue that loops without explicit state, without checkpoints, and without human-legible intermediate artifacts fail silently and expensively at exactly the moment they matter most.

The state-of-AI-engineering report presented Thursday offered a pointed data frame: teams using agents in production are spending a growing fraction of their time not writing new agents — but debugging and constraining existing ones. Loop observability tooling is still immature. The patterns for knowing when a loop should stop, retry, or escalate to a human are still being invented in production codebases.

The closing keynotes on "what to build next" converged on a single answer: build the missing infrastructure. Not more capable agents. The scaffolding that makes agents trustworthy.

Why it matters

If Monday's AIEWF sessions introduced "software factory" as the deployment model, Thursday's closing debate named the load-bearing problem underneath it: loops without constraint become loops that fail without warning. The teams that win the next eighteen months are not the ones with the most autonomous agent — they are the ones who figured out when and how to stop it.

This "build the missing infrastructure" signal is worth logging. It echoes what Anthropic's Claude Code team said in Wednesday's fireside chat, what Vercel's eve framework implicitly acknowledged with its sandbox primitive, and what Geoffrey Litt argued Wednesday when he warned about cognitive debt. The vocabulary is converging: the risk is not capability. It is controllability.

The fine print

The "great loops debate" is not a settled argument — it is an ongoing conversation among practitioners with skin in the game. The state-of-AI-engineering report is from conference reporting, not a published paper. Treat the direction as credible; wait for the public release before citing specific numbers.

Sources: latent.space/p/aiewf-daily-dispatch-locomotives · ai.engineer/worldsfair

02 · Fable's judgment — let the model route itself

Simon Willison's Fable judgment tip — model delegation in Claude Code

Simon Willison shared a tip Wednesday that kept circulating Thursday: let Fable use its own judgment rather than prescribing how it should work. The example came from the Claude Code team's fireside chat at AIEWF with Cat Wu and Thariq Shihipar.

The concrete pattern on testing: instead of telling Fable "only write tests for large features," tell it to use its own judgment about when tests add value. The model is better at that call than a human-authored rule written before seeing the actual task.

A second tip arrived from Jesse Vincent: tell Fable to delegate smaller coding tasks to lower-power models and let it decide which one. The prompt Willison used — "For all coding tasks use your judgement to decide an appropriate lower power model and run that in a subagent" — generated a memory file that Claude Code stored and applied project-wide going forward.

Why it matters. When the model routes itself, it applies judgment at decision time, with the actual task in context. A rule written in advance cannot do that. This "judgment at the point of action" principle is becoming a real production pattern among Claude Code power users — and it compounds: the model's routing decisions improve as it accumulates project context.

Source: simonwillison.net/2026/Jul/3/judgement

03 · The developer education reckoning

Course creator revenue down 50% — the AI education reckoning

Josh W. Comeau posted this week with numbers that landed hard: revenue down roughly a third on his latest course launch, with his existing courses down significantly from last year. Other course creators confirmed the same pattern — across the board, down 50% or more.

He named two causes. First, job uncertainty: developers are reluctant to invest in learning new skills when they are not sure their roles will exist in six months. Second, LLM substitution: "even if they do want to learn new dev skills, LLMs can provide personalized tutoring, so there's less incentive to buy a paid course." He added the sharper edge: LLMs are trained on the content these same educators created, without consent or compensation.

The post surfaced via Salma Alam-Naylor's blog, which titled its piece "Goodbye forever, probably" — a pointed sign-off from a practitioner taking stock of what is changing.

Why it matters. This is the feedback loop the builder community tends not to discuss. AI tools are improving developer output; they are simultaneously hollowing out the educator market that trained the builders who built those AI tools. The question of how knowledge transfer works in the next decade for developers is not hypothetical anymore. These are the practitioners writing the first draft of the answer.

Source: simonwillison.net/2026/Jul/3/josh-w-comeau · whitep4nth3r.com/blog/goodbye-forever-probably

Also on the radar

  • Google DeepMind × A24 — The frontier AI lab and the indie film studio (Everything Everywhere All at Once, Hereditary, Midsommar) announced a first-of-its-kind research partnership. Details are sparse; the pairing is genuinely unusual — a lab known for scientific rigor partnering with a studio known for aesthetic risk-taking.
  • ctx — Show HN (56 pts, 26 comments): a Rust CLI that ingests coding agent transcripts into SQLite and lets agents search past sessions before starting new work. Local, no vector database. The "agent history research subagent" pattern is the real idea here.
  • deptrust — Show HN: a CLI + MCP server that checks npm, PyPI, crates.io, and 10+ other package registries against known CVEs before agents install or suggest dependencies.
  • Kagi AI toggle — Kagi shipped granular AI-feature controls in its July 2 changelog so users can opt in or out per-feature, not just globally.

Trends in dev tools

What moved today in the tools engineers actually ship with.

  • ctx brings long-term agent memory, locally. The "agent history research subagent" pattern — spawn a subagent whose only job is to search past transcripts for relevant history before the main task starts — is a clean, practical answer to one of the most complained-about gaps in agentic UX. No hosted service, no graph database: just SQLite and a Rust CLI that runs entirely on your machine. Source: github.com/ctxrs/ctx · HN discussion
  • deptrust is the missing safety layer for agentic package management. Agents suggesting outdated or vulnerable package versions is a recurring production problem. deptrust checks public registries before the agent installs. The MCP server mode means it can be wired directly into Claude Code or any MCP-compatible workflow. Source: github.com/clidey/deptrust · HN
  • Model delegation via memory is a native Claude Code pattern now. The Willison / Jesse Vincent tip — let Fable route smaller coding tasks to lower-power subagents — works because Claude Code stores the instruction as a project memory file and applies it automatically. This is agent-level cost management that also improves latency, and it requires zero tooling changes. Source: simonwillison.net
  • Kagi's per-feature AI toggle is a UI design signal. As AI features proliferate in every product, giving users per-feature controls rather than a single on/off switch is how you avoid a backlash. Watch for this pattern to spread. Source: kagi.com/changelog

Popular skills

The agent-skills wave — portable instruction folders loaded on demand — keeps surfacing new patterns this week.

  • The loops debate crystallizes the "orchestrator vs. loop" skill design question. Whether you call it a skill, a runbook, or a loop, the AIEWF closing debate surfaces the same design problem: agents without explicit intermediate state are harder to debug and cheaper to break. Skills that include explicit checkpointing and escalation conditions are more robust than skills that simply say "repeat until done." The missing infrastructure the keynotes called for is, in part, better skill design.
  • Memory-as-skill — the Fable judgment pattern. The Willison tip works because Claude Code treats a user instruction as a memory file — a persistent, project-scoped skill the agent reads before each task. This is the skills pattern operating at the OS level. You can author these deliberately, not just incidentally, and scope them to teams, projects, or individual workflows.
  • ctx positions "agent history research" as a reusable subagent role. The ctx README describes an "agent history research subagent" in plain language: before working in an area, spawn a subagent to search past sessions for relevant history, then hand a brief to the main agent. That is a skill definition. The pattern is composable, repo-agnostic, and works with any agent framework that supports subagents.

AI fun fact

Google DeepMind and A24 announced a research partnership today, and the pairing is genuinely strange. A24 is the studio behind Everything Everywhere All at Once (the most Oscar-nominated non-English film ever) and Hereditary — films known for taking creative risks that larger studios avoid. DeepMind is the lab that built AlphaFold, AlphaGo, and Gemini. The details of what they are researching together have not been released. But the last time a frontier lab partnered with an arts institution known for doing unexpected things, it tended to produce work that neither side could have made alone.

Source: deepmind.google/blog

Sources

Comments