We Automated the Old Way of Working


Why enterprise AI deployments are repeating a century-old technology transition mistake.

Every week, another benchmark falls. Another model gets smarter, another architecture promises deeper reasoning, and the cost of inference drops by another decimal point.

If raw intelligence were still the primary source of competitive advantage in technology, these relentless breakthroughs should be widening corporate moats.

Instead, the opposite appears to be happening.

The closer we get to abundant machine intelligence, the more traditional advantages begin to compress.

If everyone can buy increasingly capable intelligence off the shelf for pennies, what exactly are enterprises competing on?

The Capital Migration

For the last few years, the technology ecosystem has operated under a single shared assumption: intelligence is the ultimate moat.

Billions of dollars continue to flow into frontier foundation models, massive context windows, and increasingly sophisticated infrastructure. The prevailing narrative suggests that the company with the smartest model wins, and the enterprise that integrates that model fastest inherits the future.

It is a familiar technology cycle. The scarce resource captures the most attention, capital, and valuation.

And if you look strictly at today’s market capitalization, that narrative appears correct. The financial rewards remain heavily concentrated around the companies building the intelligence layer.

But history suggests that early capital concentration is not always where long-term value settles.

When a technology becomes abundant, value often migrates away from the breakthrough itself and toward the constraints that remain.

We have seen this pattern before. Cheap computing did not eliminate the need for software architecture. Cheap connectivity did not eliminate the need for business models. Cloud infrastructure did not eliminate operational complexity.

Each technology wave made something abundant and exposed something else as scarce.

AI is following the same pattern !!!

While model providers compete in a margin-compressing race to make intelligence cheaper, enterprises are discovering that the difficult part is not accessing intelligence. It is embedding intelligence into the messy reality of existing systems, workflows, incentives, and decision processes.

The bottleneck is moving.

The question is no longer who has access to intelligence.The question instead is who can convert intelligence into repeatable economic output.

The Scarcity of Absorption

The scarce resource after intelligence becomes abundant is not intelligence itself.

It is organizational absorption.

Absorption is the ability of an organization to convert a new capability into repeatable economic output without proportionally increasing complexity.

Technology can scale exponentially. Organizations rarely do.

When you flood a linear organization with an exponential resource, you do not instantly create an exponential business.

You create a new constraint.

Technologists often describe this constraint as enterprise friction. They see legal reviews, governance processes, workflow changes, and human adoption challenges as temporary obstacles that better software will eventually eliminate. Sometimes they are right !

AI systems will become increasingly capable. Agents will eventually be able to diagnose broken processes, generate integrations, and automate parts of the very connective tissue that slows adoption today.

But this does not eliminate the absorption problem. It just changes its location.

The bottleneck moves from performing tasks to redesigning the organization around what machines can now do.

The scarce capability is not whether AI can complete a workflow. It is whether an organization can continuously redesign workflows, decision rights, incentives, and controls faster than competitors.

Friction is not always failure. Sometimes friction is the boundary between possibility and production.

Take something as mundane as accounts receivable deductions recovery. On paper, it looks like the perfect AI workflow: thousands of invoices, repetitive disputes, and massive volumes of unstructured information. A model can read, categorize, and draft dispute letters in seconds.Yet deployment often stalls for months.

The reason is not model capability. It is everything around the model: fragmented ERP systems, inconsistent master data, approval chains, audit requirements, unclear decision ownership, and the absence of trust in autonomous decisions.

The constraint is not the cognitive task.It is the operational connective tissue surrounding it.

  • A model can generate enterprise code instantly. Getting that code safely deployed, audited, and integrated across a complex organization takes far longer.
  • A model can answer operational questions instantly. Building trust in those answers across thousands of employees requires changing behavior.
  • A model can summarize massive amounts of information instantly. Turning those summaries into reliable decisions requires redesigning workflows and incentives.

This is why cheap intelligence does not automatically create cheap outcomes.

As I argued in The Loop Trap, the cost of intelligence is only one part of the equation. The expensive part is completing the entire loop from capability to trusted business outcome.

Inference is becoming cheap – but Organizational change remains expensive !

