The Thousand Conversations Problem [Chapter 6]

[Chapter 6 from Deliberate Alignment by Walter Reid, written in spring 2026]

AI does not fix unclear thinking. It amplifies it.

Somewhere in your organization, right now, thirty conversations are happening in parallel.

Each person, with their AI tool open in a separate tab, is asking a version of the same question the organization is supposedly aligned on. Each is receiving an answer shaped by the specific way they framed the question, the context they brought to it, the assumptions they did not know they were making. Each answer is locally coherent. Each one makes sense given the conversation that produced it.

Collectively, they are pointing in slightly different directions.

This has always been true. Organizations have always been collections of parallel, partially overlapping mental models of what the organization is doing and why. The watercooler conversation that produced a different understanding than the all-hands. The email thread that resolved something the official process had not gotten around to resolving. The tribal knowledge that lived in the heads of the people who had been there longest and evaporated when they left.

What is new is the speed at which each conversation now produces artifacts.

Before, unclear thinking moved slowly. A misaligned understanding of what the product was for would take weeks to materialize as a feature nobody wanted. There were checkpoints — reviews, handoffs, the moment where someone would say, wait, that is not what we meant. The friction was expensive in time and morale, but it was also a correction mechanism. Slowness caught errors that speed would have shipped.

Now the artifact follows the conversation almost immediately. The unclear thinking is instantiated — made real, built, sometimes shipped — before anyone has had a chance to ask whether it was right.

In the Zansei project, this dynamic became visible on a specific Thursday. One person had spent the week building a research report — seventeen pages analyzing the site’s copy, with the second half promised for the following week. Another person had been running ads at a thousand dollars a week. Zero people had completed the funnel in the previous seven days. A third person had been exploring a new feature direction that the founder had mentioned in passing on Monday. Each of these efforts was internally coherent. Each person could explain what they were doing and why. Together, they were spending money to drive traffic to copy that was being researched rather than fixed, while the product’s scope expanded in a direction nobody had agreed on. The backlog was no longer a prioritization tool. It was an anxiety archive accumulating in three different directions simultaneously.

That is the thousand conversations problem. And it is not a coordination problem.

It is a meaning problem wearing coordination’s clothes.

Why the Distinction Matters

Coordination problems have known solutions. You establish a process, a single source of truth, a set of handoffs with clear ownership. You standardize the input and the output converges. Organizational design has been solving coordination problems for a century.

Meaning problems are different. They are not about who does what or when. They are about whether the people doing the work share a sufficient understanding of why — of what the work is actually for, what success would feel like from the outside, what they would sacrifice and what they would not.

Meaning cannot be standardized. You can issue a directive that creates the appearance of resolution while the actual divergence continues underneath, now invisible because everyone has learned the right vocabulary.

The reason AI amplifies this specific problem is that the tools are exceptionally good at producing outputs that feel coherent. A person with an unclear understanding of the product vision, working with an AI assistant, will produce work that is internally consistent, well-structured, and legible — and pointed in the wrong direction. The professional surface has never been easier to achieve. The gap between professional surface and genuine alignment has never been harder to detect.

The Zansei researcher’s seventeen-page report was well-structured. It had sections and findings and recommendations. It was also answering a question nobody had agreed on, produced by someone who had no way to know the question was wrong because the question was never made explicit. The report was a coordination success — the researcher coordinated with the tools beautifully — and a meaning failure. The meaning of what the research was supposed to accomplish had never been established clearly enough to guide it.

Another team member was building something genuinely impressive in parallel — a video generation tool using Runway, Veo3, and a custom renderer. Marketing briefs that turned into thirty-second videos. High production quality. The kind of output that would have required a studio and a team five years ago. But he was working in a silo, disconnected from clients and product direction, solving a problem no one had validated. He had heard people mention wanting video content and started building. His lived experience on real production sets made him feel powerful with the AI tools, and the power was real — but it was not connected to the room.

The last ten percent is ninety percent of the effort, and while the work felt productive at first, the problem was that his solution was looking for a problem. He was not a developer or a product person or close to the client. He was building things he had heard people needed but with no validation, because there was no structure connecting his capability to the team’s direction. The thousand conversations problem embodied in one person: locally brilliant, collectively disconnected.

The Temptation of Standardization

The instinctive organizational response is standardization. One prompt template. One AI tool. One system of record that everyone queries. One voice that speaks for the organization’s intent so that everyone’s parallel conversations start from the same place.

This is not wrong. It is incomplete. And the part it misses is the part that matters.

The parallel conversations are not a problem to be eliminated. They are a resource to be synthesized. Each person who approaches a question from a different angle — the one who treats nuance as a feature, the analytical mind, the contrarian who sees what consensus is missing — each of these people is producing signal. Signal that a standard template would suppress before it could be captured.

Standardize the input and you get consistent output. You also get sterile output. An organization that has optimized its parallel conversations for convergence has also optimized them for the elimination of the unexpected. And in a world where judgment is the scarce resource, the unexpected is where the value lives.

The solution to the thousand conversations is not to make them all the same conversation. It is to build the infrastructure that lets them remain different while still being synthesizable.

What That Infrastructure Looks Like

The OpenAI harness engineering team — introduced in Chapter One — encoded their direction in a repository document that any agent — human or AI — could read before beginning work. Not documentation for its own sake. A living encoding of direction, specific enough that every agent working from it would produce consistent results without continuous re-alignment. Their early approach — one large instruction file containing everything the agent needed to know — failed. When everything is marked important, nothing is. They replaced it with a structured directory: a short entry point that served as a map, with pointers to deeper sources of truth. Design decisions documented not just as outcomes but as reasoning. Architecture described not just as what exists but as the principle behind what exists, so that the next decision made by a different person in a different context would be consistent without being identical. That is progressive disclosure applied to organizational intent — the same principle that applies to human teams.

The insight underneath that example applies to human teams with at least as much force as it applies to AI agents: anything that is not encoded explicitly enough to be read by someone who was not in the room effectively does not exist.

This is not metaphorical. During the RouteForge development described in Chapter Nine, I built a new client portal — designed it, coded it, integrated it. When I was finished, Claude Opus informed me that a client portal already existed in the codebase. It was just not documented and not connected to anything. Something that literally existed in the codebase did not functionally exist because no one had encoded it legibly enough for anyone — including the AI — to know it was there. The organizational legibility argument applies to code as much as it applies to teams. What is not encoded does not exist, even when it does.

The Slack thread that aligned the team on a decision but was never written down — it does not exist for the person who joined three months later. The whiteboard session that resolved the ambiguity in the product brief — it does not exist for the team member who was traveling that week. The institutional knowledge that lives in the head of the person who has been there longest — it does not exist for anyone the moment that person walks out the door.

Organizations have always known this. The practice of knowledge management is decades old. But the urgency was manageable when execution was slow, because the gap between losing the knowledge and feeling the consequence was wide enough to catch and correct.

When execution is fast, that gap closes. The undocumented decision becomes a shipped feature before anyone realized the decision had been made implicitly. The divergent understanding becomes a launched campaign before the synthesis that would have caught it has had a chance to happen.

What this requires in practice starts with presence. I have been in Click to Pay meetings with twenty people in person, and sometimes there is a legitimate dialog. But I don’t often hear from people on the conference line — not because they don’t have ideas, but because they aren’t present. Both literally and figuratively. They would need to shout on the phone just to make their presence felt, and if they had that type of will to be heard on the phone, they would have been in the room anyway. Presence is self-selecting. Remote participation in alignment work is observation with the appearance of inclusion. The infrastructure that makes the thousand conversations synthesizable starts with the people who are doing the synthesizing actually being in the room where the synthesis happens.

Beyond presence, the infrastructure requires legibility — not comprehensiveness. The instinct when asked to make something explicit is to make everything explicit — the complete knowledge base, the exhaustive style guide, the documentation that covers every edge case. That instinct fails for the same reason the OpenAI team’s single instruction file failed. When everything is marked important, nothing is. The file became a graveyard of rules that may or may not still reflect reality, and nobody could tell which was which.

The solution is structural: a short entry point that serves as a map, with pointers to deeper sources of truth. That is organizational legibility. Not transparency — everyone can see everything. Not documentation — there is a record of what was decided. Legibility: the organization’s intent encoded in a form that survives the people who hold it.

The Person Who Reads the Conversations

There is a person this chapter has been describing without naming.

In the previous era, they existed in the translation layers between roles. The senior developer who understood what the business actually needed. The product manager who held the tension between what users said they wanted and what the data showed they did. The account director who maintained a relationship sophisticated enough to know what the client had not yet said.

