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.
Product Judgment Used to Live in Your Head. That No Longer Scales.
The classic definition, that product judgment is a skill you earn by talking to hundreds of customers, was written before an AI could ship a feature in the time it takes to describe one. When building gets cheap, choosing gets expensive. And judgment in your head doesn't scale to agents.
The Bottleneck Moved
Product Circle's State of AI in Product 2026 asked 309 product leaders how AI changed their work. One of them wrote the whole story in two sentences: delivery of code got fast, delivery of good decisions became the new bottleneck. Building got cheap. Being wrong got expensive. Most teams haven't moved the work to match.
The Cost of Being Worth Using
AI helped 100,000 developers ship 30% more software. The number of people using it didn't move. Building got cheap. Being worth using didn't.
Every Tool Remembers What Was Asked
Feedback tools remember what customers asked for. AI-native product work needs something harder: a durable record of what the team decided, why, how agents should act on it, and how to know whether the intent held.
Judgment Debt
An AI agent found a three-year-old bug in PostHog's query engine overnight. It wasn't a bad decision. It was a good one that quietly stopped being true. I think most products are full of these, and mostly we don't look.
Where Judgment Lives
Reading State of AI Design 2026, the phrase that stayed with me was 'judgment preservation.' The report names the worry. It doesn't really say what to do about it.
The Artifact of Judgment
The best PMs are increasingly described as systems thinkers, not backlog managers. The framing is right. The usual conclusion — that this is deeply human work — assumes judgment compounds by staying tacit. It doesn't.
Context Rot Starts Upstream
Anthropic gave the runtime problem a name last fall: context rot. The runtime fix is curation. The upstream fix is intent, and most teams are still skipping that layer entirely.
Specs Written From Memory
The dangerous spec isn't the vague one. It's the good one — written without knowing what the product already decided.
Intent vs. Issues
Execution is becoming abundant. Intent is becoming the scarce input. On the layer above the issue.
Input Factories
Everyone is building agent factories. The leverage is upstream — in the inputs the agents read before the build. Most teams are scaling their ambiguity, faster.
Anthropic and OpenAI Are Pointing at the Same Gap in Agentic Coding
Anthropic names the trust gap. OpenAI expands the execution surface. Two different motions, one shared pressure: agentic coding is becoming operational, but the upstream definition of what should happen and how success is verified is still too thin.
Anthropic Just Made Specs Load-Bearing
Anthropic's new Outcomes feature turns success criteria into the agent's contract. That makes specs — not prompts — the artifact your team can't fake.
The Three-Person Team
Software teams have been coordination problems for so long we forgot they had to be. As AI absorbs the middle of the work, a different shape is starting to emerge.
Linear Says Issue Tracking Is Dead. They're Right About Half of It.
Linear's diagnosis is correct — issue tracking is over. But the fix isn't smarter tickets. It's the loop that should run before anything becomes a ticket at all.
Knowledge Over Code: What Karpathy's Token Shift Means for Product Teams
Karpathy now routes more tokens into knowledge than code. This isn't a quirk — it's the industry bottleneck shifting upstream. What it means for teams building with AI agents.
The Next Product Discipline Isn't Context Engineering. It's Intent Engineering.
Intent engineering vs context engineering: context engineering structures how an AI receives a task; intent engineering defines what the task is and how you'll know it worked. Why builders should engineer intent first.
Anthropic's 2026 Agentic Coding Trends Report: Summary & Key Findings
A summary of Anthropic's 2026 Agentic Coding Trends Report — the key findings, eight trends, and what the 60% usage vs 0–20% delegation gap means for product teams building with AI.
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 turn judgment under evidence into specs precise enough for AI agents to execute — and verify. 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.
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.
AI-Native Teams Need an Intent Layer
Brian Balfour describes the 'what' of AI-native product teams. Here's the 'how.'
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.
Design is More Than Code—But Where Do You Design the Problem?
Karri Saarinen is right that we're over-indexing on execution. But 'more consideration' won't fix it—culture is what you practice when nobody's enforcing it. The fix is infrastructure that makes intent grounded in evidence, versioned, and reviewable.
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.
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.