The load-bearing hallway: what AI coding agents break first

A team I work with spent a quarter building a personalization feature. The story of how it went wrong has no villain, which is exactly why it's worth telling.

Meeting one: the product team gets in a room, argues it out, and lands on how the feature should work. The decision goes into the PRD, the way decisions are supposed to. Everyone leaves aligned.

Meeting two, some weeks later: product sits down with the tech team. The engineers raise problems the first room couldn't have seen, and the decision changes. Everyone present agrees on the new shape. But the new shape travels the way most decisions actually travel: out loud. Someone turns it into a Jira ticket, because that's where the work gets tracked. Nobody goes back and updates the PRD, because the PRD was last meeting's artifact and everyone in the room already knows.

So now the company has two written records. The PRD says one thing. Jira says another. Both were correct on the day they were written.

Months pass. An issue shows up in production, and it traces straight back to the gap between the two documents. The product manager checks and says, reasonably: that behavior is not in the PRD. The developer checks and says, just as reasonably: it's right there on the ticket. Both of them are holding proof. And here is the detail that makes this story universal: nobody could explain why the two records disagreed. The reason lived in a meeting, and the meeting ended months ago.

Read that again. Nothing important went unwritten. Nothing written was wrong. The truth lived in the air between two documents, and air doesn't keep.

The load-bearing wall

People who renovate old houses know a classic mistake. There's an ugly wall in the middle of the floor. It doesn't seem to hold anything. It's in the way of the open kitchen you want. So you knock it down, and the ceiling sags. The wall was load-bearing. Nothing in the paint told you.

Every engineering team has a wall like this, except it isn't a wall. It's a hallway. It's the thing someone mentions at standup that saves you two days. The call you overhear from the next desk. The "wait, didn't Priya change that last week?" The tap on the shoulder before you touch something scary. The lunch where you learn the real reason a project died. None of this appears on the org chart. None of it has a line in the toolchain budget. It's free, which is why nobody notices it's infrastructure.

Now the uncomfortable reframe. Git, Jira, and PRDs were never the coordination layer. They are the record layer. They store what happened. The actual coordination, the real-time work of keeping ten fast-moving people roughly pointed in the same direction, has always happened in the human air around the records. Look at the personalization story again: both records did their jobs perfectly. The thing that failed was the connection between them, and that connection was made entirely of people remembering a meeting.

We like to think our tools coordinate us. They don't. They archive us. People coordinate us.

What the invisible layer actually does

It's worth naming the jobs this layer quietly performs, because you only see them clearly when they stop.

News travels on its own. Nobody is assigned the job of telling everyone that the endpoint moved or the deploy is frozen. It spreads anyway. Standup, lunch, a Slack thread you half-read while waiting for a build. Propagation has no owner, no process, and no budget, and it mostly works.

Somebody notices collisions. Two people are about to touch the same thing from different sides, and a third person who overheard both conversations says: wait, you two should talk. That small reflex has prevented more production incidents than any test suite ever written. It works because humans keep a fuzzy mental map of what everyone around them is doing.

Somebody remembers. Every team has the one person who knows how the old billing code actually works, why the retry logic looks insane but isn't, what the client promised in 2023. I have watched work stop, fully stop, because that one person went on leave. Not because the code was locked. Because the knowledge was. The team's most important database has legs and takes vacations. Engineering even has a grim name for this: the bus factor, as in, how many people can this project lose before it's dead. For a scary number of systems the answer is one.

Everyone knows what matters. Which module is radioactive. Whose changes you double-check. Which client escalates to the founder. What actually matters this month versus what the roadmap says. Priority spreads through the air, and almost none of it is written anywhere.

People behave because people are watching. Teams follow their own conventions partly out of discipline and partly because your name is on the commit and your reviewer will sigh. Mild social pressure is a real coordination technology. Shame ships better code than we like to admit.

Five jobs. All essential. All unpaid. All invisible until the day they don't happen.

Remote work ran this experiment first

We actually have a preview of what happens when you remove the hallway, because the world ran the experiment in 2020.

When offices closed, teams discovered how much load the office air had been carrying. Calendars filled up with meetings, because a meeting is a clumsy, expensive replacement for ambient awareness. The "quick sync" is just a hallway with a calendar invite. Whole companies spent a year confused about why everything felt slower when everyone had more focus time than ever.

The companies that did remote well did not try to recreate the hallway on Zoom. They moved coordination into deliberate writing. GitLab is the famous case: a public handbook thousands of pages long, decisions written down as a rule rather than a virtue, the explicit principle that if it isn't written, it didn't happen. They rebuilt the invisible layer as a visible one, on purpose.

That's the lesson worth keeping: the layer can be replaced, but only deliberately. Nobody drifts into a replacement. You have to notice the wall was load-bearing before you knock it down, and then you have to build a beam.

