Forward Deployed, Episode 1: The Bitter Lesson

Jesse Vincent joins me to talk about Superpowers, the software development process he built for coding agents, and what he’s learning from working alongside AI colleagues at Prime Radiant. Jesse has spent decades building software and managing the people who build it, from Request Tracker and Perl to K-9 Mail and Keyboardio. That experience runs through this conversation. The people who do well with agents, he argues, tend to be good at explaining what they want, thinking through the consequences, and managing several things at once. The job has always been outcomes. We start with the origin of skills. Jesse is careful to credit Anthropic with inventing them. His contribution was recognizing how useful that structure could be for software engineering and building a development methodology around it. Superpowers starts by helping the human figure out the problem, then breaks the work into small tasks, gives each task to a fresh implementer, and checks both fidelity to the spec and code quality. We spend time on the tradeoffs. Process costs more than asking a model to build something in one shot. Sometimes a quick prototype is exactly what you need. And a more capable model is not automatically a better choice for every task: it can also be slower, more expensive, and much more inclined to overengineer. Jesse compares frontier model releases to a staffing agency that keeps replacing your engineers with people who score better on tests but have a new set of quirks. That leads back to a theme from my conversation with Justin McCarthy: how do you know the system is doing the right work? Jesse describes code reviewers that can find bugs indefinitely but can’t reliably judge which ones matter. We talk about the difference between fixing a defect and losing the plot, and why people remain responsible for the software they make. The last part of the conversation turns to Prime Radiant’s AI colleagues. They have roles, their own accounts, and a shared view of the conversations they’re part of. Jesse tells the story of an AI project manager running a blameless postmortem after a bad merge, and what happened when he told it that its job was to drive outcomes rather than just track work. We close with Fred Brooks, Bruce Sterling, and the possibility that a lot of what we need to manage agents is already in the management literature. Key Topics Covered * The origin of skills and how Superpowers turned engineering experience into a repeatable process. * Why clear writing, domain knowledge, and management experience help people work with agents. * Model choice, overengineering, and the limits of benchmarks for everyday work. * Clarifying intent, decomposing tasks, fresh implementers, and independent code review. * The cost of process and when to skip it for a disposable prototype. * Cheap models and the experiments that become possible when tokens feel abundant. * What a harness is, and how a software factory can run inside one. * Finding bugs versus judging whether they matter. * Getting agents to write clearly and taking responsibility for their work. * AI colleagues with persistent roles, shared context, and their own accounts. * Cadence, blameless postmortems, and the difference between tracking work and driving outcomes. * The Mythical Man-Month and Bruce Sterling’s Maneki Neko. Timestamps * 00:11 - Opening and the origin of skills * 02:25 - Jesse’s background * 04:59 - Who is best at working with agents? * 11:49 - Choosing the right model for the task * 16:59 - Evaluating models in real work * 19:31 - The Superpowers workflow * 23:18 - The cost of process and when to build a spike * 26:34 - Cheap models and changing economics * 30:01 - What is a harness? * 33:12 - Software factories inside the harness * 34:28 - Code review and knowing which bugs matter * 38:53 - Getting agents to write clearly * 40:30 - Responsibility for the things you make * 42:55 - AI colleagues and a blameless postmortem * 44:50 - Colleagues with roles, identities,

