Dan Grafham Dan Grafham · @dangrafham · May 2026

Macro Thesis

Humans Moving
Up-Chain

The substrate-level shift that the entire AI moment is producing. Agents move in below. Humans relocate above.

00 · The One-Liner

The shift in two sentences

Humans are moving up-chain.
Agents are moving in below.

That's the substrate-level shift the entire AI moment is producing. Every dev tool, every workflow, every product category in software is being re-founded around this reality.

The companies that win the next decade are the ones built for the role humans are arriving at, not the role humans are leaving.

01 · Decompressed

What "moving up-chain" looks like in practice

For 50 years, software was designed for humans typing into interfaces. The implementation layer was the human's job. Tools were built for that. Agents now take the implementation layer. Not perfectly, not completely, but directionally and rapidly. The human's role doesn't disappear. It relocates. Up the chain.

Where humans used to Write the code, line by line, file by file.
Now Agents write the code. Humans review architecture and intent.
Where humans used to Read every log line, looking for patterns.
Now Agents process logs into structured signal. Humans review summaries and exceptions.
Where humans used to Fill out forms in dashboards.
Now Agents propose state changes. Humans approve or veto on a graph.
Where humans used to Maintain documentation alongside the code.
Now Agents read code directly. Humans capture the few things code can't reveal.
Where humans used to Handle every CI verification cycle.
Now Agents handle full cycles. Humans set what should pass and review the failures.
Where humans used to Orient to a codebase over hours.
Now Agents orient in seconds. Humans operate multiple agents in parallel and hold the architectural thread.

The pattern repeats across every category. Implementation moves to agents. Judgment, architecture, strategy, and review stay with humans, but at a higher altitude.

02 · Structural Prediction

The features built for the human-as-implementer era are now overhead

Every existing dev tool was built for humans doing implementation. Every one. They have features that assume a human is the primary actor: autocomplete (assumes typing), dashboards (assume reading), forms (assume filling), notifications (assume responding).

Most of those features are now overhead. Agents don't need autocomplete. They generate. Agents don't read dashboards. They query APIs. Agents don't fill forms. They call functions. Agents don't get notifications. They consume events.

The products that win the next decade are designed from scratch for the role humans are arriving at:

This isn't speculation. It's structural. Whoever builds the agent-era version of each category wins, because the human, who used to be that tool's primary user, has moved to a different altitude and needs a different tool.

03 · Why Every Category is Pre-Cambrian

Every dev-adjacent product was designed before agents existed

The agent layer arrived less than three years ago and broke the assumptions every existing product was built on. There's now a second class of user (agents reading APIs, writing code, running deploys, managing state) and the existing tools weren't designed with that user in mind. That's not a refinement. It's a re-founding event. Every dev-tool category is in a Pre-Cambrian phase: open niches, no agent-shaped winners yet, most product forms still unbuilt.

Every Category Has

A legacy winner built for humans-only

$100M+ companies, network effects, brand recognition, distribution. Built for a world without agents.

And Also

An open seat for the agent-shaped winner

Zero clear leaders. Most haven't been built yet. Whoever takes the seat is the next dominant species in that category.

IDP (Internal Developer Platform) · Backstage, Port

The legacy IDP is configuration-driven. The agent-era IDP is the live runtime graph that agents query and humans review.

IDE · VS Code, JetBrains

Cursor and Claude Code are early Cambrian attempts. Closer than anyone, still file-based. The agent-era IDE lets agents reason about the whole running system, not just the codebase.

Deploy tools · Vercel, Coolify

The current generation of indie-friendly deploy tools fixed the AWS console for human operators. None of them have been re-founded for agents deploying things. There's a Coolify-for-agents that doesn't exist.

Observability · Datadog

Pre-Cambrian observability is built for SREs reading dashboards. The agent-era observability is queryable graph state for agents and live runtime view for humans.

CI/CD · GitHub Actions

Pre-Cambrian CI: humans configure, runners execute, humans review. The agent-era CI is auto-fix on failure, auto-merge on green, agents driving the cycle with humans reviewing exceptions.

Project management · Linear, Jira

Pre-Cambrian PM has humans writing tickets. The agent-era PM is humans writing intent, agents decomposing into tickets, humans approving the decomposition.

Every single one. Every one has a Cambrian winner waiting.

04 · The Failure Modes

What incomplete up-chain transition looks like

The shift isn't automatic. Most operators stuck halfway between the old role and the new one fall into one of two failure modes: AI debt (over-structuring; the agent is happy to generate apparatus that never ships product) or shipping paralysis (over-scoping; the only bottleneck becomes the human's attention, which is infinite).

Both are what happens when humans haven't actually moved up-chain yet. They're still trying to do implementation, just through agents instead of directly. The transition isn't "use agents to write code." It's relocating to architecture, intent, and review entirely. Most of the discipline is letting go.

If you can answer one question correctly, the rest is execution: is this built for the role humans are leaving, or the role humans are arriving at?