These people were synthesizing — reading the parallel conversations, finding the signal in the divergence, surfacing the question that everyone was dancing around without asking, and converting the resulting clarity into a direction the rest of the organization could move in.

As the translation layers dissolve — as the designer and the developer and the account executive converge toward a shared capability — this work does not disappear. It becomes more important, more visible, and more load-bearing. Because the parallel conversations are happening faster, the artifacts are materializing sooner, and the cost of letting the divergence compound is higher.

The skill is not technical. It is closer to curatorial, or editorial — something that has not quite found its vocabulary because it has only recently become urgent enough to require one. It requires the ability to hold contradictory inputs without prematurely resolving them. To distinguish between productive tension — divergence that is generating signal — and destructive divergence that is consuming energy without producing meaning. To know when the conversations have generated enough to act on and when they are still processing something important that premature synthesis would foreclose.

This is not a new kind of person. They have always been in your organization. What is new is that their work, which was previously invisible because it happened in the gaps between the legible processes, is now the work that everything else depends on.

In film production, the person who holds this function has a title: second assistant director. Not the creative lead. Not the one whose name goes on the poster. The one who holds the entire production’s logistics in her head — who knows that tomorrow’s call sheet conflicts with a location change the director mentioned in passing, who reads across every department’s needs simultaneously and surfaces the collision before it becomes a cost. The function is synthesis. The title undersells it. It always has.

The version of this person in your organization may be the one who is most skeptical of the AI tools — not because they don’t understand them, but because they understand what gets flattened. The people best suited for this work are not always the ones who embrace the tools that accelerate it.

Find them. Give them the room.

Or, if you are that person: you already know. The question is whether the organization around you knows yet.

Before Anyone Opens a Laptop

This is where the chapter connects to Deliberate Alignment as a practice rather than a philosophy.

The thousand conversations problem cannot be solved in the meeting where the work gets reviewed. It cannot be solved in the retrospective where the misalignment becomes visible. It cannot be solved in the integration moment where the separately-built artifacts collide and the distance between them becomes apparent.

It can only be solved before it starts. Before the conversations diverge past the point of easy synthesis. Before the artifacts begin to accumulate in directions that will cost weeks to unwind.

And here is the part that is uncomfortable to say plainly: most organizations do not currently do that work. They approximate it. They hold the meeting that is supposed to produce alignment and leave with the feeling of having achieved it without checking whether what everyone took out of the room was actually the same thing. They produce the strategy document and assume that reading it produces the understanding it was meant to convey. They rely on the accumulated shared context of people who have worked together long enough to develop a kind of shorthand — and discover the limits of that shorthand the moment the team changes, or the pace accelerates, or the AI agents begin executing on the shorthand as if it were explicit when it never was.

Coordination problems have known solutions. Meaning problems might not. That is not a comfortable thing to write in a methodology book. But the honest version of what this chapter is saying is that the thousand conversations are already happening, the artifacts are already accumulating, and the infrastructure that would make them synthesizable rather than incoherent is, in most organizations, not built yet and not being built.

The conversations are not waiting for the organization to be ready.

And the synthesis problem does not stop at the organizational level. The person running multiple AI conversations in parallel — each producing coherent artifacts, each pointed in a slightly different direction — is the thousand conversations problem at the scale of a single mind.

The question is whether what they produce, when they converge, will be the thing the organization meant.

Coordination problems have known solutions. Meaning problems require something the field has not yet fully described. The conversations are not waiting for the description to arrive.


← Previous: Chapter 5: The Client in the Room · Contents · Next: Chapter 7: Relief or Panic — How to Know Which You Are →

Copyright Walter Reid, 2026. All rights reserved.

Deliberate Alignment [Chapter 4]

[Chapter 4 from Deliberate Alignment by Walter Reid, written in spring 2026]

The room is not where the work gets reported. It is where the work begins.

There is a name for what happens in the best two and a half hours of the Thursday meeting.

Not a new name. The thing it describes has been happening in good rooms for as long as there have been good rooms. What is new is the urgency of naming it — the specific pressure that arrives when execution becomes fast enough that the thing which was always most important can no longer be deferred past the first conversation.

Deliberate Alignment is a methodology organized around the quality of the decision before execution begins, rather than the management of execution itself. The unit of work is not the sprint. It is the room — the specific convergence of the right people, with visible work, making real decisions that an agent can act on before anyone leaves.

That definition is precise. It is also incomplete without understanding what it is not.

It is not better meetings. Meetings, as they exist in most organizations, are designed either to communicate decisions already made elsewhere or to create the appearance of collective ownership for decisions that will be made elsewhere anyway. The calendar entry and the agenda and the agreed-upon next steps are theater when the real decision has already happened in a hallway or a direct message. Deliberate Alignment is not about running that process more efficiently. It is a different process.

It is not a workshop methodology. Design sprints, war rooms, hackathons — these are relatives of the same instinct, and the iHeart story shows where that instinct comes from. The hackathon changed what was being decided on. A tangible prototype reduces decision latency by changing what the process has to evaluate. Deliberate Alignment takes that instinct and makes it the entire methodology rather than a periodic intervention.

And it is not a framework for eliminating disagreement. The room that produces genuine alignment is not a room where everyone agrees. It is a room where the disagreement is legible — where the tension between perspectives is visible to everyone, where it can be evaluated rather than avoided, and where someone with the authority to commit can make the call and have it mean something. Alignment is not consensus. It is shared understanding of a direction, including an understanding of what was decided against and why.

The Three Functions

Every room that has ever produced genuine alignment has contained three functions. Sometimes three people, sometimes fewer. The number of people is not the point. The functions are.

The first is the function of depth. Someone in the room has to understand what the client, the user, the stakeholder needs beneath what they say. Not the stated requirement. The actual pressure. The competitive anxiety that didn’t make it into the brief. The internal politics that will determine whether the right solution gets adopted or quietly shelved.

In the Zansei project, this function belongs to the person who understands that Zan’s requests for new features are not really product requests. They are expressions of a founder’s anxiety about whether the thing he has built will matter. When he says “now let’s add e-commerce,” he is not describing a product roadmap. He is describing fear that the current product is not enough. The person who hears that and responds to the fear rather than the feature request is doing the depth function. The person who adds e-commerce to the backlog is not.

This function has been systematically undervalued because it is invisible when it is working. The meeting goes smoothly. The client leaves satisfied. The direction is clear. Nobody sees the specific quality of listening that produced those outcomes because the outcomes look like they just happened.

The second is the function of taste. Someone in the room has to be willing to say when the answer is defaulting to mediocrity. Not the obvious wrong answer — that is easy to catch. The answer that is technically correct, defensible, and insufficient. The direction that will satisfy the sprint review and disappoint the user.

This function is the most politically exposed of the three because it requires pushing back against the path of least resistance in a room where the path of least resistance is what everyone wants to take. It requires a specific kind of standing — not authority, exactly, but credibility. The person who says “that’s not good enough” has to have earned the right to say it. Which means the function cannot be assigned. It can only be recognized.

In the Zansei project, this function is currently vacant. Not because the people in the room lack taste — several of them have excellent taste. But nobody has been given, or taken, the explicit role of maintaining the product’s integrity against the gravity of scope expansion. When Zan expands the scope, there is no voice in the room whose designated function is to say “that’s a different product and building it will cost us the product we have.” That absence is structural, not personal.

The third is the function of authority. Someone in the room has to be able to say yes and have it mean yes. Not yes pending approval. Not yes subject to review. Yes, this is the direction, and the execution can begin.

This function sounds simple. It is the most complicated of the three in practice, because authority without understanding is not authority — it is permission for the wrong thing. The person who can commit must be present in the room where the alignment is being built, not receiving a summary afterward. The summary degrades the alignment. It removes the context that made the direction legible and replaces it with a conclusion that looks like the same thing but isn’t.

Zan is the authority function in the Zansei project. The Thursday meeting works, when it works, partly because he is there — present, engaged, making calls in real time. The meetings where he is absent or distracted produce decisions that look like decisions until he encounters them later and reframes them from a different context. The alignment wasn’t built with him. It was built around him. Those are not the same thing.

Understanding Zan requires accepting something the framework does not make obvious: authority without depth is not always a vacancy to be filled. Sometimes it is the permanent operating condition of the person who holds the authority function. Zan is the type of person who tells you to go take pictures in Central Park. And when someone asks which part — the geese, the lake, the people, the trees — he says “Central Park.” Or worse: “I told you Central Park, what don’t you understand.” He does not know what he wants until he sees options. He has never known. He is not going to start.

