LLM Era

The agent cannot be paged. You can. Agents unbundled authorship from accountability, and the part of authorship that mattered was never the keystrokes. It was the reading. It was the willingness to defend what shipped under your name. That part needs a name now. Call it self-review.

Practices that were nice-to-have for humans become load-bearing for agents. Most organizations won't fail at agentic development. They'll buy licenses, get some wins, and plateau. The playbook for the next plateau: four layers, a method, and the human work that decides whether any of it lands.

Six months ago I wrote that a flood was coming. It's here. We tripled deployment rate in one month. Stakeholders can't produce enough work for us. We built an unbelievably powerful engine that isn't connected to the wheels. Transform the rest of the business, or accept the plateau.

We run three backend languages. That was never a goal — it's what happens when pragmatic choices accumulate over

Most people building with AI are still the orchestrator — the thing holding their own tools together. The hoist is the moment you realize those tools aren't for you. They're for an agent. Stop being the agent. Become the arbiter.

The economic protection of software was always reproduction cost. AI collapses that cost. Any business whose moat depended on software being expensive to reproduce is now structurally exposed.

Atlassian won’t vanish overnight—but inertia isn’t a moat. In an agentic world where software is cheap and specs replace tickets, workflow tools built for human task tracking face structural risk. The need for coordination remains. The shape of it doesn’t.

Agentic dev breaks planning. Work finishes before tickets get written. Estimates don't apply. But orgs still need dates. The fix: plan outcomes, not tasks. Artifact in the repo where agents read it. Ranges, not commitments. Most orgs aren't ready. Figuring it out live.

Engineering capability was earned through friction. You wrestled with syntax. You paged at 2 a.m. You learned why certain patterns were bad because you lived inside their failure modes. That friction is gone. But the struggle isn't. It's simply moving up the stack.

In the agentic era, execution is cheap but decision latency kills velocity. The solution isn't more coordination—it's architectural strategy with enough logic density that engineers can make good calls independently. Duplication beats meetings. Build the framework before you unleash the agents.