AI coding agents delete the layer

Remote work turned the hallway down. Agents turn it off.

An agent session attends no standup, overhears nothing, eats no lunch, remembers nothing from last week, and feels no embarrassment. Run the five jobs again with agents doing the work. News doesn't travel: there are no ears for it to reach. Collisions aren't noticed: there's no third person keeping a fuzzy map. Nothing is remembered: the session ends and the memory ends with it, so every agent is permanently the new hire and the bus factor of a session is zero. Priority doesn't spread: every task feels equally important to something that woke up thirty seconds ago. And nothing is watching: an agent will ship a contradiction with total confidence, because nobody ever taught it to be embarrassed.

Then add speed. A developer with an agent ships in a day what used to take a week. A contradiction that used to take two weeks to surface, slowly enough for the hallway to catch it, is now fully built on both sides by dinner. Agent A renames the endpoint after lunch; agent B spends the same afternoon building against the old name; both are done before anyone human has looked up.

There's also a quiet accounting problem here. When a company buys agent seats, the productivity math counts code produced per day. Nobody subtracts the coordination work the hallway was doing, because the hallway never had a cost line. You can't miss a line item that was never on the invoice. So teams adopt agents, output goes up, coherence goes down, and the dashboard only measures the first one. DORA's 2024 State of DevOps report caught the second one anyway: for a 25% increase in AI adoption, delivery throughput was estimated to drop 1.5% and delivery stability 7.2%. Individual developers report feeling faster. The system, measured end to end, gets less stable. That's the hallway's missing line item, finally showing up on an invoice.

Software has an old rule for this, Conway's Law. In plain words: a system ends up shaped like the communication between the people who build it. Teams that talk build parts that fit together. Teams that don't build parts that don't. The law is usually quoted as a warning about org charts, but it's really a description of the machinery that keeps systems coherent. And it has no exception for agents. If the communication structure is empty, the system will faithfully mirror the emptiness. Ten agents with zero communication between them will produce ten private architectures, stapled together at the merge.

I've written about why the usual fixes don't hold this weight: decision docs are written once and read rarely, and a rules file is a handbook, not a standup. This post is the deeper reason. Even for humans, the documents were never doing the coordination. The hallway was. The hallway is precisely the part agents don't get.

What hospitals figured out

Medicine met this exact problem a long time ago, and it learned the lesson the hard way.

A hospital runs 24 hours and people work in shifts, so the system has a built-in moment where everything one person knows must move into another person's head: the handoff. The night nurse leaves, the day nurse arrives, and the patient in bed 4 doesn't reset just because the staff did. The Joint Commission, the body that accredits US hospitals, estimates that 80% of serious medical errors involve miscommunication during handoffs. Sit with that. The most dangerous moment in a hospital is not the surgery. It's the shift change: the one moment where the ambient layer between two people is guaranteed to be zero.

And notice what hospitals did about it. They didn't hire nurses with better memories, and they didn't write a thicker handbook. They built a ritual: the structured handoff. A formal briefing at every boundary, with a fixed shape, done every single time, no matter how routine the night was. Programs built around structured handoffs measurably cut serious errors, and formal handoff training is now a requirement in medical education, not a nice-to-have. The insight is simple and transfers perfectly: wherever the ambient layer is guaranteed to be zero, you replace it with structure, at the boundary, every time.

Now look at an agent session with hospital eyes. Every session start is a shift change with no overlap. The night nurse leaves and takes the chart with her. The day nurse walks in to a patient and no report. Except this shift change doesn't happen twice a day. On a team running agents seriously, it happens dozens of times before lunch.

So the replacement layer has to be built the way GitLab built writing and hospitals built handoffs: deliberately, at the boundaries, as structure. Except you can't reorg agents into talking, and you can't ask them to get lunch together. For agents, the communication structure has to be software. Decisions recorded the moment they're made. Pushed to the agents and people they affect. A briefing at every session boundary. Something standing at the merge that says "wait, you two should talk."

This is the shape Lockstep takes, and by now you can see why it's shaped that way. The session briefing is the shift handoff. The ledger is the colleague who remembers everything and never goes on leave. The notifications are the news, traveling on purpose instead of by luck. The merge gate is the third person who says wait. None of it is a new idea. It's the hallway, rebuilt for workers that don't walk.

Back to the personalization story one last time. Both documents were right. The truth lived in the air between them, and the air was made of people remembering a meeting. For decades that was fine, because the air was always there. Offices had it. Slack carries a thinner version. Good remote teams rebuilt it in writing, on purpose.

Agents don't breathe.

Code just got cheap. Coordination didn't. The teams that win the next few years won't be the ones with the most agents. They'll be the ones who noticed the hallway was load-bearing before they knocked it down.