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.
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.
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.
Context engineering became popular because AI exposed a communication problem. Intent engineering matters more because AI exposed a decision problem. Here's why product teams should focus on 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 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.
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: 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.
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.