The next advantage will not come from organizations that simply acquire more intelligence. It will come from organizations that develop the capacity to absorb it faster than their competitors.

The Architecture Around Abundance

This does not mean all friction is valuable. Some friction is simply waste.

Legacy bureaucracy, duplicated processes, manual paperwork, and unnecessary approvals should be eliminated. Abundant intelligence should destroy these inefficiencies.

But other friction exists for a reason.

Governance, validation, institutional memory, safety mechanisms, and accountability structures are what allow organizations to move quickly without losing control.

The mistake is assuming that the fastest organization is the one with the fewest constraints. The fastest organization is often the one with the right constraints.

The companies that win will not simply deploy AI into existing processes. They will just redesign processes around what AI makes possible.

This is why the next generation of enterprise advantage will not come from thin AI wrappers. Those can be absorbed by the next model improvement cycle. The advantage instead will come from institutional infrastructure.

That means the accumulated operating system around intelligence: proprietary workflows, evaluation systems, governance mechanisms, embedded context, decision rights, and organizational learning loops.

It is not consulting or middleware. It is the machinery that allows an organization to continuously convert intelligence into economic output.

This connects directly to the argument in Forward Deployed Engineers Aren’t the Moat. The Learning Loop Is.

The value is not in humans manually implementing AI forever. The value instead is in creating a system that learns from every implementation and compounds that learning across the organization.

The risk today is that enterprises deploy decentralized intelligence inside centralized operating models.

We have seen this mistake before.

The Historical Precedent: The Lesson of the Electric Motor

The hardest part of technological transitions is not recognizing that the new tool is powerful. It is recognizing that the old system was built around the limitations of the previous tool.

Incumbents rarely fail because they lack access to new technology. They usually fail because they optimize the wrong architecture.

When managers first tried to electrify manufacturing, they automated the old way of working.

When steam powered the factory, the engine was the scarce resource. Because steam power weakened the farther it traveled, factories were built around a massive central shaft. Heavy belts and pulleys transferred power throughout the building.

If you wanted power, you positioned your machine close to the shaft. The factory was designed around the physics of scarcity.

When the electric motor emerged, it changed the economics completely. Power became cheap, distributed, and available anywhere.

The instinctive response was to replace the steam engine with an electric motor while keeping the rest of the factory exactly the same.

They automated the old way of working.

Economic historians have noted that the productivity impact of electrification was delayed because the real transformation required redesigning the factory itself.

The deeper mistake was largely architectural !

Managers were using a decentralized technology inside a centralized system.

The real transformation came when manufacturers stopped thinking about electricity as a replacement for steam and started redesigning the factory around what electricity made possible.

Machines no longer needed to orbit a central source of power. The entire production system could be rebuilt !

Value migrated away from generating power and toward designing organizations capable of absorbing it.

The technology was the independent variable. Organizational capacity determined the outcome !

A Hypothesis to Watch

If this pattern continues, the AI era will follow a familiar economic path. This does not mean AI is just another software upgrade.

AI matters because it creates unprecedented cognitive abundance. That abundance forces organizations to redesign themselves.

My hypothesis is that intelligence will behave more like electricity than oil.

Electricity became cheap and everywhere. The winners were not the companies that generated every electron. The winners were the companies that reorganized around what abundant electricity made possible.

If AI follows the same pattern, the companies creating the most durable value may not necessarily be those building the most capable models. They may be the ones solving the harder problems surrounding intelligence: workflow redesign, institutional adaptation, trust, coordination, and operational execution.

This of course does not mean incumbents automatically lose.

In fact, AI may initially strengthen incumbents. Companies with proprietary data, distribution, customer relationships, and operational scale have enormous advantages. The question is whether they use those advantages to redesign themselves or simply automate the existing machine.

As I discussed in The Slowest-Scaling Constraint, value ultimately accumulates around whatever remains difficult to scale.

For AI, that constraint may not be intelligence. It quite may be organizational adaptation.

Of course, AI may prove different. I don’t have a crystal ball.

A closed ecosystem could achieve a durable monopoly on intelligence and retain extraordinary economic rents despite falling costs.

If that happens, this thesis fails. I acknowledge that !

