October 24 to November 6
“August broke the semantic analyzer.” This sentence appears in November 4’s session log. It’s simultaneously technical problem description, humor about meta-analysis, and cultural artifact. Will anyone reading Piper Morgan documentation six months from now will encounter this phrase and understand? “We analyze our own development patterns. Sometimes our analysis tools fail hilariously. We laugh about it while fixing it.”
That’s language creating culture.
“The 75% pattern.” “Phase −1 investigation.” “Cathedral Doctrine.” “Time Lord Philosophy.” “The Excellence Flywheel.” “Archaeological discovery.” “Completion matrix.”
These aren’t standard software engineering terms. They’re our terms. They emerged through methodological documentation. They get reinforced through repeated use. They create shared understanding between human and AI agents. They encode lessons learned. They transmit methodology.
This is about how language shapes methodology. How documentation creates culture. How curated logs transmit values. And how this happens on AI teams similarly — but differently — than human teams.
The linguistic archaeology
Let’s trace some key phrases through their evolution:
“Phase −1” (Emerged October 2025)
First appearance: Gameplan template v6.0, “Phase -1: Discovery & Assumption Verification”
Context: After multiple instances of starting implementation only to discover existing infrastructure, we formalized investigation as mandatory first phase.
Evolution:
- Initially: “Check what exists before building”
- Then: “Discovery phase”
- Finally: “Phase -1 infrastructure verification”
Why this name: Standard project phases start at 0 or 1. By calling investigation “Phase −1,” we signal it happens before normal work begins. It’s pre-implementation requirement, not optional preliminary.
Cultural meaning: “Phase −1” now carries weight. When agent says “beginning Phase −1 investigation,” everyone knows: We’re checking assumptions before acting. We’re preventing unnecessary work. We’re applying archaeological approach.
The phrase encodes methodology. Anyone who reads “Phase −1” in documentation understands: Investigation before implementation. Always.
“The 75% Pattern” (Emerged November 2025)
First appearance: November 1 discovery of DocumentService
Context: Saturday sprint found DocumentService 75% complete. Sunday found todo infrastructure 75% complete. Monday found ActionHumanizer infrastructure complete. Pattern recognized.
Evolution:
- Saturday: “DocumentService exists but not wired”
- Sunday: “Todo infrastructure discovered 75% complete”
- Monday: “Another 75% pattern”
- Tuesday-forward: “The 75% Pattern” (capitalized, recognized phenomenon)
Why this name: Specific percentage (75%) makes it concrete. Not “mostly done” or “almost finished” but quantified state. Database/service/domain layers (75%) exist, integration layers (25%) missing.
Cultural meaning: “75% pattern” signals: Don’t assume missing. Investigate. Infrastructure probably exists at lower layers. Also encodes understanding: Good architecture builds deep (database/services) before wide (integration/UI).
Linguistic precision: Could have called it “incomplete infrastructure pattern” or “unfinished features.” But “75% pattern” captures specific nature: Not 50% (half-done). Not 90% (nearly complete). But 75% (foundation solid, wiring missing).
“Cathedral Doctrine” (Emerged August 2025)
First appearance: ADR-000, “Meta-Platform Architecture”
Context: Need to communicate long-term architectural vision to AI agents who live in present moment. How do you get agents to build toward 3-year vision when they only see current task?
Evolution:
- Initially: “Long-term architecture vision”
- Then: “Cathedral metaphor” (building cathedrals took generations)
- Finally: “Cathedral Doctrine” (formal methodological principle)
Why this name: Cathedrals were built across generations. Workers who laid foundations never saw completion. Required shared vision transmitted through documentation. Perfect metaphor for AI-human collaboration where “generations” are different Claude instances.
Cultural meaning: When architect invokes “Cathedral Doctrine,” it means: This decision serves 3-year vision, not immediate need. Build for future capabilities. Document vision so future agents understand intent.
“Time Lord Philosophy” (Emerged September 2025)
First appearance: Session management protocols
Context: Development work often spans multiple days. Traditional project management uses hours/days. But Claude sessions don’t map to human time. Need different temporal framework.
Evolution:
- Initially: “Don’t work through the night”
- Then: “Session-based time management”
- Finally: “Time Lord Philosophy” (playful, memorable)
Why this name: Doctor Who reference. Time Lords experience time non-linearly. Similarly, AI agents don’t experience continuous time. Each session is fresh context. Playful name makes serious methodological point memorable. It also emphasizes that the PM dictates facts to the LLMs. If I say we have 30 hours today, then so be it.
Cultural meaning: “Time Lord Philosophy” signals: Time is fluid in AI-human collaboration. Sessions can span days. Work can pause and resume. Don’t force artificial urgency. Use playful time units (jiffy, fortnight) to emphasize non-standard temporal relationship.
The humor: Calling it “Time Lord Philosophy” rather than “Asynchronous Session Management” makes it more likely to be remembered and applied. Humor aids transmission.
“Completion Matrix” (Emerged November 2025)
First appearance: November 1, Saturday sprint preventing 80% pattern twice
Context: Code works but documentation missing. Or documentation exists but evidence not collected. Or evidence collected but related docs not updated. Three levels of completion all required.
Evolution:
- Initially: “Make sure it’s really done”
- Then: “Three-level completion: code, docs, process”
- Finally: “Completion Matrix” (formalized framework)
Why this name: Matrix implies intersection of dimensions. Code level × documentation level × process level = complete when ALL cells satisfied.
Cultural meaning: “Completion Matrix” signals: Done means truly done. Not just code works. Not just documented. But all three levels verified. Prevents 80% pattern (stopping when “feels done” without systematic verification).
How language transmits methodology
The phrases aren’t just labels. They’re methodology transmission mechanisms.
Example 1: Phase −1 becomes automatic
Before formalization: Agent starts implementation. Discovers existing infrastructure mid-work. Wastes time.
After “Phase −1” named: Agent sees gameplan template. Reads “Phase −1: Infrastructure Verification.” Understands: Investigate first, always.
Transmission: The phrase “Phase −1” in gameplan templates teaches methodology without explicit instruction. New agent reads template, sees Phase −1, investigates before implementing. Methodology transmitted through language.
Example 2: 75% Pattern enables recognition
Before naming: Each discovery feels unique. “Oh, DocumentService exists.” “Oh, todos built.” No pattern recognized.
After “75% Pattern” named: Third discovery: “Another 75% pattern.” Fourth discovery: “Standard 75% pattern.” Pattern becomes visible through naming.
Transmission: Naming the pattern helps recognize it. When agent investigates and finds infrastructure, they document: “75% pattern confirmed.” Future agents reading logs see pattern, investigate more thoroughly themselves.
Example 3: Cathedral Doctrine aligns decisions
Before formalization: Agent makes good short-term decision that blocks long-term architecture. PM has to explain why decision is wrong. Frustrating.
After “Cathedral Doctrine” named: Agent reads ADR-000. Sees “Cathedral Doctrine: Build for 3-year vision.” Makes decision aligned with long-term architecture. Less human correction needed.
Transmission: The doctrine name + documentation creates shared understanding. Agent doesn’t need PM to explain each time why long-term matters. The principle is encoded in language.
The linguistic feedback loop
Language doesn’t just transmit methodology. It refines methodology through usage.
The loop:
- Problem encountered: Investigation reveals pattern (archaeological discovery)
- Language emerges: Name the pattern (“75% pattern”)
- Documentation captures: Logs record instances, explain pattern
- Agents adopt: Future agents read logs, use terminology
- Usage refines: Agents apply pattern, discover edge cases
- Language evolves: Terminology adjusts to capture refinements
- Loop continues: Better language → better understanding → better application → better language
Example: “Phase −1” evolution
Original: “Check if infrastructure exists before building”
Problem: Too vague. What infrastructure? How to check? When to stop?
Refinement 1: “Phase −1: Discovery phase”
Problem: “Discovery” too general. Discovery of what?
Refinement 2: “Phase −1: Infrastructure Verification”
Better: More specific. But what counts as verification?
Refinement 3: “Phase −1: Infrastructure Verification (15–30 minutes minimum, all layers, symbol search)”
Current state: Sustained duration, explicit methodology, tool specification.
The language evolved through usage. Each agent applying it encountered ambiguity. Refinements addressed ambiguity. Now “Phase -1” has precise meaning transmitted through documentation.
Human teams vs AI teams: Similar but different
Language creates culture on human teams too. But different dynamics:
Human team language evolution:
Emergence: Informal. Phrase appears in standup, catches on, spreads through conversation.
Transmission: Social. New team member overhears phrase, asks meaning, gets explanation.
Refinement: Organic. Team discusses, phrase evolves through dialogue.
Persistence: Cultural memory. Senior members remember origin stories.
Failure mode: Tribal knowledge. New members miss context, use phrases incorrectly.
AI team language evolution:
Emergence: Formal. Phrase appears in documentation, gets adopted through reading. Individual human provides 90% of the novely and unique personality. (Though I will admit the LLMs named our “Excellence Flywheel.”)
Transmission: Documentation. New agent reads logs/templates, applies terminology.
Refinement: Explicit. Ambiguity surfaces, documentation updated, meaning clarified.
Persistence: Written record. Every agent can trace phrase origin through git history.
Failure mode: Documentation lag. Verbal understanding advances faster than written docs.
The hybrid (human + AI collaboration):
Emergence: Human recognizes pattern, AI helps formalize naming.
Transmission: Both. Humans explain verbally, AI agents read documentation.
Refinement: Collaborative. Humans identify ambiguity, AI agents propose clarifications.
Persistence: Dual memory. Human cultural knowledge + comprehensive written record.
Advantage: Best of both. Informal emergence with formal documentation. Organic refinement with explicit capture.
The glossary we need
It usually takes me longer than it should to realize a product needs a glossary. That has happened again with Piper Morgan, where I am fnally realizing this, siz months in. It has become especially pressing now that for the first time I have other human people looking at the project and advising me on the architecture and code.
Our jargon has grown organically. Time to document systematically. The list below is an initial scan that my comms chief put together when preparing a draft of this article for me, but in the near future I will do another systematic sweep of project docs to tease out any other terms of art we’ve developed, and then I am going to edit the definitions to make sure no meaning has drifted or “flattened.”
Core Methodology Terms (relatively unique to this project)
Phase −1: Infrastructure verification before implementation. 15–30 minutes minimum. Investigates all layers (database, services, routes, handlers). Uses symbol search tools. Outputs: infrastructure map + gap analysis. Mandatory before Phase 0.
75% Pattern: Infrastructure 75% complete at lower layers (database/services/domain) but missing 25% integration layers (routes/handlers/UI). Result of good architecture built “deep before wide.” Requires wiring not rebuilding.
Cathedral Doctrine: Build for 3-year vision, not immediate need. Document long-term architecture so future agents understand intent. Named for medieval cathedrals built across generations.
Time Lord Philosophy: Time is fluid in AI-human collaboration. Sessions span days. Work pauses and resumes. No artificial urgency. Playful time units (jiffy, fortnight) emphasize non-standard temporal relationship.
Completion Matrix: Three-level completion requirement. Level 1: Code (tests passing, integration working). Level 2: Documentation (summaries, evidence, updates). Level 3: Process (criteria met, related docs updated). All levels required for “done.”
Archaeological Approach: Systematic investigation to find existing infrastructure before building new. Consistent 18–27:1 ROI. Also called “Phase −1 investigation.”
Excellence Flywheel: Small improvements compound. Each success (and failure) teaches a lesson. Each lesson improves next success. Positive feedback loop of methodology refinement.
Inchworm Protocol: Systematic completion before proceeding. Finish phase completely, verify thoroughly, document comprehensively, then advance. Prevents 80% pattern.
Verification Pyramid: Three tiers of validation. Bottom: Unit tests (fast, many). Middle: Integration tests (slower, fewer). Top: E2E tests (slowest, focused). All three tiers required.
Validation-Driven Development: Tests aren’t afterthought. They’re confidence mechanism. Comprehensive tests enable bold changes. 66 tests passing → migration is safe.
Cultural Artifacts (arise from conversation)
“August broke the semantic analyzer”: Meta-learning moment. Analysis tools revealing own limits. Going meta on meta. Humor about methodology complexity.
“Different rhythms, different stages”: Development velocity varies appropriately. June 100% → October 15%, both healthy. Match work to stage.
“The long winding road”: Non-linear path from start to done. Estimates revise as understanding deepens. Discovery-driven development, not failure.
“Two parallel realities”: Database sophisticated, web basic. Layers exist in different architectural universes. Gap invisible from within either reality.
“Accidentally enterprise-ready”: Infrastructure created for one purpose, suitable for another. Good practices accumulating into unexpected capability.
Process Terms (relatively ordinary)
Gameplan: Comprehensive implementation plan. Phases defined, acceptance criteria clear, stop conditions explicit. Template v9.0+ includes Phase -1 mandatory.
Omnibus Log: Synthesis of multiple session logs into comprehensive narrative. Pattern-020 format. Creates complete story from fragmented sessions.
Session Log: Single agent/session documentation. Chronicles decisions, discoveries, outcomes. Raw material for omnibus logs.
ADR (Architectural Decision Record): Documents significant architecture decisions. Problem, options considered, decision made, rationale. Numbered sequentially (ADR-001, ADR-002…).
STOP Conditions: Explicit criteria for stopping work. Prevents scope creep. Examples: “Stop when tests pass” or “Stop when 80% coverage reached.”
Acceptance Criteria: Specific, verifiable completion requirements. “All tests passing” or “Documentation updated” or “Related routes verified.”
Evidence: Concrete proof of completion. Commit SHAs, test results, SQL logs, performance metrics. Not opinion, measurable.
What a glossary might enable
Formalizing terminology may feel bureaucratic but ideally it should be a scaling mechanism.
Before glossary:
Agent: “Should I check if infrastructure exists?”
PM: “Yes, do Phase −1 investigation. Check all layers. Use Serena for symbol search. Spend 15–30 minutes…”
Cost: 5 minutes explanation per agent, every time
With glossary:
Agent: “Should I check if infrastructure exists?”
PM: “Yes, do Phase −1”
Agent: [reads glossary entry if unfamiliar with term, understands complete methodology]
Cost: 10 seconds, perfect transmission
The multiplication:
- 5 agents × 10 investigations each = 50 explanations
- Without glossary: 50 × 5 minutes = 250 minutes (4.2 hours)
- With glossary: 50 × 10 seconds = 8.3 minutes
- Savings: 4 hours of explanation time
But really that’s the kind of math AI’s like to do. The more important impact is consistency. A glossary ensures every agent gets same explanation. No drift. No telephone-game degradation. Perfect transmission every time.
Language as culture transmission
Here’s the key insight: Methodology without language is intuition. Methodology with language is culture.
I can intuitively understand that investigating before building saves time. But until we named it “Phase −1” and documented it systematically, each agent had to learn from scratch.
Now: Agent reads “Phase −1” in template. Looks up glossary. Understands ROI. Sees four discovery examples. Applies methodology. No explanation needed.
Language encoded methodology. Documentation transmitted culture.
This is different from human teams where senior members carry cultural knowledge in memory. With AI agents:
- No cultural memory between sessions
- No informal transmission through conversation
- No senior members modeling behavior
- All transmission through documentation
Which means: Language precision matters more. On human teams, vague phrases get clarified through context and discussion. With AI agents, vague phrases stay vague unless documentation clarifies.
Today’s meta-observation
Writing this post is literally an example of the pattern it describes.
By documenting how language creates culture, we’re using language to transmit cultural understanding about how language transmits culture. Meta-level.
Future agents reading this will understand:
- Phrases encode methodology
- Documentation transmits culture
- Glossaries enable scaling
- Language precision matters
- This understanding itself transmitted through language
The recursion is intentional. Methodology about methodology requires meta-language. “August broke the semantic analyzer” is funny because we’re aware we’re going meta. This post is deliberately self-referential because the subject is language creating self-awareness.
What this means for other AI-human teams
The pattern applies beyond Piper Morgan:
Any team collaborating with AI agents should:
- Name patterns explicitly: Don’t leave methodology implicit. When you recognize pattern, name it. Make it concrete through language.
- Document systematically: Don’t rely on verbal transmission. AI agents need written records. Comprehensive documentation enables perfect transmission.
- Create glossaries: Formalize terminology as jargon emerges. Glossary enables scaling, ensures consistency, reduces explanation overhead.
- Refine through usage: Language isn’t static. As agents apply methodology, capture edge cases, update documentation, improve precision.
- Embrace humor: Playful phrases (“Time Lord Philosophy,” “August broke…”) are more memorable than dry technical terms. Humor aids transmission.
- Go meta intentionally: Occasionally step back and analyze the language itself. How is methodology transmitted? What’s working? What needs clarification?
The hybrid human-AI team has advantage: Human cultural intuition + AI documentation discipline. Best of both worlds if you leverage it intentionally.
The living glossary
Glossary shouldn’t be static document. It should evolve as methodology evolves:
When new pattern emerges: Add entry. Name it, define it, document instances.
When terminology drifts: Update entry. Clarify meaning, add examples, distinguish from similar terms.
When usage reveals ambiguity: Refine entry. Add precision, specify edge cases, include anti-patterns.
When better name appears: Replace entry. Document evolution, explain why new term is clearer.
The glossary is living document reflecting evolving culture. Not dictionary of fixed meanings. But changelog of methodology maturation.
And maintaining it is cultural practice: When agent encounters vague terminology, they propose clarification. When human explains concept repeatedly, they formalize in glossary. When methodology evolves, documentation updates.
Language creates culture. Documentation maintains culture. Refinement improves culture.