SOFTWARE ARCHITECTURE
Why Elixir Is the Perfect Agent Framework Runtime
Elixir and OTP offer actors as agents, supervision trees for failure recovery, and process mailboxes as thought logs — a natural runtime for living …
Living Software: The Framework
Stability contracts, consequence graphs, immutable event logs, and a conductor that turns the gap between intent and reality into autonomous work.
Ambiguity as a Vital Sign
Traditional observability counts individual leaves. In a living system, ambiguity is the vital sign — it reveals where the system is still becoming.
Beyond the Horseless Carriage: What AI-Native Software Actually Looks Like
We build AI systems that mimic human workflows. AI-native software should look like a living organism, not a faster factory pipeline.
Complexity Is a Feature: A Developer's Realisation
Complexity often isn't a bug — it's a feature that benefits interpreters, gatekeepers, and incumbents. A developer's journey from automation idealist …
Building a Graph-Based Intent Modelling Tool
A proof-of-concept tool for graph-based system modelling — defining system behaviour, validating it structurally, and generating tests from the …
Adopting System Models Incrementally
Practical guide to adopting graph-based system models incrementally. Covers escape hatches, LLM workflows, and week-by-week adoption strategy.
The Self-Validating Graph
Graph-based system models validate themselves through structural checks, semantic analysis, and automatic test generation from invariants.
Code Is a Lossy Format
Source code is a lossy format that discards intent. LLMs expose this weakness. Graph-based models preserve meaning as first-class structure.
WebAssembly 3: The Runtime of Living Systems
WebAssembly 3.0 transforms architecture from metaphor to mechanism — providing the runtime metabolism your living, self-healing system needs.
The Evolution from Code Craftsmanship to Living Systems: A Conversation About the Future of Software Architecture
Exploring the paradigm shift from imperative coding to declarative systems, hybrid architectures, and self-healing codebases that evolve autonomously.
Building Hybrid Declarative Systems: A Practical Architecture Guide
Learn how to architect hybrid declarative systems that combine symbolic reasoning with machine learning for trustworthy, explainable AI decisions.
Architecting for AI Agents: A New Way to Think About Software Design
When autonomous agents own modules, architecture shifts from crafting code to shaping living, self-healing systems that evolve without constant human …
Enterprise AI Architecture: Building Self-Healing, Autonomous Systems with Distributed Intelligence
Building enterprise-grade AI with autonomous nodes, distributed intelligence, and self-healing mechanisms for resilient systems that adapt without …
Abstraction Is Hard: Why Wrong Abstractions Are Worse Than No Abstractions
Creating good abstractions is one of software development's hardest challenges. Learn when to abstract, when not to, and how to avoid costly mistakes.
What 'Enterprise Software' Actually Means: Beyond the Buzzword
Enterprise software is everywhere, but what does it really mean? A practical guide to understanding when software truly deserves the enterprise label.
Kokeshi vs Lego: Two Philosophies of Software Architecture
Two fundamental software architecture approaches: nested abstractions like Russian dolls versus composable pieces like Lego blocks. Learn when to use …
Why Every Developer Should Know About Double-Entry Bookkeeping: And It's Not About Accounting
Discover why double-entry bookkeeping, a 500-year-old accounting practice, is actually one of the most elegant software architecture patterns for …