Context Clues

Product strategy

Parkinson's Law of Triviality

A team's attention tends to run in inverse proportion to what's at stake. The small calls get the debate, and the big ones pass with little discussion and less written down.

Product strategy

Disagree and Commit

Disagree and commit is a promise to back a decision you argued against. It works only when the disagreement is kept somewhere, so the team knows what it bet against and when to look again.

Product strategy

Escalation of Commitment

When a decision starts failing, the person who made it tends to invest more. What helps is changing what admitting the miss costs, before anyone has to.

Product strategy

Resulting

A good outcome doesn't prove a good decision, and a bad one doesn't prove a bad decision. Grading calls by results alone teaches teams to abandon what works and repeat what got lucky.

Product strategy

Tripwire

A risk is easy to acknowledge and easy to ignore. A tripwire decides in advance which evidence will force the plan to react.

Product strategy

Premortem

The plan passed review. Six weeks later, it failed. A premortem asks what most likely went wrong before execution begins.

Product strategy

The Outside View

A detailed plan explains why this project should work. The outside view asks what happened the last several times your team tried something similar.

Product strategy

Stop Condition

An agent that stops too early wastes a run. An agent that was never told where to stop can spend a promise someone else made.

Product strategy

Blast Radius

A small action can carry a large blast radius when customers, workflows, or dependent decisions inherit its effects.

Product strategy

Reversible by Whom?

A decision can be reversible for the company and costly for everyone who acted on it. The real question is who pays when it is undone.

Product strategy

One-Way Doors

Most decisions are two-way doors, and agents are right to walk through them fast. The trouble is the few that aren't, and the fact that reversibility depends on more than the decision itself.

Product strategy

Signal vs. Noise

The worst automated system isn't one that misses problems. It's one that flags so many non-problems that you stop listening.

Product strategy

Honest Uncertainty

The worst output from an automated system isn't a wrong answer. It's a confident wrong answer that looks right.

Product strategy

The Certainty Tax

Every point of confidence gained is a cost paid somewhere: slower response, more tokens burned, longer deliberation. The question isn't whether to pay it. It's when.

Product strategy

Approval Theater

Signing off on something you didn't look at is not approval. It's permission to do whatever you were going to do anyway.

Product strategy

Trusting a scheduled agent by watching what it does over time means it was already doing that unsupervised the whole time you were watching. Something has to check its work before the first run, not after enough of them.

Product strategy

Conflict Detection

A new ticket can mention the same decision, the same system, the same words as an old commitment, whether it's carrying that decision out or reversing it. Similarity alone can't tell you which.

Product strategy

Decision Debt

Teams track tasks long after they stop tracking the assumptions behind them. That is how old decisions become decision debt.

Product strategy

Current State

A team can be surrounded by status updates and still be unable to answer a simple question: what is actually true right now? The difference is not more reporting. It is a current state.

Product strategy

Standing Brief

An interrupt-only system has to be stingy with interruptions or nobody listens to it. That's a deliberate design choice, not a flaw, but it means real, true information routinely doesn't clear the bar to get surfaced at all. Something has to carry the rest.

Product strategy

Coase Theorem

A support lead says the real problem is sales overpromising. The sales lead says the real problem is support refusing to commit to real deadlines. Both descriptions are accurate. Assigning blame between them turns out to be the wrong question entirely, and there's a rigorous reason why.

Product strategy

Conway's Law

Three engineers each own one service, and the API between them ends up with three separate ways to represent the same customer, because each engineer built the version they understood best. Nobody sat down and designed that inconsistency on purpose. The team boundary drew it before a line of code existed.

Product strategy

Nerve Center

A PM says she can't hand a decision to someone else because no one else has the full context. It sounds like control. Transferring everything she's picked up from a dozen scattered conversations this week would take about as long as making the call herself, and that's the actual reason it doesn't get handed off.

Product strategy

IKEA Effect

A team keeps defending a homegrown internal script that breaks monthly, over a purpose-built tool that does the same job without breaking. Ask why, and the real answer is rarely about which one actually works better. It's that one of the two, they built with their own hands.

Product strategy

Interrater Reliability

A pipeline report says 40% of deals sit in 'proposal' stage. One rep only marks a deal 'proposal' once a signed statement of work goes out. Another marks it the moment a number comes up on a call. Both fields are filled in correctly. The 40% doesn't mean what it looks like it means.

Product strategy

