SharePlane Thesis · October 2026

The Bottleneck Moved

Software engineering was built around the assumption that implementation was scarce. It isn’t anymore.

The argument is not that engineering disappears. It is that the economic constraint that shaped software organizations is weakening, and the valuable work is migrating upward.

As implementation gets cheaper, rigor migrates upward.
Implementation abundance Judgment scarcity Cognitive continuity Bounded autonomy Context systems engineering
SharePlane infographic showing implementation scarcity shifting toward judgment, context, verification, and AI-native engineering.
01 · ORIGIN

The old bottleneck was implementation.

For most of my career, I would have rejected the idea that software developers were becoming unnecessary. Not because software development was sacred. Because software was hard.

Taking an idea from somebody’s head and turning it into something useful, reliable, secure, supportable, understandable, deployable, and maintainable required enormous amounts of human effort.

You needed people who could translate requirements. People who could design systems. People who could write code. People who could test it. People who understood infrastructure, security, deployment, operations, and the peculiar archaeology required to explain what everybody else had built.

Then you needed meetings so all those people could explain their portion of reality to one another.

That was not stupidity. It was an adaptation to scarcity. Implementation was expensive. The organization formed around that constraint.

I no longer think that constraint can be assumed.

Infographic comparing implementation scarcity with judgment scarcity.
Semantic object: bottleneck migration. Implementation abundance changes what remains scarce.

This is not about whether AI can code

That argument is already boring.

Models can write code. They can write bad code. They can write excellent code. They can misunderstand requirements, invent APIs, recover from mistakes, refactor entire systems, diagnose failures, write tests, operate tools, inspect environments, create repositories, build interfaces, manipulate infrastructure, analyze evidence, and occasionally find extraordinarily creative ways to screw something up.

So can people.

The interesting question is no longer whether an AI can produce software. The interesting question is what happens when producing software is no longer the expensive part of software engineering.

That is a different problem.

02 · ECONOMICS

Software is becoming abundant.

We have historically confused the value of software with the cost of producing it.

Applications felt durable partly because they were expensive. You spent months building one, so naturally you protected it. You created teams around it. You accumulated institutional knowledge around it. You avoided touching certain areas because only two people understood them.

Eventually the implementation itself became the institutional memory.

That is a terrible place to store institutional memory.

Increasingly, I think the implementation should be treated as a projection. Potentially an important projection. Potentially a regulated projection. Potentially one that needs extraordinary engineering discipline. But still a projection.

The durable assets are moving elsewhere: intent, constraints, semantics, ontology, state, evidence, authority, interfaces, policy, provenance, acceptance criteria, and historical reasoning.

Durable versus regenerable engineering stack.
Semantic object: durable core vs. regenerable projection.
Implementation is disposable only when the cost and risk of regeneration are lower than the cost and risk of preservation.

The context is becoming more valuable than the code

I increasingly care less about preserving every intermediate artifact and more about preserving enough structured context that another capable system can reconstruct what matters.

That changes how you think about files, repositories, documentation, memory, search, version history, evidence, and even HTML.

A good HTML artifact can be both a human interface and machine-readable context. A repository can be created because a problem needs somewhere to exist, then archived when the problem is complete. A file system stops being boring infrastructure and becomes part of the reasoning architecture.

The questions change: What does the machine need to know? What does the human need to know? What must persist beyond this session? What is canonical? What can be regenerated? What must never be summarized away? What evidence proves the current state?

Those are no longer documentation questions. They are engineering questions.

03 · ROOT

Operate closer to root.

The industry is already building abstractions around models. Useful, sometimes excellent abstractions. But abstractions always expose what their designers think you should need and conceal everything else.

I would rather understand the primitives: files, processes, Git, shells, APIs, databases, permissions, identity, containers, networking, state, context windows, retrieval, model behavior, tool invocation, memory, and evidence.

Once you understand those pieces, abstractions become choices rather than dependencies. You can use them when they help, bypass them when they get in the way, and replace them when something better appears.

Someone who becomes an expert in this year’s AI product may have learned a product. Someone who learns how models consume context, operate tools, manipulate files, preserve state, recover continuity, and interact with authority has learned something more durable.

AI-native engineering hierarchy from applications and abstractions down to primitives.
Semantic object: primitives beneath abstractions.

Prompt engineering was never big enough

