← THE COURSEDAY 04 OF 07

DAY 04 · Architect

Architect — Govern the Patterns AI Builds Within

Ask five engineers to build the same feature with AI and you'll get five architectures. All five compile. All five merge. That's not five mistakes — it's one org with no enforced patterns, diverging at machine speed.

Five engineers, five architectures, all merged this week

One builds the data-access layer with a repository pattern. One calls the database directly from the component. One invents a caching layer nobody asked for. One writes a bespoke error-handling scheme that exists nowhere else. One reaches for a library the team deprecated eighteen months ago.

All five compile. All five pass the tests they wrote for themselves. All five clear code review, because the reviewer is checking whether the code works, not whether it matches four other PRs they haven't seen. And all five merge into the same codebase this week.

This is not a talent problem. Every one of those engineers is good. It is an architecture-governance problem — and AI turned it from a slow leak into a flood. A human writing that code by hand might have paused, glanced at the neighbouring files, and matched the house style. AI does not pause. It generates the most statistically plausible solution to the prompt in front of it, with no memory of the last prompt and no knowledge of your patterns unless you gave them to it. So it invents. Every prompt. At speed.

AI can't violate what's enforced

You cannot govern AI output by asking people to be careful. Careful does not scale to the volume AI now produces, and it does not survive the moment a deadline hits. The only governance that holds is structural: making the right thing easier for the AI to produce than the wrong thing, and enforcing the boundary automatically so a violation cannot merge even when nobody is watching.

The most important shift in 2026 is where architecture documentation lives. It used to live in an Architecture Decision Record a human read before writing code. Increasingly, the architecture that matters lives in AI-instruction files — AGENTS.md — that the agent loads at generation time and treats as law. As the industry now frames it: AGENTS.md is becoming the new ADR. Not a replacement — a composition. The ADR explains the why for humans; the AGENTS.md enforces the how for agents. One is prose. The other is executable.

Architect is the practice of governing AI output through enforced patterns instead of human gatekeepers.

The five sub-practices of Architect

A1
Codify Patterns
Your approved patterns — data access, API shape, component structure, naming — published where the AI consumes them: markdown, version-controlled in Git. Plus an explicit anti-pattern registry, so the AI knows what NOT to generate. If a pattern lives only in a senior's head or a Confluence page, the AI cannot follow it.
A2
Document Decisions
ADRs in a standard format — Status, Context, Decision, Consequences — linked from AGENTS.md so the AI loads them automatically and cites the relevant decision. When a decision is superseded, the supersession propagates into the AI's context, so it stops generating the old pattern.
A3
Enforce via Review
Multi-agent code review that analyses every PR before a human sees it — separate agents for correctness, security, standards, and patterns. The end state is policy-as-prompt: guardrails run inline during generation, so the agent validates each block against the rules before it presents it. You stop catching violations. You prevent them.
A4
Integrate Pipelines
Agentic CI/CD that understands your topology — intelligent test selection, build-failure root-cause analysis, deployment risk scoring by blast radius. Human-only review at AI velocity becomes the bottleneck; the pipeline has to carry its share.
A5
Evolve Architecture
A tech-debt registry the AI can consume, so in areas you're migrating away from, the AI generates the new pattern even when the surrounding code still uses the old one — instead of copying and reinforcing bad patterns at AI speed.

Wild West vs Architecture-Native

The Wild West
Patterns: tribal, in senior heads
ADRs: in Slack threads, or nowhere
Enforcement: manual review, reviewer-dependent
Every PR: a surprise
Tech debt: compounds at AI speed
Architecture knowledge: walks out when people leave
The Architecture-Native Org
Patterns: codified in AGENTS.md, loaded every session
ADRs: machine-readable, cited by AI at generation time
Enforcement: policy-as-prompt — violations blocked pre-generation
Every PR: conforms to the enforced pattern
Tech debt: trends down despite AI velocity
Architecture knowledge: encoded, retained, enforced

The uncomfortable truth

Ungoverned AI does not just fail to help your architecture. It actively degrades it, and the measurements are not flattering.

AI-generated code shows 41% higher churn — lines revised or reverted within two weeks of being committed — than human-written code (GitClear 2025). Churn is your tech-debt clock. Alongside it, copy-pasted code rose from 8.3% of commits in 2020 to 12.3% in 2024, blocks of five or more duplicated lines grew eightfold in 2024 alone, and refactoring collapsed from 24.1% to 9.5% over the same period (GitClear 2025). Duplication up, refactoring down — a codebase getting worse, faster, on autopilot.

And it lands on real hours. Teams where AI writes more than 40% of the code see rework rates rise 20-25%, costing roughly seven hours per team member per week (Faros 2026). A full working day, per engineer, per week, spent redoing what AI produced without a pattern to produce it against. None of this is an argument against AI. It is an argument against ungoverned AI.

If you answered A or B to any of those, your architecture is tribal — and AI is dismantling it at machine speed. That is not a judgement of your engineers. It is the natural gravity of moving fast: patterns lived in people's heads because that was good enough when a human wrote every line and paused to match the house style. AI removed the pause.

The Architect practice closes the gap by moving your patterns out of the wiki and into the AGENTS.md the AI loads every session, writing your decisions as machine-readable ADRs the AI cites at generation time, and running multi-agent review and policy-as-prompt so the boundary is enforced structurally — so that, at the mature end, AI cannot violate architecture, because architecture is the context it generates from.

SELF-ASSESSMENT
01
Where do your patterns live? — When an engineer uses AI to build a feature, where does the AI learn how your org does data access, error handling, API design?
  • A - Nowhere. The AI invents it, and the engineer fixes what they happen to notice in review.
  • B - In a wiki or Confluence page a human might read first — but the AI can't load it.
  • C - In an AGENTS.md the agent loads every session, covering the patterns behind most of our decisions.
02
When did you last decide something architecturally? — Your most important architecture decisions: where are they?
  • A - In Slack threads and a few people's memories.
  • B - In an ADR folder, but the AI has no idea it exists.
  • C - In machine-readable ADRs linked from AGENTS.md — the AI cites the relevant one when it makes a choice.
03
What catches an architectural violation? — An AI-generated PR calls the database straight from the UI. What stops it?
  • A - Maybe a reviewer notices. Maybe it merges.
  • B - A linter catches a couple of obvious cases; most boundaries go unmonitored.
  • C - An AI review agent checks every PR against our patterns and ADRs before a human looks — and policy-as-prompt stops the worst violations before they're even generated.

The Free CRAFT Scorecard shows you your starting archetype and exactly which sub-practices are your weakest — 25 questions, 5 minutes, something specific about your org, not something generic. Take it at craftmethod.co/scorecard/free. — Luis