This type of person thrives with AI, assuming there are people who can translate those words to actions. Before, you had to go photograph everything in Central Park and return like an episode of Mad Men, lay the options on his desk, and have him select. Now the options can be generated in minutes. The translation layer — the people who hear “Central Park” and understand what questions to ask before anyone starts shooting — is more important, not less. The framework’s job is not to fix the founder. It is to build the translation layer that lets the founder’s instinct become actionable without requiring the founder to articulate what he cannot articulate.

The danger is what happens when Zan sees the speed. If you can provide a full prototype in a week that would have taken months before, he will expect the mobile app or the multi-tenant system done by next Monday. Expectation inflation — the authority function seeing AI-enabled speed on one task and generalizing it to everything — is a failure mode the framework has to absorb. The translation layer has to manage not just the founder’s direction but the founder’s sense of what is possible.

Why One Person Can Hold Two Functions

The three functions are not job descriptions. They are capacities that need to be present in the room. The same person can hold more than one.

The person who understands what the client needs beneath what they say often also has the taste to recognize when the answer is insufficient. Those two functions travel together in people who have spent significant time close to users — who have developed their taste through repeated exposure to the gap between what was built and what was needed.

The person with authority to commit sometimes also holds the depth function — the founder who has been closest to the problem, who understands the user’s anxiety because they shared it before they built the solution. That combination is powerful when the authority is paired with genuine understanding and dangerous when it isn’t. Zan at his best is both. Zan on a day when he is running on pattern-matching from a single data point is the authority function operating without the depth function, and the direction that emerges will be confident and wrong.

What the framework requires is not that three distinct people occupy three distinct boxes. It requires that when any significant decision is being made, all three functions are present and active. The check is simple: is someone listening at depth, is someone willing to say when it isn’t good enough, and is someone able to commit with genuine understanding of what they are committing to? If any of those questions has no answer, the room is not ready to produce alignment.

The framework requires that the functions be present. It does not require that they remain distributed across multiple people indefinitely.

The New Prioritization Question

The old prioritization question — given scarce execution capacity, what should we build first? — dissolved in the previous chapter when the denominator disappeared. The new question is: given that we can build almost anything, what should we decide to build at all?

That is not a ranking problem. It is a decision problem. And it requires the three functions to be present. The depth function to understand what building this will actually mean for the person it is built for. The taste function to assess whether this is the direction that will matter or merely the direction that is available. The authority function to commit to one direction and foreclose the others.

The decision that resolves ambiguity for every execution that follows it is worth more than the decision that resolves one task cleanly. The decision that lets the room disperse with shared understanding of what the next month looks like is worth more than the decision that produces one feature quickly.

This is what the Zansei team is missing. Not execution capacity — the team can build almost anything in hours. What it is missing is the decision that would let every member build confidently in the same direction without requiring constant re-alignment. The Thursday meeting produces that decision, sometimes, for a few days. The methodology is the attempt to produce it reliably.

What the Room Requires

A room that produces genuine alignment requires that the work is visible. Not described — visible. The prototype, the draft, the live system, the actual artifact that the decision is being made about. The client who is reacting to a description is imagining something. The client who is reacting to a prototype is evaluating something. These produce different quality decisions.

It requires that the people in the room can make the decision. Not advise on it. Make it, with authority that holds outside the room. A room full of people who are present to inform a decision that will be made by someone who is not present is not an alignment session. It is a research process that will produce a summary that will degrade the alignment before it reaches the person who can commit.

It requires that the decision survives the room. The output of a Deliberate Alignment session is not minutes. It is a shared understanding explicit enough to be acted on independently — specific enough that two people who were in the room can make separate decisions the following day that point in the same direction without checking with each other first.

And it requires that the people in the room trust each other enough to say what they actually think. Psychological safety — the condition where people believe they will not be punished for speaking up — is not a soft organizational concern in this context. It is load-bearing. The room that cannot hold genuine disagreement cannot produce genuine alignment. What it produces instead is the appearance of alignment, which is more dangerous than acknowledged disagreement because it is invisible until the execution is already underway in the wrong direction.

The Framework Applied to Zansei

The Zansei project is not a success story. It is a work in progress, and the framework is being tested on it in real time.

What the Thursday meeting gets right: it assembles most of the functions. The depth is present. The authority is present when Zan engages rather than absorbs. The work is visible on the screen at the end of the table. For two and a half hours, the room functions as the methodology describes.

There was a Thursday in March where it worked. The business consultant, who held the client relationship, asked the developer to produce a brand document and a white-label overview — something a new partner could use to get up to speed quickly. The request was reasonable. The timeline she was imagining was a week. The UX lead, who could have built it with her eyes closed, sat quietly. The developer nodded.

I was annoyed before I understood why I was annoyed. The business consultant had been in every meeting — she was the person closest to the partner’s needs. The UX lead was sitting right next to her, the person who could articulate the brand’s voice in her sleep. And both of them had deferred the ask to the developer. Not because he knew the brand better. Because producing a deliverable still felt like a technical act, even when the deliverable was pure judgment. The knowledge to produce those documents was in the room. It had been in the room for months. The taste and the depth were present. They just didn’t recognize themselves as sufficient.

So I did it while the conversation continued. Opened Claude, shared screenshots of the product flow, attached two media briefs as examples, and asked for both deliverables. Before the meeting moved to the next topic, both documents were in Slack. Not perfect. Good enough to use, good enough to improve, produced in five minutes from the understanding that was already present in the room.

The room went quiet for a moment. Not because the documents were impressive — they were functional, not beautiful. Because the speed made visible something the team had not confronted directly: the gap between what they knew collectively and what they were producing was not a capacity problem. It was a willingness problem. The understanding was there. The encoding was not.

And then the thing I did not say out loud, because it was not the moment: I could produce those documents because I held all three functions simultaneously — I understood what the partner needed, I could judge whether the output was sufficient, and I had the authority to ship it without asking. The business consultant had the depth. The UX lead had the taste. Both were in the room. Neither acted. So I held all three, and for five minutes the framework worked perfectly — and the question I could not stop thinking afterward was why I had needed anyone else in the room at all. That question is not one this chapter can answer. But it is one the book will return to.

What it gets wrong: the taste function is not held consistently. The decision that the meeting produces is not always encoded explicitly enough to survive the week. The authority that commits on Thursday sometimes re-opens what was committed on the following Monday, having encountered a new piece of information that was not in the room. The alignment is real but fragile — produced by proximity and presence, not by a system designed to sustain it. Initially, the Thursdays were demos without direction — work shown, reactions given, nothing decided that would hold past the weekend.

The fix is not to have longer meetings or more meetings. It is to be more deliberate about what the meeting is for. The first fifteen minutes of ritual — what did you do, what will you do, any blockers — is not alignment work. It is status reporting that could be asynchronous. The two and a half hours in the middle is the alignment work.

The more fundamental fix is to name the vacancy. The taste function is not held. Nobody in the room has the explicit standing to say “that is a different product” when the scope expands, and have the authority function hear it as information rather than resistance. Without that voice, the backlog of features and client requests becomes what the previous chapter called an anxiety archive — not a prioritization tool but a growing list of things that might matter, maintained by a team that cannot say no. Naming that vacancy is not a personnel problem. It requires a conversation about what the room needs that it does not currently have, and who is willing to hold it.

That conversation is itself a Deliberate Alignment session. The methodology is recursive. The room that designs the room is the same kind of room as the room it is designing.

The Zansei project will continue after this book is written. Some Thursdays will produce the two and a half hours of real alignment. Some will produce demos without direction.

What the framework offers is not a guarantee that every room will work. It is a description of what a room that works requires, specific enough that you can look at your own room and ask which of those things are present and which are absent. The three functions. The visible work. The decision that survives the room. The trust that makes genuine disagreement possible.

If all of those are present, something will happen in the room that is difficult to describe from the outside and immediately recognizable from the inside. The options become real. The direction becomes clear. The people leave knowing what they are building and why, and the knowledge is specific enough to act on without checking back.

That is what the Thursday meeting feels like in its best two and a half hours. Not efficient. Not optimized. Alive.

It is not a meeting. It is the work.

The room that produces alignment is not the room where everyone agrees. It is the room where the decision is made by the people who have to live with it, in the presence of everything they need to make it well.


← Previous: Chapter 3: What Agile Got Right (And Why It’s No Longer Enough) · Contents · Next: Chapter 5: The Client in the Room →

Copyright Walter Reid, 2026. All rights reserved.

When Building Was the Hard Part (And What Happened When It Stopped) [Chapter 2]

