Forward Deployed

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 path to decision infrastructure* 02:48 - Primitive’s intellectual foundations and socio-technical systems* 07:12 - Patterns, programming as theory building, and decision infrastructure* 12:06 - Design rationale, IBIS, and the cost of preserving decisions* 16:24 - Decision capture friction and why agents change the incentive to document rationale* 18:08 - Misalignment, ADRs, and why agents take away the wrong things* 21:02 - Context as points, alignment as a vector, and the structure of a decision* 23:01 - Capture, retrieval, application, and drift in long-running agent loops* 27:44 - The variance spectrum and the “everything is purple” example* 35:15 - How Primitive captures decisions and makes them available across tools* 36:19 - What counts as a decision* 37:32 - Real-time team awareness and decision enforcement* 39:52 - Fixed decisions, exceptions, design systems, and common law versus civil law* 44:05 - Enterprise memory as a base layer of existing systems of record* 48:56 - Enrichment, commitments, and the limits of the “company brain” metaphor* 54:02 - Herbert Simon’s Administrative Behavior and the closeLinks & ReferencesKasey and Primitive* Kasey Klimes* Kasey Klimes background* Primitive* Primitive newsletterKasey’s writing* Epistemic Hygiene* English isn’t a programming language (yet)* An Agency Machine* When to Design for EmergenceIdeas discussed* Administrative Behavior by Herbert Simon* A Pattern Language by Christopher Alexander* Programming as Theory Building by Peter Naur* Linkography by Gabriela Goldschmidt* Brain of the Firm by Stafford Beer* Augmenting Human Intellect by Douglas EngelbartAbout Forward DeployedForward Deployed is a podcast about the intersection of AI, software development, and the enterprise. Subscribe if you are trying to understand what it means to build AI systems that work in the real world: systems with context, evaluation, workflows, failure modes, and some theory of how people and agents stay aligned. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit www.forwarddeployed.com

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 McLuhanLinks & ReferencesAndrew and The McLuhan Institute* The McLuhan Institute* About The McLuhan Institute* The McLuhan Institute newsletter* Andrew McLuhan on X* Andrew’s language post* Can We Survive AI?* Can We Survive AI? Part Two* Is the Medium Still the Message?* Seven Ways of Understanding Media* Laws of New Media* Maelstrom Escape StrategiesMarshall McLuhan and media theory* Understanding Media from MIT Press* Laws of Media* Marshall McLuhan Estate: Common Questions* The Playboy Interview: Marshall McLuhanAbout Forward DeployedForward Deployed is a podcast about the intersection of AI, software development, and the enterprise. Subscribe if you are trying to understand what it means to build AI systems that work in the real world: systems with context, evaluation, workflows, failure modes, and some theory of how people and agents stay aligned. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit www.forwarddeployed.com

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 Development and the OK Point* 22:08 - “Everything runs on exhaust” and designing human sense-making moments* 25:57 - The danger of self-reinforcing optimization loops* 28:28 - Anton, Aaron’s voice agent* 33:11 - The value and daily cost of a conversational thinking partner* 35:19 - Artifacts, durable reactions, and Alephic’s working model* 38:15 - Consulting, pitching, and feedback as an established interaction pattern* 40:11 - Smaller teams, smaller companies, and what organization design must retain* 41:45 - Persuasion, ground truth, and model sycophancy* 43:40 - Open source, authority, and hybrid decision systems* 47:00 - Letting data challenge strategy and prior leadership decisions* 48:52 - Applied preference and learning what leaders actually value* 50:32 - Embodied judgment, consistency, and two kinds of intelligence* 52:46 - Team Human and AI as a new tool for humansLinks & ReferencesAaron and his work* Aaron Dignan* Aaron Dignan at BRXND* Brave New Work* The Ready* Rocket Money* AI & The New AverageOrganization design and agent systems* Everyone is a manager* The 80-to-99-percent workflow gap* Introducing Time-Oriented Software Development* ElevenLabs Conversational AI* Team Human by Douglas RushkoffAbout Forward DeployedForward Deployed is a podcast about the intersection of AI, software development, and the enterprise. Subscribe if you are trying to understand what it means to build AI systems that work in the real world: systems with context, evaluation, workflows, failure modes, and some theory of how people and agents stay aligned. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit www.forwarddeployed.com

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 Gell-Mann amnesia problem* 34:59 - SICP, Redis, and speaking in the language of computation* 35:57 - Attractor, context windows, and deterministic control flow* 39:53 - Discovery mode versus ordering a known outcome* 40:37 - Throwaway web pages and decision interfaces* 43:53 - Never drag it back in: building the collaborative loop* 44:55 - Natural-language specifications and disposable harnesses* 47:14 - Deliberate cognitive latency and the Toyota Production System* 49:14 - The Goal, ambition, and why efficiency cannot be the goalLinks & ReferencesJustin and Diffusion* Justin McCarthy on X* Diffusion* About Diffusion* A New EquilibriumSoftware factories and agent systems* Software Factories and the Agentic Moment* Digital Twin Universe* The StrongDM Software Factory* The Culture of AI EngineeringBooks and concepts* Structure and Interpretation of Computer Programs* Toyota Production System* The GoalAbout Forward DeployedForward Deployed is a podcast about the intersection of AI, software development, and the enterprise. Subscribe if you are trying to understand what it means to build AI systems that work in the real world: systems with context, evaluation, workflows, failure modes, and some theory of how people and agents stay aligned. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit www.forwarddeployed.com