Revenue Recognition

A $120,000 annual contract is paid in full on January 3rd. The revenue dashboard shows a huge January and a dead February. The company delivered the same service to the same customers in both months. The swing lived entirely in when the cash happened to arrive, not in anything the business actually did.

Product strategy

Near-Decomposability

Every domain report looks clean: strategy is on track, sales is fine, support tickets are down. A customer churned the week after a pricing change, and the reason lived entirely in the gap between two reports that were each individually correct. Nobody inside either domain was ever going to see it.

Product strategy

Situation Awareness

A weekly brief lists twelve tickets shipped, three deals closed, and a competitor's price change. Every line is accurate. The reader finishes it and still can't say whether the week was good or bad, or what it means for the one coming. A complete list of facts and an understanding of where things stand were never the same document.

Product strategy

Costly Signal

Two competing products both claim the easiest onboarding in the category, on the same landing page template, in the same words. A prospect reading both pages learns nothing about which one is actually true, because both companies could make that exact claim whether or not it holds.

Product strategy

Ecological Fallacy

A team's power-user persona says integrations are the top priority. A real power user on the call says integrations matter least to them, speed is what they actually want. Neither the persona nor the customer is wrong. A fact about the group and a fact about a member of it were never the same kind of claim.

Product strategy

Soundness

A quarterly plan names 'reduce onboarding time' as a top goal. Nobody on the team can point to a single shipped thing under it. Meanwhile a team has been heads-down all quarter on something the plan never mentions. Both facts can be true on the same day, in the same company, without anyone lying.

Product strategy

State Estimate

A product agent looks at a backlog with 183 items and says the roadmap is full. Then an engineer points out that half of it is abandoned, three shipped already, and the one thing the customer is waiting on changed shape in review. The agent was not dumb. It was looking at measurements and mistaking them for state.

Product strategy

Revealed Preference

A user tells you price is the top blocker, then upgrades the week a new feature ships, not the week a discount runs. Neither answer is wrong. One was a claim with nothing else on the table to weigh it against. The other was a choice made while a cheaper option sat right there, unchosen.

Product strategy

Throughput

34 points this sprint, 41 the one before, 29 before that. The number moves every two weeks and nobody can say whether the team is actually getting faster, because points measure a guess made at the start, not anything that happened after.

Product strategy

Drift

A competitor's pricing page said 'no setup fees' for two years. Three weeks ago a fee quietly appeared under implementation, everything else on the page untouched. The page changed. Nobody caught what it meant.

AI coding agents

Void or Voidable

Forty defaults an agent picked over two quarters, and nobody chose any of them. Not every one needs the same treatment. The distinction that tells you which comes from contract law, not engineering.

Context engineering

Supersession

A stale decision in the context window is worse than no decision, because it gives the agent confidence in the wrong constraint.

Product strategy

Entity Resolution

A team's decision gets one name in a Slack thread, another in the Linear ticket, and a third in the customer call that prompted it. To a system reading all three, that's three unrelated records unless something links them.

Context engineering

Product Context Layer

Product management writing describes the job in different words, but it keeps landing on the same fact: someone has to hold the why and connect it to whoever builds next. A product context layer is what happens when that job stops living only in one person's head.

Product strategy

Proactive Brief

A decision you recorded but were never reminded of at the right moment is one you made twice: once on purpose, once by accident. Proactive Brief is built to reach you before you think to ask.

Product strategy

Two Answers

Give a coding agent the same task twice and you get two different, plausible answers that disagree with each other. The fix is not a better model. It is a shared record of what the team already decided.

Product strategy

Greek Fire

For more than five centuries, Greek Fire's enemies could barely counter it. Then it vanished, not defeated but forgotten, because the recipe lived only in a few heads. Your systems can be lost the same way.

Product strategy

Sixteen Agents

You talk to Brief as one thing. Behind it, sixteen agents each own one part of the product picture and keep it current from your existing tools. Here is the whole team and what each one does.

Product strategy

Stigmergy

A colony coordinates with no plan and no direct messages, only the traces each worker leaves for the next. Software teams and their agents run on the same mechanism, and it works only as well as the traces do.

Product strategy

Working Memory

An agent has a large, capable working memory and, on its own, no long-term memory of your team. Bigger context windows and better retrieval improve the first and do nothing for the second.

Product strategy

Overruled Precedent

You follow the precedent set by the code around you. Almost every time it is right. This is about the one change where it is wrong, and why your agent cannot see it coming.