[Chapter 2 from Deliberate Alignment by Walter Reid, written in spring 2026]

Methodology does not follow philosophy. It follows economics. Every time the cost structure changed, the way people organized around it changed to match.

In 1970, a software engineer named Winston Royce published a paper that would become one of the most influential and most misread documents in the history of software development.

The paper described a process in which software moved through sequential phases — requirements, design, implementation, testing, deployment — each completed before the next began. The diagram showed these phases flowing downward, like water over a series of steps. It was called, eventually, waterfall. Royce did not call it that. More importantly, Royce did not endorse it.

The paper’s actual argument was almost precisely the opposite. Royce described the sequential model and then spent the remainder of the paper explaining why it was fundamentally flawed. He called for iteration. He called for early prototyping. He called for the involvement of the customer throughout the process. The diagram that became the emblem of heavyweight process for three decades was an illustration of what not to do.

This matters not as a historical footnote but as a lesson about how methodologies actually travel. What spread was not Royce’s argument. What spread was the diagram. The sequential model was visually clean, organizationally legible, and easy to put in a contract. You could tell a client exactly what they would get and when. The fact that it did not work particularly well was, for a time, less important than the fact that it was understandable.

This is how methodology wins. Not through intellectual persuasion. Through organizational convenience. The thing that is easiest to adopt beats the thing that is most correct, until the cost of the incorrectness becomes impossible to absorb.

Why Waterfall Made Sense

Computing time in the 1970s was expensive in a way that requires historical imagination to appreciate. Organizations paid for access to mainframes by the minute. Running the wrong program was a financial event. Changing code rippled through every piece it touched, and tracing those ripples consumed time that was itself expensive. A modification to a system that had been in production for six months might require weeks of testing to validate that nothing had been broken. The test environments were manually assembled. The tests were largely manual. Change was not free.

In this environment, the sequential model was not irrational. If change is expensive, minimize change. If minimizing change requires knowing what you are building before you build it, invest in knowing. Gather requirements exhaustively. Design comprehensively before coding. Test everything before shipping. The overhead was enormous but the alternative — discovering in month eight that you had built the wrong thing — was worse.

The problem was the one Royce identified in 1970 and that practitioners spent three decades rediscovering: exhaustive upfront specification assumes the future is knowable with precision, and the future is not. Requirements change because businesses change. Clients change their minds because they do not fully know what they want until they see what they asked for.

Waterfall produced a specific, predictable failure mode: software that was precisely what was specified, and not what was needed. The Standish Group’s early data told the story — more than 30 percent of projects cancelled before completion, fewer than 20 percent delivered on time and on budget. Not catastrophically wrong software. Software that arrived late, over budget, and partially wrong. The signature failure of a process that optimized for planning at the expense of adaptability.

The fix was not to plan better. The fix was to make change cheaper.

The Shift That Created Agile

Between 1970 and 2001, the cost of changing software fell steadily, quietly, and cumulatively. Hardware became cheaper. Version control made it possible to reverse bad changes. Test frameworks made validation automatic. By the late 1990s, the math underneath waterfall had shifted. The exhaustive upfront specification was premised on change being expensive. When the cost of getting it wrong and correcting dropped below the cost of the overhead required to get it right the first time, the premise dissolved.

This is the context into which Kent Beck walked with Extreme Programming and seventeen practitioners walked with the Agile Manifesto. They were not describing a philosophical revolution. They were describing the rational response to a new cost structure. Iterate fast because iteration is cheap. Keep the customer close because you can afford to discover you misunderstood and correct quickly. Release often because the overhead of releasing has fallen to the point where infrequent releases are economically unjustified.

The Manifesto’s four values read as philosophy. They are better understood as economics. Each value is a prescription for a world in which iteration is cheap and specification is expensive relative to correction.

Agile did not win because it was philosophically superior to waterfall. It won the same way waterfall won — through adoptability. The ceremonies fit the organizational shape that already existed. That they also happened to be correct for the cost structure was, in a sense, a bonus. The adoptability came first.

What Agile Produced

Delivery frequency increased. DORA’s research confirms what practitioners already felt: the best teams deploy multiple times a day. Project failure rates declined. Developer experience improved. The daily standup, whatever its limitations, surfaces problems earlier than the monthly status meeting.

And something subtler happened that is relevant to everything that follows. Organizations got better at the mechanics of building software and did not get proportionally better at the question of what to build. The sprint became a well-oiled machine for delivering features. Whether the features delivered were the right features remained stubbornly harder than the delivery itself.

This is not a criticism of agile. Agile was designed to make iteration cheap. It was not designed to make the initial decision correct. The assumption was that cheap iteration would eventually produce convergence on the right answer, through repeated feedback and course correction.

That assumption held when iteration cycles were measured in sprints. It strains when iteration cycles are measured in hours.

The Counter-Argument Worth Acknowledging

AI-assisted development is producing measurable productivity improvements. The tools are genuinely useful. But two data points from analysis of AI-generated codebases are worth sitting with separately, because they are telling different stories.

The first: code churn — the percentage of code written and then discarded within two weeks — roughly doubled between 2021 and 2024 in teams using AI assistance heavily. The critics read this as evidence that AI makes code worse. More code is being written and thrown away.

The second, less discussed: the rate of refactored or “moved” code — an indicator that developers are thinking carefully about structure and reuse — declined sharply over the same period.

These are different signals. The churn says wrong decisions get executed fast. The declining refactoring says something more unsettling: people stop thinking structurally when the tool thinks fast. The developer who used to pause before writing a new module — who would ask whether this logic already existed somewhere, whether this function belonged here or in a shared library — that pause is disappearing. Not because the developer lost the skill. Because the tool makes it faster to write the new thing than to find and integrate the existing thing. The economics of the moment favor duplication over design.

The first signal is a decision-quality problem that AI makes visible. The code is discarded because the decision before the code was wrong, and AI executes the wrong decision faster than a human would have. The human writing code inefficiently was, in the process of writing inefficiently, discovering that the decision was flawed before too much had been built against it. The AI removes that accidental correction mechanism.

The second signal is subtler and points somewhere different. It suggests that speed itself degrades a specific kind of judgment — the structural judgment that asks not just “does this work” but “does this belong here.” The churn problem is a decision-quality problem. Deliberate Alignment is designed to address it. The refactoring problem is something else: a capacity problem, operating below the level of any meeting or methodology. It shows up later, as accumulated technical debt that nobody planned and nobody measured, produced by a cognitive habit that nobody noticed was disappearing.

The first signal says the next problem is upstream of execution. The second says it may also be inside the people doing the executing. This book addresses the first. The second is worth naming honestly, even here, because pretending both signals point the same direction would be the kind of false resolution the rest of this book is trying to avoid.

The Pattern, Stated Plainly

When building was expensive, you planned exhaustively before building. Waterfall.

When building became cheap, you iterated toward the answer. Agile.

When building approaches free, iteration is no longer the bottleneck. Something else is.

There is a circle worth closing here. When Royce and the businesses that adopted his diagram front-loaded planning, they did so because development was costly. Mainframe time was expensive. A mistake in month six meant a budget-ending rewrite. So they invested in knowing before building, because building was the thing they could not afford to get wrong.

Deliberate Alignment front-loads thinking for the opposite reason. Building is approaching free. The wrong thing arrives instantly. The cost is no longer the build — it is the rework cycle when what arrives is not what was needed, multiplied by the speed at which the wrong thing propagates. You plan before you build not because building is expensive, but because it is so cheap that an undirected build produces waste at a rate no team can absorb.

The same conclusion — think before you act — reached from opposite ends of the cost curve. DA is not a return to waterfall. It is arriving at waterfall’s instinct from the other direction.

It is like baking bread. Once the ingredients are in and you start to bake, if the bread doesn’t taste good or doesn’t rise, you don’t fix the bread. You make another loaf. So you get the ingredients ready ahead of time and you plan the recipe — but now the bake takes one minute. The planning is not because baking is hard. The planning is because baking is so easy that a bad recipe wastes nothing but your attention, and attention is the thing you cannot get back.

The practitioners who defended waterfall in 1999 were not irrational. They were experienced. They had seen agile’s predecessors come and go and concluded, reasonably, that each new methodology was mostly repackaging with new vocabulary. They were right that most of what agile claimed was not new. They were wrong that the underlying shift was incremental.

The practitioners defending agile-with-AI as the appropriate response to this moment are not irrational either. They may be right that better tools improve agile practice in the short term. They are, this book argues, wrong that the underlying shift is incremental.

