Matthias Steinbauer

Technology

My phone decides how big a ticket can be

Published

In our team, my phone decides how big a ticket can be. Not the model. Not me. The screen.

It sounds like a bad idea, but it’s the most useful rule we’ve found so far for working with an AI coding agent. This post explains how the setup works and why the constraint is the real gain.

The setup

At .LOUPE we run an agent that picks its own work from the backlog:

  • at most three issues in parallel
  • its own branch and its own pull request for each issue
  • it mainly runs when I’m not at my desk: evenings, on the road, in the gaps

When it reaches a point where it would have to decide rather than implement, it stops and pings my phone. That’s a hard limit.

What I can’t judge must not be built

The rule follows from the setup. You can’t judge a large diff on six inches of screen, least of all while standing on a mountain. And what I can’t judge must not be built.

So the loop only picks issues small enough for me to approve standing up.

By the way, a notification at 19:23 doesn’t mean I’m working at 19:23. It means something moved forward without me and needed me exactly once.

The best thing that could have happened to our backlog

Every backlog has those small things nobody wants to touch. They’re too small to clear your head for, and too annoying to do on the side. Ours now get an AI-based triage automatically, and some of them simply get done.

We humans stay with the bigger and often more interesting chunks, as it should be.

Why I can close the terminal

There’s a second reason I can walk away at all: the agent can’t reach anything important.

  • It only sees issues a human has looked at first.
  • It merges nothing by itself.
  • It has neither production data nor secrets.
  • It runs in a completely isolated VM, with exactly the tools it’s allowed to use.

For us that’s not optional. We build a GRC platform, and our customers trust us with sensitive data. An agent that could reach everything would be exactly the risk we warn others about. Once the boundaries are drawn properly, you don’t have to trust the agent blindly. You only have to check what comes out.

The number hardly anyone talks about

Most people talk about how much these agents can do. The more relevant number in practice is how much the human behind them can still review.

If the agent writes code faster than anyone can seriously judge it, “review” turns into ticking a box. The bottleneck is then no longer writing but understanding. That’s why it pays to fit the work to your review capacity, not the other way round.

In compliance this is called human oversight, and it’s only real if the human can actually judge what they approve. That goes for a risk assessment as much as for a pull request. And it depends on where they’re standing: up a mountain or back in the office.

← All posts