Land the Plane
Software engineering, AI-assisted development, and what it actually takes to lead engineering teams in the agentic era.
Latest episodes
Cleared to Land
For five episodes the bottleneck has been climbing upstream. This week it arrives at the one place it cannot climb past — intent, the single node in the whole pipeline that has no machine oracle. When agents can build anything and check almost anything except whether it was the right thing, the job collapses to one thing: saying what you meant, well enough to be checked, and keeping the saying.
The plane finally lands. For five episodes the constraint has been moving upstream — from psychological safety to people to review to verification to last week's four-day build that produced a beautiful, unvalidated demo. This week it reaches the top of the pipeline and stops, because there is nowhere left to go. Intent is the one node no machine can grade. Agents now build the code and increasingly check the code, and the whole industry is racing to give the specification an oracle — Spec Kit, Kiro, Tessl — but every one of those tools still terminates at a human saying "yes, that is what I meant." So the engineer's job collapses to three verbs: specify intent, capture it, validate it. And the captured intent — the conversation, the pivots, the rejected paths — becomes the one artifact a human still uniquely owns.
Touch and Go
When agents do the typing, a four-day build stops being about whether you can build the thing and becomes a pure intent exercise — the best proof you have of what is worth building, and a factory for demos that look done and are not. Those turn out to be the same fact.
Last week the argument was that the bottleneck in agentic development climbs upstream until it lands on intent — deciding what correct means. This week we test that claim in the most concrete place it shows up: hand a cross-functional team four days and an agentic workflow and ask them to prove what can actually be built. When the agent does the construction, the four-day clock stops measuring whether you can build the thing and starts measuring whether you know what is worth building. The room fills with non-engineers holding running software. And every beautiful demo carries the same quiet defect — it proves only that someone could describe it plausibly, not that it is right. These four days are the best intent laboratory we have and a factory for plausible-but-unvalidated demos, and the uncomfortable part is that those are the same fact.
Holding Pattern
When the agent writes the code for free, the bottleneck does not vanish — it moves to verification, and then it keeps climbing upstream until it lands in the one chair only a human can sit in: deciding what "correct" even means.
Last week was the cost of agentic coding. This week is the upside — told honestly. Agents now write most of the code, and for free, which means generation stopped being the thing that gates how fast you ship. So what gates it now? The answer is verification — proving the code is actually right — and the good news, the real upside, is that verification is far more automatable than people think. Agents can write the tests, run the fuzzers, triage their own pull requests. But here is the twist that makes this episode: every time you automate a stage of verification, the bottleneck does not disappear. It climbs one step upstream. And it keeps climbing until it reaches the one node in the whole pipeline that has no machine answer — deciding what the software is supposed to do in the first place. That is where the work goes now. Not typing. Not even reviewing. Owning the spec.
Pilot Monitoring
When the agent writes the first draft, your job stops being to fly the plane and starts being to watch the instruments — and watching is the harder job.
The agent writes the code now, which means the load-bearing human act has quietly moved from writing to reviewing. But review just changed shape underneath us. The line-by-line nitpicking we called "code review" is becoming the bot's job — and the bot is better at it. What's left for the human is the part a model structurally cannot do: understand what it's approving, and be willing to say, out loud, "I don't get this, walk me through it." This episode argues that code review was never really about catching typos. It was a social act of distributed understanding — and in the agentic era it becomes the load-bearing wall of the whole system.
Crew Rest
Why time with other humans is the maintenance schedule for the part of the work AI can't run.
Engagement just hit a fifteen-year low, the loneliest people in the building are the ones at the center of it, and the agent on your screen feels like company without being any. This episode argues that as agents absorb the typing, the scarce input shifts from individual output to the relational capital between people — and that capital gets built off the keyboard, in rest and unhurried human time, not at it. Time with other humans isn't a wellness nicety. It's the maintenance schedule for the one part of the system AI can't run.
When the Planes Don't Land
Intent, agents, and the coming reshape of engineering work.
Karpathy moves to Anthropic, GitHub Spec Kit reframes the source of truth, and Thoughtworks warns about cognitive debt. The main piece argues that as agents take over the typing, three things get load-bearing in a way they never were before — capturing intent explicitly, refusing to pay the cargo cult tax, and treating psychological safety as a throughput argument rather than a soft skill.