Forward Deployed

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, and shared context* 47:51 - Nora, Cadence, and driving outcomes* 51:58 - Cadence as a product* 53:21 - The Mythical Man-Month and Maneki NekoLinks & ReferencesJesse and his work* Jesse Vincent’s blog* Prime Radiant* Superpowers* Superpowers on GitHub* KeyboardioStories and related conversations* Today at work: an AI-led blameless postmortem* A quick trip to the uncanny valley* Forward Deployed, Episode 8: The Factory Has To Prove It WorksReading recommendations* The Mythical Man-Month by Frederick P. Brooks Jr.* Maneki Neko by Bruce Sterling.About 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

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

Welcome to episode six of Forward Deployed. Noah sits down with Rohit Krishnan, author of Strange Loop Canon, to talk about what happens when we take the word “agent” seriously.Rohit brings together AI, markets, economics, organizational theory, and simulation. The conversation moves from principal-agent problems to enterprise world models, data-first ontologies, MarketBench, model self-knowledge, and the harder question underneath all of this: how do we build agentic systems that can coordinate, learn, and act inside messy organizations?Key Topics Covered* Agents as an economic problem: Why principal-agent theory, markets, and organizational design matter for AI agents* Rohit’s path: Startups, markets, McKinsey, investing, AI, and the long-running attempt to connect economics with technology* Enterprise world models: Why organizations may be a richer substrate for world models than the physical or visual domains alone* Data-first ontologies: How company histories, email, Slack, docs, GitHub, Jira, and other streams can produce a live model of how work actually happens* Small models and simulations: Why Rohit is experimenting with small JEPA-style models and daily retraining instead of treating frontier LLMs as the whole system* Counterfactuals and prediction: How world models can help answer questions like whether a customer will renew, how to respond to a contract, or which actions are likely to produce which outcomes* MarketBench: Why Rohit and Andrey Fradkin built a benchmark for asking whether AI agents can bid on their own capabilities and costs* Model self-knowledge: Why Gemini tends to overbid, GPT tends to underbid, Claude is directionally better, and none of them are well calibrated enough yet* Memory and onboarding: Why agents still feel like brilliant day-one employees, and why markdown files, project context, and memory systems are only partial answers* Specs, workflows, and co-evolution: Why real software work is not just satisfying a fixed spec, but helping the spec and the deliverable evolve together* Kids and AI: How to help children use AI as a tool for creation and discovery without outsourcing their own taste, voice, or imaginationTimestampsNote: timestamps are approximate* 00:00 - Introduction: Rohit Krishnan, Strange Loop Canon, and market mechanisms for agents* 00:55 - Rohit’s background across AI, economics, startups, consulting, investing, and simulation* 04:30 - Why “agents” are an economic and organizational problem* 09:55 - Why technology wants answers while economics designs mechanisms* 11:00 - Enterprise world models and the limits of traditional digital twins* 14:00 - Building organizational world models with small JEPA-style systems* 16:15 - Public datasets, Enron, startup data, and daily decision support* 17:20 - Modeling companies through email, Slack, docs, GitHub, Jira, and Confluence* 20:35 - Data-first ontologies and why static top-down ontologies break as companies change* 24:10 - Counterfactual questions, model priors, and where LLMs regress toward the median* 27:00 - Frontier models, unknown unknowns, and why expertise still shapes the questions worth asking* 32:30 - MarketBench and using markets to coordinate AI agents* 35:35 - How model auctions work: success probability, token cost, bids, and allocation* 37:05 - Model calibration: Gemini overconfidence, GPT underconfidence, and Claude’s relative advantage* 40:00 - Whether prior performance data can improve model self-knowledge* 41:40 - Agents as brilliant day-one employees and the limits of current memory systems* 44:35 - Onboarding, markdown files, context windows, and the need for better mechanisms* 47:00 - Misalignment in coding agents and why tests do not solve the whole problem* 48:50 - Software companies, software factories, and rediscovering The Mythical Man-Month* 50:50 - Why requirements, specs, and deliverables have to co-evolve* 51:30 - Using world models to discover workflows and skills inside an enterprise* 53:00 - Kids, AI, creation vs. consumption, and preserving individual voiceLinks & ReferencesCore References* Rohit Krishnan - Guest on this episode and author of Strange Loop Canon* Strange Loop Canon - Rohit’s Substack* MarketBench: Evaluating AI Agents as Market Participants - The paper by Rohit Krishnan and Andrey Fradkin* Agent, Know Thyself! (and bid accordingly) - Rohit and Andrey’s writeup on MarketBench* Andrey Fradkin - Rohit’s MarketBench coauthorConcepts & Frameworks* Principal-agent problem - The economic framing Noah and Rohit return to when talking about AI agents* MarketBench - Benchmarking whether agents can estimate their own success probability and task cost* SWE-bench - The software engineering benchmark used as one task source for MarketBench* JEPA / I-JEPA - Joint Embedding Predictive Architecture and world model context* Enron email dataset - Public organizational dataset Rohit discusses as a testbed for enterprise world models* The Mythical Man-Month - The classic software engineering reference Noah invokes near the endPrevious Episodes* Episode 1: The Bitter Lesson* Episode 2: Claude Code Skills and the Progressive Disclosure Problem* Episode 3: Context Engineering* Episode 4: The Special Forces Model* Episode 5: Aligning AgentsAbout the HostsNoah Brier is co-founder of Alephic, an AI consulting company helping brands and enterprises build custom AI systems.Rohit Krishnan is an independent researcher and writer whose work spans AI, economics, markets, organizational theory, and simulations. He writes Strange Loop Canon.Connect with the Hosts* Noah Brier: LinkedIn | X/Twitter* Rohit Krishnan: Strange Loop Canon | X/Twitter* Alephic: alephic.comSubscribe for weekly episodes exploring how AI is actually being deployed in the real world.Newsletter: Sign up for updates at forwarddeployed.com 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

