Featured Series
Start your journey with these curated article series
The Strategic PM: What Product Management Looks Like After the Specification Factory
When you stop being a specification robot, you start being the strategist your company actually needs.
Starting Small: The 30-Minute Pilot That Sells Itself
You don't adopt a specification language. You adopt a faster way to get work done.
The Full Stack of Intent: From Customer Problem to Production Code
How Chronos connects requirements to data, APIs, UIs, and infrastructure—without anyone being locked in.
Introducing Chronos: A Language for Product Intent
Requirements that validate. Specifications with type safety. Product intent as a first-class artifact.
The Specification Factory: Having Your Cake and Eating It Too
What if PMs could be more strategic and engineers could get better specs—at the same time?
The Spec Gap: What Engineering Sees That Product Doesn't
The translation layer between product intent and engineering execution is lossy. Here's what gets lost—and what it costs.
The Best Product Managers Are Looking Down
The highest-value work in product happens heads-up—strategy, customers, discovery. So why do we spend most of our time heads-down, writing specs?
Rethinking Your AI Tooling Strategy
The sophistication spectrum: autocomplete → conversational generation → structured factories. What to ask your AI tools, the cost curve shift, the talent transformation, and what comes next when factories build factories.
Architecture as Code: The Living Architecture
You've defined APIs, data models, and UI components. But there's a fourth definition missing: the architecture itself. Not diagrams that drift, but a machine-readable, queryable, always-current representation that can validate itself.
Standing on Giants: The Composable Stack
You don't need to build this from scratch. Separate concerns into composable layers—schema validation, security scanning, testing, observability, quality enforcement. In one implementation, ~70% was off-the-shelf OSS tools. We just need to orchestrate them.
Self-Healing Pipelines: Closing the Loop
The traditional flow: deploy → user finds bug → human fixes → deploy again. The self-healing flow: deploy → automated health checks → anomaly detection → auto-rollback → root cause analysis → improvement. A factory that learns from its mistakes.
The Observability Foundation: Watching the Factory Work
You can't improve what you don't measure. For human-driven pipelines, comprehensive instrumentation is aspirational. For AI factories, it's table stakes. How to build visibility into every pipeline stage.
Measuring What Matters: The Metrics You've Always Wanted
Every engineering leader wants the same visibility: deployment frequency, lead time, change failure rate, rework rate, stability. Industry research shows these metrics separate elite from low performers. The problem was collecting them consistently—until now.
The Maturity Ladder: Why Organizations Get Stuck
Most orgs follow a recognizable maturity progression: Ad hoc → Repeatable → Defined → Measured → Optimizing. Quantitative management is where they get stuck. Why systematic data collection and causal analysis were too expensive—until now.
The Anatomy of a Self-Checking System
LLM-only generation is costly and inconsistent. The solution: structured quality gates at every pipeline stage. How 12 of 20 checkers can be fully programmatic, 4 hybrid, and only 4 require full LLM calls.
Why Machines Don't Get Bored
Performance hit doesn't matter when machines are fast and getting faster. Monotony doesn't matter when the workers never get tired. The case for AI-driven quality gates and what changes when the cost of comprehensive checking drops to near-zero.
The Best Practices We Abandoned
Every engineering org has 'the list'—practices we all agree matter but somehow never get done consistently. Not because we don't know better, but because the system was too costly and difficult for humans to maintain.
The Complete Software Factory: Generative Domain Languages for Every Layer
My factory has evolved from a single-layer solution to a complete ecosystem. With Smithy for APIs, Capacitor for data, and Flux for UIs, I've eliminated boilerplate across the entire stack.
The Movie Night MVP
The plan was ready. The tickets were filed. I pressed 'go' on my software factory and sat down to watch a movie. What happened next was the culmination of my entire journey.
The Factory Awakens: From Vision to Plan
With a new hybrid approach in place, it was time to put the factory to the test. Could it take a simple vision and automatically generate a full-fledged development plan?
The Generator Epiphany: A Hybrid Approach
I was using the wrong tool for the job. The breakthrough came when I stopped asking creative AIs to do deterministic work and embraced the power of code generators.
The High Cost of an LLM Taskmaster
My attempt to automate code quality led to a surprising outcome: a system that was both expensive and inconsistent. I had built an army of AI checkers, and they were failing me.
The 'No-Code' Dream and the Manual Reality
I started as a skeptic of the 'no-code' AI revolution. I was right to be, but for the wrong reasons. My journey began in the frustrating, manual reality of prompting and patching.
Talking to the City
The ultimate evolution of the Software City is when you no longer have to look for answers—you can simply ask.
The Engineer's Life on the Streets
We've seen the city from above. Now we descend to street level to see how it transforms the daily life of a frontline engineer.
The Architect's View from the Sky
From a high altitude, the city tells a story that no diagram ever could. An architect finally sees the patterns of cost, risk, and decay across the entire system.
The Future: From Living Architecture to Sentient Systems
When our systems can understand and explain themselves, we unlock a new era of agency, resilience, and collaboration between humans and machines.
The Visual Payoff: Always-Accurate Diagrams
The living architecture model doesn't just answer questions; it can generate any visualization you need, on-demand, guaranteed to be a perfect reflection of reality.
A New Dimension: Welcome to the Software City
If flat maps are failing us, we need a better way to see. Let's stop drawing diagrams and start building worlds.
The Payoff: Asking Questions of Your Architecture
When your architecture is a living, queryable model, everyone in the organization is empowered to ask better questions and get real answers.
The Flat World of Architecture
We hand new engineers a flat, outdated map and wonder why they get lost. The problem isn't the mapmaker; it's the map.
How It Works: Deriving Architecture from Reality
Living architecture isn't magic. It's a pipeline that synthesizes truth from the signals your system is already emitting.
A Better Way: The Living Architecture
What if our architecture wasn't a static artifact doomed to obsolescence? What if it was a living, breathing model of our system, continuously updated and accessible to all?
Management is Flying Blind
The people responsible for making strategic decisions about the business are relying on architectural information that is scattered, outdated, and fundamentally untrustworthy.
The Mirage of Documentation
Our architectural knowledge is trapped in places that are hard to find, inaccessible to engineers, and unintelligible to the very tools we rely on.
The Acceleration Trap: Why Architecture Can't Keep Up
CI/CD automated our deployments. Now, AI is automating code creation. Our methods for understanding architecture are stuck in the past, and the cracks are starting to show.