Product strategy

Seven Seconds

Every person leaves. Every line gets rewritten. What makes it the same company ten years on is not the people or the code. It is the memory of why, and that is the one thing nobody keeps.

Product strategy

Why coding agents ignore your rules

You wrote the rule down. The agent broke it anyway. It is not being defiant, and a longer rules file will not fix it. Here is what actually will.

Product strategy

Context, compared

Nine ways teams give coding agents context, scored against what independent research says a real solution has to do. Only one shape passes all five tests.

Product strategy

Path dependence

A wrong default caught on day one is a one-line fix. Caught on day two hundred, after everything has been built on top of it, it is a migration.

Product strategy

Goodhart's law

Your test suite was evidence that the code worked. Then the agent made passing it the goal, and evidence became the thing being manufactured.

Product strategy

Gell-Mann amnesia

The agent did not get more reliable on the second page. You lost the ability to catch it, and mistook that for the agent being right.

Product strategy

Tacit knowledge

The reason your product context never reaches the agent is not that no one wrote it down. It is that the people who hold it know more than they can tell.

Product strategy

Principal and agent

You did not hire an employee. You entered the oldest studied problem in delegation, and the AI solved the half everyone feared while leaving the half no one watched.

Product strategy

The default answer

I expected three runs of one model to diverge. They agreed almost perfectly, and the agreement turned out to be the more unsettling part.

Product strategy

The whole product

The first team proves your product is useful. The next team proves it is whole.

Product strategy

Chesterton's fence

Not seeing a reason is not the same as there being no reason, and the gap between those two is where most expensive mistakes live.

Product strategy

Survivorship bias

The most important data point is almost always the one that is missing, and it is missing for the exact reason that makes it matter.

Product strategy

Four risks

The question that dominated software for twenty years, can we build it, is the one your agent just answered. It was never the only question. It was one of four.

Product strategy

Common knowledge

The child who said the emperor was naked told nobody anything they did not already know. That is the whole point, and it is the most useful distinction I know.

AI coding agents

Ghost decisions

The agent did not make a mistake. It made a decision, one of thousands, that no one asked it to make and no one will remember, because no one made it.

Product strategy

Productivity is not value

Your engineers say AI made them faster. Your board wants to know where that shows up in the business. The honest answer is that you cannot see it, and the reason is not your dashboard.

AI coding agents

Your CLAUDE.md is a junk drawer: a migration playbook

There is no correct length for a flat context file. Trim it and the agent misses the decision it needed; fill it and the decision it needed is buried on line 2,830. The fix is not a better file.

AI coding agents

The firehose problem: your coding agent has all your permissions

Least privilege for a coding agent was never a narrower scope on the firehose. It is not handing the agent the firehose at all.

Context engineering

Loop engineering forgot the loop needs a memory

You can automate the loop. You can't automate the context the loop needs each time around, and the moment you removed yourself from every iteration, you removed the one thing that used to supply it.

AI coding agents

You can't review your way out of a context problem

AI made writing code cheap and shipping it expensive. Everyone is scaling review to close the gap. But review inspects the output when the defect was in the input, and inspection has never been how you build quality in.

Product strategy

Everyone Is a Builder Now

Product management is dead. Design is dead. Engineering is dead. Except none of that is true: the three jobs are collapsing into one. Meet the product builder, and the two shapes of the role we're hiring for.

AI coding agents

Decision capture for AI coding agents: a write-path problem, not a discipline problem

Your team will not be more disciplined about documenting decisions, and it is not a character flaw. It is economics. Capture has to cost almost nothing, which means it cannot be a separate act.

Context engineering

The context window is not the bottleneck. Relevance is.

The seductive idea is that million-token windows let you stop curating and just hand the agent everything. That gets worse, not better, as the window grows, because the real job was never fitting the context. It was selecting it.

Product strategy

On Taste

Tech is speedrunning 250 years of philosophy to teach machines taste. Here is the history they skipped, and why the corpus approach is doomed while a context graph might not be.

Context engineering

Your agent stores beliefs, not decisions

Your agent keeps overruling decisions your team already made. CLAUDE.md, raw integrations, and agent memory.md all fail for one provable reason, and it points to the seven properties any store of decisions must have.

Context engineering

Context engineering, explained

Context engineering is the new defining skill for building with AI agents. It's the discipline of curating everything a model sees, not just the prompt, and keeping that context current.

