The Scarcity Shift: AI can help your team build more software. But who has the attention to understand, evaluate, and maintain it all?
In November 2025, the US FAA made an unusual decision. It announced flight reductions at 40 major airports as the government shutdown put increasing strain on air traffic controllers.
The problem wasn't a shortage of aircraft or a lack of people wanting to fly.
The FAA was concerned about the limited capacity of the people responsible for keeping those aircraft safely separated. Controllers had been working without pay, staffing pressures were mounting, and the FAA decided to reduce traffic rather than allow risk to build.
I think there's an interesting parallel here with what's happening in software development.
AI coding tools let engineers put far more work into motion. Features, prototypes, pull requests, entire apps; all of which used to take weeks, can now be executed in hours. But as we all know, producing the software is only part of the job. Someone still needs to understand it, evaluate it, make decisions about it, and ensure everything works together.
AI has dramatically increased what engineers can produce. It hasn't automatically increased how much they can keep track of.
And I suspect that's becoming one of the biggest constraints on engineering productivity. In our previous article, we explored how [the bottleneck is moving from building to deciding]
Now I want to look more closely at the resource behind those decisions: engineering attention.
How AI is changing engineering productivity
For years, engineering capacity largely depended on headcount and time. Want to ship more? Hire more engineers, improve development processes, or give the team more time.
AI has completely changed that equation, but as we’re starting to see, the relationship between individual productivity and organizational productivity is more complicated than expected.
Atlassian's 2026 State of Developer Experience research found that 87% of developers say AI helps them ship work faster, but here's the interesting part: 72% reported experiencing the same or more friction than before AI.
Let’s pause and think about that: developers can produce software faster, but many aren't seeing a corresponding improvement in how easily they get work done. The familiar problems haven't disappeared either: finding information, navigating dependencies, dealing with technical debt, understanding requirements, and coordinating with other teams still take significant effort.
So where did the productivity gains go?
Some are undoubtedly translating into better software and faster delivery. But some are being absorbed by the growing amount of work faster development creates, which brings us to a distinction I think product and engineering leaders need to pay more attention to:
Engineering time and engineering attention aren't the same thing.
Time is the number of hours available. Attention is the capacity to understand a problem deeply enough to make good decisions about it.
You can free up ten hours of implementation work without automatically creating ten hours of uninterrupted, high-quality thinking. Especially if those same hours are now fragmented across more projects, reviews, decisions, and interruptions.
Why AI-generated code creates more engineering work
Let's return to air traffic control for a moment.
Now, a controller isn't responsible for flying every aircraft. Their job is to understand what's happening across the airspace and ensure that airplanes can operate safely together. More airplanes mean more relationships, potential conflicts, and things requiring attention.
Software teams are experiencing their own version of this in SaaS right now.
An engineer can now use AI to generate a lot more changes within their projects. From a productivity perspective, that’s obviously positive, as long as those changes are actually worthwhile. The caveat is that every single pull request still has to be reviewed. Every new service still has to fit into the existing architecture. Every new feature still has to work with everything that's already in production.
And the output isn't always as reliable as it first appears.
In the 2025 Stack Overflow Developer Survey, 66% of respondents who answered the AI-frustrations question identified one particularly troublesome problem: AI-generated solutions that were almost right, but not quite. And the next biggest frustration? Debugging it at 45% of respondents.
I think "almost right" is worth noting, and broken code is relatively straightforward to reject.
However, code that looks correct requires more careful thought. You have to understand what it does, identify what might be missing, and decide whether you trust it enough to put into production. That kind of work demands ongoing attention, like watching airplanes in your airspace.
So as AI produces more plausible-looking results, we also need more experienced engineering judgment to keep up. Additionally, while we're excited about how much faster AI helps us write software, we should also consider how much extra work we're giving to those who have to understand it.
What happens when that attention is already committed?
Another problem exists, and I think it's even more consequential.
Not all engineering attention goes toward evaluating new code, as a substantial amount is already committed to software the organization built months or years ago. Think about the systems your team currently owns. This could be the authentication service, internal integrations and apps, reporting infrastructure, custom-built analytics, and much more.
Someone needs to understand how those systems work, why certain decisions were made, how they interact with other services, and what happens when something changes.
Now add more AI-generated applications and capabilities to that estate.
The initial build might have become dramatically easier (I think AI has made that happen), but more systems now compete for your team's attention.
In Team Topologies: Organizing Business and Technology Teams for Fast Flow, Matthew Skelton and Manuel Pais explored this concept: the importance of managing a team's cognitive load, which is the mental effort required to understand, develop, and operate the systems it owns. They argue that a team can only handle so much complexity effectively. Exceed it, and the team's ability to deliver and respond to change suffers.
Unfortunately, AI doesn't automatically remove that limit. In fact, it could even make it easier to exceed it, because creating another capability takes far less effort than before.
Consider a B2B SaaS company building its own AI-powered analytics experience: a conversational interface might take a weekend to prototype. But what happens next?
Customers want consistent metrics, different access permissions, better performance, new data sources, more sophisticated analysis, and reliable answers from increasingly complex data. The engineering team now has to maintain everything that provides that, and continuously improve as customer requirements evolve.
None of these is necessarily a bad engineering investment, but together, they take up engineers’ attention. Every hour spent understanding and maintaining those systems is an hour not spent solving your core problems.
So the hidden cost of building more software isn't just the code you have to maintain. It's the attention you have to keep giving it.
Start managing attention, not just capacity
So what should CTOs and CPOs do differently?
I don't think the answer is to discourage engineers from using AI or slow down development, but rather to be more deliberate about where the resulting work and the attention needed to support it goes.
I'd start with four changes.
1. Look beyond engineering hours.
Most teams track velocity, cycle time, deployments, and engineering utilization.
I'd also want to understand how much work is happening concurrently: How many initiatives are engineers switching between? How much time goes into reviewing, debugging, coordinating or maintaining existing capabilities?
A team can look highly productive on paper while being stretched too thin to do any of them particularly well.
2. Be willing to stop things.
AI makes starting new initiatives extraordinarily easy, but that doesn't mean every prototype needs to become a product.
If an experiment isn't producing useful evidence, stop it. If a feature isn't creating value, reconsider its place on the roadmap. If it is creating value but you don’t want to own it, partner with someone.
Removing unnecessary initiatives frees up attention for the ones that matter.
3. Protect time for deep engineering judgment.
Your strongest engineers are valuable because they understand the architecture, anticipate problems, recognize trade-offs, and know when something isn't worth building. So give them the space to exercise that judgment.
More meetings, more reviews, and more concurrent projects aren't necessarily the best use of your most experienced technical people.
4. Think carefully about what your team should own.
This is potentially the most important decision.
Every capability you build requires ongoing engineering attention. And some capabilities do deserve it: they encode your unique domain expertise, proprietary data and workflows, and the things customers choose your product for.
Others, not really. And if a specialist partner can provide a capability that would otherwise require substantial ongoing engineering attention, it's worth asking whether owning that capability yourself is the best use of your team.
Where do you want your best engineers thinking?
This brings us back to a question at the heart of our Three-Layer Model for Intelligent Products.
Where do you actually want your best engineers spending their attention?
On the proprietary experiences, workflows, and domain knowledge that make your product different? Or on building and maintaining the underlying analytics capabilities that many other software companies also need?
Both require real engineering expertise, but they don't necessarily create the same strategic value for your business.
That's where ThoughtSpot Embedded fits.
By providing the AI-native analytics experience and the foundation that supports it, ThoughtSpot Embedded helps product teams avoid building and maintaining those capabilities entirely on their own.
There will always be integration and product decisions to make. But your team doesn't need to develop every underlying analytics capability from scratch. That means less attention devoted to undifferentiated engineering work, and more available for the things that make your product worth choosing.
That, I think, is ultimately the point.
Build what differentiates you →
Next in the series: When almost any idea can become a working prototype in a weekend, what happens to product prioritization? Why your product backlog is about to become infinite.



