Closing the Loop

A page almost nobody used had gotten slow. With a dozen devices it loaded instantly. With a few thousand, it crawled, because every device was being checked against every other device.

It affected too few customers to ever beat anything on engineering’s roadmap. Nobody was wrong about that. It would have sat forever.

Instead, a support engineer with codebase access pointed an agent at it, traced the cause, and had a patch ready for review in about an hour. The same investigation used to cost an afternoon, and nobody could justify an afternoon on that page. (Codebase access wasn’t standard on the team yet. Getting it is its own story.)

The bottom of the backlog

Support files a bug and engineering triages it against everything else. Urgent bugs get fixed, and most medium ones eventually do. At the bottom of the backlog, the answer is “not now,” indefinitely. The customer gets a workaround and the ticket ages.

Nobody owns these bugs because owning them isn’t rational for anyone. Engineering owns the code but can’t justify the time. Support owns the customer but can’t touch the code. Product owns priorities and has bigger problems. The bug falls into the gap between three reasonable positions.

Change what support hands over

The usual request:

We found a bug. Can you reproduce it, find the cause, write a fix, test it, and ship it?

For a low-priority bug, that’s easy to defer.

The new one:

We found a bug. Here’s the reproduction, the cause, and a PR with a test. Can you review it?

That’s a review. The code owner can still reject the approach, ask for changes, or decide the fix is riskier than it looks. Support doesn’t need production access or a shortcut around anyone’s process. The only thing that changes is how much it costs engineering to say yes.

What the agent changed

Support engineers could always submit the occasional fix, and a few did. The slow part was learning an unfamiliar codebase well enough to change it safely, so it only happened when someone was stubborn enough to do it on their own time.

An agent makes that part fast. It can find where a function is used, trace the data, explain an existing test, and draft a patch. What used to take stubbornness becomes routine.

It doesn’t replace judgment. The person driving still has to read the stack trace, query the data, and tell user error from a product bug. Without that, the agent writes a convincing patch for the wrong problem.

It starts with hiring

One search bug returned unrelated records while customers typed. To most people it was “search is weird.” The actual cause: search also looked inside each record’s ID, a long random string of letters and numbers, so typing “ab3” could match any record whose ID happened to contain “ab3.”

Naming that takes someone who can follow the query. A support team that can’t will forward the symptom and wait. A team that can hands engineering a precise diagnosis, and with code access, often the fix too.

Not every company needs support shipping PRs. But every company has a bottom of the backlog, and the people who understand those bugs best are usually the ones who keep getting the tickets. Give them a checkout, the tests, and the same review everybody else gets. The code owner still decides what ships.