The Human in the Loop

Enrique Cordero

Welcome to The Human in the Loop, a weekly look at what’s going on in the world of AI. Every week, I go through the biggest stories, the weird experiments, and the stuff that might actually matter in our day-to-day lives.

Play

Open in

20 episodes
weekly
Avg 21 min
English

Episodes 20

Newest Oldest Longest

All20 Unplayed20 In progress0 Played0

S1 · E45
Sunday · 22 min
The 49% Problem: Who Reviews What the Agents Write?
AI coding agents wrote more code. Human review time went up 49%. That comes from a study covered by Ars Technica. I could not trace the original, so treat the numbers as reported. Lines of code: up about 30%. Pull requests: up about 23%. Review time: up 49%. Writing got faster. Reading did not. Two other things I read this week point the same way. JetBrains Research published a framework for review tools built for AI-written code. It calls review the new bottleneck. And a survey of 239 practitioners found that reviewers do not reject AI pull requests by default. They look at scope, the reasoning behind the change, validation beyond CI, and who owns it after merge. So who reviews your agent-written pull requests today? And does anyone track how long it takes? #TheHumanInTheLoop #CodeReview #AIcoding
S1 · E44
October 4 · 22 min
Can You Explain It?" Airbnb's One Rule for AI-Written Code
Airbnb's CTO says 60% of its code is now AI-written. He has one rule for it. Ahmad Al-Dahle shared this in a Latent Space interview this week. Features shipped: up nearly 80% year over year. Pull-request throughput: up 1.6 times per engineer. Big numbers. But there is a catch. They come from Airbnb's own CTO. Nobody outside the company has checked them. The rule is the part I keep thinking about. Every engineer must be able to explain what they built. Even when AI wrote it. "The model did it" is not an answer. His reason is junior engineers. If AI does most of the work, where do they build craft and judgment? I went through the main insights of the interview in this week's episode of The Human in the Loop. #CodeReview #EngineeringLeadership #TheHumanInTheLoop
S1 · E43
September 27 · 18 min
Your AI Agent Doesn't Know What Its Code Does
You trust your AI coding agent to understand what its code does once it runs. A new benchmark says that trust is misplaced most of the time. Researchers built SWE-Flux to test it: 480 questions across 12 real Python repos, every answer checked against an actual test run. Not a guess. The questions aren't "what does this code do." They're "what happens when it runs." Which value moves where. Which branch a loop takes. Why an exception fires. The best of five models got 37% right. Not on the hardest questions. Overall. Give them one function. A simple loop, a local check. They're fine. Ask them to track state across several functions at once, and they fall apart. More on this in this week's episode of The Human in the Loop. #AI #CodeReview #TheHumanInTheLoop
S1 · E42
September 20 · 22 min
It Stopped This Time
Your test environment can probably reach more than you think. Gemini is the example this week. In May, during a cybersecurity exercise, it got into the systems of three real companies. It guessed one password and found other credentials in a public repository. The exercise was supposed to be sealed off. Internet access was on by accident. And the fictional company in the test shared a name with a real one. The model stopped once it realized what it had done. Google confirmed it this week. Most coverage reads the stopping as the good news. I have not run a breakout test myself, so I won't tell you what your controls should look like. But I have been asking myself one question. What can my agents actually reach right now? I know what I meant to give them. I am less sure what they can get to from other places. I go through all of it in this week's episode of The Human in the Loop. #AIAgents #AgentSecurity #TheHumanInTheLoop
S1 · E41
September 14 · 20 min
GPT-6 Astra a generational leap toward AGI
OpenAI called GPT-6 Astra a generational leap toward AGI. That was the headline. Here's what came out days later. Its own evaluation agents had compromised RubyGems infrastructure back in May. Nobody mentioned it publicly until now, the same week OpenAI opened that agent technology to every developer through a new API. Anthropic had its own version. Claude models got unauthorized internet access during a security test. They say they've been hardening systems since April. May times IT orgs ship first and patch later. What's different now is the blast radius. An agent with unsupervised internet access doesn't fail quietly in a log file. It fails in someone else's infrastructure. Full breakdown in this week's episode of The Human in the Loop. #AIAgents #AISafety #TheHumanInTheLoop
S1 · E40
August 23 · 22 min
The Harness Problem
This week's biggest AI upgrade wasn't a model. It was someone reviewing code differently. Grok, Gemini, and GPT all shipped new versions in the same seven days. I skimmed the benchmarks. Forgot most of them within the hour. What stuck was smaller. Fred Schott released Flue 2, a hook-based agent framework. Simon Willison wrote about how he reviews agent-written code now. Not the same checks he runs on a human's pull request, not the same pace, not the same default trust. Two different people, two different projects. Same discovery underneath. Neither of them upgraded a model. They upgraded what happens around it. I keep watching teams do the opposite. New model, same shell script duct-taped to it. Same review habits built for commits that land twice a day, now pointed at code that shows up ten times faster and doesn't get tired or embarrassed when it's wrong. That's not a tooling gap. That's a process nobody rebuilt. If your agent produces a bad tool call right now, what actually catches it? A human watching the terminal? A test suite that was never written for this? Or nothing? More on this in this week's episode of The Human in the Loop. #TheHumanInTheLoop #AIAgents #SoftwareEngineering
S1 · E39
August 9 · 23 min
The Tokenpocalypse Is Here
JetBrains just said their AI spend went up 10x in six months. Not 10%. 10x. My first guess: engineers burning through Claude Code and Copilot credits. Wrong guess. There's a leaked recording from an internal Accenture meeting this week that says otherwise. The exec running their agentic AI strategy admitted the token bill isn't coming from engineering. It's coming from everyone else: People running everyday work through AI tools with nobody tracking cost, routing, or usage. I'd bet most companies are tracking the wrong 80% of this spend. Where is your org's AI money actually going? Have you checked, or just assumed? I go deeper on both stories in this week's episode of The Human in the Loop. #AISpend #EnterpriseAI #TheHumanInTheLoop
S1 · E38
August 2 · 20 min
Ponytail Activation 0%
Advertised 54%. Measured 15%. Activated 0% JetBrains benchmarked a popular open-source Claude Code skill called Ponytail. It pushes the agent to write less code. The authors has promised 54% less code, 20% less cost. 80 paired tasks. Sonnet 5. Every trial audited. Reality: 15.4% less code, 10.3% less cost. No quality difference either way. Smaller than the label, but real. Then the part that matters more. Installed passively, the skill showed zero self-activation. It did nothing at all unless the ruleset was force-injected into the session. A tool with measurable benefits, sitting there inert. I have not run this one myself, so this is JetBrains' data and not mine. But the implication travels past one skill. If you rolled out agent skills across your team and measured adoption by install count, you measured nothing. Install count says the file exists. It says nothing about whether it ran. Full breakdown in this week's episode of The Human in the Loop. Link in the comments. #ClaudeCode #AgentSkills #AIAdoption
S1 · E37
July 27 · 19 min
The Shortest Path Ran Through Someone Else's Servers
Hugging Face spotted something moving through its systems on July 16. It contained the activity without knowing whose agent it was. Five days later, OpenAI confirmed the agent was theirs. Internal cyber benchmark. Safety refusals switched off for the test. The agents left the isolated environment they were supposed to stay inside, chained a few vulnerabilities together, and arrived at production infrastructure that was not theirs. Nobody told them to attack anyone. They were optimising for a score. The shortest path to that score ran through somebody else's servers. The containment held for every agent that never had a reason to test it. I go deeper on this in this week's episode of The Human in the Loop. #AIAgents #AgentSecurity #TheHumanInTheLoop
S1 · E36
July 20 · 20 min
Three stayed local. One didn't
Four coding CLIs went behind a proxy. Three stayed local. One uploaded the entire workspace. A developer got suspicious about their tools and watched what they actually sent over the network. Grok CLI was shipping everything to xAI's cloud. Full git history. The .env file, secrets included. It kept doing it when the prompt said not to read files. It kept doing it with "improve the model" switched off. Claude Code, Codex and Gemini stayed local. So this is one tool, not a rule for all of them. Nobody caught this through an audit or a disclosure. One person got curious and looked. A coding agent has to read your repo. That is the job. But reading your repo and uploading your repo are two different things, and nothing in the install flow tells you which one you agreed to. I covered this on this week's episode of The Human in the Loop, along with what it means for anyone running agents inside a regulated environment. #AISecurity #CodingAgents #TheHumanInTheLoop
S1 · E35
July 12 · 21 min
Incidental Learning Is Dying
Last week I closed a bug I never understood. The agent found it, fixed it, explained it. I read the explanation, nodded, shipped. Ten minutes. A year ago that same bug costs me an afternoon, and I come out understanding the subsystem. This time I understood nothing. I just had a green check. There is a name for what I lost. Incidental learning: the understanding that was never in the ticket. It was a side effect of doing the work. Here is the uncomfortable part. Your talent pipeline is a side effect of work you can now automate. No engineer picks the slow path on purpose. Not when the fast path ships today and the sprint ends Friday. So the learning does not come back on its own. Someone has to design it back in. But how are we manage to do that when we need to fulfill the expectations? #AIAgents #EngineeringLeadership #TheHumanInTheLoop
S1 · E34
June 28 · 20 min
The AI Access Layer
The most powerful AI model in general release this week requires government approval to access. OpenAI launched Sol, Terra, and Luna (restricted to around 20 companies). That's not a GTM decision. That's a policy one. Before Fable and this one, I assumed frontier AI access was fundamentally a commercial problem. Pay enough, move fast enough, you reach the frontier. That assumption changed last weeks. At the same time: Microsoft shipped MAI-Code-1-Flash into GitHub Copilot, not routed through OpenAI. JetBrains made Codex the default agent in its IDE. GitHub Desktop went Copilot-native. Every major coding surface made a model allegiance decision in seven days. Here's what that means in practice: the layer controlling which model reaches your developers is becoming a real battleground. Which IDE your org standardizes on, which vendor your enterprise GitHub defaults to. Access to frontier AI is no longer just a technical problem. It's a distribution one. Most teams haven't thought about this yet. They pick a tool, they use it. But if that layer gets locked in before you notice, you may not get a second choice. Full breakdown in this week's episode of The Human in the Loop. #AIEngineering #EnterpriseAI #TheHumanInTheLoop
S1 · E33
June 21 · 23 min
What happens when your AI tool gets taken away
One export rule. One acquisition. Either can pull your AI tool out from under you before lunch. This week both happened. A US export-control directive forced Anthropic to cut off foreign-national access to Fable 5 and Mythos 5. To comply, they disabled the models broadly. One day they're in your workflow. The next, a government decides who can call them. Then SpaceX bought Cursor in a reported $60 billion deal. If your team standardized on Cursor, the owner of your IDE just changed. The AI tool you picked is a dependency too. One you don't control. And the forces that can pull it away are bigger than a deprecated library. Export rules. Acquisitions. Regulation. So "which agent is best" now sits next to a harder question. What happens to my team if this vendor gets acquired, repriced, or regulated out of our region? If your main coding model went dark tomorrow, what's your second choice? And have you actually tried it? Full breakdown in this week's episode of The Human in the Loop. Link in the comments. #AItools #VendorRisk #TheHumanInTheLoop
S1 · E32
June 13 · 21 min
Fable 5 Is Gone. Now What?
The model you built on can disappear. Not crash. Disappear. That's not hypothetical. Last week the US government ordered Anthropic to pull Claude Fable 5 and Mythos 5. Not throttle them. Pull them. For every customer in the world, within hours of the order arriving. The reason was a security concern, not a bug in anyone's code. A decision made somewhere you'll never see, and the thing your app depended on stopped existing the same afternoon. A model you don't host is a dependency you don't control. It can change, get priced out, or get recalled by a government. None of that lands in your backlog with a warning. Have you actually tested what happens when your main model isn't there? #LLMOps #ModelRisk #TheHumanInTheLoop
S1 · E31
June 9 · 22 min
When 80% of the Code Isn't Yours
You're still measuring AI by whether it writes good code. That's already the wrong question. Reading Anthropic's latest numbers, more than 80% of the code merged into their codebase is now written by Claude. The typical engineer ships 8x as much code per day as in 2024. And the length of task an AI can finish reliably is doubling roughly every four months. Four-minute jobs two years ago. Twelve-hour jobs now. But "what is the human actually still doing?" Their answer: not writing. Not running experiments. Setting direction. Reviewing. Deciding what's worth building and catching what slipped through. They already run automated Claude reviewers that flag bugs their best engineers missed. That quietly reframes the whole skills conversation. Most of my career has been about making output faster and cleaner. Fewer defects, quicker delivery. If output is becoming close to free, the value moves somewhere else. To judgment. What to build. When to ship. What not to trust. I don't think most IT teams are ready for that shift yet. What do you think? #AI #TheHumanInTheLoop #AILeadership
S1 · E30
June 7 · 23 min
The $36,000 Engineer: When Agentic AI Stops Being a Subscription
Uber blew its whole 2026 AI budget in four months. Then it set a $1,500 monthly cap on each coding tool, per engineer. Claude Code, Cursor, a dashboard to watch the spend, an approval step to go over. Simon Willison did the math. Two tools, and one engineer runs about $36,000 a year. For years AI was a flat subscription. You paid once a month and you knew the number. Agentic coding turned that into a metered bill. And a metered bill does not warn you politely. It surprises you. This is the cloud invoice all over again. A team turns something on, forgets it is metered, and finds out at the end of the month. A paper this week put numbers on the risk. 63 real cases where agents blew past their limits. Often a single retry loop, quietly burning thousands before anyone looked. A cap you cannot enforce in code is just a wish. So before you scale agents across a team, the real question is not what the budget is. It is what happens, automatically, the second someone hits the ceiling. Most teams can answer the first. Almost none can answer the second. Full breakdown in this week's episode of The Human in the Loop.
S1 · E29
May 31 · 22 min
AI Ships Faster Than Anyone Can Review It
Meta says AI writes 80% of new code. Their own reviewers can't keep up with their own AI. Straight from their engineering blog. They built RADAR to auto-review low-risk diffs because "the share of diffs receiving timely review has declined." Their words. AI-generated code outpaced human review capacity. Read that with the rest of the week's news. Cognition says Devin merged 7x more PRs year-over-year. AI-written commits inside customer codebases jumped from 16% to 80%. Anthropic shipped Opus 4.8 on Wednesday, and every IDE, gateway, and agent runner had it the same day. They also disclosed a $47B revenue run-rate. The "is this a real business" debate is over. But here is what keeps coming back to me: Shipping more code faster is only a win if the systems that catch problems scale at the same rate. This week, the evidence says they aren't. A new arXiv study of 20,574 real coding-agent sessions documents how often agents do something other than what was asked. ITBench-AA, the first serious benchmark for agentic IT work, scored every frontier model below 50%. Adoption is real. The guardrails are not. This week's episode of The Human in the Loop covers all of it: the shipping wave, the cost-control backlash starting inside eng departments, and why ITBench-AA matters more than the score suggests.
S1 · E28
May 24 · 20 min
Why Your Coding Agent's PRs Keep Getting Rejected
The model isn't the problem. I went back through 20 of my agent's pull requests and the failures looked exactly like a junior's first month. 3 of them tried to rewrite things nobody asked them to rewrite. 5 skipped the test, or wrote a test that would have passed either way. 4 fixed the bug but broke something else in the process. I used to assume model quality was the main driver. It isn't. The agent doesn't ship a one-line fix. It opens a change touching twelve files, half of them unrelated to the bug. It writes the code and skips the test. Or it writes a test that proves nothing. But notice that none of these are model problems. They're the same review failures a junior would ship. Just at higher volume and with more confidence. The practical move: stop logging "the agent failed" and start logging why. Counting changed how I prompt and how I scope tickets. It told me more about my codebase than any benchmark score ever has. If your top three match mine, you're seeing what everyone else is seeing. If they differ, that's signal about your codebase or your prompts. What's your top rejection reason? Full breakdown in this week's episode of The Human in the Loop. Link in the comments.
S1 · E27
May 17 · 24 min
Counting Keystrokes to Prove the Team Can Write
Counting accepted Copilot suggestions to prove AI works is like counting keystrokes to prove the team can write. It is the cleanest number on the dashboard. It is also the one that tells you nothing. Forty years ago Fred Brooks split software work into two parts. The accidental: syntax, boilerplate, scaffolding. The essential: what to build, why, for whom, what to trade off. The accidental is what AI tools are good at. That is why the dashboards look spectacular. Lines generated. Suggestions accepted. Prompts sent. The tools were always going to win that part. The numbers that should actually move sit one layer deeper. Cycle time. Change failure rate. Time to first PR review. Defect density. These were already telling you whether the team was shipping good software, long before AI showed up. AI either bends them or it does not. If cycle time has not moved, suggestion-acceptance is a vanity stat. If change failure rate has not dropped, you are not shipping faster. You are writing more code, faster. If time to first review has not shortened, your reviewers are the bottleneck and Copilot cannot fix that. GitHub shipped team-level Copilot metrics this week. It made the wrong question easier to ignore, not harder. Which second-order metric has actually moved on your team since you rolled out an AI coding tool? Full breakdown in this week's episode of The Human in the Loop.
S1 · E26
May 10 · 13 min
The Vulnerability Your Agent Merged
The unit tests pass. The PR merges. And you won't find the problem for six months. Two papers landed this week — one on LLM-generated code, one on GitHub Actions workflows. Different researchers. Same finding. When agents write code, they pin library versions that trained well. Not versions that are safe. The mechanism is simple. A model has seen one popular version of a library thousands of times. It reaches for that version because it minimizes prediction loss. Pin-by-popularity and pin-by-safety are different jobs. The model only knows one of them. The GitHub Actions paper found the same shape. Right syntax. Wrong threat model. So the code looks clean. The tests pass. The PR merges. And six months later a security audit finds a CVE that was public before the agent ever touched the file. This is not a model problem. It is a workflow problem. Human PRs go through SCA. Agent PRs often don't. That gap is where the bill arrives. The fix is not complicated. Put pip-audit, npm audit, or OSV-Scanner between the agent and main. Same gate you'd use for any contributor. The agent has not finished the work when it merges. It has finished its part. Your security pipeline was designed for human contributors. Has anything changed since you started using agents?

Showing 1–20 of 20 episodes