There’s a piece of math going around that should make every engineering team uncomfortable.

James Shore laid it out cleanly: if AI coding tools let you write code twice as fast, your maintenance costs need to drop by half, or you’re losing. Three times as productive? You need one-third the maintenance burden. If the ratio doesn’t hold, you haven’t improved your situation. You’ve traded a temporary speed boost for permanent indenture, to use Shore’s word. The code exists. It has to be read, debugged, updated, and eventually replaced, and no AI tool writes code that maintains itself.

This isn’t a contrarian take for the sake of it. It’s just accounting.

The core of Shore’s argument is that LLM-assisted coding dramatically lowers the cost of writing code while leaving the cost of owning code roughly unchanged. If anything, there’s evidence it goes the other direction: AI-generated code tends to be verbose, confident, and subtly wrong in ways that are hard to catch on review. The code looks reasonable. It often isn’t. And every line you ship is a line you’re responsible for forever, or until you pay the rewrite tax.

This is the thing that productivity benchmarks don’t measure. GitHub Copilot’s “developers are 55% faster” numbers are about time-to-first-commit, not time-to-maintained-and-understood. Those are different things.

GitLab Bets the Farm

Meanwhile, GitLab dropped an announcement this week that used the phrase “agentic era” in a workforce reduction notice, which tells you where we are.

The short version: GitLab is cutting up to 30% of the countries where it has small employee concentrations. The company has been notable for its aggressively distributed workforce, with employees spread across dozens of countries, a model that became a kind of identity. The explicit framing in the announcement is that they’re restructuring around what AI-assisted and agent-assisted software development looks like at scale.

When “agentic era” shows up in a layoff notice, it’s not marketing anymore. It’s a structural bet with real consequences for real people.

What GitLab is implicitly claiming: the way software gets built is changing fast enough that teams should be reorganized around it now, not after seeing how it plays out. That’s a strong conviction. It’s also a convenient story for a company that needs to reduce headcount, so apply appropriate skepticism to the framing.

But the underlying question is legitimate. If agents can handle more of the routine work, what does the right team size and composition look like? Nobody actually knows yet. GitLab is making a choice rather than waiting to find out. Whether that’s visionary or premature is a question the next few years will answer.

Shopify’s Public Agent Experiment

Shopify’s Tobias Lütke shared details this week about River, their internal coding agent, and the most interesting thing about it isn’t the AI part.

River doesn’t do DMs. If you message it directly, it politely declines and asks you to create a public channel instead. Lütke himself works with River in a public channel, and he noted that more than 100 people have joined that channel to watch the interactions.

This is a deliberate organizational design choice, not a technical constraint. The reasoning is obvious once you think about it: if every agent interaction is searchable and observable, the whole company learns from every interaction. You can’t have a few power users hoarding techniques while everyone else struggles. The knowledge is ambient.

There’s also something accountability-adjacent happening. When your coding agent conversations are public, you’re more likely to ask questions that are actually worth asking. The social pressure of visibility probably filters out low-effort queries.

The contrast with most enterprise AI deployments is stark. The default is private sessions, private history, no visibility across teams. That’s the path of least resistance, but it’s also a path where most of the organizational learning gets lost.

Whether River is producing code that passes Shore’s maintenance test is a question Lütke didn’t address. But the deployment model is genuinely interesting, and it’s a concrete answer to one of the harder questions in enterprise AI adoption: how do you spread skills across a large organization without making it a training program?

The Math Problem Remains

These stories are connected by the same underlying tension. GitLab is betting that agents change the economics of software development enough to justify restructuring now. Shopify is trying to spread agent skills across their organization as fast as possible. Both moves assume that velocity gains from AI coding tools are real and durable.

Shore’s argument doesn’t say they aren’t. It says the gains only matter if they’re not offset by maintenance costs. That’s the part nobody has figured out yet.

The optimistic case: AI tools will eventually get better at generating code that’s readable, testable, and structured in ways that actually reduce long-term maintenance burden. There’s some evidence this is already happening at the margin, with models that are better at following existing conventions and generating tests alongside the code.

The pessimistic case: the incentives are wrong. The productivity metrics everyone is tracking measure code shipped, not code maintained. Teams that optimize for the metric will hit the goal and miss the point.

What would it look like to actually test Shore’s hypothesis? You’d need to track maintenance hours per feature shipped, not just development hours. You’d need to measure bugs per line over time, not just bugs caught in review. Most teams aren’t doing this, which means most teams won’t know whether they’re winning or losing the maintenance math until it’s already a problem.

This week GitHub also updated its Copilot individual plan lineup, effective June 1: a new Max tier, flex allotments on Pro and Pro+. More model access, more premium requests. The product is maturing and pricing is getting segmented accordingly. That’s not surprising, but it’s worth noting as context for how much money developers are now being asked to spend on tools that may or may not be improving their actual situation.

Shore’s math doesn’t say don’t use AI tools. It says be honest about what they’re costing you. That’s advice most teams aren’t taking seriously enough yet.