A year ago, our list of things we wanted to build into our own stack was constrained by a familiar question: can we justify the cost and effort of building this? Most ideas didn't survive it. The ones that did were the few clearly worth the investment.
That filter has largely stopped working, and the reason is worth sitting with. When the cost of building something drops far enough, the question "is this worth building?" stops eliminating much. Almost everything starts to look worth building, because almost everything now clears a much lower bar. The backlog stops being a prioritised list and becomes something closer to infinite.
We didn't anticipate this when we started embedding AI across our delivery. The expectation was that lower build costs would simply mean we got more done. What actually happened was more complicated, and the complication is the interesting part.
The old constraint was doing useful work
Cost was never just a cost. It was a filter that quietly killed bad ideas before we had to think hard about them. If something would take three weeks to build, the three weeks forced a question about whether it really mattered. Plenty of mediocre ideas died there, automatically, without anyone having to make a deliberate call.
Remove most of that cost and the filter goes with it. The mediocre ideas now survive, because building them is cheap enough that "why not" becomes a plausible answer. We found ourselves with a long list of things that were all individually justifiable and collectively impossible, because the one thing that hadn't changed was our capacity to maintain, govern, and pay attention to what we'd built.
Capability became close to infinite. Capacity stayed firmly finite. The gap between those two is where the difficulty lives.
What we got wrong first
Our first instinct was to build a lot, because we could. Several internal tools got built quickly that each made sense in isolation. The problem surfaced later: every one of them needed maintenance, oversight, and a place in someone's attention. A tool that takes a day to build can still take a year to look after.
We'd shifted the bottleneck without removing it. The constraint moved from "can we build this?" to "can we responsibly own everything we've built?" — and we hit the second wall faster than expected, having ignored it on the way in.
A few things ended up on the back-burner not because they failed, but because keeping them running well wasn't worth the ongoing attention relative to other things we could give that attention to. That's a different kind of decision than the cost-benefit calls we were used to, and we weren't initially set up to make it well.
How we prioritise now
What we've landed on is less about evaluating ideas individually and more about being honest that attention is the scarce resource. A few questions do most of the filtering.
Does it remove a recurring tax, or is it a one-off convenience? Things that claw back time every week compound. Things that solve a problem we hit once usually aren't worth the ongoing ownership.
Is it measurable? If we can't tell whether it's working, we can't tell when it stops working — and an unmonitored AI system that quietly degrades is worse than not having built it.
Does it compound with what we already run, or does it sit alone? Capabilities that build on each other are worth more than the sum of isolated tools, and they're cheaper to own because they share context and oversight.
And the one we underused at first: what are we choosing not to do if we do this? When capacity is the real constraint, every yes is a no to something else. Making that trade explicit is most of the discipline.
The harder skill
The thing none of this is, is technical. Deciding what to build was easy when cost decided most of it for us. Now that it doesn't, the decision requires actual judgement about what matters — and judgement is harder to develop than capability, because there's no tool that produces it.
This is the part of AI adoption that gets least attention, because it's not a technology problem and it doesn't have a product to sell against it. The businesses that do well with AI over the next few years won't be the ones who can build the most. Building is becoming a solved problem. They'll be the ones who get good at choosing — at looking at an infinite backlog of individually reasonable options and being disciplined about the few that are actually worth their finite attention.
We're still learning that skill. We're better at it than we were six months ago, mostly because we've felt the cost of getting it wrong. If you're starting to feel the same pull — that you could now build far more than you can sensibly run — that tension is worth taking seriously early.