AI coding agents

Why spec-driven development isn't enough

Spec-driven development works, but a spec is a snapshot. The decisions that make it stale happen in Slack and on calls, and the agent keeps building the old plan.

AI coding agents

Why your engineers got coding agents and shipping didn't speed up

Your engineers are writing more code, but shipping has not sped up because the bottleneck moved to review, coordination, and deciding what to build.

AI coding agents

46% to 95%: What a Controlled Benchmark Reveals About AI Coding Agents and Product Context

We ran a controlled benchmark: eight tasks, forty-one decision points, forty-eight runs. AI coding agents without product context followed team decisions 46% of the time. With context, 95%. The gap is about information access, not model capability.

AI coding agents

Why ACP Changes the Way We Build with Agents

MCP operates on a client-server model with centralized intelligence. ACP treats agents as first-class citizens in a network, enabling genuine specialization, composable pipelines, and context as a first-class concern.

AI coding agents

AI 'Brain Fry' Is Real, and the Fix Isn't Less AI. It's Better Conversations With It

New research named the exhaustion you feel after reviewing AI code: brain fry. The fix isn't less AI; it's reviewing decisions, not diffs.

Context engineering

Multi-Agent AI Pipelines: Solving Context Loss Between AI Agents

Multi-agent workflows amplify the telephone game. The teams that build shared decision infrastructure first will ship faster with fewer regressions.

Context engineering

You Already Have a Product Graph. You Just Can't Query It.

Your team's product knowledge exists as an interconnected graph of decisions, tradeoffs, and customer signals. You just can't query it.

AI coding agents

Stop Debugging Code. Start Debugging Decisions.

Your agent shipped perfect code that does the wrong thing. The bug isn't in the implementation—it's in the product decision that was never made clear.

Product strategy

I Almost Built the Wrong Thing

I almost built Brief as a meeting bot that simulated product reviews. That would have copied the surface instead of solving the real problem: context infrastructure.

Product strategy

Why Do Tools for Product Managers Suck?

PM tools fail because they track the how and ignore the why. Without decision infrastructure, they become ledgers instead of strategic partners.

AI coding agents

The AI Only Gets You to 80% Complaint is Backwards

The complaint that AI only gets you to 80% misses the point. Agents can handle the finish work when you give them context. The real bottleneck is product sense.

Product strategy

The Future is the Product Developer

The boundary between product, engineering, and design is dissolving. AI coding agents and modern tooling enable product developers to own initiatives end-to-end, from insight to production. This is the new default builder.

Product strategy

Quarterly Planning is Dead

Quarterly planning worked when shipping a meaningful change took months. That world is gone. AI coding agents ship features while you're still grooming the backlog. It's time to replace quarterly batches with continuous decisions.

AI coding agents

You Just Became a Manager of AI Agents (and the Communication Chain is Broken)

AI agents fail at the seams. Rebuild the communication chain with explicit decisions, tight briefs, and fast feedback.

Product strategy

Remote Killed the Shoulder Tap. AI is Breaking It Again.

Product work used to ride on tiny, informal moments. Remote work erased that layer. Now AI coding agents are shipping features before PMs can add context—and the rework is piling up.

Context engineering

Context Windows Will Keep Growing (But That Won't Solve the Problem)

Larger context windows just create more noise. AI agents need directed attention, not infinite context, to build coherent products.

AI coding agents

Are You Treating Your Coding Agent Like a Mushroom?

Coding agents crush refactors but flail on new features when they’re kept in the dark about users, priorities, and constraints.

Product strategy

Product Management Has a Velocity Problem

Hands-on keyboards stopped being the bottleneck. Product judgment, taste, and decision-speed are the new constraints, and AI can help close the gap.

Product strategy

What PMs Actually Need (vs. What We Keep Building for Them)

Product managers are drowning in metrics and workflows, but what they really need is clarity, better tools for expressing ideas, and alignment with engineering and company decision-making.

Context engineering

The Hidden Cost of Context-less AI Development

Why missing business context wastes time and ships elegant solutions to the wrong problems.

AI coding agents

Building AI that understands product impact, not just code quality

How to pair AI code generation with business context so teams ship fast and stay aligned with product strategy.

Context engineering

That code you rejected 3 times? Your AI just suggested it again.

Why AI coding assistants keep suggesting the same wrong solutions, and how context memory solves the endless repeat cycle.