James Cham joins me for what is basically one of our recurring AI freakout calls, recorded.James is a partner at Bloomberg Beta and one of my favorite people to talk to when a new model or workflow suddenly makes the world feel slightly miscalibrated. Back in 2024, he and I recorded AI & The Enterprise with James Cham for the BRXND newsletter, which covered AI cycles, opinionated enterprise software, and where durable value might live. This conversation picks up from there. We started with Fable, because Fable forced a strange question: what if the best use of the frontier model is not writing the code, but deciding what work deserves which model in the first place?Thanks for reading Forward Deployed! Subscribe to receive new episodes.From there we get into the experience curve, building ahead, why better tickets make better models, the shift from MCPs to skills plus CLIs, and the way meetings change when everyone knows the transcript is becoming source material for agents.The core question of the episode is the one James and I keep circling: what does the edge know months before the enterprise can see it, and how do you tell when diffusion has become real conversion?Key Topics Covered* Fable as planner: Why the frontier model may be more valuable deciding the work than doing every step of the work.* Building ahead: Why fast-improving models make it risky to build only for what works today.* Experience curves and TSMC: How planning for future yield changes what looks rational in the present.* Tickets as agent ergonomics: Why “good for the model” and “good for the human developer” are starting to converge.* Skills, CLIs, and MCPs: Why Noah has moved toward deterministic skill calling and CLI-backed knowledge work.* Company brains: How call transcripts, deals, contacts, and structured internal data become the substrate for AI work.* AI-native meetings: Live artifacts, recorded prompts, and the new habit of saying the important thing out loud because the model needs to hear it too.* Edge users: Why people like Justin McCarthy, Jesse Vincent, Ethan and Lilach Mollick, and highly structured teams see new patterns first.* Lab-to-enterprise diffusion: Why labs do not see every use case, and why people outside the labs have an advantage from using heterogeneous models.* Bottlenecks, O-rings, and Amdahl’s law: Why the slowest remaining step in the loop matters more than average task exposure.* Token maxing: Why pushing people to use more tokens can be a forcing function for exploration, even if the metric eventually gets gamed.* Small sparks: James’s investor lens for watching tiny edge behaviors before they become aggregate numbers.* What James is reading: C. Thi Nguyen on games and Jon McNeill on Tesla, management consulting, and operational discipline.Timestamps* 00:00 - James Cham joins for a regularly scheduled AI freakout call* 02:00 - Fable, one-shot Joust, and what changed in one week* 05:00 - Fable as planner, not just code writer* 07:00 - Experience curves, Morris Chang, and pricing for future yield* 10:15 - Building ahead and planning for the models of 2027 or 2028* 13:35 - Tickets, model routing, and why solving the wrong problem is the real failure mode* 17:00 - Skills, CLIs, MCPs, Codex, Claude Code, and the company brain* 25:00 - Command lines versus GUIs for agent work* 28:00 - Meetings that produce live artifacts* 31:30 - Recording meetings so agents can recover prompts, scopes, and decisions* 33:00 - Justin McCarthy, Jesse Vincent, and empathy for agents* 36:15 - Documentation culture, AI scribes, and making implicit work explicit* 38:10 - The diffusion timeline from labs to edge users to enterprise* 42:00 - Heterogeneous models and why the labs cannot see everything* 44:45 - Bottlenecks, O-rings, Amdahl’s law, and the 0.01 percent problem* 45:15 - Token maxing as a forcing function for exploration* 49:20 - James’s current reading list: C. Thi Nguyen and Jon McNeillLinks & ReferencesJames* James Cham on X* James Cham on LinkedIn* Bloomberg Beta* Alchemist interview with James ChamPrior James conversations* AI & The Enterprise with James Cham* The AI Investment Outlook* How AI Is Transforming Organizations: Do We Still Need Bosses?* AI for the Enterprise: James Cham and James GrossConcepts and papers* Software Dark Factory Q&A* Reflections on the Software Dark Factory Q&A* O-Ring Automation* The Computer and the Dynamo* Games: Agency as Art* The Algorithm by Jon McNeill* The Goal* Toyota Production SystemTools and systems discussed* Claude Fable 5 and Claude Mythos 5* Claude Fable* OpenClaw* OpenClaw docs* CodexAbout Forward DeployedForward Deployed is a podcast about the intersection of AI, software development, and the enterprise. Subscribe if you are trying to understand what it means to build AI systems that work in the real world: systems with context, evaluation, workflows, failure modes, and some theory of how people and agents stay aligned. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit www.forwarddeployed.com