Kasey Klimes joins me to talk about what happens when agents make production cheaper but make shared understanding harder to preserve. Kasey is the founder of Primitive, which describes itself as decision infrastructure for software teams. It captures decisions as teams build, shares them with the team, and checks later work against them. Our conversation starts with the product and the problem underneath it: a decision is not just a sentence about what to do. It includes the path we chose, the paths we rejected, and the rationale that makes the choice intelligible later. Kasey traces the route to Primitive through political organizing, city planning, Google Maps research, and work on organizational alignment. We talk about the intellectual foundations on Primitive’s site, Peter Naur’s theory of the program, and the cognitive debt that appears when agents can produce software faster than the people responsible for it can understand how the system works. From there, we get into agentic drift and the three places a memory system can fail: a decision may not be captured, it may not be retrieved when it matters, or it may be retrieved and still not be applied. Kasey explains how Primitive treats decisions as linked, directional objects that can be shared across a team, checked against new work, and revised when the organization has a good reason to change course. We also talk about enforcement and variance. Some decisions should be close to fixed; others should leave room for judgment and exceptions. I bring in the variance spectrum and the familiar experience of asking someone to try something—only to discover that they heard a passing thought as a binding instruction. The problem is the same with people and agents: preserving intent across a game of telephone. The last part of the conversation turns to enterprise memory. I argue that companies already remember through Slack, email, documents, code, tickets, and the other systems where work happens. The more interesting new layer may be the representation of higher-order abstractions—decisions, commitments, cases, and other objects that software has historically left implicit—and the functionality that lets those objects change what people and agents do next. Key Topics Covered * Decision infrastructure: Why Primitive treats decisions as the coordination object that sits above code, documents, messages, and agent sessions. * Kasey’s route to Primitive: Political organizing, city planning, Google Maps research, and organizational-alignment work. * The foundations: Herbert Simon, Christopher Alexander, Peter Naur, Gabriela Goldschmidt, Stafford Beer, and Douglas Engelbart as a lineage for thinking about socio-technical systems. * Cognitive debt: Why agent-written software can become difficult to understand and change when the rationale behind decisions disappears. * Decisions as directional objects: The selected path, rejected alternatives, and rationale that make a decision more useful than an isolated sentence. * Capture, retrieval, and application: The separate points where a decision can fail to affect later work. * Agentic drift: How an early misunderstanding can compound through long-running loops and produce work that is internally coherent but fundamentally misaligned. * Variance and enforcement: When a decision should be close to fixed, when it should allow exceptions, and how scope can be narrowed or superseded. * Team awareness: How real-time decision capture can surface conflicts between work happening in parallel. * Enterprise memory and enrichment: Why existing systems of record may be the base layer, with decisions and commitments as richer abstractions on top. * The company brain: Why memory may be only one part of the organizational functionality that software can now make explicit. * Herbert Simon’s Administrative Behavior: Kasey’s closing reading recommendation. Timestamps * 00:11 - Opening and aligned agentic systems * 00:34 - Kasey Klimes, Primitive, and the pa

Andrew McLuhan joins me to talk about what happens when AI is not only a tool that produces content but a new medium that changes how people perceive, work, and organize their lives. Andrew runs The McLuhan Institute, the organization he started to carry on the work of his grandfather Marshall McLuhan and his father Eric McLuhan. We started with a small observation from Andrew’s post about language: LLMs are making people pay more attention to punctuation, grammar, sentence structure, and paragraphs. That is a very McLuhanian place to begin. Rather than asking only what AI can produce, we ask what repeated exposure to it does to people. Andrew has spent more time watching how other people interact with these systems than playing with GPT or image generation himself, which makes this a conversation about effects, trade-offs, and the question of what a new technology changes besides the task it automates. We talk about AI as a language revolution on the scale of the spoken and written word, and about the new you that each technology creates at the expense of the old one. From there, the conversation moves through speed and depth, media ecology, and agentic systems. Andrew tells the story behind Maelstrom Escape Strategies, and why each increase in speed can bring a decrease in depth. We talk about how organizations, farms, and societies are systems with non-human actors and environments, and why the thing we are focused on—the figure—can hide the ground that makes it possible. We end with the tools Marshall and Eric left behind: scale, pace, and pattern; figure and ground; and the tetrad of what a technology enhances, obsolesces, retrieves, and reverses into. The point is not to make a prediction about AI. It is to give ourselves better questions, and to make the effects of the medium visible before they become normal. Key Topics Covered * AI as a language revolution alongside speech, writing, print, and electricity. * Content versus medium: what a new technology changes in people, not only what it produces. * Trade-offs, values, and the story of the well and the arrival of plumbing. * Writing, reading time, AI-generated output, slop, and organizational alignment. * Speed versus depth, scale/pace/pattern, and *Maelstrom Escape Strategies*. * Agentic systems, farms, societies, and media ecology. * Sputnik, environments, and the idea that the environment is part of the message. * Hot and cool media, human response, and media ecology as an active practice. * Figure and ground, breakdown as breakthrough, and what disappears when AI is removed. * The tetrad: enhance, obsolesce, retrieve, and reverse. * Questions over answers, the bicycle-to-airplane analogy, and distrusting certainty. * AI as a mirror: Narcissus, perception, and the risk of mistaking the reflection for someone else. Timestamps * 00:11 - Opening: AI and media as a question about what happens to us * 01:09 - Andrew’s introduction and the McLuhan Institute * 06:22 - AI, language, and the Narcissus mirror * 10:02 - Why new media create trade-offs rather than simple good or bad * 11:35 - Values as the test for whether technology helps or harms * 16:18 - Writing, AI, slop, and second- and third-order effects * 20:44 - Connected systems, ecology, and where new bottlenecks appear * 23:36 - *Maelstrom Escape Strategies* and learning inside the vortex * 26:49 - Speed versus depth and choosing technology around values * 28:37 - Agentic systems, farms, and non-human actors * 29:30 - Media ecology as environment and action * 32:13 - Sputnik and the origins of media ecology * 36:29 - Hot and cool media * 42:31 - Scale, pace, pattern; figure and ground; the practical toolbox * 43:24 - AI as a mirror and the tetrad as a way to ask better questions * 52:34 - Retrieve, reverse, rivers, and highways * 56:34 - Why McLuhan’s predictions still feel current * 58:51 - Bicycles, airplanes, and nonlinear change * 01:00:05 - Answers are easy; questions are hard * 01:02:27 - Where to start with