Welcome to episode five of Forward Deployed. Noah sits down with Taylor Pearson to continue the conversation about how we align agents, and why the best models may come from outside traditional software engineering.Taylor brings a background that cuts across history, internet businesses, The End of Jobs, risk parity investing, complexity science, and recent deep work with Claude Code. The conversation moves from firms and transaction costs to Toyota, military doctrine, memory, skills, and the problem of getting agents to work toward the right goal.Key Topics Covered* Aligning agents: Why the episode starts with the question of how to align agents and what engineering can borrow from organization design, markets, and systems theory* Taylor’s path: From history, SEO, ecommerce, and The End of Jobs to finance, risk parity, complexity science, and AI work* Claude Code as a turning point: Why agentic command-line systems felt more transformative for Taylor than chatbot workflows* Historical analogies for AI: Electricity, factory design, Toyota, and the need for a new pattern language for agentic work* Companies as agentic systems: Why firms may be a more useful model than deterministic software systems for coordinating agents* Junior employees and agents: The familiar failure mode where the work is done well but aimed at the wrong problem* Bottlenecks and specs: Why fixing pull requests is not the whole game, and why the bottleneck may move upstream into briefs, specs, and coordination* Pace layers and skills: Best practices, project architecture, plans, code, and how different layers of a system move at different speeds* Memory and context: How skills, files, and externalized memory help agents carry useful context between sessions and systems* Jobs and firm boundaries: How AI changes the calculus around what belongs inside a company, what gets outsourced, and which roles collapse together* Writing, investing, and complex systems: Why some domains resist fixed best practices because everyone adapts to the same patternsTimestampsNote: timestamps are approximate* 00:00 - Introduction: Taylor Pearson, complexity theory, organizations, and aligning agents* 01:15 - Taylor’s path from history to SEO, ecommerce, The End of Jobs, finance, and AI* 03:30 - The GFC, The Black Swan, markets, systems thinking, and transaction costs* 07:00 - Claude Code, Codex, and the agentic workflow shift* 13:45 - Historical analogies for AI, electricity, factories, and pattern languages* 18:00 - Why companies may be the better model for agentic systems than software systems* 20:45 - Organization metaphors, the Toyota Production System, and agents as junior employees* 24:00 - Bottlenecks, specs, briefs, and the coordination work before code* 27:05 - Mission alignment, pace layers, skills, best practices, and architecture* 32:20 - Cynefin, best practices, good practices, and emergent practices* 34:50 - Boyd’s OODA loop, Schwerpunkt, and shared objectives* 39:05 - Memory, role boundaries, and what changes inside and outside the firm* 43:25 - Externalized memory, skills, and context across systems* 46:25 - Generalization, AI writing, de-slopping, and verifiable rewards* 49:15 - Writing, investing, complex systems, and the Maginot Line problem* 51:20 - Closing thoughtsLinks & ReferencesCore References* Taylor Pearson - Guest on this episode* The End of Jobs - Taylor’s book on work, technology, and entrepreneurship* The Black Swan by Nassim Nicholas Taleb - The GFC-era entry point Taylor mentions* Thinking in Systems by Donella Meadows - The systems thinking reference in the conversation* Images of Organization by Gareth Morgan - The organization metaphor book Taylor recommends* The Goal by Eliyahu Goldratt - The bottleneck and theory-of-constraints reference Noah returns to* The Phoenix Project - The IT follow-up to The GoalConcepts & Frameworks* Ronald Coase and transaction cost economics - Why work happens inside or outside firms* Toyota Production System - The people-and-machines operating system discussed in the episode* A Pattern Language - Christopher Alexander’s pattern-language idea applied to agentic work* Stuart Brand’s pace layers - The model Noah uses for best practices, architecture, plans, and code* Cynefin framework - Simple, complicated, complex, and chaotic work domains* John Boyd’s OODA loop - Decision-making and shared objective reference* Schwerpunkt - The point-of-effort concept Taylor connects to agent alignment* Systemantics by John Gall - The Maginot Line and previous-war problem discussed near the endTools & Platforms* Claudesidian - Noah’s Obsidian/Claude framework* OpenAI Codex - The competing agentic coding interface discussed in the episode* Obsidian - Note-taking and memory system context for agent workflows* Alephic - Noah’s AI consulting companyPrevious Episodes* Episode 1: The Bitter Lesson* Episode 2: Claude Code Skills and the Progressive Disclosure Problem* Episode 3: Context Engineering* Episode 4: The Special Forces ModelAbout the HostsNoah Brier is co-founder of Alephic, an AI consulting company helping brands and enterprises build custom AI systems.Taylor Pearson is an author and investor whose work spans entrepreneurship, markets, complexity theory, and AI. He is the author of The End of Jobs.Connect with the Hosts* Noah Brier: LinkedIn | X/Twitter* Taylor Pearson: Website | X/Twitter* Alephic: alephic.comSubscribe for weekly episodes exploring how AI is actually being deployed in the real world.Newsletter: Sign up for updates at forwarddeployed.com 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