But if AI follows the pattern of previous technological revolutions, the earliest signals will not appear in benchmark charts or model rankings. They will appear in where organizations struggle, where capital accumulates, and where profits persist.

Every technological revolution eventually stops rewarding the people who produce the breakthrough and starts rewarding the people who reorganize the world around it.

The AI race may not ultimately be won by whoever creates the most intelligence. It may be won by whoever learns how to reorganize around it fastest.

How much of this abundance can your organization actually absorb?


The Real AI Race Isn’t for Better Models. It’s for Pricing Power.


Every Sunday night, someone somewhere is refreshing an LLM leaderboard.

A new model edges out the old one on a coding benchmark. Another claims a fractional improvement in reasoning. Social media fills with grand declarations that everything has changed again.

It usually hasn’t !

We’ve spent the last two years obsessing over who has the smartest model. We should probably spend the next two asking a very different question.

Who still has the ability to charge a premium?

Because pricing power, not model intelligence, is what ultimately determines who builds enduring businesses.

This is the fundamental mistake much of the industry is making right now. AI doesn’t simply make software easier to build. It changes what customers are actually willing to pay for. Those are two very different things.

As AI capabilities become widely available, intelligence itself starts looking less like a premium feature and more like electricity. Useful. Essential. Increasingly expected. But rarely differentiated. That shift has serious consequences for enterprise software.

For decades, software companies competed by building capabilities that were difficult for others to replicate. AI is rapidly lowering that barrier. When many vendors can assemble remarkably similar capabilities from the same handful of frontier models, differentiation disappears faster than most pricing models can adapt.

The real competition isn’t for better models. It’s for pricing power.

Value Creation vs. Value Capture

Enterprise software has historically been an extraordinary business.

Building great software required years of engineering investment. Once built, however, every additional customer cost almost nothing to serve. High gross margins followed naturally because the difficult part was creating the product, not delivering it.

AI changes both sides of that equation. Generating software is becoming dramatically cheaper, and capabilities that once took years to build are becoming accessible to far smaller teams.

The application layer absolutely matters. Pretending otherwise is a mistake. Workflow design, user experience, deep integrations, trust, governance, and domain expertise all create immense value. But the question isn’t whether they create value. The question is whether they create sustainable pricing power. Those are not the same thing.

When the underlying intelligence for these tools increasingly comes from the same small set of foundation models, capability itself converges far faster than previous generations of enterprise software. If a customer can achieve a similar outcome from five different vendors, the differentiation shifts away from the capability itself and toward the operational advantages surrounding it. Value is created, but the ability to charge a premium for it disappears.

When Labor Becomes Software

This compression creates a dangerous economic dynamic for vendors trying to shift from selling seat licenses to selling outcome-based “digital workers.”

The pitch sounds compelling: We aren’t selling software anymore; we are replacing human labor. If a human agent costs $30 an hour, and our AI agent costs $5 an hour, we can command massive pricing power.

That strategy works perfectly, right up until three other AI agent startups launch in the same vertical.

As labor is converted into software, it becomes increasingly subject to software commoditization forces. If one vendor charges $5 an hour, a competitor operating a more efficient execution loop will offer it for $2. The value-based pricing model rapidly degrades into a cost-plus race to the bottom. The irony is that replacing human labor with software does not necessarily create a software monopoly. It may simply create a larger and more competitive software market.

The better these systems become at performing human tasks, the more they are exposed to the same economic forces that affect human labor markets: competition, substitution, and price pressure.

Meanwhile, enterprise customers expect more. They expect longer context windows, autonomous agents, and reasoning instead of simple retrieval. They expect voice, memory, automation, orchestration, and continuous improvement.

Yet every one of those improvements increases computational work behind the scenes.

So vendors find themselves caught between two opposing forces. Customers expect prices to fall because “AI is getting cheaper.” Meanwhile, the cost of reliably delivering enterprise-grade AI often rises as workflows become more sophisticated.

That’s not simply margin compression. It’s the steady erosion of pricing power.

The Investor Paradox

This dynamic exposes a fundamental disconnect in the markets today. Investors often assume that AI will expand software margins because more work becomes automated. The exact opposite may happen in many categories.

