The Builder's Log
Design operations, engineering culture, and the future of building products.
Get the Builder's Log
Join product engineers and design operations leaders getting signal on how to build better software.
The Backlog Is Dead. Now What?
Issue tracking is dying because AI collapsed the cost of fixing. But the harder question — what to build and why — just got louder. The backlog's successor isn't nothing. It's structured intent.
What Is Intent Engineering? The Discipline That Replaced Prompt Engineering
Intent engineering is how product teams specify what to build precisely enough for AI agents to execute without guessing. Here's the complete guide: what it is, why it matters, and how to practice it.
From Static Docs to Living Specs
A spec that doesn't change after it's written is a spec that's already wrong. Here's how we made specs react to evidence, survive review, and grade their own implementation.
Prompting Split Into 4 Skills — Only One of Them Scales
The industry is noticing that 'prompting' has fragmented into multiple disciplines. That's not a sign the skill is evolving. It's a sign it's the wrong abstraction.
YC Is Right About the Problem. The Name Will Kill the Solution.
Y Combinator's Spring 2026 RFS nails the problem: teams need help figuring out what to build. But calling it 'Cursor for PMs' mis-categorizes a stack problem as a persona tool.
Why Your AI Prompts Fail: The Missing Layer Between Intent and Output
Your prompts aren't the problem. What's missing is everything that should exist before you write them.
Direct Design Needs an Intent Layer
Direct Design removes the handoff between design and code. But someone still has to know what to build. That's the harder problem—and it was always upstream.
We Asked Gemini to Compare Journey Tools. It Called Us a Gen 3 Disruptor.
When Google's AI compared the journey management landscape in 2026, it split the market into three generations. Here's what it said—and what it means.
Journey Management Lost. Journey Context Won.
Journey management tools are dying because building got faster than planning. But the solution isn't to abandon journeys—it's to make them executable. The teams that win will be the ones whose journeys generate specs, not slide decks.
Why Jira Tickets Fail AI Agents
You gave your AI agent access to Jira. It read every ticket. It still built the wrong thing. Here's why.
The Sparse Bits Between
Andrej Karpathy says the programmer's contribution is now 'sparse and between.' That's not a problem—it's a signal. The bits that remain are the ones that matter most.
AI Agents Don't Close the Gap
Speed has never been the thing holding product teams back. The real bottleneck isn't code generation—it's definition.
The Double Diamond is Cracking
The Double Diamond assumes execution is expensive. AI just made it instant. The framework isn't wrong—it's built for a world that no longer exists.
The Future is Journey Execution, not Journey Management
Journey maps are failing because they are passive. In an AI-native world, the map shouldn't just be a dashboard—it must be the executable specification that drives the product.
AI-Native Teams Need an Intent Layer
Brian Balfour describes the 'what' of AI-native product teams. Here's the 'how.'
From Journey Maps to Intent Layer
The Journey Map is no longer the output. It is the input. Pathmode creates structured Intent Specs from user friction.
The Vibe Coding Hangover
Vibe coding feels like a superpower—until the second developer joins. Here's what happens when AI-generated codebases meet real teams, and why intent is the cure.
The Intent Layer
Agentic AI doesn't need prompts. It needs intent—structured, contextual, traceable to user friction. Here's the full framework for the missing layer in the software stack.
Why We Built the Intent Layer
The industry is experiencing 'The Vibe Coding Hangover.' We built Pathmode to be the cure.
Your Best Work is Stuck in a PDF
You validated the insight. You mapped the journey. Everyone nodded. Then engineering shipped something else entirely. The problem isn't your research. It's where it lives.
Design is More Than Code—But Where Do You Design the Problem?
Karri Saarinen is right: we are over-indexing on execution. But the answer isn't just 'more consideration.' It's building infrastructure that makes problem definition a first-class artifact.
Your Title is a Lens, Not a Lane
Designers don't just make Figma files. PMs don't just write specs. As AI collapses the implementation layer, what remains is judgment—and the ability to ship.
The Spec is Becoming the Product
When agents execute directly from specs, the spec is no longer a handoff document. It's the highest-leverage artifact your team produces.
The Disappearing Middle of Software Work
As AI agents handle implementation, the craft of software shifts to the ends: defining intent and verifying outcomes. The teams that master both will build the best products.
Your Journey Map Is Lying to You
Journey maps have a dirty secret: they're one-way streets. Insights flow in, but outcomes never flow back. Here's how we're building a learning system, not just a planning tool.
The Case Against Research Repositories
Research repositories were built to store insights. But storage is not the goal; shipping is. To build better products, we must move from passive libraries to active design engines.
Looking for step-by-step guides? Check out the Intent Playbook — executable blueprints for product teams.