Durable Sessions vs Comprehend-First: Which Should You Use?
// TL;DR
These two skills solve completely different problems and most teams need both. If your AI product streams responses to users and you're experiencing disconnects, multi-device blindness, or broken stop buttons, start with Durable Sessions. If you're a developer using AI to write code in unfamiliar codebases and shipping changes you don't fully understand, start with Comprehend-First. Durable Sessions is an infrastructure architecture framework; Comprehend-First is a personal developer workflow. They operate at different layers of the stack and are complementary, not competing.
// HOW DO THEY COMPARE?
| Dimension | Christensen Durable Sessions AI UX Framework | Priscila Andre's Comprehend-First AI Coding Skill |
|---|---|---|
| Best for | Teams building AI chat/agent products that need resilient, multi-device streaming UX | Individual developers who need to deeply understand unfamiliar codebases before writing or generating code |
| Problem domain | Real-time streaming infrastructure and AI product architecture | Developer comprehension workflow and AI-assisted code quality |
| Complexity | High — requires architectural redesign of streaming layer, transport protocol changes, and infrastructure investment | Low — requires changing personal prompting habits and creating reusable Markdown prompt files |
| Time to apply | Days to weeks for audit; weeks to months for full implementation | Minutes to hours; can be applied to the very next coding session |
| Prerequisites | Existing AI product with streaming architecture; understanding of SSE, WebSockets, pub/sub patterns | Access to an AI assistant (ChatGPT, Claude, Copilot, Cursor, etc.) and a codebase you need to work in |
| Output type | Architectural design — session layer, transport protocol decisions, agent topology changes | Mental model — structured comprehension outputs like flow diagrams, tables, and component trees |
| Target user | Platform engineers, AI product architects, infrastructure leads | Any software developer using AI coding tools, especially those onboarding or reviewing PRs |
| Scope of impact | System-wide — changes how every user experiences the AI product | Individual — changes how one developer understands and contributes to code |
| Creator background | Mike Christensen, Ably (real-time infrastructure company) | Priscila Andre de Oliveira, Sentry (application monitoring company) |
| Key risk if ignored | Fragile AI UX that breaks on network drops, can't support multi-device, and has ambiguous stop buttons | Shipping 'slop code' — AI-generated changes you don't understand into production codebases |
What does Christensen's Durable Sessions AI UX Framework do?
Durable Sessions is an infrastructure architecture framework created by Mike Christensen of Ably. It diagnoses why AI chat and agent-driven product experiences break under real-world conditions — network disconnects, multi-device usage, and users needing to interrupt or steer live agent responses.
The framework identifies the Single-Connection Trap as the root cause: most AI products stream responses via SSE over a direct HTTP connection. If that connection drops, the stream is gone. If a user opens a second tab, it sees nothing. If a user hits "stop," the system can't distinguish that from a network disconnect.
The solution is a Durable Sessions layer — a persistent, shared 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 disconnects), Continuity Across Surfaces (sessions follow users across devices), and Live Control (users can steer or cancel agents mid-generation). The framework provides a 10-step workflow for auditing your current architecture, identifying failure modes, and implementing the session layer using pub/sub patterns and bidirectional transports like WebSockets.
What does Priscila Andre's Comprehend-First AI Coding Skill do?
Comprehend-First is a personal developer workflow created by Priscila Andre de Oliveira of Sentry. It addresses a specific failure mode: developers using AI to generate code in codebases they don't understand, resulting in what Andre calls "slop code" — changes that work superficially but lack intentionality.
The core principle is simple but powerful: use AI for comprehension before generation. Andre found that 67% of her actual AI usage was comprehension-related, with only 2% being code generation. The framework formalizes this into a reusable skill called Catch Me Up, which offers six structured exploration modes: Architecture, Convention, Feature, Trace, Syntax, Testing, and History.
The workflow inserts a mandatory comprehension gate into the standard AI-assisted development cycle, expanding it from three phases (Research → Plan → Implement) to four: Research → Comprehend → Plan → Implement. You declare your role, select an exploration mode, ask specific questions, demand structured visual output, and verify the AI's understanding before proceeding. Only once your mental model is aligned do you move to planning and implementation.
How do they compare?
These skills operate at entirely different layers of the software development process and serve different audiences.
Durable Sessions is a systems architecture framework. It's relevant when you're building or maintaining an AI-powered product that streams responses to end users. The audience is platform engineers, infrastructure leads, and product architects. The output is architectural decisions — transport protocol choices, session layer design, agent topology changes. Implementation takes weeks and affects every user of the product.
Comprehend-First is a personal productivity framework. It's relevant when you're a developer working inside a codebase — any codebase — and using AI tools to help. The audience is individual engineers at any level. The output is a better mental model. Implementation takes minutes and affects the quality of your next commit.
The only overlap is that both frameworks deal with AI in software engineering. But Durable Sessions is about how AI products deliver responses to users, while Comprehend-First is about how developers use AI to understand code. A team could easily need both: Durable Sessions for their product architecture and Comprehend-First for how their engineers work with AI day-to-day.
On complexity, Durable Sessions is significantly harder to implement. It requires infrastructure changes, protocol migrations (SSE to WebSockets), and possibly adopting a pub/sub platform. Comprehend-First requires nothing more than changing how you prompt your existing AI tools.
Which should you choose?
Choose Durable Sessions if you are responsible for the architecture of an AI product that streams responses to users, and you're experiencing any of these symptoms: responses lost on network drops, no multi-device session continuity, ambiguous stop button behavior, or orchestrator bottlenecks in multi-agent setups. This is an infrastructure investment that pays off in product quality and user trust.
Choose Comprehend-First if you are a software developer using AI coding tools (Cursor, Copilot, ChatGPT, Claude, etc.) and you want to stop shipping code you don't fully understand. This is especially valuable when onboarding to new repositories, reviewing PRs in unfamiliar areas, or investigating regressions. It requires zero infrastructure and delivers value immediately.
Choose both if you're building an AI product (Durable Sessions for your streaming architecture) and your engineering team uses AI coding assistants (Comprehend-First for developer workflow quality). They are complementary frameworks that reinforce each other: Durable Sessions improves what your users experience, and Comprehend-First improves what your engineers ship.
If you can only invest time in one today, Comprehend-First delivers faster ROI because it requires no infrastructure changes and improves your next coding session. Durable Sessions has higher long-term impact on product quality but demands a larger upfront investment.
// FREQUENTLY ASKED QUESTIONS
Can I use Durable Sessions and Comprehend-First together?
Yes, and most teams should. They solve different problems at different layers. Durable Sessions fixes your AI product's streaming architecture so end users get resilient, multi-device experiences. Comprehend-First fixes your engineering workflow so developers understand code before generating it. Use Durable Sessions for product infra and Comprehend-First for developer productivity.
Do I need Durable Sessions if I'm using the Vercel AI SDK?
Likely yes. The Vercel AI SDK uses SSE by default, which means you're in the Single-Connection Trap. If a user's connection drops mid-stream, the response is lost. If they open a second tab, it's blind. If they hit stop, the system can't distinguish it from a disconnect. Durable Sessions addresses all three of these failure modes.
Is Comprehend-First only for junior developers?
No. The creator is a senior engineer at Sentry who describes herself as an 'agent manager.' The skill is especially valuable for senior engineers who review PRs in unfamiliar areas, return from leave to find conflicts, or onboard to new subsystems. Comprehension needs scale with codebase size and complexity, not inversely with experience.
What tools do I need for the Comprehend-First workflow?
Any AI assistant that can accept code context — ChatGPT, Claude, Cursor, Copilot Chat, Windsurf, or similar. The skill is stored as a reusable Markdown prompt file locally. No special infrastructure, plugins, or paid tiers are required. The value comes from the structured prompting methodology, not any specific tool.
How long does it take to implement Durable Sessions?
The audit phase (steps 1–3) takes a day or two. Designing and implementing the session layer (steps 4–8) typically takes weeks, depending on your existing architecture's complexity. If you're migrating from SSE to WebSockets and introducing a pub/sub layer, expect a meaningful infrastructure project. The validation phase (step 9) adds another few days.
Does Comprehend-First work with agentic coding tools like Devin or Codex?
Yes, and it's arguably more important with autonomous agents. The framework's core warning is that agents can go in the wrong direction if you don't verify their understanding. The Research → Comprehend → Plan → Implement cycle applies directly: let the agent research, but you must personally comprehend its findings before allowing it to plan and implement.
What is the biggest mistake teams make that Durable Sessions prevents?
Building resume and replay logic inside the agent code itself. This couples your AI agent to connection management concerns, scales poorly with multiple clients and devices, and makes agent code unnecessarily complex. Durable Sessions moves all delivery complexity into the session layer, letting the agent focus solely on generating responses.
What is slop code and how does Comprehend-First prevent it?
Slop code is AI-generated code shipped into production without the developer genuinely understanding what it does or why. Comprehend-First prevents it by mandating a comprehension gate before any code generation. You must be able to explain the relevant code in plain language before prompting AI to modify it. The standard is 'keynote code' — code you'd proudly present publicly.