5-Rule Architecture Evaluator vs Durable Sessions AI UX
// TL;DR
These two frameworks solve completely different problems and should never be evaluated as alternatives. Use Dima's 5-Rule Front-End Architecture Evaluator when you need to choose or audit a front-end folder structure (FSD vs Vertical Slices vs Layered). Use the Christensen Durable Sessions Framework when your AI-powered product's streaming UX breaks on disconnects, multi-device use, or lacks live agent control. If you are structuring code, pick Dima's. If you are fixing AI chat delivery infrastructure, pick Christensen's.
// HOW DO THEY COMPARE?
| Dimension | Dima's 5-Rule Front-End Architecture Evaluator | Christensen Durable Sessions AI UX Framework |
|---|---|---|
| Best for | Choosing or auditing front-end codebase architecture (folder structure, module boundaries) | Diagnosing and fixing AI chat/agent streaming delivery infrastructure |
| Problem domain | Front-end code organisation and developer experience | Real-time AI UX resilience, multi-surface delivery, and agent control |
| Complexity | Moderate — 5 scoring criteria, 10-step workflow, requires architectural knowledge | High — requires understanding of streaming protocols (SSE, WebSockets), pub/sub, and agent topology |
| Time to apply | 1–3 hours for a full audit; 30 minutes for a quick architecture selection | Days to weeks — involves infrastructure redesign and transport layer changes |
| Prerequisites | Familiarity with front-end project structures, basic understanding of cohesion/coupling | Understanding of SSE, WebSockets, pub/sub patterns, and AI agent architectures |
| Output type | Architecture recommendation with scored rubric and cohesion-coupling matrix placement | Gap analysis against 3 foundational capabilities plus a redesigned session architecture |
| Team size relevance | Scales from solo dev to large teams — team size directly affects recommendation | Most relevant for product engineering teams shipping AI-powered products to end users |
| Creator background | Dima — front-end architecture educator, YouTube-based teaching | Mike Christensen (Ably) — real-time infrastructure, AI Engineer conference speaker |
| Actionability without code changes | High — can reorganise folders and modules without rewriting logic | Low — requires transport layer and infrastructure changes to implement |
| Ongoing use | Architecture Decision Loop — revisit after each release cycle | One-time infrastructure migration, then layer on additional capabilities incrementally |
What does Dima's 5-Rule Front-End Architecture Evaluator do?
Dima's framework gives front-end teams a concrete, repeatable method to choose between three architecture patterns — Feature Sliced Design (FSD), Vertical Slices, and Layered Architecture — or to audit an existing codebase that has become painful. It scores any architecture against five rules: High Cohesion, Low Coupling, Discoverability, Mental Model Match, and Incremental Adoption.
The framework is opinionated. For small projects, it recommends Layered Architecture (components, services, API folders). For medium-to-large projects, it recommends Vertical Slices (feature-first folders with technical sub-folders inside). It only recommends FSD if the team already knows it, the project is confirmed large, and the team accepts the classification overhead. The 10-step workflow includes plotting the architecture on a Cohesion-Coupling matrix and testing for the Classification Problem — where two developers would place the same component in different layers.
The output is a scored rubric, a quadrant placement, and a specific architecture recommendation tied to project size and stage.
What does the Christensen Durable Sessions AI UX Framework do?
The Christensen framework diagnoses why AI chat and agent-driven product experiences break under real-world conditions — network drops, multi-device usage, and the inability to interrupt or steer an agent mid-generation. It identifies the root cause as the Single-Connection Trap: the default pattern where stream health is coupled to one client's connection.
The framework prescribes introducing a Durable Sessions layer — a persistent, shared, independently addressable resource that sits between agents and clients. Agents write events to the session; clients subscribe to it. This architectural inversion unlocks three foundational capabilities: Resilient Delivery (streams survive disconnections), Continuity Across Surfaces (session follows the user across tabs and devices), and Live Control (clients can steer or cancel agents mid-generation).
It also addresses the SSE Resume-Cancel Conflict (connection closure is ambiguous between disconnect and cancel) and the Orchestrator Dual-Purpose Problem (forcing orchestrators to relay sub-agent progress). The output is a redesigned streaming architecture built on pub/sub channels.
How do they compare?
These frameworks operate in entirely different domains with zero overlap. Dima's framework is about code organisation — where files live in a front-end project and how modules relate to each other. Christensen's framework is about delivery infrastructure — how AI-generated content reaches end users reliably across connections, devices, and agent topologies.
You could use both on the same project without conflict. A team building an AI-powered SaaS product might use Dima's framework to structure their front-end codebase into Vertical Slices (cart, settings, chat) and simultaneously use Christensen's framework to ensure their AI chat streaming architecture survives network drops and supports a stop button.
Dima's framework is faster to apply (hours, not weeks) and requires no infrastructure changes — it is primarily about folder structure and module boundaries. Christensen's framework demands real engineering work: replacing SSE with WebSockets, introducing a pub/sub session layer, and rewiring how agents emit events.
Dima's framework is relevant to any front-end project regardless of whether it involves AI. Christensen's framework is specifically for products with AI agent or chat streaming interfaces.
Which should you choose?
Choose Dima's 5-Rule Front-End Architecture Evaluator if:
- You are starting a new front-end project and need to pick an architecture
- Your existing codebase has become painful — merge conflicts, slow onboarding, unclear file placement
- You are debating FSD vs Vertical Slices vs a simpler layered approach
- You need a quick, structured decision framework that produces a concrete recommendation
Choose the Christensen Durable Sessions Framework if:
- Your AI chat product loses responses when users switch networks or close tabs
- You need a stop button or steering capability during agent generation
- You want the same AI conversation visible across multiple tabs or devices
- You have a multi-agent architecture where the orchestrator has become a bottleneck for progress updates
Use both if you are building an AI-powered product and need to organise your front-end codebase well and ensure your AI streaming UX is resilient. They are complementary, not competing.
Can you use these frameworks together on the same project?
Yes, and for AI product teams this is the strongest approach. Apply Dima's framework first to establish your front-end folder structure — likely Vertical Slices for a medium-to-large AI product, with feature folders like `chat`, `agent-dashboard`, `settings`. Then apply Christensen's framework to redesign the streaming architecture within the `chat` feature slice, introducing a Durable Sessions layer so agent responses survive disconnects and support live control.
The architectural principles align well: Dima's emphasis on High Cohesion and Low Coupling maps naturally to Christensen's Agent-Client Decoupling. Both frameworks reject coupling that creates fragility — Dima at the module level, Christensen at the infrastructure level.
// FREQUENTLY ASKED QUESTIONS
Can I use Dima's 5-Rule Architecture Evaluator for AI products?
Yes. Dima's framework applies to any front-end project regardless of whether it involves AI. It evaluates folder structure, module boundaries, and code organisation — concerns that exist in every front-end codebase. It does not address AI-specific streaming or delivery challenges, which is where Christensen's framework applies.
Does the Christensen Durable Sessions framework help with front-end code organisation?
No. It focuses exclusively on how AI-generated content is delivered to clients — streaming architecture, connection resilience, and agent-client communication patterns. For organising your front-end codebase into folders and modules, use Dima's 5-Rule Evaluator or a similar code architecture framework.
Which framework is faster to apply?
Dima's framework is significantly faster. A full architecture audit takes 1–3 hours; a quick selection takes 30 minutes. Christensen's framework requires days to weeks of engineering work because it involves replacing transport layers, introducing pub/sub infrastructure, and rewiring agent output pipelines.
Do I need to know Feature Sliced Design to use Dima's framework?
No. The framework evaluates FSD as one of three options alongside Vertical Slices and Layered Architecture. It actually recommends against FSD for most projects — only suggesting it when the team already knows FSD, the project is confirmed large, and the classification overhead is acceptable.
Is the Christensen framework only for WebSocket-based apps?
No, but it strongly recommends moving to bidirectional transport like WebSockets if you need Live Control (stop buttons, steering). The core concept — Durable Sessions as a shared pub/sub layer — can work over multiple transport types, but SSE alone cannot support the full set of three foundational capabilities due to the Resume-Cancel Conflict.
Can these two frameworks be used together?
Yes, and for AI product teams this is recommended. Use Dima's framework to structure your front-end codebase (folder architecture, module boundaries), then use Christensen's framework to design the streaming delivery infrastructure within your AI chat or agent features. They address completely different layers of the stack.
Which framework should I use if my AI chatbot loses responses on mobile?
Use the Christensen Durable Sessions Framework. Lost responses on mobile are a classic Single-Connection Trap symptom — your stream health is tied to one connection. The fix is a Durable Sessions layer where agents write to a persistent channel and mobile clients reconnect and resume automatically without agent-side replay logic.
Which framework helps with merge conflicts in a large front-end team?
Dima's 5-Rule Front-End Architecture Evaluator. Merge conflicts typically signal low cohesion — feature code scattered across many folders so multiple developers edit the same files. The framework will likely recommend Vertical Slices, grouping all code for each business feature into one folder to reduce cross-feature file contention.