The Framework
ARC is a recursive pattern. It operates at every scale: a function, a service, a subsystem, an organisation.
The same questions repeat:
Do we understand what we are building?
Are we reinforcing patterns or creating exceptions?
Are we consolidating learning or letting drift accumulate?
Three Phases, One Coherent System
ARC is not a checklist. It is a recursive pattern that operates at every scale.
Align
Define architecture before code
Explicit architectural decisions. Shared understanding. Pattern identification.
Realize
Pattern + feature together
Implement with intention. AI-assisted with guardrails. Coherent execution.
Consolidate
Validate and propagate
Verify coherence. Extract patterns. Prevent drift. Systemic integrity.
Align
Architecture before code
Before writing a single line, make architectural decisions explicit. Define what patterns apply, what boundaries exist, and what the team needs to understand.
Alignment is not about documentation. It is about shared mental models.
When alignment is implicit, every developer makes different assumptions. The system fragments even when everyone is competent.
Explicit Decisions
Make architectural choices visible and documented before writing code.
Shared Understanding
Ensure the entire team knows the 'why' behind technical decisions.
Pattern Identification
Recognize recurring problems and prepare intentional solutions.
Boundary Definition
Establish clear interfaces and responsibilities between components.
Key Questions in Align
- What architectural decisions affect this work?
- What patterns should we reinforce or establish?
- What boundaries must be respected?
- Does everyone understand the ‘why’?
Align does not require meetings or documents. It requires explicit decisions that the team can reference.
AI-Assisted Realization
When using AI tools during Realize, provide explicit architectural context. AI amplifies whatever patterns it finds, explicit or implicit.
- Share pattern definitions and constraints
- Reference existing implementations as examples
- Define boundaries the AI should respect
- Review generated code against alignment decisions
Without explicit context, AI produces locally optimal, globally inconsistent code.
Realize
Pattern + feature together
Implementation is not just about shipping features. It is about embodying patterns.
Every feature is an opportunity to reinforce architectural coherence. Every exception is a potential source of drift.
AI can accelerate Realize, but only with proper guardrails. Speed without direction produces divergent implementations.
Pattern + Feature
Implement features while simultaneously establishing or reinforcing patterns.
AI-Assisted Guardrails
Use AI tools with explicit architectural context to maintain coherence.
Intentional Execution
Every line of code serves both the immediate need and the larger system.
Progressive Enhancement
Build incrementally without sacrificing architectural integrity.
Consolidate
Validate and propagate
After implementation, verify coherence. Did we follow our patterns? Did new patterns emerge that should be extracted?
Consolidation closes the loop. What we learn in one cycle becomes alignment for the next.
Without consolidation, every implementation is an island. Patterns accumulate but are never shared. The system grows without learning.
Verify Coherence
Check that implementations align with established patterns and decisions.
Extract Patterns
When variation becomes clear, extract reusable patterns. Not before.
Prevent Drift
Identify and correct deviations before they become embedded.
Propagate Learning
Share discoveries across the team and update architectural decisions.
The Torvalds Rule
“Don't abstract until you have three concrete implementations.”
Premature abstraction is the enemy of coherence.
In Consolidate, we wait until patterns truly emerge before extracting them. Two similar things might just be similar. Three reveal a pattern.
The cost of wrong abstraction is higher than the cost of duplication.
Fractal Nature
ARC does not happen once. It happens continuously, at different levels of the system, whenever decisions are made.
The same cycle applies to:
- A single function being refactored
- A feature being implemented
- A service being designed
- A platform being architected
- An organisation adopting new practices
Scale changes. The questions remain.
ARC & Agile
| Aspect | Agile | ARC |
|---|---|---|
| Focus | Velocity & iteration | Coherence & patterns |
| Architecture | Emergent (often implicit) | Explicit & intentional |
| Decisions | Team autonomous | Team aligned on patterns |
| AI Integration | Tool for speed | Tool with guardrails |
| Technical Debt | Managed later | Prevented by design |
ARC does not compete with Agile.
Agile answers “how do we move?”
ARC answers “are we still moving together?”
Go Deeper
The book expands each phase with examples, case studies, and practical techniques.
Explore the Book