Automation increases the supply of software capabilities faster than enterprise demand can absorb them. The market has historically rewarded companies that create scarce capabilities. AI’s challenge is that it may create abundant capabilities faster than businesses can absorb them. When supply expands rapidly, differentiation becomes harder and pricing power weakens.

AI may create trillions of dollars in macroeconomic value. It may also make it incredibly difficult for individual software companies to capture that value.

The Loop Trap, Revisited

As I argued in The Loop Trap, enterprise AI isn’t expensive because of tokens. It’s expensive because of loops.

Retries. Approvals. Validation. Tool calls. Human intervention. Recovery paths. You know the drill! Those loops don’t disappear when models improve. If anything, customers demand more of them.

Inevitably, some legacy software incumbents will argue that enterprise inertia will protect them from this reality. They believe that because they are already integrated into the client’s infrastructure, their pricing remains safe.

But workflow lock-in is a defensive moat, not an offensive one. I am not sure how many amongst us realize this!

Workflow lock-in protects retention. It does not automatically protect expansion. The moment a CIO realizes that an automated capability has become a cheap commodity utility, the psychological willingness to pay a high SaaS premium vanishes. During the next renewal cycle, procurement will aggressively squeeze that line item down, using the threat of cheaper alternatives as leverage.

The incumbent keeps the customer, but loses the margin.

The companies that understand this will spend less time chasing benchmark improvements and more time reducing execution cost. Because every dollar saved inside the execution loop is effectively recovered pricing power.

So Who Wins?

The winners won’t necessarily have the smartest models. As I argued in Systems Over Scale, the true operational gains don’t come from a smarter standalone model; they come from better routing, tighter validation loops, and superior system design.

The winners will have advantages that competitors can’t download through an API.

Distribution. Deep workflow integration. Proprietary operational data. Customer trust. Efficient architectures. Low customer acquisition costs. Operational discipline. Those are the things that actually matter – the basics of a good business that the world seems to have forgotten about in the last two years !

They aren’t glamorous advantages, but they are incredibly difficult to copy. If a company possesses none of them, it’s probably not building a durable software business. It’s temporarily renting intelligence from someone else’s foundation model.

Where Value Actually Moves

Value rarely disappears during technological change. It migrates.

As models commoditize, value moves away from the models. As coding becomes easier, value moves away from writing code. As intelligence becomes abundant, value moves toward everything required to make that intelligence dependable inside an enterprise.

Governance. Integration. Security. Observability. Operational efficiency. Business execution.

The obvious narrative over the last two years was that the application layer would capture the majority of the value. But as those margins begin to trap the unprepared, the Second-Order AI Thesis becomes increasingly compelling. The enduring value remains in building the systems, the integration harnesses, the strict governance, and the actual organizational structures required to make all this abundant intelligence usable, predictable, and secure at scale.

The last two years have been a race to build intelligence. The next decade will be a race to keep charging for it.

As usual, these are strictly my personal views.

The Loop Trap: Why Cheap Tokens Don’t Mean Cheap Tasks


In almost every enterprise AI conversation right now, someone eventually says the same thing: “Tokens are basically free.” I understand why people say it. If the expensive part of building with AI was inference, then cheaper tokens should unlock everything. But that assumption hides a bigger problem. The real cost of enterprise AI was never just the tokens. It was the messy human work required to turn a probabilistic answer into something a business is willing to bet on.

I’ve started seeing the same pattern play out in enterprise agent deployments. A team lets an advanced coding agent loose on a sprawling, decades-old monolithic service, targeting a move to a modern microservices architecture. The agent spends hours autonomously iterating on a large pull request, running local test suites, and fixing its own syntax errors. When the run finishes, the compute bill is often the smallest part of the exercise.

The real invoice arrives the next morning. A senior architect inherits a massive PR with thousands of lines of modified code. Because the agent iterated blindly against the compiler simply to get the tests to pass, it introduced architectural debt: it duplicated data structures, bypassed established caching patterns, and broke shared utilities. The architect spends the next day untangling the mess, tracing regressions, and ultimately rejecting the PR. The tokens were cheap, but the task itself was incredibly expensive.