The pattern says so. The pattern has said so twice before.


The Bottleneck Has Moved

The constraint was never the code. It was always upstream. Execution time was just good enough at hiding it.

Around 2012, a mobile team at iHeartRadio went on a ski trip.

The trip was a hackathon. Four days, no meetings, build whatever you think is worth building. The lead developer was learning Swift — not because anyone asked him to, but because the potential was obvious and the potential was new and that combination produces a specific kind of energy in a good engineering team. They were not waiting to be told what mattered. They already knew.

By the end of four days, they had built things. Real things. A customer talk radio station concept. A full-screen album art redesign that changed the entire feel of the listening experience. Prototypes that answered questions nobody had been able to get answered through the normal process of design reviews, stakeholder meetings, and prioritization discussions.

Then they went back to the office.

The prototypes sat. Not because nobody was interested. Because it wasn’t clear who could decide. The executives had opinions. The design organization had designed, by the CDO’s own account, every conceivable UX and UI option. And yet the decisions that would have let the team move — which direction, which experience, what to build toward — did not come.

The CDO said something to the mobile product team that stayed with me. Paraphrased: don’t come to a meeting with opinions, because the people you’re talking to have better titles.

The team built fast. The decisions moved slowly. The competitive window was wide enough, in 2012, to survive the wait. Nobody felt the full cost of the delay because the delay was normalized into the rhythm of how things worked.

That was the constraint. Not the code. Never the code. The constraint was upstream, invisible to anyone measuring sprint velocity or deployment frequency, and protected by an organizational structure that had confused hierarchy with judgment.

What AI changes in that story is not the politics. It is the cost of the delay.

The Constraint Moves

Goldratt’s central insight is simple enough to state in a sentence: every system has one constraint at any given time, and the performance of the system is determined by that constraint.

The five focusing steps that follow are what make it operational. Identify the constraint. Exploit it — get the most out of it before doing anything else. Subordinate everything else to the constraint — stop optimizing what is not the bottleneck. Elevate it — if exploiting is not enough, invest in increasing its capacity. And when it breaks through, go back to step one. Because the constraint will have moved.

That fifth step is the entire argument of this book.

For most of software development’s history, execution was the bottleneck. There were not enough developers. The ones you had could only build so fast. The field identified that constraint and optimized against it for two decades. Lean software development. Kanban. DORA metrics. Continuous deployment. Each optimization was applied to the right constraint and each one worked. The organizations that invested in them got measurably better.

The constraint has broken through. Execution, for teams at the frontier of this shift, is no longer what limits the system. But the field is still on step three — subordinating everything to a constraint that has already moved. Continuing to optimize deployment frequency and cycle time is improving something that is no longer the bottleneck. It produces the appearance of progress. The velocity metrics go up. The wrong things get built faster.

Matt Gunter, writing about the misapplication of constraint theory to software, arrives by a different route at the same destination.1 His argument against TOC in software is that the flow metaphors break down for knowledge work, that throughput optimization creates what he calls “intention blindness” — it cannot reflect the value of strategic decisions. The real levers, he argues, are not throughput optimization but something else — improving skills, reducing unforced errors, increasing the level of decision quality. He is arguing against the vehicle and pointing at the destination. The conclusion he reaches independently — decision quality — is the one this chapter is built around. Convergent evidence from someone trying to argue the other way is worth more than confirming evidence from someone already on your side.

The constraint is upstream. It is the quality of the decision before execution begins.

Decision Latency

Velocity measures how fast a team executes. It is a reasonable measure of execution speed and a poor measure of anything else.

The metric the field does not yet have a name for is the one that matters most in a world where execution is cheap. Call it decision latency — the gap between when a commitment is made and when its quality is validated.

In the iHeart story, the decision latency was months. The prototypes existed. The options were concrete. But the validation — did we build toward the right thing — arrived slowly, through the slow accumulation of user data, competitive signal, and executive opinion. The execution was fast. The decision latency was long. The constraint was not the sprint. It was the gap between commitment and confirmed direction.

When execution takes weeks, long decision latency is painful but recoverable. You discover in month three that the decision in month one was wrong, you course-correct, you lose three months.

When execution takes hours, long decision latency is catastrophic. The bad decision propagates into artifacts before anyone has asked whether it was right. The doubled code churn is this dynamic made visible. The execution is faster. The decision latency is unchanged. The wrong things are built at speed and the waste arrives before the course correction.

Decision latency is the new constraint. Shrinking it is the new work.

The Constraint You Think You Have

There is a version of this misidentification that is worth naming directly, because it explains why entire sectors are moving slower than they should.

I have watched it happen in healthcare IT. The regulatory barriers are real — HIPAA, FDA clearance, payer integration standards that took decades to partially achieve. Anyone who tells you these do not matter has not worked in a health system.

But here is what the data actually says. When health system leaders are surveyed about the biggest barrier to AI adoption, the top answer is not regulatory uncertainty. It is immature AI tools — cited by 77 percent of respondents. Financial concerns come second at 47 percent. Regulation comes third, at 40 percent.2

The thing most health system leaders cite first in conversation is third in the data.

That gap between the conversation and the data is the diagnostic. The regulation is real. The regulation is also performing a psychological function that has nothing to do with compliance. It is providing the story that makes the real constraint — immature infrastructure, missing talent, slow decision-making — feel like someone else’s problem. The external constraint is more comfortable than the internal one. Regulation is a wall you can point at. Decision-making speed is a mirror.

What makes this pattern durable is that it is self-reinforcing. The organization that identifies the wrong constraint invests in managing it, builds reporting structures around it, develops institutional expertise in navigating it. That investment creates its own justification. The people who have spent three years managing regulatory risk are not wrong that regulatory risk exists — they are wrong that it is the binding constraint, and they now have careers that depend on not seeing the difference. The external constraint stops being a misidentification and becomes an identity.

This pattern is not unique to healthcare. Every organization pointing at an external constraint while the internal one goes unnamed is doing the same thing. “Technical debt” can be a version of the same misidentification — teams fixing code when the real problem is decision quality upstream, velocity treated as a vanity metric while the constraint it measures has already moved. The question is always the same: what would you do if the external barrier were removed tomorrow? If the honest answer is “we still could not move quickly,” you have been managing the wrong constraint. Possibly for years. Possibly while building an organization optimized to keep managing it.

The Boundary Condition

There is a version of the Mastercard story that belongs here as a boundary condition — and it is worth understanding why Click to Pay existed before understanding why the constraint theory breaks against it.

Click to Pay was born from a relevance crisis, not a technology problem. As Apple Pay, Google Pay, and other wallets proliferated, they used the Visa and Mastercard rails invisibly. The acceptance mark — the thing that once told a consumer this place takes your card — stopped meaning anything when every place took everything. The brand was disappearing into the infrastructure it had built. Click to Pay was the response: a product designed to solve a relevance problem, organized as if it were solving a technology problem. That misidentification — strategic constraint dressed as technical constraint — is the healthcare pattern from earlier in this chapter, operating at the scale of a global payments network.

At scale — three hundred or more developers, multiple competing institutions, decisions that required alignment across Visa, Mastercard, American Express, and Discover before any code could be written — the constraint was not execution and it was not decision quality in the traditional sense. It was decision authority. Nobody could say yes in a way that meant yes. The committee’s real function was not to make decisions but to provide political cover for the absence of decisions.

AI would not have helped that. AI might have made it worse — faster execution of a direction nobody was actually committed to, amplifying the incoherence before the political process had time to quietly bury it.

This is the boundary of the argument. When decision authority is so distributed across competing interests that yes cannot be said at all, the constraint is not decision quality. It is organizational structure. That is a different problem, and this book does not solve it.

How common is that situation? More common than the framing of “boundary condition” implies. Enterprise software teams, government contractors, any organization where multiple institutions must align before a single line of code can be committed — these are not rare. They are a substantial portion of the industry. The Mastercard dynamic is not an edge case. It is the normal operating condition for a significant fraction of the people reading this book.

What this book addresses is the iHeart situation: capable people, real potential, decisions that could have been made but weren’t, because the structure around decision-making was unclear and the culture was hostile to the expression of informed opinion. If you are in that situation, the framework in the following chapters is for you. If you are in the Mastercard situation, the framework will not be sufficient. Knowing which situation you are actually in is itself a decision-quality problem — and it is worth solving before you go further.

What This Means for the Metrics

Velocity will not disappear. It will be demoted.

The useful analogy is heart rate. Heart rate is real. Monitoring it tells you things worth knowing. But no serious athlete optimizes for maximum heart rate. It is a health indicator, a lagging measure of effort expended. Optimizing for it directly selects for stress rather than fitness.

