From Code Engineering to Loop Engineering

A few months ago, Shopify’s head of engineering, Farhan Thawar, gave a talk at Compile 26 called “What Is Your Job Now.” He runs engineering for 3,000 engineers at Shopify — first customer of GitHub Copilot back in 2021, full agentic rollout since. He’s not speculating; he’s reporting.

His closing line, from the talk transcript: “The clankers will write and review code. Get over it.”

The part that stuck with me — the thing I’d already felt but hadn’t named — was his framing of what’s left. Thawar describes two loops he runs every day. The parallel loop: break a task into subtasks, hand each one to an agent, come back and consolidate and validate. The sequential loop: pair deeply with one AI on a big reasoning model, then have a second model interrogate the first. You’re not writing the code in either of them. You’re designing the loop the code runs through.

This is the third post in a series I didn’t plan to write. Two weeks ago I said every engineer just became a manager. Last week I said the bottleneck moved to review. Now comes the prescriptive part: your job is to write the loops.

Because the loops are failing. A recent survey by Coleman Parkes for Undo put numbers on it: 300 senior engineering leaders, mostly running mission-critical systems. Their teams spend 9.8 hours a week producing code with AI agents — and 16.9 hours a week debugging it. 35% of the AI-generated code reaches production before the team has fully understood it. Eighty-one percent had at least one production incident tied to it in the prior six months.

Read those numbers as a leadership diagnosis: 16.9 hours of debugging a week is a missing validation loop, and 35% of code shipping uncomprehended is a missing understanding loop. These teams handed the writing to the machine and never built the loops around it. The code got faster; the engineering didn’t.

Thawar’s team hit the same wall I wrote about last week. “The bottleneck is code review,” he says. PR volume and PR complexity both went up at Shopify. And here’s the part that should make every eng manager wince: he flashed the four scariest letters in the human language — LGTM — and said the humans were never good at this either. So Shopify built a review loop out of the same material: a council of LLMs, different models checking different things, deciding whether code goes to production or gets sent back with commentary. The review queue gets its own loop. Nobody demos it, but that’s where finished work comes from — I said that last week, and Shopify is living it.

So what does “write the loops” mean, practically, for a leader? Here’s what Shopify actually does, and what I’d steal:

First, the humans keep the responsibility. “Responsibility can be shared, but it cannot be given away. Your name goes on the PR.” The loop doesn’t dilute ownership — it concentrates it.

Second, protect human time like it’s the scarce resource, because it is. Shopify lets engineers use only the biggest, most expensive models. A smaller model’s bug costs a human many hours to find. Human debugging hours are the bottleneck, so you don’t optimize the model bill at the expense of the review bill.

Third, no token limits, but circuit breakers. Runaway agents get stopped and the engineer gets a message: you’ve spent X dollars today, keep going? This is the management loop around autonomy — guardrails, not permission slips.

Fourth, stop managing by spreadsheet. Token counts, PR counts, lines of code — Shopify watched all of them move and concluded none of them can tell you if a team is good. Their best artifact: an intern deleted six lines of code and saved $600,000 a year in infrastructure spend. No metric on any dashboard would have flagged that intern as awesome. What they track instead: project duration is going down, PR complexity is up, and — my favorite — the ambition of projects is going up. Weekly demos are how they gauge velocity. Learning every week, not shipping every week.

And Thawar had my favorite answer to the question every executive is asking — “can’t I make my dev team smaller?” His version: “We have 3,000 engineers. Why can’t they act like 100,000?” The cost of trying something collapsed, so the only failure is thinking small.

The corollary that cuts deepest for hiring: the value moved to taste and judgment. Thawar’s line to people bringing him work: “How did you choose this solution among the 10,000 possible right solutions?” That’s the spec-writer instinct, the skeptic instinct — the archetypes from my first post in this series. The loop designer is the engineer who can hold ten thousand options and pick the green path.

Thawar closed with the line that ties all three posts together: the code is not the collateral. The learning is the collateral. His story — a 50-person team, 18 months of work, walked out of a founder review and rebuilt the simpler architecture in 3 months — is the whole thesis in one anecdote. The first system was a loop of learning disguised as a project.

So here’s the mandate for your team: stop evaluating engineers on what they write, start evaluating them on the loops they build. Does every agent’s output pass through a validation loop a human designed? Is your production full of prototypes someone LGTM’d at 5pm? Are your review loops keeping up with your generation loops?

The clankers write and review the code. The loops are the job. Write good ones.