The Altitude Problem: Why Strategy and Execution Were Never Separate


Every post-mortem I have sat through has the same line in it. “The strategy was right, but execution let us down.”

I have been pushing back on this for years. In 2013 I wrote Execution Rules, Strategy Drools, and my view hasn’t changed. There is no such thing as an awesome strategy with awful execution. If the people and money you actually had couldn’t pull it off, it wasn’t awesome. It was a nice idea. Strategy and execution are different only because one comes first. Once the work starts they should be the same thing, with what you learn from executing changing the strategy. There is a reason the top job is Chief Executive Officer.

In 2020 I wrote What the heck is strategy? and added a piece I had underplayed. When we don’t acknowledge the real constraints, we end up saying ridiculous things like “great strategy, but execution failed us.” Acknowledge them up front, then challenge them from first principles to see if they are as real as they look.

A poor say/do ratio has the same root. Organizations talk about it as if people are flaky. Mostly we just say far more than we can handle. Saying is cheap and gets applause today. The bill arrives two quarters later, usually when someone else is holding it. Nobody takes anything off the list when they add to it, and every yes looks small on its own. I wrote in 2020 that it is easy to pile on assumptions and get overconfident. Each assumption nobody checks turns into a promise nobody can keep.

This is where zooming in and out comes in. Most of these failures come from sitting at one altitude. The leader who says the strategy was right has never followed one customer problem from the board slide down to the person who has to fix it. The leader with the long list has never added up the work on the ground and held it against the size of the team.

You teach this by making people do it. Have them trace one real thread, top to bottom. Put strategy people in a customer queue for a few weeks, and put detail people in front of the board. When something doesn’t add up, say out loud that you are going down to look. People copy that.

It is also exhausting, as I said in 2020. That is a good reason to grow more leaders who can do it, so you can save your own energy for fewer, bigger decisions. Give them a compass and not a map, and leave room to improvise.

If I had to boil it down to two questions: what are we stopping to make room for this? And if the strategy is right, what should I be seeing on the ground? If I can’t answer the second one, I should go and look.

What Happens When Attacking Gets Cheaper Than Patching


AI is making cyberattacks cheaper. It may also be making our response to them more dangerous.

Picture an attacker who can generate and test 100,000 attacks for what used to cost 100. Most of them fail. But that doesn’t matter. He just throws those away and keeps the few that work.

Now picture the bank on the other side. It can’t push 100,000 changes into production and hope the failures are harmless. Every change has to be checked against dependencies, data integrity, uptime and customer impact.

That gap is what worries the crap out of me about AI and cybersecurity. Attackers get cheap iterations. Defenders don’t.

The economics are changing

Sophisticated cyberattacks used to require scarce expertise. Finding vulnerabilities, developing exploits and getting around defenses took time and skill. AI is lowering the cost of much of that work.

In a September analysis⁠, Google’s Threat Intelligence Group reported that monthly vulnerability disclosures roughly doubled between January and August 2026. Vulnerabilities observed being exploited increased from an average of 10.5 per month in 2025 to 18 in 2026.

Not all of this can be attributed to AI. But Google found that much of the growth in exploitation came from n-days, vulnerabilities that had already been disclosed. Google suggests AI tools may be helping attackers analyze software patches, vulnerability disclosures and proof-of-concept code to develop exploits faster.

Consider the implications.

A vendor releases a security fix. The attacker can use information about the vulnerability to target systems that haven’t been patched. The enterprise has to test the fix and deploy it across a complex environment.

The attacker may be getting faster at exploiting the gap between a patch becoming available and its deployment. The defender still has to live with the consequences of getting that deployment wrong.

When the fix becomes the problem

In July 2024, CrowdStrike deployed a faulty security update that disrupted approximately 8.5 million Windows devices⁠ worldwide.

But Microsoft’s November 12 outage is an even more interesting example. According to Microsoft’s preliminary incident report⁠, the company traced the failure to a software fix deployed in July. It passed testing, rolled out globally and operated without visible problems for more than three months.

Then a combination of increased network traffic and reduced capacity exposed the defect. Servers stopped responding. Redirecting traffic to other servers overloaded those too.

Why hadn’t testing caught it?

The defect was more likely to occur on newer machines with more processor cores. Microsoft’s load tests used weaker hardware configurations with fewer cores, along with a different mix of traffic. The tests were run on the wrong combination of machines and workloads.

A test only checks what someone thought to test.

This wasn’t an AI failure. But it illustrates how difficult it already is to safely change complex systems. Now imagine AI dramatically increasing the volume and speed of software changes. Does our ability to validate them improve at the same rate?

This week, JPMorgan experienced a software defect that delayed transactions involving other banks. Separately, the NSA’s classified network suffered a disruption reportedly linked to security patching⁠.

