Keith Adams — General Partner, Pebblebed; formerly Chief Architect at Slack, HHVM at Facebook, VMware
Keith Adams has spent his career at the systems layer — VMware, HHVM at Facebook, Chief Architect at Slack. Now he backs frontier-tech founders at Pebblebed. He and Kent ask what happens when the twenty-year-old software playbook goes blank, whether AI is amplifying virtuosos or leveling the field, and what the agent world costs us in flow state.
Season 1 · Episode 8
Keith marks November 2025 — the release of Opus 4.5 — as the inflection point where resistance to coding agents stopped being a defensible position. Prior to that, you could still find thoughtful people who were skeptical. After, it became untenable. The twenty-year playbook — TDD, iteration, code legibility, continuous integration — was rendered largely irrelevant almost overnight. But Keith's frame for this is Kübler-Ross: you grieve the expertise you built, and then you realize you're holding a blank sheet of paper. That's terrifying if your identity was built on mastery. It's invigorating if you can see it as what it is: an open invitation to build things that weren't buildable before.
We have a blank sheet of paper collectively as a profession right now to figure out how we do business. And I think it's incredibly invigorating to realize we get to live through a time where all of this stuff I wasn't sure would ever be built is going to be built for sure.
Keith expected AI to be a great democratizer — to raise the floor for everyone, making programming broadly accessible. What he's actually observing is the opposite. The people he knows who are most engaged in a creative loop right now are the people who were already virtuoso creators. AI is acting more as an amplifier of existing differences in facility than as a leveler. The billion-dollar lever is going to the people who were already building things at speed. The "personal computing for everyone" democratization is happening slower than expected, and the gap between the top of the distribution and the middle is widening, not narrowing.
The people who I know who are most engaged in a creative loop right now are the people who are virtuoso creators already. It seems like if anything this has been more of an amplifier of differences in facility than a leveler.
Edward Yarden's 1994 book "The Decline and Fall of the American Programmer" predicted that offshoring and better tools would destroy the American software job. He was right about the trends and wrong about the conclusion — because software is more like roads than like coal. Build more roads and you don't reduce travel, you generate more of it. Programming has been getting cheaper and more accessible for decades, and every time it does, demand expands to consume all the new capacity and then some. The same dynamic almost certainly holds now. The scary part is the transition: real people in the middle of their careers, whose specific skill sets are devaluing right now, even if the profession as a whole expands.
Everybody I know, myself included — the more you use these tools, the busier you seem to be. And that's interesting, right? That sort of suggests that there's not a lump of software out there that we just need to churn through.
Programming language design has always been applied psychology — how do you design notation that fits the way human minds reason? The question now is what makes a codebase legible to an LLM, which reasons in fundamentally different ways. One possibility Keith finds interesting: proof-carrying code — where code comes annotated with formal proofs of its properties, rather than readable source that humans have to interpret. If the agent can verify correctness against properties rather than reading and understanding logic, the whole notion of "readable code" may become less important than "property-annotated code."
Programming language design as a discipline has always been applied psychology. But now the question is how do you write code that's legible to something that doesn't reason the way we reason?
Keith names the phenomenological cost precisely: the agent world no longer has the flow state that drew many of us to programming. Traditional programming was a deep immersion — you entered a communion with the problem and the code, lost track of time, solved things by inhabiting them. Working with agents is interrupt-driven, breadth-first, and more like being an air traffic controller than like being a craftsperson. You're managing planes, not flying them. That's a different skill set, a different experience, and for many people, a genuinely different relationship with the work — one that may not produce the same intrinsic rewards even as it produces more output.
Programming doesn't have the flow state that it used to have anymore. The agent world feels more like being an air traffic controller — very interrupt-driven, trying to get productivity through breadth instead of through that kind of deep immersion.
Don't miss an episode
New episodes every other Wednesday. No hype, no predictions, no certainty sold — just honest conversation that helps you stay ready for whatever's next.
Unsubscribe any time.