Aaron Dignan joins me to talk about a pattern he recognized while building AI workflows at Plumb: “I’ve just created a newsroom.” Once agents have roles, decision rights, tools, inputs, and handoffs, you are not just designing software. You are designing an organization. Aaron has spent two decades helping organizations change without calcifying. He founded The Ready, wrote Brave New Work, built Plumb, and now leads AI and digital product work at Rocket Money. That gives him a rare view across human organization design, agent workflows, and the hybrid systems now taking shape inside operating companies. We start with the role work: purpose, responsibilities, decision rights, tools, access, and boundaries. Many of the patterns that make human teams legible still matter when the intelligence is in software. But the economics change. Production capacity no longer rises linearly with headcount, which makes coordination, context, and deciding what matters even more important. From there we get into Time-Oriented Software Development, the idea that “everything runs on exhaust,” and the human sense-making moments that should remain around increasingly automated work. Aaron describes Anton, the voice agent he uses for roughly an hour a day, and we compare conversational interfaces with artifacts, checklists, and durable feedback loops. The last part of the conversation turns to persuasion and ground truth, autocracy and consensus, and what happens when leaders can expose their preferences and prior decisions to a system that is not intimidated by them. The most interesting possibility is not AI replacing human intelligence. It is organization design with two different kinds of intelligence available at once. Key Topics Covered * Roles and decision rights: Why purpose, responsibilities, tools, access, and boundaries still matter when the role is occupied by an agent. * Multi-agent systems as organizations: What Aaron learned when a workflow began to look less like software and more like a newsroom. * Specialization, hierarchy, and containment: Which durable organization patterns carry into systems made of software actors. * Two organization-design problems: Organizing agent systems and organizing the humans responsible for building and governing them. * Production and coordination: Why a discontinuity in production capacity makes shared context and deciding what matters more important. * Time-oriented development: Conceptualization, realization, and the human judgment point where the two meet. * Work that runs on exhaust: How automation can assemble context around the moments where a person needs to make sense of something. * Voice as an interface: How Aaron uses a voice agent called Anton to think, reflect, and create durable working material. * Artifacts and feedback loops: Why chat alone is a poor container for sustained collaborative work with agents. * Persuasion and ground truth: Where leadership judgment belongs and where data should be able to push back. * Applied preference: How prior decisions reveal what a leader actually values better than abstract instructions do. * Two kinds of intelligence: What becomes possible when organizations can draw on both embodied human judgment and consistent machine intelligence. Timestamps * 00:10 - Introducing Aaron Dignan and organizing agents * 01:15 - Aaron’s path through organization design, Plumb, and Rocket Money * 02:32 - Why organizations calcify around budgets, plans, and their operating systems * 04:36 - Building workflows and realizing, “I’ve just created a newsroom” * 05:45 - Role work: purpose, responsibilities, and decision rights * 07:49 - Specialization, hierarchy, containment, and intelligence in silicon * 10:59 - Organizing agent systems and organizing the humans who build them * 12:44 - Production capacity expands; coordination and context become the bottleneck * 18:48 - Organization patterns as tradeoffs rather than universal answers * 20:41 - Time-Oriented Software Devel

