Tasks Accelerate

I · The Curve We Just Watched

In 1957, IBM shipped the first Fortran compiler for the IBM 704. It marked one of the first major abstraction shifts in software. Before Fortran, engineers worked much closer to the machine: assembly, symbolic instructions, machine-specific code.

Three years ago, software engineering felt like it was shifting again. GitHub Copilot suggested the next line. Some engineers accepted maybe a third of the suggestions; others ignored them. It was useful. It was not transformative.

At Google Cloud Next in April 2026, Sundar Pichai disclosed that 75% of all new code at Google is now AI-generated, up from 50% in late 2025 and roughly 25% in October 2024. In eighteen months, that share tripled.

In thirty-six months, software engineering moved from a discipline where AI offered autocomplete to one where AI drafts the majority of the first pass. That curve compounded faster than cloud, mobile, or the original SaaS wave.

The question for technology leaders is simple: when does this happen to the rest of enterprise work?

Parts of it will. But likely not on the same curve.

II · The Extrapolation

It is tempting to extrapolate from code. If autocomplete became AI-generated code in three years, then perhaps enterprise agents for sales, support, finance, and operations will follow the same arc: a few years to workflow automation, a few more to increasingly autonomous operations.

The hyperscalers provide the primitives. ISVs embed agentic capabilities into the systems companies already use. Together they offer the tools to build an autonomous enterprise.

But software engineering is unusual. To see why the analogy breaks, look at what made code generation accelerate in the first place.

III · The Verifiability Gap

Code has properties most knowledge work does not:

• Syntax. It follows rigid, language-specific rules.
• Compilation. It compiles or it doesn't.
• Feedback. A function returns the expected value or throws an exception.
• Proof. Unit tests pass or fail; builds succeed or break.

Engineers operate inside a verifiable feedback loop. The system confirms correctness in seconds. That speed is what made the curve compound.

Many enterprise workflows don't have those same properties. When an agent drafts a customer email, what is the unit test? When it reconciles a financial entry, what is the type check? When it resolves a support ticket, what is the assertion of correctness?

The right answer depends on customer history, regulatory nuance, brand voice, and the state of an account relationship. The signal comes late: churn, NPS, an audit finding, weeks or quarters after the agent acted. Sometimes it never arrives clearly. A customer leaves quietly. A regulator files a note. This is the verifiability gap, and it is the primary constraint on the agentic curve.

IV · Five Levels of Autonomy

The Society of Automotive Engineers defines six levels of driving automation, from Level 0 (fully manual) to Level 5 (fully autonomous). Enterprise AI is climbing a similar ladder, and most organizations sit far lower on it than the demos suggest. The five levels below adapt that scale to the enterprise.

Most enterprises are at Level 1. A few are at Level 2. Level 3 remains rare, relegated to narrow domains like IT service desks or expense reimbursement. Level 4 is aspirational, and Level 5, full cross-domain autonomy, is still a long way off.

Each level requires more maturity in governance and integration. The jump from L2 to L3 is not a model upgrade; it is a re-architecture of who owns the workflow, the data, and the customer relationship when something breaks. It demands context engineering across people, systems, and tacit knowledge. It doesn't compound the way code generation did, because the bottleneck isn't the model. It's the architecture.

V · Agents Move Into the Enterprise Stack

Agents are being embedded directly into the systems companies already use, close to the CRM, the ERP, the service desk, and the HR system.

That is the rational first move. Agents live close to the systems of record, the permissions, and the existing user behavior. But it creates a new problem: context continuity. The result is a proliferation of agents, each trained on siloed data, each governed by a different policy.

The hard question follows: who owns the customer journey when several systems are each running their own agent?

Answering it isn't a model problem. It's an architecture problem, the same constraint that makes the jump from L2 to L3 so slow. The work is connecting data, policy, and ownership across systems that were never designed to share them.

VI · Tasks Move First. Jobs Change Slowly.

Code generation accelerated tasks. It did not eliminate the job of software engineering: figuring out what to build, stitching the primitives together, designing for failure, owning the operational consequences.

The same applies to enterprise work. Drafting an email is a task. Understanding the nuance behind it, what the customer actually needs, is the job. Resolving a ticket is a task. Owning the outcome and handling the edge cases is the job.

What changed first is implementation speed. A task that took two days may now take two hours. The leverage moved. The judgment did not.

Tasks accelerate quickly when verification is straightforward. Jobs change slowly because judgment, context, and accountability remain the constraint. That is why predictions of full autonomy tend to miss the shape of the curve: as tasks get faster, the surface area of design, governance, and ownership only expands.

VII · What This Means

Three implications.

The agentic curve will compound. But the path runs from bounded tasks to verified workflows to governed orchestration. The advantage won't come from the model everyone can buy. It will come from the judgment, the governance, and the ownership that no model hands you.