Closing the Loop

A team lost its PM and spread the job across engineers using Claude Code. Most of it worked. They got four good lists and nobody to put them in order.

Every company has a Dave: the person the whole operation runs through. At a startup it's usually the founder. Here's what handing over the calls actually takes.

A founder asked me which title takes over the coordination he can't keep doing. I read 111 job postings to find out. Every title gets a slice of the job.

A founder on Reddit hired strong people for every function and ended up spending half his week connecting one team to another. Here's what's actually left on his desk.

A Reddit thread on whether AI destroyed product craft drew 140 comments and one great fix: write the kill criterion down before the build. Nobody asked who's allowed to pull it.

He did something more useful than most people do when they ask this question. He wrote the list. Then fifty-three comments argued about junior versus senior, fractional versus part-time, and nobody looked at the work itself.

Your tech lead knows exactly what broke. What your tech lead might not know is that the same release carried the one feature you promised the board would be live by Thursday.

A client had built an automated intake system. Requests came in, got routed, got assigned to a named human being. I asked what the business rule was for one of the assignments. Nobody had an answer.

Every coordination tool is proud of the same thing: staying out of the way. That's not a flaw. It's also not the job that's actually missing.

Hired for one thing. Ended up running more of it, more than once. Here's the actual difference between closing a gap and taking one over.

The real first move isn't producing a plan. It's refusing to produce one before you actually know what you're planning against.

More agents doesn't mean more control — it just makes it easier to lose your own grip on what you're actually running. Here's how to tell if it's already happened.

The Operator Vacuum shows up the same way everywhere. You just have to know how to read the signals from outside, before they become a crisis.

You've tried the tool, the hire, the process, and doing it yourself. None of it worked. Here's the one job those fixes were never built to do — and what actually closes the gap.

The Founder Bottleneck: you can diagnose it perfectly and still not fix it, because it is not a discipline problem. It is a seating problem.

Process doesn't create ownership. It just makes the absence of it more organized. The Process Trap, and what actually closes the gap.

Hiring a project manager fixes tracking. It doesn't fix ownership — and those are different jobs. The Hire Trap, and what actually closes the gap.

The symptoms are always about people. Low buy-in. Dev is slow. Nobody follows through. Almost none of it is the actual diagnosis.

Last week's piece named the Operator Vacuum. This week: what's supposed to fill it, and why most orgs have someone doing the job without anyone having designed the role.

You've tried the obvious fixes. Same symptoms. That's because the problem isn't delivery. It's a structural gap nobody owns.

You hired for outcomes. But the real value — the part that makes outcomes stick — happens in the 80% before any solution takes shape. Here's what leaders miss, and what readiness actually looks like.

There are two leadership modes when you bring in a fractional operator: task-direction and goal-direction. Most leaders default to the first one. The engagement starts working when they switch to the second.

The JD describes the problem you can see. The job that actually needs doing is usually one layer underneath it. A pattern I keep running into — across tech, startups, and commercial forestry.

A backlog is not a mental model. Tickets are not understanding. In an AI-generated project, the gap between access and internalization opens fast.

The generation effect is real — and AI just made it very easy to skip the step that builds judgment. Here's what that costs you, and when you'll notice.

AI closed the documentation gap most product teams spend years trying to close. But it revealed a different one — the gap between having information and having internalized understanding. That's where leadership actually lives.

The old sequence — understand deeply, then design, then build — existed because building was expensive. That constraint is gone. The question is whether your process knows it yet.

AI is the hub of my workday now. I'm all in. And that's exactly why I'm more convinced than ever that the fundamentals are non-negotiable — because without them, you're just exploring everything and building nothing.

We built a perfect, distraction-free onboarding flow—and it stalled out. Here is why breaking the golden rule of CRO and giving users an escape hatch resulted in a 300% conversion bump.

A fully loaded roadmap doesn't guarantee compounding value. Learn how to maintain clarity of mind, respect your foundational strategy, and catch product drift before it eats your runway.

You've got scope. Now you need a sequence. But if your roadmap looks like a detailed 6-month delivery schedule, it's a fiction. Learn why the only question that matters at 0→1 isn't "what do we ship next?"—it's "what do we need to learn next?"

Most founders treat an MVP like a stripped-down version of their final vision. That is how you build an inadequate product that takes too long. To ship something that matters, you need to define exactly one core flow—and ruthlessly cut everything that doesn't block it.

Refusing to choose is far more dangerous than moving slowly. If you haven't explicitly ranked your project sliders, the universe will rank them for you.

You’ve done the thinking. You have a thesis. The model might work. So the urge to build kicks in. But this is the moment founders lose objectivity — when sunk cost, identity, and optimism start distorting signals. Without clear failure criteria, MVPs expand, evidence gets reinterpreted, and money burns while confidence stays high. The real risk isn’t quitting too early. It’s continuing too long.

Early traction answers one question well: does anyone care? It answers a much harder one very poorly: does this work as a business? This piece examines why teams defer unit economics, how early momentum masks structural risk, and why waiting to confront viability is one of the most expensive mistakes a startup can make.

Early customer conversations can be useful — but they’re often mistaken for validation. When anecdotes replace evidence, teams move faster with more confidence, not less risk. This post explains why that’s dangerous, how it quietly distorts early product decisions, and what “validation” actually has to do at this stage.

Early-stage teams often mistake motion for clarity. When a product thesis isn’t defensible, every downstream decision becomes noisier, slower, and more expensive than it needs to be.

New platforms don't fix broken delivery — they organize the dysfunction. The Tool Trap and what's actually behind it.

The real job of a product manager isn't shipping features—it's detective work. Here's the first-principles thinking that cuts through noise and actually delivers results.

When AI works, it's helpful. When it doesn't, it's a frustrating time sink. Here's my pragmatic take—and a 5-step filter to decide if it belongs in your product work.

Great execution habits aren’t enough if strategy keeps flickering. When stakeholders change direction based on external signals without grounding the tradeoffs, teams pay the price in rework, misalignment, and morale. Here’s how to make strategic shifts with real accountability.

Teams don’t fail because they can't execute — they fail when goals aren’t visible and aligned week to week. The “execution flywheel” is a lightweight weekly cadence that makes goals transparent, builds trust, and sustains momentum.

Hire slow, fire fast’ isn’t about being ruthless — it’s about protecting your team. Rushed hires create long-tail damage, and delayed exits quietly drain morale. This piece breaks down what the mantra actually means in practice, and how strong leaders use it to build durable, high-performing teams.