Velocity is the heart rate of software development. Useful to monitor. Dangerous to optimize. The organizations that built their entire performance culture around it will find, as execution costs fall, that they have tuned an instrument measuring something increasingly peripheral.

Decision latency will become the primary metric for teams at the frontier. Not because it is easy to measure — the field does not yet have standard instrumentation for it. But because it is the measure that corresponds to the actual constraint. Speed at low quality produces more waste faster. Quality at low speed produces the iHeart hackathon — right direction, wrong pace. Quality at high speed is what Deliberate Alignment is designed to produce.

The hackathon worked, imperfectly, because it changed the cost of decision-making. A tangible prototype is cheaper to evaluate than an abstract proposal. The executive who cannot decide between two UX directions described in a document can sometimes decide between two they can actually use. The concreteness reduced the decision latency — not by speeding up the process, but by changing what the process had to evaluate.

That instinct — make the decision easier by making the options real — is the same instinct behind what this book will name in two chapters. The difference is that in 2012 the hackathon took four days to produce the prototypes. Now the prototypes can exist before the meeting that will decide between them.

The constraint is the same as it always was. The cost of carrying it has changed.

Velocity measures how fast you move. Decision latency measures whether you moved in the right direction. Only one of those was ever the constraint.


Notes

  1. Matt Gunter, “How ‘Theory of Constraints’ misguides software improvement,” Medium, March 2024.
  2. “Adoption of artificial intelligence in healthcare: survey of health system priorities, successes, and challenges,” Journal of the American Medical Informatics Association 32, no. 7 (2025). Scottsdale Institute member survey, Fall 2024, 43 responding US health systems. https://academic.oup.com/jamia/article/32/7/1093/8125015

← Previous: Chapter 1: The Meeting That Finished After the Work Did · Contents · Next: Chapter 3: What Agile Got Right (And Why It’s No Longer Enough) →

Copyright Walter Reid, 2026. All rights reserved.

The Meeting That Finished After the Work Did [Chapter 1]

[Chapter 1 from Deliberate Alignment by Walter Reid, written in spring 2026]

The bottleneck was never writing the code. It was always deciding what to write.

Picture a room.

A new business developer sits across a table from a client they have been trying to land for six months. The brief came in three weeks ago. The pitch was sharp. Today is supposed to be the close — the conversation that ends with a signature.

But something is happening in the room that wasn’t in the plan.

The client is talking about what they actually need. Not what’s in the brief. Not what they told the procurement team. The real thing — the competitive pressure they didn’t put in writing, the internal politics around the last vendor, the thing their CEO said at the all-hands that is quietly reshaping every priority they have. The new business developer is listening with a different quality of attention than usual because they know this matters. Every nuance is being tracked.

By the time they shake hands and the client says yes, a product has already been built.

Not metaphorically. Not ‘in concept.’ Actually built. The conversation was being transcribed in real time, fed into a system that understood the context, and while the two people were still in the room negotiating the terms of what they would make together, an agent had already begun making it. By the time the new business developer gets back to their desk, the first version is waiting.

Nobody in the room mentioned this part. It didn’t seem like the moment.

This is not science fiction. The technical infrastructure for this exists today, in rougher form than it will in two years. What doesn’t exist yet is any coherent framework for what it means. For how teams should be organized around it. For what skills it demands, what roles it obsoletes, and what kind of judgment it elevates in ways we have not yet learned to reward.

This book is that framework. Or the beginning of one.

The Problem That Changed

Every methodology in software history was a rational response to a cost structure. Waterfall made sense when changing code was expensive — you planned exhaustively because getting it wrong meant a rewrite that could consume the project budget. Agile made sense when changing code became cheap — you iterated toward the answer because correction cost less than prediction.

Both were right for their moment. Both followed economics, not philosophy.

In August 2025, a small team at OpenAI began an experiment they would later call “harness engineering.” They started with an empty repository — no code, no scaffolding, nothing. Their constraint was deliberate and absolute: no human-written code. Every line would be generated by AI agents. Three engineers drove the process, growing eventually to seven.

Five months later, the repository contained approximately one million lines of code across roughly 1,500 merged pull requests. The team estimated they built in one-tenth the time it would have taken to write the code by hand.1

Read that number carefully. Not twice as fast. Not ten percent faster. One-tenth the time.

When Kent Beck made changing code cheap, he changed methodology. When AI makes building code cheap, it changes something larger. It changes what is scarce.

The bottleneck has moved. What is scarce now is the quality of the decision before execution begins — the clarity of what to build, the accuracy of the understanding of who it is for and why they need it, the ability to synthesize the nuance in the room between what someone says and what they mean.

This is not a new insight about what matters. Good product managers have always known that understanding the problem is harder than solving it. What is new is that the gap between understanding and solution has collapsed to near-zero. Now the gap is hours. Sometimes less.

This changes the stakes of the decision. It changes what it means to get the alignment wrong.

Back to the Room

Return to the new business developer and the client.

What made that conversation valuable was not that it produced a requirements document. It was that it produced understanding — the kind that lives in the gap between what someone says and what they mean, between the brief that went through procurement and the actual pressure that kept the client’s CEO up last Tuesday night.

Under waterfall, that understanding was captured imperfectly in a specification and then handed to a team that turned it into software over months, losing fidelity at every translation.

Under agile, that understanding was gathered iteratively, in sprints, with the customer checking in every two weeks to course-correct. Better. Slower than necessary.

What I am describing in this book is what comes next. A model where the conversation itself is the specification. Where the understanding reached in that room — if it is rich enough, if it is genuinely shared, if the right people are present and asking the right questions — becomes the direct input to execution that happens in real time.

The discipline this requires is not the discipline of sprinting. It is the discipline of alignment. Of making sure that before a single agent begins executing, the humans in the room have genuinely converged on what they mean.

I call this Deliberate Alignment. Not because the word is elegant — there are more poetic options, and I considered them. But because deliberate carries exactly the weight I need it to. It implies intention, not accident. It implies that alignment is not something you hope happens in the course of a meeting but something you engineer, with rigor, before anything else begins.

The rest of this book is about what that engineering looks like.

A Map of What Follows

Chapter Two traces the history of methodology as a history of bottlenecks — how waterfall made sense, how agile emerged from a shift in economics rather than philosophy, and why the current shift is structural rather than incremental. It introduces decision latency as the metric that should replace velocity.

Chapter Three examines what agile got right and what was scaffolding for a constraint that no longer exists. The sprint, the standup, the backlog — each was rational for its era. The chapter asks what remains when the era changes.

Chapter Four introduces Deliberate Alignment as a practice: the three functions that must be present in any room that produces genuine alignment, what it is, what it is not, and what happens when one of those functions is absent.

Chapter Five follows the depth function into the client relationship — where the conversation becomes the specification and the client becomes a participant in alignment rather than the object of it.

Chapter Six names the thousand conversations problem: what happens when everyone has AI and the parallel work is locally coherent but collectively incoherent. This is a meaning problem, not a coordination problem, and the distinction is load-bearing.

Chapter Seven turns the lens personal. When the process stops carrying you, what is left is the judgment — yours, unmediated, visible. Five diagnostic questions help you locate yourself on the spectrum between relief and panic.

Chapter Eight takes the longest view — Personal Software as a Service, and what happens when the economic barrier that made bespoke a luxury disappears. The template existed because custom was expensive. That is the only reason it existed.

Chapter Nine is the proof of life. Three people, one real problem, a franchise operator who needed to stop spending four hours a week in a spreadsheet so she could take her family to Ireland. RouteForge demonstrates the framework, the PSaaS argument, and the dissolving dependency between the three functions — all in a single story.

Chapter Ten is the honest reckoning. What I am confident about. What I am inferring. What would falsify the argument. And what the practitioners who live this will know before I do.

We are not at the end of methodology. We are at the end of one bottleneck and the beginning of understanding the next one.

The meeting has already finished. The question is whether the work it produced was the right work. That question is what Deliberate Alignment is designed to answer.


Notes

  1. Ryan Lopopolo, “Harness engineering: leveraging Codex in an agent-first world,” OpenAI, February 11, 2026. https://openai.com/index/harness-engineering/

Contents · Next: Chapter 2: When Building Was the Hard Part (And What Happened When It Stopped) →

Copyright Walter Reid, 2026. All rights reserved.

Mastercard Is Developing the RIGHT Product WRONG

I worked at Mastercard for 7 years. I even won the CEO Force for Good Award. Spent a few of those years building small business products. You know what small businesses already figured out? You don’t give every employee the company card. You give them something with limits, categories, expiration dates.