The phrase makes the important skill sound like discovering the right incantation.

The harder problem is context: what should the system know, how should knowledge be represented, what belongs in active context, what belongs in durable storage, what deserves exact preservation, what can be compressed, what must remain attributable, and how work survives a session boundary.

That is context systems engineering.

04 · AUTONOMY

I do not trust the machine.

And I increasingly think that is irrelevant.

Trust is the wrong objective. For years, one of the strongest arguments against autonomous software engineering was straightforward: you cannot trust AI to do this correctly.

Correct. So don’t.

Design the system so trust is unnecessary. Define the expected state. Constrain authority. Observe inputs. Observe outputs. Verify invariants. Preserve evidence. Separate proposal from execution. Maintain rollback. Record provenance. Require explicit authority where consequences become irreversible.

Then let probabilistic machinery do what probabilistic machinery does. It can explore, fail, generate something ugly, throw it away, try again, discover a better path, misunderstand something, and recover.

The internal path does not need to be beautiful. The externally relevant outcome needs to be bounded and verified.

Autonomy without trust pipeline showing objective, agent action, verification, authority gate, execution, and evidence.
Semantic object: bounded autonomy. Probabilistic actor, deterministic control around consequential action.
Probabilistic semantics. Deterministic authority.

Autonomy is not the absence of control

Serious autonomy is engineered freedom inside bounded authority.

The machine should know what it may do. The system should independently know what happened. Important state should be inspectable. Consequential transitions should leave evidence. Irreversible actions should have explicit authority boundaries. Failures should be recoverable. History should be reconstructable.

05 · ORGANIZATION

The biggest productivity gain may not be coding.

It may be the collapse of translation boundaries.

Consider the usual sequence: business intent, product interpretation, architecture interpretation, design interpretation, engineering interpretation, testing interpretation, security interpretation, operations interpretation, documentation interpretation.

At every transition, information is lost.

People schedule meetings because the artifact does not contain enough context. They create tickets because the receiving team was not part of the original conversation. They write presentations explaining systems that already exist. They produce diagrams that go stale the moment implementation changes. They spend enormous amounts of time reconstructing one another’s mental models.

Now imagine keeping the intent attached to execution all the way through.

The same operating context can contain the objective, architecture, evidence, implementation, acceptance criteria, historical decisions, constraints, and current state. Agents can consume it. Humans can inspect it. The system can update it.

The result is not merely faster software development. It is less organizational entropy.

Infographic contrasting handoffs with a continuous human and agent loop.
Semantic object: cognitive continuity replacing repeated translation.

One person can hold continuity across many roles

I am not claiming that one person suddenly becomes the world’s leading expert in thirty disciplines. The important change is that one capable person can maintain cognitive continuity across work that previously crossed many functional boundaries.

Historically, scaling capability usually meant dividing work. Dividing work meant handoffs. Handoffs meant coordination. Coordination meant latency and translation loss.

AI lets one capable person stretch much farther across the problem space before specialization becomes necessary.

That changes the economics of teams.

06 · PROFESSION

The developer question gets uncomfortable.

I am not convinced software developers disappear. I am increasingly convinced that the market may need far fewer people whose primary value is converting specifications into implementation.

Programming remains valuable. Understanding systems remains valuable. Deep technical expertise remains valuable. Knowing how computers actually work remains valuable.

But implementation itself is losing scarcity.

That means technical value migrates toward problem decomposition, judgment, architecture, systems thinking, context construction, verification, security, operational reasoning, evidence, authority design, failure analysis, human understanding, and knowing what deserves permanence.

New engineering value stack showing compute, models, code, tools, systems, context, verification, authority, and judgment.
Semantic object: engineering value migration.

Experience can become an advantage or a trap

The people I worry about most are not necessarily junior developers. Junior people may adapt remarkably quickly because they have less identity invested in the old operating model.

The harder transition may be for experienced technical people whose expertise has hardened around assumptions that used to be correct: applications are expensive to create; large capabilities require large teams; software should be preserved because rebuilding it is costly; specialization is always more efficient than continuity; development throughput is constrained primarily by implementation capacity.

None of those statements suddenly became universally false.

But every one of them is becoming conditional.

07 · BOUNDARY

Throwaway does not mean careless.

As implementation gets cheaper, rigor migrates upward.

