Klingen Skill Architecture vs Christensen Durable Sessions
// TL;DR
These two frameworks solve entirely different problems and are complementary, not competitive. Use the Klingen Coding Agent Skill Architecture Method when your coding agent gives bad answers because it lacks product-specific knowledge. Use the Christensen Durable Sessions AI UX Framework when your AI chat or agent experience breaks due to disconnections, multi-device failures, or lack of user control over a running agent. Most teams building AI products will eventually need both — skill quality first, then delivery resilience.
// HOW DO THEY COMPARE?
| Dimension | Klingen Coding Agent Skill Architecture Method | Christensen Durable Sessions AI UX Framework |
|---|---|---|
| Best for | Making coding agents give correct, context-aware answers for your product | Making AI chat/agent UX resilient to disconnections and multi-device use |
| Problem domain | Agent knowledge and instruction quality | Streaming infrastructure and real-time delivery |
| Complexity | Medium — requires iterative trace review, eval setup, and skill file authoring | High — requires architectural redesign of streaming layer, transport swap, pub/sub integration |
| Time to apply | Days to first skill; weeks for auto-research loop maturity | Weeks to months for full Durable Sessions layer implementation |
| Prerequisites | A coding agent environment (Claude, Cursor, Codex), product documentation, tracing capability | An existing AI streaming product, understanding of SSE/WebSocket transport, pub/sub infrastructure |
| Output type | A skill file (CLAUDE.md / .clinerules) plus eval suite and search endpoint | An architectural design with Durable Sessions layer, transport changes, and multi-agent pub/sub channels |
| Creator background | Marc Klingen — CEO of Langfuse (open-source LLM observability), ex-ClickHouse | Mike Christensen — Ably (real-time infrastructure platform) |
| Iteration model | Auto-research loop with human-reviewed skill improvement candidates | Architectural audit → capability scoring → infrastructure redesign |
| Key risk if skipped | Agent hallucates APIs, uses stale docs, picks wrong integration path | Users lose responses on disconnect, can't stop generation, no multi-device sync |
| Multi-agent relevance | Indirect — skills can guide orchestration patterns but focus on single-agent instruction | Direct — eliminates orchestrator relay bottleneck by having sub-agents write to shared session |
What does the Klingen Coding Agent Skill Architecture Method do?
The Klingen method solves a specific and widespread problem: coding agents (Claude, Cursor, Codex) are powerful general tools, but they produce wrong, hallucinated, or outdated results when working with your specific product. The framework treats a "skill" as a structured manual — not intelligence — that tells the agent in what order to apply its capabilities for a specific task.
The method walks you through auditing the agent's pre-skill failures, building a skill file with style rules and an agent sitemap (links to docs, never copies), exposing a search endpoint for documentation, setting up LLM-as-judge evaluations, and running an auto-research loop to iteratively improve the skill. A core principle is Reference Over Duplication: the skill points to live documentation rather than embedding it, preventing the same staleness problem the skill was designed to fix.
This framework is especially valuable for infrastructure-level or "unopinionated" products with deep documentation where users don't know which setup path is right.
What does the Christensen Durable Sessions AI UX Framework do?
The Christensen framework diagnoses and fixes a different class of problem: your AI chat experience breaks under real-world conditions — network drops, multi-device usage, or users wanting to stop or steer an agent mid-generation. The root cause is what Christensen calls the Single-Connection Trap: direct HTTP streaming couples the health of the response to a single client connection.
The solution is a Durable Sessions layer — a persistent, shared, independently addressable resource sitting between agents and clients. Agents write events to the session; clients subscribe to it. This architectural inversion simultaneously unlocks three foundational capabilities: Resilient Delivery (streams survive disconnections), Continuity Across Surfaces (sessions follow users across devices), and Live Control (clients can steer or cancel a running agent).
The framework also addresses the SSE Resume-Cancel Conflict (closing a connection is ambiguous between disconnect and cancel) and the Orchestrator Dual-Purpose Problem (orchestrators forced to relay sub-agent updates).
How do they compare?
These frameworks operate at entirely different layers of an AI product stack and have almost zero overlap in what they address.
Klingen operates at the knowledge layer. It ensures the agent knows what to do — which APIs to call, which docs to read, which questions to ask. Without it, a capable agent wastes turns wandering toward the right answer or ships wrong instrumentation.
Christensen operates at the delivery layer. It ensures the agent's output reaches the user reliably — surviving disconnections, working across devices, and giving users real-time control. Without it, even a perfectly skilled agent delivers a fragile experience.
In terms of complexity, the Klingen method is more accessible. A team can ship a first skill file in days and iterate from there. The Christensen framework requires a more significant architectural investment — swapping SSE for WebSockets, implementing pub/sub infrastructure, and redesigning how agents and clients communicate.
The Klingen method is clearly better for teams whose primary pain is agent accuracy and onboarding quality. The Christensen framework is clearly better for teams whose primary pain is production UX failures — dropped responses, no multi-device support, and a stop button that doesn't actually work.
Which should you choose?
If you are building coding agent skills or onboarding experiences for a technical product, use the Klingen Coding Agent Skill Architecture Method. It directly addresses why agents give wrong answers for your product and provides a complete iteration loop from baseline audit through auto-research.
If you are building or fixing a consumer-facing AI chat or agent product, use the Christensen Durable Sessions AI UX Framework. It directly addresses why your AI experience feels fragile compared to non-AI chat products and provides a clear architectural path to resilience.
If you are building a full AI product with both a coding agent integration and a user-facing chat experience, you need both — and you should start with Klingen. Getting the agent's knowledge right is prerequisite to caring about delivery resilience; a perfectly resilient stream of wrong answers is still a bad product. Once the agent reliably solves user problems, invest in Durable Sessions to make the delivery bulletproof.
Neither framework replaces the other. They are complementary layers of a mature AI product stack — one ensuring the agent knows what to do, the other ensuring the user actually receives the result.
// FREQUENTLY ASKED QUESTIONS
Can I use both the Klingen Skill Architecture and Christensen Durable Sessions together?
Yes, and most mature AI products should. They solve different layers of the stack: Klingen ensures the agent gives correct, context-aware answers using a skill file and eval loop; Christensen ensures those answers reach users reliably across devices and network conditions. Start with Klingen for agent quality, then layer on Durable Sessions for delivery resilience.
Which framework should I use if my AI agent gives wrong answers about my product?
Use the Klingen Coding Agent Skill Architecture Method. It is specifically designed for this problem — agents hallucinating APIs, using stale docs, or picking wrong integration paths. You build a skill file with style rules and an agent sitemap, then iterate using traces and auto-research to systematically eliminate failure modes.
Which framework fixes AI chat responses being lost when users disconnect?
Use the Christensen Durable Sessions AI UX Framework. It replaces direct HTTP streaming with a persistent session layer that buffers events independently of any client connection. When a user reconnects, they resume exactly where they left off. The agent never needs to know the client disconnected.
Does the Klingen method work with agents other than Claude?
Yes. While examples reference CLAUDE.md and Cursor, the method applies to any coding agent environment that accepts instruction files — including Codex, Cline (.clinerules), Windsurf, or custom agent setups. The principles of progressive disclosure, reference over duplication, and trace-based iteration are agent-agnostic.
Is the Christensen Durable Sessions framework only for WebSocket-based apps?
No, but it recommends WebSockets or equivalent bidirectional transport when Live Control (stop buttons, steering messages) is needed. The core concept — a persistent session layer between agents and clients — can sit atop various transports. However, SSE alone cannot support Live Control due to the Resume-Cancel Conflict.
How long does it take to implement each framework?
The Klingen method can produce a working first skill in days, with the auto-research loop maturing over weeks. The Christensen framework requires weeks to months because it involves architectural changes — new session infrastructure, transport layer changes, and reworking how agents and clients communicate. Klingen is faster to start.
Do I need an observability tool like Langfuse to use the Klingen method?
An observability tool with tracing is strongly recommended but not strictly required. The method relies heavily on reading agent traces to identify failure modes and guide skill improvements. You could manually log agent actions, but a proper tracing tool like Langfuse makes the process dramatically more efficient.
What if I have a multi-agent system — which framework helps more?
Both contribute differently. Christensen directly solves the orchestrator relay bottleneck by having each sub-agent write to a shared Durable Session. Klingen helps each individual agent perform its task correctly via skill files. For multi-agent systems, Christensen's architectural contribution is more significant, but each agent still benefits from well-designed skills.