Building the Cathedral: When AI Agents Need the Big Picture
September 27
“The problem,” I told my Lead Developer at 5:02 PM Saturday, “is that the agents are laying bricks instead of building a cathedral.”
Then I explained the story about the brick layer working on Christopher Wren’s cathedral (apparently it originated in Bruce Barton’s, “What Can A Man Believe,” published in 1927).
Eight hours into what should have been a simple GitHub integration cleanup, we’d discovered something more fundamental: without architectural vision, even sophisticated AI agents optimize for the wrong things. They solve immediate problems brilliantly while missing the larger structure they’re supposed to be creating.
Saturday’s GREAT-2B became an object lesson in why the big picture matters — and how providing it transforms not just what agents build, but how they build it.
The morning that started simple
GREAT-2B looked straightforward on paper: “Complete GitHub Spatial Migration.” The gameplan assumed we were 75% done and needed to finish the remaining integration work. Maybe three hours of systematic cleanup.
By noon, we’d discovered the first layer: services weren’t using the spatial intelligence router at all. They were bypassing it entirely through direct imports to the legacy GitHub agent. Not incomplete migration — architectural pattern violation.
By 2 PM, we’d found the second layer: the router itself was only 14.3% complete. Missing 12 of 14 essential methods. Services were bypassing it out of necessity, not negligence.
By 4 PM, we understood the third layer: this wasn’t about completing features. It was about completing infrastructure so the features could exist.
Each discovery changed how we approached the work. But the real transformation came when we changed how we explained the work to the AI agents.
When agents lay bricks instead of building cathedrals
The Lead Developer’s Phase 1A report was telling. The agents were executing tasks with precision but missing strategic context. They were fixing individual import statements without understanding why spatial intelligence mattered. Implementing router methods without grasping how feature flags enable architectural flexibility.
High-quality brick-laying. Perfect individual execution. But no cathedral emerging from their work.
The breakthrough came when we shifted from task assignment to vision sharing. Instead of “implement these 12 missing methods,” we explained: “Complete the router that enables spatial intelligence, which provides dimensional context for all GitHub operations, which supports the feature flag architecture that lets us migrate safely without breaking production systems.”
Same work. Completely different agent behavior.
The cathedral metaphor in practice
With architectural context, agents began optimizing for different things:
Brick-laying mode: Implement methods as quickly as possible, focus on syntax correctness, complete individual tasks.
Cathedral-building mode: Understand delegation patterns, maintain consistency across all methods, verify the complete router supports the migration it’s designed to enable.
The quality difference was measurable. Router completion went from mechanical method addition to thoughtful architecture preservation. Import refactoring became strategic rather than syntactic.
Most importantly: agents started catching issues I hadn’t anticipated. When they understood the spatial intelligence vision, they verified that feature flags actually worked. When they grasped the migration strategy, they tested fallback patterns proactively.
The layers of Saturday’s discoveries
What started as “complete 25% migration” became a masterclass in architectural investigation:
Layer 1: Surface symptoms — Services using direct imports instead of router patterns
Layer 2: Bypass necessity — Router missing essential methods, forcing workarounds
Layer 3: Infrastructure gaps — Incomplete foundational systems blocking higher-level work
Layer 4: Vision clarity — Agents need architectural context to optimize correctly
Each layer required different solutions. But addressing them systematically, rather than treating symptoms, produced sustainable results.
By 9:15 PM, we had a 121% complete router (17 methods implemented vs 14 originally in the legacy agent), zero breaking changes, and a template for future router work. More importantly: a methodology for giving AI agents the big picture they need to build excellently.
The difference vision makes
The cathedral metaphor isn’t just about motivation — it’s about optimization targets. When agents understand they’re building spatial intelligence infrastructure, they approach each method differently:
Without vision: “Implement get_open_issues to match the legacy agent signature”
With vision: “Implement get_open_issues with proper spatial/legacy delegation, consistent error handling, and feature flag respect”
Without vision: “Fix imports to use the router instead of direct agent access”
With vision: “Migrate services to router pattern while preserving all functionality and enabling spatial intelligence adoption”
The second approach takes longer per task but produces architecture that supports future development rather than just solving immediate problems.
The systematic approach to scope revelation
Saturday demonstrated something crucial about complex projects: scope often reveals itself through investigation rather than upfront analysis. The Inchworm Protocol handled this gracefully:
- Start with best current understanding (25% migration completion)
- Investigate systematically (discover architectural bypass)
- Dig deeper when patterns emerge (router completeness analysis)
- Adjust scope based on evidence (infrastructure completion first)
- Complete systematically (router + imports + verification)
No panic when assumptions proved wrong. No forcing the original plan despite evidence. Just methodical adjustment based on what the investigation revealed.
This only works when agents understand the larger goal. With cathedral vision, they help refine scope rather than blindly executing outdated plans.
The infrastructure-first wisdom
The deepest lesson from Saturday was about sequencing: complete infrastructure before building features on top of it. The spatial intelligence system was sophisticated and well-designed. But without a complete router, services couldn’t use it safely.
Agents with architectural vision understood this naturally. They pushed for router completion not because the gameplan required it, but because they could see it was prerequisite for everything else working properly.
This is what the cathedral metaphor teaches: every individual task is part of a larger structure. Understanding that structure changes how you approach each component.
The template for future work
Saturday’s router completion established patterns for CORE-QUERY-1 (completing routers for Slack, Notion, and Calendar). But more importantly, it established a methodology for giving AI agents the context they need to build systematically.
Before each phase: Explain not just what to build, but why it matters in the larger architecture
During execution: Connect individual tasks to strategic outcomes
At verification: Check not just that it works, but that it supports the intended evolution
The result: agents that optimize for architectural coherence rather than just task completion.
The ongoing cathedral
GREAT-2B is complete, but the cathedral metaphor continues to deliver. Sunday brings CORE-QUERY-1, applying the router completion patterns to three more integration services. The vision remains consistent: spatial intelligence infrastructure that enables dimensional context for all external service operations.
Each router we complete strengthens the foundation. Each service we migrate makes the spatial intelligence more valuable. Each systematic step builds toward a more capable and coherent system.
The agents now understand they’re not just fixing imports or implementing methods. They’re building the infrastructure that makes Piper Morgan’s spatial intelligence possible.
That’s what architectural vision provides: the context to build excellently rather than just correctly.