Data becomes more important. Identity becomes more important. Authority becomes more important. Interfaces become more important. Evidence becomes more important. Provenance becomes more important. Acceptance criteria become more important. Observability becomes more important. Historical context becomes more important.

The implementation can become cheap precisely because the durable system around it is strong.

There will also remain software where implementation itself deserves extraordinary care: medical devices, avionics, cryptographic systems, low-level infrastructure, real-time control, safety-critical software, high-performance systems, validated regulated systems, and components where failure cost overwhelms generation cost.

Disposable implementation is not a universal license to regenerate everything before breakfast.

The principle is simpler: do not preserve implementation merely because implementation used to be expensive. Know what actually carries value. Preserve that.

Durable

  • Intent and purpose
  • Semantics and ontology
  • State and data
  • Contracts
  • Authority and identity
  • Evidence and provenance
  • Acceptance criteria
  • Decision history

Regenerable when appropriate

  • Application implementations
  • UI variants
  • Scaffolds
  • Intermediate code
  • Temporary workflows
  • Experiments
  • Prototypes
  • Derived projections
08 · CONSEQUENCE

This changes architecture and leadership.

Traditional architecture still matters. Another layer is appearing above it.

What is the durable truth? Where does authority live? What context needs to survive? What is canonical versus derived? What can be regenerated? What must remain deterministic? What evidence proves correctness? What does an agent need in order to safely reconstruct capability? How do we replace a model, provider, framework, or application without losing institutional knowledge?

That is an architecture built for a world where implementations are cheap and cognition is abundant but unreliable.

Leadership faces the same shift. Giving everyone an AI coding assistant and measuring tickets closed may capture a fraction of the value. The larger opportunity is rethinking the organization around the new constraint.

If implementation is no longer the bottleneck, what is?

Judgment. Clarity. Context. Authority. Verification. Decision latency. Organizational memory. The ability to distinguish what matters from what merely exists.

Adding AI to an organization designed around implementation scarcity may simply make the old machinery move slightly faster. Redesigning the machinery is a different proposition.

09 · CONCLUSION

The bottleneck moved.

I do not think software engineering is ending. I think something more interesting is happening.

The constraint that defined much of software engineering is weakening. Implementation is becoming abundant. And when a constraint moves, the system eventually reorganizes around the new one.

The scarce capability is increasingly not producing software. It is understanding what should exist. Preserving why it exists. Giving machines the context required to act coherently. Defining what must remain true. Determining where authority belongs. Proving that outcomes satisfy intent. Knowing which artifacts deserve permanence and which can disappear tomorrow.

That is a harder discipline than writing code.

It requires broader technical understanding, not less. Stronger judgment, not weaker. Engineers who understand the machinery beneath the abstractions and the organizational system above them.

And it requires getting comfortable with an idea that would have sounded reckless not very long ago:

A great deal of the software may not matter very much.

The capability matters. The context matters. The evidence matters. The authority matters. The outcome matters.

The code is increasingly just how we happened to get there this time.

The bottleneck moved. Software engineering needs to move with it.

10 · FOLLOW THE THINKING

Check the argument against the outside world.

This is an experience-backed engineering thesis, not a claim that every developer, repository, or organization is already living in the same future. The external record is useful precisely because it both corroborates and complicates the argument.

What remains my thesis:

That implementation abundance will move the engineering bottleneck toward judgment; that cognitive continuity can reduce translation loss; that more implementation will become rationally disposable; and that the profession will reorganize around those changes. The sources above support mechanisms and direction. They do not prove those consequences as universal facts.

Continue through SharePlane

The Application Is Disposable. The Context Is Not.

The direct predecessor. It established the durable-context premise that this Work extends into engineering economics and organizational design.

Let Intelligence Be Messy. Make Authority Boring.

Companion doctrine for separating probabilistic intelligence from consequential authority.

Inference at the Ambiguity Frontier

Repeated, understood reasoning migrates toward deterministic machinery while models remain concentrated at genuine ambiguity.

The Agent Is Not the Security Boundary.

The surrounding system, not the agent’s intentions, carries the real security and authority boundary.

Relationship treatment in this Owner-UAT package is proposed reader navigation. Canonical inter-Work edges remain governed by SharePlane Work metadata and are not created by similarity alone.

SEMANTIC LAYER

Machine-readable by design.

