Your Loop, Not Theirs: AI Agents as Team Members

Whose Loop Is It, Anyway?

11,000 lines of code. One pull request. Written overnight by an AI agent.

A human developer is supposed to review it before it ships to production.

Nobody reads 11,000 lines. They skim the first hundred. They check that tests pass. They approve it because the release is due and the agent hasn't been wrong yet and what else are they going to do—read until Thursday?

I've watched three clients navigate this exact scenario in the last month. The pattern is always the same: the review process stays in place, but the reviewing stops happening. We keep the human, we lose the oversight, and we call it progress.

The Grammar That Gives Away the Game

Jon Udell said something last week that made me stop scrolling. Simon Willison amplified it, and I read it twice because the whole argument is in the sentence structure:

"I dislike the phrase 'human in the loop' because it cedes authority to the machines. It's our loop. We work the way we always have—now we recruit agents to join the team."

The grammar matters. "Human in the loop" puts the machine's process at the center and bolts you on as a checkpoint. You're not running anything. You're the safety theater between the agent's work and production. The system flows around you.

Flip it. It's your loop. The agents join your team. They don't get the wheel.

If you sign things for a living—audits, financial statements, legal opinions, medical decisions—this isn't a philosophical debate. It's the difference between delegating work and outsourcing judgment.

We've Seen This Movie Before

The last time a generation of professionals signed off on outputs too complex to actually read, we got 2008.

Mortgage-backed securities. Collateralized debt obligations. Synthetic CDOs built on top of those. The rating agencies had models. The banks had oversight committees. Everyone had a process. The structures were so layered, so mathematically elegant, that actual review became impossible. So we kept the approvals and lost the understanding.

Nobody woke up planning to abandon due diligence. They just kept saying yes to things they couldn't fully evaluate, and the system interpreted that as control.

I was working in financial services risk then. I watched smart people sign their names to exposure calculations they couldn't recreate from scratch. The math was sound. The models were validated. The failure was structural: when the thing you're approving is too complex to review, you're not providing oversight—you're providing a signature.

The Unreviewable Pull Request Is the Tell

Here's what I'm seeing now, today, in shops deploying AI agents:

• Legal teams using contract review agents that flag "issues" in 60-page agreements, but the agent wrote the summary, so you're reviewing the review

• Finance teams with AI-generated reconciliation reports where a human "checks" outputs by... running the same agent twice and comparing results

• Security operations where an agent triages 4,000 alerts overnight and a human approves the disposition by looking at the top 10

The humans are still in the process. The checkpoints still exist on the flowchart. But when the output arrives in a volume or complexity that makes real review impossible, the authority has already moved. You just haven't felt it yet because your name is still on the approval.

This isn't an argument against AI agents. I use them. My clients use them. They're extraordinary at pattern matching, summarization, first-pass analysis. The problem isn't the agent. It's what happens when we design workflows where agent output bypasses human judgment while still requiring human signature.

What Actually Changes

I spent fifteen years watching automation transform financial controls. The firms that got it right didn't just add AI to existing processes. They redesigned the work so humans stayed in authority.

That means the work arrives in pieces small enough to actually review.

Not 11,000 lines of code. Not a 60-page contract summary with "key issues highlighted." Not a reconciliation report with 800 line items and a green checkmark at the top.

If an agent is drafting code, it submits functions, not features. If it's reviewing contracts, it flags clauses with the original text, not summaries. If it's triaging alerts, it creates a decision queue, not a done pile.

The agent is fast. The agent is tireless. The agent doesn't get to approve its own work just because a human clicked a button at the end.

The Question That Matters

Where in your operation is an agent already producing work nobody really reviews?

Not work that gets "checked." Work that gets read. Work where a human could articulate the judgment call, not just confirm the output looks plausible.

Because here's the uncomfortable truth I keep running into: we're recreating the approval theater of 2008, but faster and with better documentation.

The pull request gets logged. The review timestamp gets recorded. The approval is traceable. And six months later, when something breaks, everyone will point to the process and wonder how it happened.

It happened because we designed a system where humans couldn't actually do the job we assigned them, then acted surprised when they didn't.

It's Still Your Loop

The fix isn't a better attitude about AI. It's structural.

If you're a partner signing off on audit work, demand that agent outputs arrive in reviewable chunks. If you're a legal director approving contract positions, require that AI summaries link to underlying clauses you can read. If you're a CTO approving code, set a hard line on PR size regardless of who—or what—wrote it.

The agents don't get to set the workflow. They're extraordinary tools. They're not the authority.

I've survived enough technology cycles to know how this goes. The firms that maintain control are the ones who designed for it. The ones that lose it are the ones who assumed the checkbox was enough.

Nobody gets fired the day the 11,000-line pull request merges. The accountability just slowly disappears.

What to Do Monday Morning

Here's the conversation to have with your team:

1. Inventory the agent outputs in your workflow. Where is AI generating work that humans approve?

2. Ask the reviewers: "Can you actually review this, or are you checking that it looks reasonable?" The honest answer tells you everything.

3. Set a complexity threshold. If a human can't review it in the time allocated, the work needs to arrive differently.

4. Redesign for reviewability. Agents can work overnight. Humans can't read 11,000 lines. Design the handoff accordingly.

The technology is here. The agents are capable. The question isn't whether to use them.

The question is: when you sign your name, do you still know what you're signing?

Because if the answer is "sort of" or "the system says it's fine," the loop isn't yours anymore. You just haven't noticed yet.

What are you approving that you can't actually review? I'm curious what this looks like in your world—hit reply or find me on LinkedIn.