And on November 19, Reuters reported⁠ that JPMorgan had disclosed a cyberattack targeting third-party vendors. Attackers accessed certain marketing data held by those vendors, potentially including customer names and email addresses. The bank said this was unrelated to Monday’s outage.

These events have different causes. But together they illustrate how attacks and operational failures can affect interconnected systems, including those outside an enterprise’s direct control.

The two sides don’t pay the same costs

An attacker can attempt thousands of exploits and discard the failures. He doesn’t have to maintain service availability, satisfy regulators or worry about breaking a customer’s payment system.

The defender does !!!

Even if AI makes writing a patch nearly free, deploying it safely can remain expensive.

This is the argument I explored in Migrating Scarcity⁠. When something becomes abundant, scarcity moves elsewhere.

In cybersecurity, producing exploits and fixes is becoming cheaper. Establishing confidence that a fix is safe in production may not be getting cheaper nearly as quickly.

AI can help, of course. It can identify dependencies, generate tests, simulate failures and automate recovery. But none of that guarantees the tests represent what actually happens in production. Microsoft’s experience is a useful reminder.

There is a human dimension too.

Experienced engineers often recognize problems because they have watched systems fail in unexpected ways. They developed that judgment through routine maintenance, incident response and troubleshooting. If AI takes over much of that routine work, who develops the judgment needed when something unusual happens?

That is the problem I explored in The Corner Case⁠. Automating work can also remove the experience through which people learn to handle exceptions.

What should boards ask?

Most boards already ask about cybersecurity threats, vulnerabilities and incident response.

I would add three questions.

How fast can we safely change our systems? Measure the time between a critical fix becoming available and its safe deployment, not simply how quickly a patch can be installed.

How well can we contain a failure? Ask for actual recovery and rollback times, including failures involving critical third parties.

Who can recognize when an automated fix is unsafe? And how are we developing the next generation of people capable of making that judgment?

The bigger question

The marginal cost of cyberattacks doesn’t have to reach zero for the economics to change dramatically. If attackers can multiply their attempts faster than defenders can safely respond, we have a structural problem.

If the pressure to respond faster produces more outages, we have an even bigger one.

The answer isn’t simply to patch faster or slower. It is to make changes safer, failures easier to contain and operational judgment easier to develop.

The question is no longer just whether we can keep attackers out – It is whether we can keep critical systems running while attacks and defenses both change at machine speed.

Writing the fix is getting cheap. Trusting it still costs a lot !!!

The Future of the Software Business


When AI makes software cheaper to build and business processes easier to automate, who gets to keep the profits?

For most of the last thirty years, software has been an extraordinary business.

Build a product once, Sell it to thousands of customers, Charge recurring fees, Keep the incremental cost of serving another customer relatively low. That’s pretty much the recipe! SaaS of course made this model even more attractive.

AI is challenging the economics behind this model in three ways.

1. It is making software cheaper to produce.

2. It is allowing customers to use applications without interacting with their interfaces.

3. It is allowing software to perform work rather than merely help people perform it.

While I do expect the total software market to grow significantly, I don’t expect the existing software companies to capture that growth in proportion to their current market positions.

My bet is that the greatest opportunity for profit will shift from selling software to taking responsibility for getting work done.

Software is becoming cheaper to reproduce

AI doesn’t make enterprise software free. Security, reliability, scalability and maintenance remain difficult. But functionality that once required a large engineering organization can increasingly be developed by much smaller teams.

A software feature is valuable partly because of what it does and partly because of how difficult it is for someone else to reproduce. When reproduction becomes cheaper, the second source of value weakens.

What happens when customers stop using the application?

Suppose I want to approve an employee’s promotion. Today I might log into an HR application, navigate through several screens, review compensation data and submit an approval. Tomorrow I might ask an enterprise agent to review the case, compare compensation, verify the budget and prepare a recommendation. Once I approve it, the agent completes the transaction.

The HR application remains important. It holds employee records, organizational structures and compensation history. But I may never open it.

This is the logic behind the argument that SaaS companies should expose their functionality through standards such as MCP and allow ChatGPT, Claude or Copilot to handle the interaction. I agree with the architectural direction – but I am not convinced by the economics.

Say a vendor earns $100 per employee per month. If customers increasingly consume those capabilities through external agents, why should the vendor automatically retain the same price? Gross margins could improve. But higher gross margins on substantially lower revenue aren’t necessarily a better business.

Of course, established vendors won’t just passively surrender all of that revenue. They can charge for API calls, introduce agent licenses, bundle their own agents with the application or restrict access to certain capabilities. Those are credible defenses, especially when switching costs are high.

A standard like MCP isn’t a real business moat, and neither is owning the agent that calls it.

Why I wouldn’t bet on orchestration alone

A common prediction is that value moves from individual applications to platforms that coordinate them. There is some truth to this. But why should the agent platform retain attractive margins?