This Work carries its thesis, ontology, lineage, distinctions, retrieval hooks, and boundary conditions alongside the human narrative.

Canonical semantic spine
Implementation scarcityencouragedSpecialization
SpecializationrequiredHandoffs
HandoffsproducedTranslation loss
Generative AIreducesImplementation cost
Implementation abundancemoves bottleneck towardJudgment scarcity
Persistent context + bounded authority + verificationenableCognitive continuity
Cognitive continuityreducesHandoffs
Cheaper implementationrequiresRigor to migrate upward
Lineage

The Application Is Disposable. The Context Is Not. established the earlier premise: implementations can become disposable while context remains durable. The Bottleneck Moved extends that premise into the economics, organization, and professional identity of software engineering.

Critical distinctions

Software ≠ implementation. Disposable ≠ careless. Autonomy ≠ trust. Context ≠ prompt. Memory ≠ authority. Abstraction ≠ capability. AI-native ≠ AI-dependent. Implementation abundance ≠ zero engineering cost.

Canonical machine representation
{
  "thesis": "Software engineering was organized around implementation scarcity. As implementation becomes abundant, value migrates upward toward judgment, context, verification, authority, and systems thinking.",
  "doctrine": "As implementation gets cheaper, rigor migrates upward.",
  "authority_model": "Probabilistic semantics. Deterministic authority.",
  "boundary": "Implementation is disposable only when regeneration cost and risk are lower than preservation cost and risk."
}
Reader Trust Stack · governed projection

Check the work, not just the conclusion.

The article is the primary reading surface. Evidence, counterevidence, lineage, semantics, portability, and publication state remain attached without pretending corroboration converts a thesis into settled fact.

Evidence & counterevidence

What supports this Work

  • Independent industry researchDORA 2025: State of AI-assisted Software Development
    DORA characterizes AI as an amplifier of an organization’s existing strengths and weaknesses, with the largest returns coming from the underlying organizational system rather than the tool alone.
  • Independent industry researchDORA: Balancing AI tensions
    DORA reports that AI accelerates initial code generation while time savings are often reallocated to auditing and verification; higher AI adoption is associated with greater throughput and greater instability.
  • Counterevidence / randomized trialMETR: Early-2025 AI and experienced open-source developers
    In a randomized trial of 16 experienced developers completing 246 tasks in mature repositories, early-2025 AI tools increased completion time by 19 percent.
  • Capability-change evidenceMETR: Developer productivity experiment design update
    METR says it is likely developers were more accelerated by AI in early 2026 than in early 2025, but calls the magnitude weakly evidenced because of selection effects.
  • Measurement nuanceMETR: Task Substitution and Uplift
    METR argues that AI productivity depends partly on which tasks people choose once AI is available, so speed on old tasks and value from new tasks are not the same measure.
  • Primary technical guidanceAnthropic: Effective context engineering for AI agents
    Anthropic frames context as a critical finite resource and context engineering as curating the high-signal state, tools, and information required for effective long-horizon agents.
  • Primary technical guidanceAnthropic: Writing effective tools for agents
    Anthropic argues that agent effectiveness depends strongly on tool design, meaningful returned context, evaluations, and clear functionality boundaries.
  • Primary platform evidenceOpenAI: Introducing the Agents API
    OpenAI says useful long-running agents need a harness that manages context, tools, and subagents, plus persistent environments where agents can work with files, run code, and save intermediate results.
  • Standards / risk frameworkNIST AI RMF Core: Measure and Manage
    NIST calls for testing before deployment and during operation, rigorous performance assessment, documented measurement, independent review, and risk-response controls.
Claim discipline

What is asserted, and how it is bounded

Externally supported observations are separated from Tony Malott’s forward inference. The thesis does not claim universal developer speedups, universal role elimination, or that every implementation should be regenerated.

Inspect the claim-evidence register →

Lineage & relationships

Follow the thinking

This Work extends The Application Is Disposable. The Context Is Not. and connects conceptually to deterministic authority, ambiguity-frontier, and agent-boundary Works.

Inspect proposed reader relationships →

Lifecycle & portability

Take the complete artifact with you

Offline Owner-UAT package includes the human publication, seven infographics, semantic model, evidence register, relationship decisions, provenance, portable Work record, and integrity manifest.

Inspect manifest →

Type to search the current Work.

Browse the full SharePlane corpus →