Why Product Teams Fight? And How to Fix It?
Unpacking the product manager’s heartbreak and the invisible forces that cause it.
We had the roadmap.
We had buy-in.
We had a cross-functional team firing on all cylinders.
Six weeks later, we were demoing a feature we bled for.
Our eyes were baggy.
Our Slack thread was 300 messages deep.
We thought we nailed it.
Until the leadership leaned back in her chair and said, “This doesn’t solve a real problem.”
No metric moved.
The launch got pulled.
And just like that, a win turned into a ghost.
What happened? Not scope creep. Not tech debt. Not poor PMF.
We were just working at the wrong level.
There’s an invisible force behind most team conflicts in product orgs and it’s not bad code, poor specs, or even unclear goals.
It’s something deeper.
Subtler.
A clash of levels.
Inspired by Shreyas Doshi’s framework, this article unpacks how product teams operate across three mental altitudes:
Execution,
Impact, and
Optics
and how unconscious fixations at these levels quietly break alignment, kill morale, and lead to “WTF just happened?” moments after reviews.
This isn’t a cheerleading article for frameworks.
This is a post-mortem for what goes wrong in the trenches and how to spot it early before you ship a ghost product no one asked for.
Poll: What's Your Default Operating Level
(Want the quick take? Jump to TL;DR →)
The 3 Levels of Product Work - Explained (With Emotional Damage)
Let’s unpack these levels through a lens you’ll feel in your bones.
1. Execution Level: “Let’s just ship the damn thing.”
This is where most ICs live.
It’s Jira boards, tickets, mocks, timelines, QA, and scope cuts. At this level, the questions are:
Is the PRD clear?
Is the team unblocked?
Are we on track?
You feel good when the feature ships.
You feel great when you overcome chaos and still hit the deadline.
The trap?
You start to believe that shipping = success.
But it’s not. Shipping is just the middle of the story.
Think: Launching a well-designed onboarding experience... that no user ever enters because you forgot to update the app store screenshots. Classic execution-only focus.
2. Impact Level: “Does this move the needle?”
This is the altitude most PMs aim for and where leadership expects you to operate.
Here, the focus is:
Are we solving a top user problem?
Will this change behavior?
What metric should move? How will we measure it?
The work isn’t done at launch. It’s done when users change, and numbers shift.
The trap?
You dismiss the team’s effort when results lag. You get too obsessed with numbers and forget how hard it is to build.
Think: Launching a new referral feature and declaring it a failure after one week because referrals didn’t spike even though awareness hadn’t ramped and bugs were being fixed.
3. Optics Level: “How will this be perceived?”
This level is often misunderstood or looked down upon. But it’s critical.
Optics isn’t just PR. It’s:
The story you tell your execs
The confidence your sales team gets
The trust you build with your users
At this level, you’re asking:
How will this land in the board meeting?
Are we aligning with strategic narratives?
Can we package this as a strategic win?
The trap?
You over-optimize for perception. You build decks, not value. You launch press releases no one clicks through.
Think: Launching a complex AI feature just to say you're "AI-first," even though your users still struggle with basics.
Case Study: Slack Threads - A Level Mismatch in the Wild
Let’s walk through Slack’s infamous Threads launch - not to critique it, but to diagnose what happens when different levels of product thinking aren’t aligned.
In 2017, Slack rolled out Threads after years of internal discussion and repeated user requests.
At first glance, it looked like a win:
Execution Level: Nailed
Threads were technically sound.
You could reply in-line to any message, keeping the main channel clean.
Creating a thread was intuitive: click, type, done.
The UI was polished, with thoughtful rollups and notification cues.
If you were a PM or engineer on that team, you probably felt proud.
You shipped what you promised. You built something clean. From an execution lens, this was textbook.
But...
Impact Level: Shaky
Behavior didn’t change. Users still replied in the main channel.
Metrics didn’t improve for engagement or retention.
Many power users reported they actively avoided threads because they broke conversational flow.
Why?
Because the problem Threads tried to solve - "channel chaos" - wasn’t felt universally.
Many users had already adapted to the chaos and found comfort in context-rich, linear discussions.
Even worse, Threads lacked feature parity with regular messages:
No image uploads
No slash commands
No code snippet support
In a tool where teams frequently share screenshots, snippets, and commands, this limitation made Threads feel like a second-class citizen.
Optics Level: Confusing
The announcement was crisp, but internally, users struggled.
The "All Threads" panel reversed scroll behavior (newest at top), breaking mental models from main channels.
Thread replies didn’t surface visibly in the main feed, so ongoing conversations felt hidden.
Slack reused UI from “All Unreads”, leading to odd design inconsistencies.
From a perception lens, the launch lacked narrative clarity. It didn’t answer:
Why this? Why now?
What pain does this remove for most teams?
How should we expect to work differently now?
Summary:
Slack Threads didn’t fail because it was poorly built. It failed because it was perfectly built at the wrong level.
Execution was celebrated internally.
Impact was misjudged - users didn’t change.
Optics were mismatched - the design, defaults, and behaviors felt out of sync with how people used Slack.
This isn’t a critique of the team.
It’s a masterclass in how products must align across all three levels to land.
The Real Problem: Fixation, Not Focus
Now here’s the kicker: it’s not bad to focus on a level.
You need to focus on execution to ship.
You must think about the impact to create value.
You should care about optics to earn trust and runway.
But the real bug is:
When we become fixated on a level, without realizing it.
And worse, when we argue without naming the level mismatch.
Act 2: The Meeting Where No One Said What They Meant
Picture this.
You’re on a google meeting or a zoom meeting room.
The team is debating whether a feature should have gone live.
The PM defends it hard: “We executed flawlessly. This was a beast of a build.”
The VP says: “But it didn’t hit any north stars. It was a miss.”
The designer whispers: “We didn’t even tell the story well… marketing didn’t know what to do with it.”
Three people.
Three truths.
All valid.
All fighting the wrong fight.
Because they’re not actually disagreeing on the facts - They’re operating from different levels.
The Matrix of Mismatches (and How They Break Teams)
Here’s how this plays out in your team, every week:
Every one of these ends in the same thing:
Confusion.
Frustration.
Misinterpretation.
And yet the root issue remains unnamed.
So… Who Fixes This?
You do.
As the product leader, you must operate at all three levels—even if your team doesn’t.
says it best:“You can’t expect everyone to operate at every level. But leaders must be fluent across all.”
So, how do you lead here?
Act 3: The 7 Rules for Multilevel Product Thinking
1. Know Your Default
Are you an execution PM? A comms PM? A metrics PM? Know where you default — and when you need to stretch.
2. Name All 3 Levels at Project Kickoff
Ask:
Execution: What are we building?
Impact: What’s the behavior change?
Optics: How will we communicate this?
3. Spot Fixations Early
If a stakeholder says:
“We worked so hard on this.”
...they’re probably stuck in Execution.
If they say:
“Why didn’t this change churn?”
...they’re in Impact.
Recognize it. Name it. Adjust.
4. Practice Altitude Switching in Meetings
Learn to say:
“Zooming out for a second...”
“Back to the execution...”
“Let’s consider how this will be received...”
Language creates altitude awareness.
5. Map Reviews to Levels
Weekly standups? → Execution.
Mid-project check-in? → Impact.
Final review? → Optics + Impact.
Don’t show up to a PR review with bug lists.
6. Narrate Transitions Between Levels
Say things like:
“Zooming out to impact for a second…”
“Let’s drop to execution for this blocker.”
“Here’s how this might land with the VP…”
Language shifts minds.
7. Coach Your Team on the Framework
Make it explicit. Teach your designers, devs, EMs.
Show them how to recognize level mismatches and resolve them before they spiral. Use simple phrases like:
“This feels like a level mismatch,” can de-escalate confusion.
Bonus: The “Oh Shit, We’re Fixated” Checklist
If you're hearing any of these...
“We worked so hard on this. Why isn’t it appreciated?”
“This doesn’t move the needle.”
“Leadership didn’t even see what we built.”
“Why didn’t marketing support this?”
…pause.
You’re likely in a level conflict.
Act 4: The Launch That Landed
Let’s go back to our story.
That failed sync feature?
We re-scoped it.
Re-messaged it.
Aligned it with a bigger narrative on financial visibility.
Split the work across two milestones.
We shipped less. But with clarity.
The next review? Green light.
Marketing was in. Support was prepped.
The launch? Quietly successful.
Retention nudged upward. Perception ticked positively.
All because we stopped fighting at the wrong level and aligned on the right one.
Owner Energy, Builder Discipline, PM Maturity
When you genuinely care about making an impact—not just shipping on time or looking smart, you automatically start caring about strategy.
Because the more you care about strategy, the more you respect execution.
You stop blaming devs. You start fixing real things.
You stop over-optimizing ROI and start minimizing opportunity cost.
That’s how great PMs are built:
They don't just shift levels.
They earn clarity through scars.
And they choose which problems are worth living with.
TL;DR
Most product dysfunction doesn’t stem from poor specs, weak engineering, or misaligned goals. It stems from people unknowingly operating at different altitudes.
These levels are:
Execution: Building the thing right
Impact: Building the right thing
Optics: Telling the right story about it
When teams fixate on one level and miss the others, they launch features that go nowhere.
This essay breaks down each level, brings it to life with real-world examples (like Slack Threads), and offers 7 practical rules to lead across them.