Loading...
Loading...
point of view · operating thesis
Not a blog post. A working thesis on how I think about technology, teams, and the work of leading engineering at scale.
last reviewed · May 2026
the thesis
It was not the stack when we moved to cloud. It was not the stack when we moved to containers. It is not the stack now that we have agents. The bottleneck is clarity of intent, encoded in durable artifacts, enforced by systems rather than willpower. The leaders and builders who win this cycle are the ones who industrialize craft and bargain honestly with the humans whose careers it reshapes.
Underneath that argument are three load-bearing beliefs. Each one is fully developed across multiple posts. Each one has a contrarian edge. Expand any of them to read the case.
the thesis · three pillars
Code is becoming regeneratable exhaust. The durable artifact is the specification.
For most of the last thirty years, software organizations measured the wrong things. We measured velocity in commits, quality in coverage, seniority in lines shipped. That structure rested on a quiet assumption: turning intent into working software was the hard part. The typing was the bottleneck.
That assumption is breaking. With agentic coding tools, the act of turning a clear specification into working code has become genuinely cheap. What stayed hard, and got more visible by the day, is everything upstream. Knowing what to build. Knowing what good looks like. Reviewing whether the generated artifact actually meets the intent.
So spec review is becoming the new code review. Seniority shows up in clarity of thinking, not speed at the keyboard. The repository becomes a fossil record. The spec becomes the strategy.
“The code is exhaust. The spec is the product.”
“A vague feature shipped fast is a bug factory in slow motion.”
“If your team's generated code is wrong, you may not have a code problem. You may have a spec problem, a verification problem, a standards problem, or a review problem.”
“Standards enforced by automation beat standards enforced by willpower, every time.”
AI elevates work; it does not replace it. The scarce skills become problem framing, system design, taste, and the capacity to evaluate.
AI agents are a lever against the gravity of operational drudgery. In the same way that cloud freed us from racking servers and patching disks, agents free us from babysitting dashboards and chasing cost anomalies and reading the same triage runbook for the hundredth time. That is not a productivity story. It is a redistribution of human attention.
Most leadership conversations about AI miss this. They argue about model capability. The bottleneck is not model capability. It is the organization's capacity to evaluate whether outputs are correct. You need fewer generators and more evaluators. Augmented humans correct in real time. Automated errors compound.
There is a humanist version of the same idea. AI is not replacing us. It is reminding us what we are actually here for. The keyboard work was never the meaningful part of being an engineer or a leader. The judgment was. The taste was.
“The future of work will be defined by how effectively we use agents to reduce toil and reclaim human judgment.”
“Generative AI does not replace anything. It reduces the marginal cost of specific cognitive outputs.”
“The bottleneck is not model capability. It is the organization's capacity to evaluate whether outputs are trustworthy.”
“It's not humans versus machines. It's humans with machines, compounding value.”
Principles over personalities. Defaults inherited, not chosen. Trust compounds faster than velocity.
If your strategy cannot survive a leadership transition, it was a preference, not a strategy. Someone's aesthetic. A personality expressed as architecture. The revolving door of leadership is not a threat to good strategy. It is a test of it.
This shows up in different language across the year. In Building Cloud From Zero, it was the discipline of making the right thing the default before anyone builds workarounds. In Pipeline-First Is Not a DevOps Initiative, it was trust-scaling, the move from individualized heroics to systemic delivery. In When Winning Teams Lose, it was accountability flowing upward, because if you publicly criticize your team while protecting yourself, you create the culture problem you are complaining about.
And in the populism essay, it became the coda I had been building toward all year. Builders set the language. Builders own the trust deficit. Vague reassurance is not safety. Specificity is. Workforce optimization is a cancer phrase.
“If you are building monuments to yourself, you are building tomorrow's technical debt.”
“Platforms only work when defaults are inherited, not chosen.”
“In the long run, trust compounds faster than velocity.”
“The best thing any of us can build is something that keeps getting better after we're gone.”
It was not the stack when we moved to cloud. It was not the stack when we moved to containers. It is not the stack now that we have agents. The bottleneck is the frame: the constraints, invariants, acceptance criteria, and situational judgment that determine whether an agent run succeeds or fails. As models get better at execution, the bottleneck moves upstream to framing. The organizations that learn to build better frames will outperform the ones chasing better models.
Tools matter, but they rarely fix unclear ownership, weak incentives, or disconnected priorities. Before we argue about platforms, we should agree on who owns the outcome, how work flows between teams, and what the business is actually trying to do. The tooling conversation becomes easier, and cheaper, once those are clear.
The advantage will not go to the organization with the most AI pilots or the biggest model budget. It will go to the one that builds feedback loops, challenges its own assumptions, and adapts the operating model as the work changes. Shipping velocity without learning velocity is just expensive motion.
Prompt engineering taught us how to talk to a model. Spec engineering is what we are learning now: a clear, versioned, reviewable specification, a layer of project standards, and a coordinated set of specialists working inside the guardrails. In an agentic SDLC, code becomes the regeneratable output of that system. The artifact your organization is producing is no longer the codebase. It is the specification. The repo starts to feel less like inventory and more like a fossil record.
A platform is not successful because it exists. It is successful when teams can move faster with less friction and more confidence. Every platform decision should be evaluated by whether it makes the daily work of engineers easier, not by how elegant it looks on an architecture diagram. Discipline does not scale. Automation does. Standards belong in files, not in heads.
Developer experience is not an internal nicety or a recruiting perk. It shows up in delivery speed, quality, reliability, cost, and the ability to retain the engineers you want to keep. Treat it like a product with measurable outcomes, not a side project that gets attention when someone complains loudly enough.
Teams move faster when they trust the system, their leadership, and each other. Governance, observability, and human-in-the-loop are not friction. They are the engineering work that makes speed sustainable. When trust is present, small process problems get solved quietly. When trust is absent, even good processes produce friction. Leaders spend too much time on process and not enough on the conditions that make process unnecessary.
Leaders do not need to write every line of code, review every PR, or sit in every design session. But they do need to understand how the work is changing, especially when AI, platform shifts, or new delivery models are rewriting the ground rules. There is a unique kind of empathy that comes from debugging your own code at 11 PM. Leadership three layers removed from the craft makes slower, weaker decisions.
Strategy that cannot survive a leadership transition was a preference, not a strategy. Platforms only work when the defaults are inherited, not chosen. If you are building monuments to yourself, you are building tomorrow’s technical debt. The best thing any of us can build is something that keeps getting better after we leave the room. That is not a small ambition. It is the whole job.
Technical alignment without sociopolitical alignment is not safety. It is just better engineering for a worse outcome. Vague reassurance is not safety. Specificity is. When we describe an engineering vision in the same words we would use with someone whose career is being reshaped by it, we sound like the villain in a movie. Builders set the language. Builders own the trust deficit. Pick the version of the bargain you can live with.
the arc · twelve months
The thesis was earned post by post. Here is the through-line, with the line from each post that pushed the argument forward.
“Welcome back, old friend.”
“Structure, clarity, and repeatability are what really stand the test of time.”
“Will you be ready to step into the roles that don't exist yet?”
“The future of work will be defined by how effectively we use agents to reduce toil and reclaim human judgment.”
“The quality of the output depends heavily on the quality of the guardrails you provide.”
“Your skepticism might be wisdom, not resistance.”
“Minimalism is not about doing less. It's about using what already exists more intelligently.”
“Celebrate your team's wins. Own the losses yourself.”
“In the long run, trust compounds faster than velocity.”
“AI did not replace my judgment. It demanded more of it.”
“If you are building monuments to yourself, you are building tomorrow’s technical debt.”
“You need fewer generators and more evaluators.”
“The pipeline is the artifact. The culture is the product.”
“What 30 years of experience actually gives you is a library of failure modes.”
“The bottleneck is no longer the typing. It is the thinking.”
“Platforms only work when defaults are inherited, not chosen.”
“Technical alignment without sociopolitical alignment is not safety. It is just better engineering for a worse outcome.”
“The code is exhaust. The spec is the product.”
“Engineering rigor is not a domain. It is a disposition.”
“Models climb frames. Leaders build them.”
“The model still did the judgment work. The code decided what counted as done.”
signature framings · vocabulary
These phrases recur enough across the year to be considered shorthand for the POV.
the contrarian edges · refusals
A point of view is defined by its refusals as much as its claims. These are the six framings the argument pushes back against.
"AI takes your jobs" is investor narrative, not forecast. If there are no jobs, there are no consumers. If there are no consumers, the growth story collapses.
Most of what vendors label as "agents" today are not autonomous agents in any rigorous sense. Pair programming, not autopilot.
AI tools are not failing developers. Leaders are failing to create the conditions for developers to succeed with AI tools.
Kubernetes for one service, React for a static page, multi-cloud as a hedge. Big tools feel like progress. They are usually a tax on the next engineer.
If your IT strategy cannot survive a leadership transition, it was a preference, not a strategy. Someone’s aesthetic. A personality expressed as architecture.
"Workforce optimization" is a cancer phrase. "We are using AI so a smaller team can do harder work and get paid better for it" is a real plan. Pick the version you can live with.