I assumed a three-person pod augmented with the best available agents could ship reliable product increments without a fourth set of eyes. The assumption came from watching other small teams move fast in enterprise tools and ministry platforms. In practice the pod released a curriculum update for volunteer leaders that carried mismatched age-group tags across print and digital versions. The mismatch surfaced only after hundreds of churches had already printed materials for the quarter. The cost showed up in support volume, lost trust with volunteer coordinators, and two weeks of emergency fixes that pulled senior engineers off roadmap work.
That experience exposed the real limit. Smaller teams do not automatically gain leverage from AI by shrinking headcount. They still carry coordination work that does not disappear when routine tasks are automated. Charlie Munger’s latticework of mental models makes the pattern visible. One model shows incentive misalignment: the pod optimizes for output velocity while verification sits outside any single person’s measured goals. Another model tracks second-order effects: when routine coding and drafting shrink, senior contributors absorb more context-switching and cross-checks that used to be distributed.
The latticework also surfaces the model of scale. Coordination load does not track lines of code or tokens processed. It tracks the number of distinct decision points that must stay consistent across people, agents, and downstream users. Treating verification as optional overhead ignores that model.
The model that treats verification as overhead
Most pods describe their AI setup as removing repetitive checks. The agents draft, the humans review once, and the release happens. This framing collapses verification into a single step rather than a distributed property of the system. Munger’s approach forces the opposite view: verification is an ongoing cost that must be assigned explicitly or it migrates to the most senior person on the team.
In one observed case the pod used an agent to generate volunteer lesson outlines from existing sermon notes. The agent handled tone and length well. It did not maintain consistent scripture references across the three age bands the product served. The single human review caught obvious mismatches but missed the pattern because the reviewer had already internalized the source material. The error only appeared when a children’s director printed the materials and found the middle-school version referencing a passage the preschool version omitted.
The misread here is simple. The team modeled verification as a final gate rather than a persistent cross-check distributed across roles. Once that model is corrected, the fourth set of eyes becomes a deliberate assignment instead of an assumed safety net.
How senior ICs actually spend their time once routine work disappears
After agents absorb drafting and basic QA, the remaining work for experienced contributors shifts toward reconciliation. They reconcile conflicting outputs from multiple agents. They reconcile the product’s data model with the constraints of print-first users who cannot receive updates after distribution. They reconcile the pace of one volunteer’s planning cycle with the cadence the platform now pushes.
This shift is rarely logged as coordination time. It appears as individual deep work. In reality the senior IC is performing the latticework manually: holding the mental models of user constraints, technical limits, and agent behavior in tension at once. When that work stays invisible, the pod slowly loses capacity for new feature development because the experienced people are fully occupied keeping existing flows coherent.
The hidden coordination layer that still scales with headcount
Even at three people the coordination surface grows with each new agent or data source added. Each agent introduces its own context window and failure modes. Each new data source requires someone to decide which version becomes authoritative when they diverge. The surface does not shrink when headcount is low; it simply concentrates on fewer shoulders.
One ministry platform team added a scheduling agent to handle volunteer reminders. The agent needed access to the same curriculum metadata the human designers used. No one owned the mapping between the agent’s reminder logic and the print deadline the volunteer actually followed. The result was reminders sent after the print window had closed. The fix required a human to insert a manual gate that the original three-person pod had assumed the agent would manage. The gate still exists because the coordination rule was never assigned to a specific owner.
Your Turn: Apply This Today
- Map every recurring handoff in your current pod’s workflow on a single shared document, including steps currently handled by agents, and mark which person or role owns consistency for each one.
- Pick the three handoffs that have produced the most recent defects or rework and assign an explicit owner who is not the same person doing the originating work.
- Schedule a 30-minute weekly review where the owner reports only on whether the assigned consistency rule held, without discussing new features.
- Remove one agent-driven step that currently lacks an assigned human verifier and replace it with a manual checkpoint for the next two releases to measure the actual time cost.
- Document the second-order effect of each agent you rely on by writing one paragraph on what breaks when that agent’s output diverges from the rest of the system.
- Identify the senior IC who spends the largest share of time on reconciliation and surface that time in the next planning session as coordination load rather than individual capacity.
The same coordination visibility problem appears in different forms across the posts on context windows that close only with a real coordinator and permission gates that keep agents from running schedules. Both show how unassigned overhead eventually surfaces as lost time or broken trust.
I consult with product leaders building AI-augmented tools for ministry on coordination overhead, verification models, and small-team scaling. Let’s talk.