Model providers are building agents. Hyperscalers have infrastructure, distribution and enterprise relationships. If multiple platforms can call the same tools and execute the same workflows, the orchestrator can become interchangeable too.

The difficult part is not invoking an application. It is knowing what should happen, under which circumstances, with whose permission, and what to do when something goes wrong.

The system of record is not the system of authority

Picture a bank investigating a suspicious transaction. The core banking application records it. A financial crime system identifies unusual activity. An agent gathers evidence and recommends whether to block it.

Who makes the decision?

Today, the bank’s policies establish the criteria, authorized employees or systems exercise the decision rights, and the bank remains accountable to its regulators.

AI doesn’t eliminate that structure. But it changes how much of the work can be delegated. The bank could authorize an external platform to execute predefined actions within approved policies and escalate decisions requiring human authorization. That platform would hold delegated decision rights, but not unrestricted authority.

The bank would retain ultimate regulatory accountability. The vendor could accept contractual liability for failures within its agreed responsibilities.

Decision rights can be delegated. Accountability cannot always be transferred.

In Migrating Scarcity, I argued that when intelligence becomes abundant, scarcity shifts toward the ability of institutions to absorb and authorize it. That becomes a central economic question for enterprise software.

When software does the work, pricing has to change

Take a company with 1,000 people processing invoices. Its software costs $100 per employee per month, so the vendor earns $1.2 million annually. Now assume automation allows 200 people to handle the original workload. Under unchanged seat-based pricing, the vendor’s revenue falls to $240,000.

The customer is substantially more productive. Yet the vendor has lost 80% of its revenue.

But the vendor doesn’t inevitably lose 80%. It could charge per invoice. And lower processing costs could create demand for more automation. Human users could decline while total software consumption increases.

Still, changing the pricing metric isn’t the same as changing what the company sells. Charging per invoice is still selling software if the customer remains responsible for the operation. Taking responsibility for processing those invoices correctly is a different business.

Isn’t that just outsourcing?

Taking responsibility for outcomes sounds like business process outsourcing, and there is considerable overlap.

The difference lies in how the operating capability scales. Traditional outsourcing often required additional people as transaction volumes increased. An AI-native operations provider has the opportunity to separate transaction growth from headcount growth.

But that opportunity depends on something very specific. How much work can the system complete without human intervention, and how expensive is the work it cannot?

The economics of exceptions

Imagine an illustrative AI-native operation charging $2 per transaction. A routine transaction costs $0.20 to execute. One requiring human investigation costs $12. Other operating costs add $0.40.

At 95% straight-through processing, average cost is about $1.19, a contribution margin of 40.5%. At 90%, cost rises to $1.78 and contribution margin falls to 11%.

Nothing changed about the selling price or the AI model. Only the exception rate changed. The last few percentage points of automation can determine whether the economics work.

My hypothesis is that mature, standardized operations with sufficiently high straight-through processing rates can achieve 15–30% operating margins. Contribution margins exclude product development, sales and corporate overhead, so these are different measures. The attraction isn’t SaaS-style margins. It’s that a provider might earn attractive operating margins while capturing a much larger portion of the customer’s total spending on the process.

The profit opportunity comes from spreading the cost of building and controlling the operation across many customers, while keeping the incremental cost of execution and exceptions low.

Why this won’t simply commoditize

This is the obvious challenge to my argument. If model providers, hyperscalers and SaaS incumbents can all offer autonomous operations, why should any operating platform retain pricing power?

Some won’t. Routine, standardized work with low switching costs will face price competition, and providers that simply package an agent with a few APIs will struggle to defend margins.

The stronger positions are in processes where reliability is difficult to establish and failures are consequential. A provider that has handled millions of cases under agreed controls has evidence of competence, and replacing it means retesting controls and changing contractual responsibilities.

But reliability alone isn’t a permanent moat. The advantage comes from continuously improving the economics of execution while maintaining that reliability. A competitor may reproduce the technology. Matching the operating performance across thousands of exceptions, changing customer requirements and regulatory obligations is a different challenge.

What would prove me wrong?

I would reconsider in three cases. First, if conventional SaaS vendors retain their pricing power despite declining human usage, without assuming greater responsibility for business outcomes. Second, if general-purpose orchestrators capture most incremental enterprise automation profits. Third, if productized operating businesses fail to generate attractive returns after accounting for exceptions and liability.

If I ran a software company, I would ask three questions.

  1. Which parts of our revenue depend on users, which on transactions, and which on capabilities customers cannot easily replace?
  2. What decision rights would customers trust us to exercise, and what liability are we prepared to accept?
  3. Does our business become more valuable when our customers become more productive?

If the answer to the last is no, adding AI features won’t fix it.

For thirty years, software companies built great businesses by selling tools that people used to do work. The next generation will increasingly be built around taking responsibility for getting the work done.