NOT because small businesses don’t trust people. Because unconstrained delegation doesn’t work in the real world.

Now we’re about to hand AI shopping assistants our personal credit cards.
If your kid wants Robux, do you give them your Sapphire card with a $50 limit, merchant blocks, real-time alerts, and liability protection? Or do you buy a $50 gift card?

You buy the gift card. Because the mental model is different. One says “act freely, we’ll monitor you.” The other says “here’s your boundary, that’s it.”
Now swap “kid” with “AI agent.”

I mean am I the only one who is watching Moltbot? https://www.cnet.com/tech/services-and-software/from-clawdbot-to-moltbot-to-openclaw/

And here’s what nobody’s saying: when every consumer has an AI agent negotiating at machine speed, what’s fast when everyone else is fast too?
Price wars collapse margins. Great for consumers until there’s no competition left. See: Amazon, small business.

Agents optimize for speed over fit. Fastest answer wins, not right answer.
Merchants start gaming agent behavior instead of earning trust. SEO 2.0, but humans can’t play.

Mastercard, Visa and I’m guessing American Express are building impressive infrastructure. For credit…

But nobody’s asking if we should even be giving software our credit card in the first place.

These are Fortune 1000 companies with the infrastructure and talent to build something FUNDAMENTALLY different. But they’re optimizing the old tool instead of asking if the old tool was ever right for this job.

Maybe someone reading this will see the difference between me calling something out and being mean. Or maybe they won’t.

Truthfully, I don’t think I’m being mean. I think I’m doing exactly what Mastercard taught me to do. You think through a payments problem and make it safe, trusted and reliable for users, every time. I know they still can.

The Problem Isn’t That Payments Aren’t Ready for AI: It’s That Credit Was Never Built for Delegation

I know what Mastercard and Visa are doing. I have 300+ LinkedIn colleagues old and new that share it everyday.

So I know those companies are not asleep. They see autonomous agents coming. They understand tokenization, spend controls, delegated authorization, liability partitioning.

And they’re doing exactly what you’d expect: adapting a 60-year-old credit infrastructure to handle a new class of economic actors. Quite literally in fact.

But here’s the question that is left to quiet corners of the office: What if layering guardrails on credit is just performance?

What if the entire premise… “that we solve machine-driven commerce by making credit cards ‘safer'” is wrong from the start?


Credit Was Never Designed for Autonomy

Credit cards have (mostly) solved a beautiful problem.

A human initiates every transaction. Judgment happens before authorization. Accountability gets reconciled after. Risk? Well… that can be sorted out later.

This worked because economic and moral agency lived in the same person.

Even fraud models assumed: “Someone meant to do something… we just need to verify it was them.”

That assumption shatters when the actor is:

  • Autonomous
  • Operating at machine speed
  • Executing on behalf of intent, not expressing intent

So when we say “machine payments,” we’re not extending commerce. We’re unbundling who gets to act economically and credit was NOT designed for that.


The Roblox Test: Parents Already Understand This

Ask any parent: why don’t you give your kid a credit card for Roblox?

I mean, not because credit cards are unsafe. We don’t give them to kids because credit expresses the wrong relationship.

Credit says: “Act freely now, we’ll reconcile later.”

A gift card says: “Here’s your boundary. That’s it. No surprises.”

Now swap “child” with the software tools people are starting to use:

  • Shopping agents running in the background
  • Subscription managers acting on your behalf
  • Assistants booking services you mentioned once

The discomfort people feel isn’t technophobia. It’s recognition that giving a hundred dollar bill to a toddler is a recipe for disaster. They know intuitively that open-ended authority doesn’t map to delegated action.

I’ve watched parents navigate this for years. First with app stores, then game currencies, now digital assistants. They don’t want “controls on spending.” They want “no spending beyond what I loaded.”

The mental model isn’t broken. The payment instrument is.


What the Networks Are Building (And Why It’s Honestly Not Enough)

The networks are responding:

  • Tokenized credentials (software never sees the raw card)
  • Merchant restrictions and spend caps
  • Time-boxed authorizations
  • Delegation models with revocation
  • Clear liability boundaries

This is good engineering. Dare I say, responsible engineering.

But notice what doesn’t change: The underlying frame is still open-ended credit with controls bolted on afterward.

The architecture assumes:

  • Authority first, constraints second
  • Reconciliation happens post-transaction
  • The human remains accountable—even when they didn’t act

This works in enterprise. It works (mostly…) for platforms.

But for regular people using autonomous tools daily? It’s the wrong mental model entirely. It’s even worse when you consider how the next generation is being brought up with AI.

I spent six years at Mastercard. I worked on Click to Pay, the SRCi standard, EMVCo’s digital credential framework. I know exactly how sophisticated these systems are. They’re engineering marvels.

But here’s what I also know: the card networks ride the credit rails like Oreo rides the cookie. It’s a perfect product that hasn’t fundamentally evolved in 60 years. Tokenization is brilliant… but it’s still tokens for credit. Virtual cards are cleve, but again, they’re still virtual credit cards.

The innovation is all in risk management and fraud prevention. Usually for banks or the enterprise. Almost none of it questions whether credit is the right starting point for AI.


The Card-on-File Trap

Here’s what actually happens when you give a software provider your credit card.

You think you’re saying: “Charge me $20/month for this service.”

You’re actually saying: “This system now has economic authority to act on my behalf, across any merchant, at any time, within whatever controls I maybe configured once.”

That’s not a payment. That’s a signed blank check with fine print meant to protect the business, not the consumer.

Don’t get me wrong. Virtual cards help. Spend limits help.

But they’re trying to make credit safe for a use case it was never designed for.

The mental model people need isn’t: “Which tools have my credit card?”

It’s: “What economic permissions has each tool been granted?”

That’s not a checkout problem. That’s a fundamental permission architecture problem. And credit, by design mind you, doesn’t encode permission. It encodes obligation.


What Would a Real Solution Look Like?

Let me be specific about what’s missing.

The consumer needs a payment instrument that defaults to constrained authority:

  • Prepaid by design
  • Rules set at creation, not bolted on after
  • Works anywhere cards are accepted today
  • Owned by the person, not the platform
  • Grantable per tool, revocable instantly
  • No provider lock-in

Think of it as a gift card that works everywhere and can be programmed with intent.

“This $50 can only be spent at grocery stores this week.” “This $200 is for travel bookings, nothing else.” “This agent gets $30/month for subscriptions—if it runs out, it stops.”

Not credit with virtual card wrappers. Not debit with spend notifications. Pre-funded permission that expires or depletes.


Could Mastercard or Visa Build This?

Yes. Absolutely. In fact I wrote this article because someone from my network who works at Mastercard will see it. Maybe even you.

They have the infrastructure. They have merchant acceptance. They have fraud systems that could adapt.

Here’s what it would take:

Option 1: Native Network Solution

Mastercard or Visa creates a new credential type:

  • Issues as prepaid instruments with programmable rules
  • Links to digital wallets and software platforms
  • Enforces constraints at authorization time (not reconciliation)
  • Designed for per-tool delegation, not per-person identity

This isn’t a “virtual card program.” It’s a new primitive that sits alongside credit and debit in the network’s clearing rails. It would require:

  • New BINs or credential markers
  • Authorization logic that respects programmatic constraints
  • Issuer partnerships that understand delegated use cases
  • Probably a new liability framework

I’m not holding my breath. This challenges too much of the existing business model.

Option 2: Independent Layer

Someone builds an agnostic prepaid credential:

  • Sits on top of existing card networks (uses Mastercard/Visa rails)
  • Issued as prepaid cards with open-loop acceptance
  • Designed specifically for tool delegation
  • Consumer loads value, sets rules, distributes to software
  • No “relationship” with the tool provider, just encoded permission

This exists in adjacent markets (corporate expense cards, teen banking, creator economy platforms), but nothing is purpose-built for autonomous tool delegation yet.

The closest analogies are:

  • Privacy.com (merchant-locked virtual cards)
  • Brex/Ramp (corporate expense controls)
  • Greenlight/Step (teen spending boundaries)

But none of these default to: “I’m giving economic permission to software acting on my behalf, and I want hard limits encoded in the payment instrument itself.”


Why This Matters Now

The networks aren’t wrong to adapt credit. But they’re optimizing for:

  • Institutional liability models
  • Backward compatibility
  • Merchant comfort
  • Incremental innovation

They’re not optimizing for how regular people will actually use autonomous tools. Just trying to embed their Oreo cookie in every new Supermarket that pops up.