Welcome to episode four of Forward Deployed. Noah sits down with Chris Papasadero to explore the deep parallels between Special Forces operations, enterprise software deployment, and creative direction—and what all of it means for building AI agents that actually work in the real world.Key Topics Covered* The Forward Deployed Engineer (FDE) model: How Palantir’s approach to embedding technical experts mirrors Special Forces doctrine* Force multiplication: Why Green Berets are designed to produce outsized output from minimal input — and what that means for AI agents* Comfort with ambiguity: The Special Forces selection pipeline, the Star Course, and why a 2% selection rate tests for the right traits* Cultural embedding: Why Palantir contractors in Afghanistan succeeded by understanding the operational environment, not just the software* Organizational structure and bureaucracy: NCO-led detachments, pushing planning to the lowest level, and the OSS Simple Sabotage Field Manual* Three layers of alignment: Shared cultural values, doctrine, and experience — Chris’s framework for aligning both teams and AI agents* Second and third-order effects: Why software engineering (like warfare) is a creative pursuit, not a six sigma factory process* Showrunners and creative direction: The role of holding both operational and creative vision across a large, autonomous team* Warhol Factory vs. Ford Factory: Why creative production is a better analogy for agentic systems than industrial automationTimestampsNote: timestamps are approximate* 00:00 - Introduction and the origin of “Forward Deployed”* 01:30 - Chris’s background: Special Forces and Palantir* 05:00 - The Forward Deployed Engineer (FDE) model at Palantir* 08:30 - Cultural embedding: Why Palantir worked in Afghanistan* 12:00 - Special Forces as force multipliers* 15:00 - The selection pipeline and comfort with ambiguity* 18:30 - The Star Course: Navigating alone without external guidance* 21:00 - Maintaining the big picture in the fog of war* 25:00 - Organizational structure: NCO-led detachments and decentralized planning* 29:00 - Planning for failure: Incorporating contingencies from the start* 33:00 - The Simple Sabotage Field Manual and organizational bureaucracy* 37:00 - Applying military frameworks to AI agents* 41:00 - Three layers of alignment: Values, doctrine, and experience* 45:00 - Second and third-order effect analysis* 49:00 - Software engineering as a creative pursuit* 52:00 - Showrunners, dailies, and creative direction* 56:00 - The Warhol Factory model for agentic systems* 59:00 - Wrap-up and key takeawaysLinks & ReferencesCore References* Palantir — Forward Deployed Engineering* OSS Simple Sabotage Field Manual* Forward Deployed Episode 1: The Bitter Lesson* Forward Deployed Episode 2: Claude Code Skills* Forward Deployed Episode 3: Context EngineeringConcepts & Frameworks* Special Forces (Green Berets) — Force Multiplication doctrine* The Star Course — Special Forces land navigation assessment* NCO-led detachments — Decentralized command and planning* Andy Warhol’s Factory — Creative production modelRelated Content* The Bitter Lesson by Richard Sutton — General methods that leverage computation* Previous episodes of Forward DeployedAbout the HostsNoah Brier is co-founder of Alephic, an AI consulting company helping brands build custom AI systems. He writes about AI strategy and implementation.Chris Papasadero is this episode’s guest, bringing deep experience at the intersection of Special Forces operations, defense technology, and enterprise software deployment.Connect with the HostsNoah Brier: LinkedIn | X/TwitterSubscribe for weekly episodes exploring how AI is actually being deployed in the real world. 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