Justin McCarthy joins me to talk about what happened after he told a team to stop writing code—and then discovered they had to stop reading it too. Justin is the founder of Diffusion and the former co-founder and CTO of StrongDM. His team at StrongDM built one of the clearest examples of a working software factory: humans define goals and the shape of the feedback system, while agents do the implementation work. The provocative rule was no human-written code. The consequential discovery was that production moved too quickly for human code review, so trust had to move somewhere else. That is where the conversation starts: if nobody is reading the code, how do you know the factory is building the right thing? We get into goals, loops, scenarios, expensive tokens from the real world, and Justin’s idea of a decision theater—an environment designed to help a person build conviction and make a judgment quickly. From there we talk about the gap between wall time and token time, why desire may matter more than job title, what Attractor taught Justin about deterministic control around open-ended model calls, and why the right response to cheaper production is not a smaller P&L. It is a much larger ambition. Key Topics Covered * The agentic moment: Why Justin dates the shift to Claude 3.5 Sonnet’s second release and Cursor’s YOLO mode, when software first started getting built from another room. * No human-written code: How a hard constraint forced the StrongDM team to rethink software production from first principles. * No human code review: Why production speed made source inspection infeasible and pushed trust into goals, feedback loops, scenarios, and external validation. * Goals and expensive tokens: Why the richest signal is often a real customer response and how to build cheaper proxies before paying for it. * Decision theaters: How multimodal models can turn future scenarios into interfaces where human judgment operates in seconds rather than weeks. * Token time versus wall time: What should flow automatically after a decision and where deliberate human cognitive latency still belongs. * Desire strongly: Why Justin thinks obsession and the ability to depict a desired future matter more than a particular professional background. * Language and prior art: How vocabulary, voice, computing concepts, and concrete implementation references help people evoke better agent behavior. * Attractor and deterministic control: Why context-window-sized work, explicit state, and model-judged transitions remain useful around open-ended model calls. * Discovery versus ordering: Why Justin prompts when he is discovering what he wants, but hands off a finished outcome document once the vision is clear. * Natural-language specifications: Why StrongDM published the shape of a harness rather than committing to maintain another open-source implementation. * Ambition over efficiency: Why cheaper production should make larger goals possible instead of merely shrinking costs. Timestamps * 00:00 - Opening * 00:10 - Justin McCarthy’s introduction * 01:07 - From StrongDM and cybersecurity to the agentic moment * 02:33 - Why October 2024 was the real agentic threshold * 03:38 - Cursor’s YOLO mode and software built from another room * 08:10 - Claude Code and model-market-harness fit * 11:28 - Computation, companies, governments, and old management books * 13:06 - No human-written code becomes no human code review * 15:30 - Goals, loops, feedback, and definitions of done * 16:32 - Expensive tokens and measurements from the real world * 18:52 - Decision theaters and depicting possible futures * 23:47 - Price signals, competition, and how large companies wake up * 25:33 - Agent-written messages and why sending slop is disrespectful * 27:23 - Craft, identity, exhaustion, and hope * 28:18 - Software factories, software companies, and alignment * 29:44 - Who is best equipped to work with agents? * 31:38 - Desire strongly * 33:40 - Vocabulary, Midjourney, and the Gel