I’ve also seen this movie before.

During the Click to Pay rollout, we spent enormous energy making guest checkout “better” while consumers were already moving to wallet-based payments. We optimized the legacy flow instead of asking whether the flow itself was right.

This feels similar. We’re making credit “work” for machine delegation when we should be asking: is credit the right tool for this job at all?


The Uncomfortable Truth

If you wouldn’t give a 10-year-old unrestricted credit, you probably shouldn’t give it to software acting on your behalf.

The difference is: we have social scripts for saying no to kids. We don’t yet have them for saying no to tools that are “just trying to help.”

And here’s what keeps me up: consumers are already adapting. They’re creating burner emails, using virtual card services, setting spending alerts, manually revoking access.

They’re reverse-engineering permission systems on top of credit—because the payment instrument doesn’t give them what they actually need.

The market is screaming for a different primitive. The networks are selling better guardrails.


What I’m Watching For

I’m not arguing credit disappears. I’m arguing it shouldn’t be the default for delegated action.

What I want to see:

  • A prepaid instrument designed for tool delegation (not just “safer credit”)
  • Per-agent permission models that don’t require virtual card sprawl
  • Consumer control that’s encoded in the payment primitive, not layered on top

This could come from the networks. It could come from a startup. It could come from a fintech that realizes the wedge isn’t “better banking”—it’s better permission systems for software-driven commerce.

But right now? We’re asking consumers to manage:

  • Virtual card sprawl
  • Per-tool spend limits
  • Post-transaction reconciliation
  • Liability disputes with machines

When what they actually need is: “I gave this tool $50 and permission to buy groceries. That’s it.”

Not credit with constraints. Permission with teeth.


A Note on Defending the Status Quo

I’m not naive. I know why the networks are moving slowly.

Credit is profitable. Interchange is their business model. Prepaid has thinner margins. And building new primitives is expensive, especially when the existing rails work “well enough.”

But “well enough” has a shelf life. Consumer behavior is already changing. The tools are already here. And at some point, “we added more controls to credit” stops being an answer to “why does my shopping assistant need my credit card in the first place?”

I don’t think Mastercard or Visa will get disrupted. They own the rails. But I do think they risk optimizing the wrong primitive while someone else defines the default for machine-driven commerce.

And if that happens, it won’t be because they weren’t smart enough. It’ll be because they were too invested in making the old thing work—instead of asking whether the old thing was ever right for the new job.


What if AI Could Argue With Itself Before Advising Me?

“What if asking ChatGPT/Claude/Gemini wasn’t about getting the right answer — but watching the argument that gets you there?”

This is the question that caused me to launched GetIdea.ai — a side project that became a system, a system that became a mirror, and a mirror that occasionally throws insults at my ideas (thanks Harsh Critic 🔥).

Over the past few months, I’ve been building a multi-agent AI interface where ideas are tested not by a single voice, but by a council of distinct personalities. It’s not production-scale, but it’s already the most honest and useful AI interaction I’ve ever had. It started with a simple, frustrating problem:


🤔 The Problem: One Voice Is Almost Never Enough

First, if you’re at all like me you may feel most AI chats are really monologues disguised as a dialogue.

Even with all the right prompting, I still had to:

  • Play the Devil’s Advocate
  • Be the Strategic Thinker
  • Remember the market context
  • Question my own biases

And worst of all — I had to trust that the AI would play fair when it was really just playing along.

What I wanted wasn’t “help.” What I wanted was debate. Structured, selective, emotionally differentiated debate.


💡 The Concept: Assemble the Squad

So I built GetIdea.ai, a real-time multi-agent system where AI personas argue with each other so I don’t have to.

You ask a question — like:

“Should I quit my job to start an indie game studio?”

And instead of one fuzzy maybe-response, you get a brutal realist, a business strategist, and sometimes a Hype Champion trying to gas you up just enough to ignore them both.

What started as a test of CrewAI and WebSocket orchestration became a real product with:

  • Confidence-based agent routing
  • Conversation memory
  • Typing indicators
  • Real-time squad assembly
  • Modular personalities like:

This isn’t just multiple answers — it’s structured dissent, with context, consistency, and enough personality to feel like a team, not a trivia night.

🧠 How It Actually Works (And Why It Matters)

Let’s say you ask:

“Should I quit my job to start an indie game studio?”

Here’s what happens under the hood:

🧠 GetIdea.ai instantly assembles a confidence-filtered squad of AI advisors. In this case:

  • 🔥 Harsh Critic: high confidence in risk analysis, startup failure patterns, and tough love
  • 💰 Business Strategist: high confidence in financial models, scalability, and unit economics
  • 💡 Creative Catalyst: low confidence in risk — but very high in vision, innovation, and potential

Now here’s the kicker:

Each agent knows its strengths. It doesn’t pretend to be an expert in everything — it plays its role.


🎭 The Augment in Action (Yes, this really happened)

So, how does it work? Let’s use your question: “Should I quit my job to start an indie game studio?”

Instead of one answer, the system instantly assembles an advisory squad based on confidence. For this query, it routes to three distinct personas: a visionary, a pragmatist, and a realist.

Then, you get to watch the argument unfold in real-time.

🔥 Harsh Critic:

“The market is brutally competitive and often financially disastrous. Without groundbreaking innovation and a financial safety net, it’s a fool’s errand. Keep your job while testing your concept on the side.”

💰 Business Strategist:

“Consider your revenue model and target audience. Ensure diversified income streams and validate your concept with market research before making a decision.”

💡 Creative Catalyst (not triggered this time):

(Filtered out) — their confidence score wasn’t high enough to weigh in unless you lowered the threshold.

🔥 Harsh Critic:

“Sure, the Strategist makes good points — but you’re not in the business yet. Talking revenue models before you’ve validated demand is like planning a restaurant menu before knowing if anyone’s hungry.


🧪 Why That Matters

This isn’t a debate for entertainment. It’s a mirror for your own bias.

If you:

  • Want optimism → lower the threshold, and 💡 Creative Catalyst joins.
  • Want realism → leave it high, and only the tough love sticks.
  • Want synthesis → add 🔄 Synthesis Master, who bridges their insights into a decision framework.

That’s the hidden power of GetIdea.ai: It’s not answering your question — It’s helping you ask better ones.


🧪 The Experiment Behind the Scenes

There’s a hidden slider in the UI: Confidence Threshold. Slide it down, and you get wild ideas. Slide it up, and only the most certain agents speak.

That single control taught me more about my own bias than I expected. If I don’t want to hear Harsh Critic, it’s not because he’s wrong — it’s because I’m not ready for him. But when I am ready? His hit rate is scary.

Also — each conversation starts with “assembling your expert advisory team.” Because that’s how this should feel: like you’re being heard, not processed.


✨ Why This Matters (to Me and Maybe to You)

This isn’t a startup pitch. Not yet.

But it’s a signal. That we’re moving from:

  • Query → Answer to
  • Question → Assembly → Synthesis

That’s not just more useful — it’s more human.

And honestly? It made me want to ask better questions.


👀 Coming Next in the Series

In Part 2: “The Build”, I’ll share:

  • The architecture I’m modernizing
  • Why crew_chat.py is 2,100 lines of chaos (and still worked)
  • What went wrong (and hilariously right)
  • How this system gave me real-time feedback on my own decision patterns

And eventually in Part 3: “The Payoff”, I’ll show where this is going — and why multi-agent systems might become the UI layer for better thought, not just better output.


✅ TL;DR (because I built this for people like me):

GetIdea.ai is:

  • A real, working multi-agent chat system
  • Built in CrewAI, FastAPI, and WebSocket magic
  • Designed to simulate collaborative, conflicting, yet emotionally readable decision-making
  • Still messy under the hood, but intentionally honest in tone

And maybe… it’s the future of how we talk to machines. By teaching them to talk to each other first.


🔗 Your Turn: Test It, Shape It, or Join In

The project is live, and this is where you come in. I’d be grateful for your help in any of these three ways:

  1. 🧪 Share Your Results: Try the tool with a real problem you’re facing. Post the most surprising or insightful piece of advice you get in the comments below.
  2. 💡 Suggest a Persona: What expert is missing from the council? A ‘Legal Advisor’? A ‘Marketing Guru’? Comment with the persona you think I should build next.
  3. 🤝 Become a Beta Tester: For those who want to go a step further, I’m looking for a handful of people for a 15-minute feedback session to help improve the experience. If you’re interested, just comment “I’m in!”

You can try the system right here: GetIdea.ai

I’m excited to hear what you think!