For most of modern computing, the race was about making computation cheaper and faster. Now we are entering a world where the computer can generate changes faster than the organization can safely absorb them. AI isn’t eliminating the enterprise bottleneck. It is reversing the historical economics of software. Computation is becoming the easy part, and human coordination is becoming the scarce resource.

The uncomfortable realization is that we spent the last decade trying to remove humans from software delivery, only to discover that humans were not the bottleneck we thought they were. They were the control system. When you treat intelligence as an effectively unlimited resource, the operational friction doesn’t disappear. It simply migrates up the stack. We’ve spent years assuming that if we could just automate the code generation, the governance would take care of itself. It just won’t.

The irony is that the first problems appear exactly where we expected the magic to happen: inside the loops themselves. We assume this cycle is free because the tokens are cheap. But errors in these systems compound. The next decision is built entirely on the assumptions created by the previous one. If an agent makes the wrong assumption early, the next several iterations can become an expensive exercise in fixing the consequences of that original mistake. You aren’t scaling capability. You are spending more compute and latency cleaning up mistakes the system created for itself.

The raw economics here are deeply deceptive. The system doesn’t eliminate cost; it simply transfers it from GPUs to people. The model finishes its run in a few hours, but the humans inherit the uncertainty. They now have to reconstruct the reasoning, validate the assumptions, and decide whether the output is safe to ship. Ultimately, the bottleneck has moved from creation to trust.

If you push this architecture to its logical endpoint, you end up with agents optimizing other agents, adjusting prompts, retrieval strategies, and evaluation criteria overnight. The assumption is that another layer of AI can evaluate and improve the first layer. But enterprise software rarely has a perfect definition of success. The danger is that the system starts optimizing what it can measure instead of what the business actually values. It learns how to pass the tests, not necessarily how to preserve the architecture. This is the enterprise version of Goodhart’s Law.

The counter-argument sounds compelling: run enough experiments, and one breakthrough will justify all the failures. Platform developers will tell you that a mature agent architecture operates in an ephemeral sandbox, meaning unsuccessful runs can simply be deleted without leaving a single line of messy code behind. But enterprise software is not a lottery where losing tickets disappear without cost. Even if the code branch is cleanly deleted, the human time spent defining the task, managing the system, and reviewing the failure logs to understand why it missed the mark is still a massive tax on engineering velocity.

The other defense is that AI will simply review AI, relying on an ensemble of specialized judge models or rigid pipeline checks to audit the output. Proponents argue that if your CI/CD and regression testing suites are robust enough, bad architecture will be caught automatically. This assumes enterprise systems possess perfect, exhaustive test environments that capture subtle structural intent, which is almost never true for a legacy codebase. A system can easily pass every automated integration test while still producing structurally unmaintainable garbage that requires a human to untangle.

Without deterministic verification layers, entire ensembles can become highly confident about the same incorrect conclusion. Many enterprise AI deployments will fail not because the models aren’t intelligent enough, but because leadership is rather blind to the sheer cost of coordinating intelligent systems.

If spinning loops doesn’t automatically reduce the total cost of delivery, we have to change how we build. The answer isn’t longer execution loops; it’s a completely different control architecture. We need systems that preserve state instead of repeatedly reconstructing it. We need ways to summarize intent rather than syntax, so humans review decisions instead of thousands of generated lines. And we need deterministic boundaries where software takes over: business rules, financial limits, and termination conditions should not be negotiated by another language model. If a system detects a strict logic circle, such as executing multiple consecutive iterations without a change in environment state, the infrastructure should kill the loop instantly.

The history of computing has largely been about reducing the cost of computation. AI changes the problem. Computation is becoming abundant. Coordination isn’t though. As token prices collapse, coordination costs increasingly become the dominant constraint in many enterprise AI systems. The companies that win this phase won’t be the ones running the biggest models or the longest loops. They’ll be the ones that understand where autonomy helps, and where another loop is simply avoiding a decision.

The irony is that the companies that win enterprise AI may not be the ones that automate the most work. They may be the ones that build the best judgment systems around the work machines can already do.

Cheap intelligence is abundant. Reliable outcomes aren’t. That’s the real loop trap.