Welcome to episode three of Forward Deployed. Noah and Lance dive deep into context engineering—the art and science of filling context windows with just the right information for agents to take the next action.Key Topics Covered- Context engineering: Why Karpathy’s term matters more than prompt engineering for agents- Three core techniques: Reducing context, isolating context, and offloading context to file systems- Skills vs MCPs: Why progressive disclosure beats loading everything into context- Claude Diary: Building agent memory through reflection and evolving CLAUDE.md- Why subagents should isolate context, not anthropomorphize org charts- Production patterns from Manus: Compaction, file system offloading, and sandbox architecture- The convergence of agent primitives: Read, write, reduce, and recombine- Why treating agents like humans works: Dual-use tools and new coworker onboardingTimestamps- 00:10 - What is context engineering and why should we care?- 00:37 - Karpathy’s definition: Filling context windows with just the right information- 01:15 - Context engineering vs prompt engineering: Tools bring context too- 02:27 - Three buckets: Reducing, isolating, and offloading context- 04:30 - Dynamic context loading: Skills as just-in-time context- 06:38 - Skills as context offloading: Progressive disclosure of tools- 09:15 - Sandboxes beyond Manus and Claude Code: Application integration patterns- 12:12 - Context isolation through subagents: Not org charts- 14:41 - Using isolation as a feature: Test-driven development with blank slate agents- 16:33 - Real-world subagent challenges: Shared file systems and context bottlenecks- 20:47 - Claude Diary: Automatic memory through session reflection- 22:53 - CLAUDE.md bloat: Reducing unnecessary words like Strunk and White- 28:06 - Dual-use tools: Why Claude Code uses bash, grep, and human-readable commands- 31:02 - Skills discovery problems: From manual search to automated finding- 34:22 - Agent primitives: Read, write, reduce, and creative recombination- 36:32 - Tool search and action space design: How to find the right function- 40:50 - Hooks as determinism: Injecting code into agent loops- 41:41 - Skills everywhere: ChatGPT’s progressive disclosure discovery- 43:12 - Nano Banana: Text on images unlocks new agentic workflowsLinks & ReferencesCore References* 🔗 Karpathy tweet on context engineering * 🎙️ Manus webinar on context engineering * 📄 Cognition blog post on multi-agents * 📄 Simon Willison on skills and file systems * 🔗 Anthropic Model Context Protocol announcement * 🔗 GitHub MCP docs (Anthropic) Technical Resources* 🔗 Claude Code hooks documentation * 🔗 Anthropic frontend design skills example * 📄 Obra magic skills repository * 🔗 Vercel sandboxes docs Tools & Frameworks* 🔗 LangChain Docs (Python)* 🔗 Cerebras Systems – Technology * 🔗 DeepMind Nano Banana info * 🔗 ChatGPT Skills directory Related Content- 🎙️ Karpathy on Dwarkesh Podcast - Discussion of AI development principles- 📚 The Elements of Style by Strunk and White - “Reduce unnecessary words” as principle for CLAUDE.md- 📄 The Bitter Lesson by Richard Sutton - General methods that leverage computationAbout the HostsNoah Brier is co-founder of Alephic, an AI consulting company helping brands build custom AI systems. He writes about AI strategy and implementation.Lance Martin is a founding engineer at LangChain, where he works on developer tools for building AI applications.Connect with the Hosts- Noah Brier: LinkedIn | X/Twitter - Lance Martin: LinkedIn | X/Twitter* * *Subscribe for weekly episodes exploring how AI is actually being deployed in the real world. 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