← Build log

The TPM's Secret Weapon: Why Problem Decomposition Beats "AI, Fix This"

December 2024

One of the most basic things you learn, whether it’s in seventh grade algebra or software engineering, is how to break things down into their most simple pieces, especially when you’re trying to debug something. You started learning this with math when you begin to isolate different equations and pieces of equations to understand what could be going wrong. It’s the same process for building software.

Engineers are trained in this, but in a way, technical product managers are too. We just don’t do it at the code level, generally speaking. Some of us have dabbled in it, or if you’re like me, you have done some software engineering, so you understand some of those principles. But this is one of the key gaps between what TPMs do today and what engineers do. They understand how to distill things and use techniques that break problems into solvable parts until you’ve found the root cause of something.

This sounds obvious, but when you’re trying to build applications as a solo builder, these principles become really important when you’re working with AI.

TLDR - What You’ll Gain:

  • The systematic problem decomposition approach that engineers use (and TPMs need)
  • Why “AI, fix this” leads to technical debt and multiple conflicting solutions
  • How to leverage your TPM puzzle-solving brain with AI without annoying engineers
  • Bottom Line Value: Problem decomposition is your competitive advantage as a technical solo builder.

The AI Shortcut Trap

What happens is if you ask AI to solve a problem, sometimes it will take the shortest path, which often is crappy code. It will create alternative ways of doing things that you’re already doing elsewhere, creating multiple versions of the same solution that then become really convoluted over time and nearly impossible to unwind without completely refactoring the whole thing.

I will say that with AI, refactoring is so much easier and so much faster, but it’s still fraught with danger. The better thing to do is really practice and learn how to break problems down into their smallest possible parts. This is the key, and in this use case with VoiceCatcher’s pause detection, this is what we did to finally solve this really seemingly simple problem.

The TPM Advantage (And Curse)

Here’s where it gets interesting for technical product managers. When you get into this with engineers, a lot of times the phrase “stay in your lane” is really appropriate. If a product manager starts suggesting technical solutions (which I have done) or trying to identify the technical problem, it gets really annoying really quickly. And engineers will let you know. And rightly so. They should be letting you know that it is not your job to solve the engineering problem.

However, working with AI, you get to do a little bit of both and you can use your own power of reasoning to ask it to try different things and it never runs out of patience.

This can be challenging when you’re a technical product manager because you know just enough to be super annoying and to be a real distraction to your engineers. Sometimes you get it right, but most of the time - I would say 90% of the time - the engineers are far better off without you spitballing. But if you have a brain like mine, it’s really hard to resist that. I like helping to solve the problem and solving the puzzle, because in the end, I’m a puzzle solver, and most technical product managers are to some degree.

The Systematic Breakdown That Actually Worked

With VoiceCatcher’s pause detection, here’s exactly how problem decomposition saved the day:

Step 1: Isolate the Components

Instead of asking AI to “fix pause detection,” I broke it into testable pieces:

  • Audio file quality (controlled test files)
  • Configuration settings (threshold calculations)
  • Timing data availability (Whisper output structure)
  • Algorithm logic (detection and application)

Step 2: Test Each Piece in Isolation

  • ✅ Audio files: Perfect silence regions detected manually
  • ✅ Configuration: Math checked, thresholds verified
  • ✅ Timing data: JSON structure confirmed, data flowing
  • ❌ Algorithm logic: This is where we found the problems

Step 3: Drill Down Into the Failing Component

Once I isolated that the algorithm was the issue, I broke that down further:

  • Field name references (t0/t1 vs start/end)
  • Detection layers (word-level vs segment-level)
  • Boundary logic (timing-only vs semantic context)

Each of these was a separate bug that had to be fixed individually.

Why This Matters for Solo Builders

As a solo builder using AI, you’re essentially both the PM and the engineer. But you can leverage your PM problem decomposition skills to guide the AI more effectively:

The Wrong Approach:

Prompt: "My pause detection isn't working, please fix it."
AI Response: Creates a completely new implementation that conflicts with existing code.

The Right Approach:

Prompt: "I need to debug why pause detection returns 0 pauses. Let's start by verifying the timing data structure. Show me how to log the exact field names and values."
AI Response: Targeted debugging code that reveals the field name mismatch.

The Framework That Works

1. Decompose Before You Prompt

  • Break the problem into the smallest testable units
  • Identify which component is actually failing
  • Ask AI to help with specific pieces, not the whole problem

2. Use Your TPM Brain

  • Apply the same systematic thinking you use for product roadmaps
  • Question assumptions (just like you do with stakeholder requirements)
  • Test hypotheses one at a time

3. Embrace the Puzzle-Solving Advantage

  • Your natural curiosity about “why” things work is actually valuable here
  • You can explore technical rabbit holes without bothering real engineers
  • AI has infinite patience for your “what if we tried…” questions

The Business Case for This Approach

Time Investment:

  • Problem decomposition approach: 40 hours over 3 weeks (spread out)
  • “AI fix everything” approach: Would have led to complete refactor (weeks of cleanup)

Quality Outcome:

  • Systematic approach: Robust solution that handles edge cases
  • Shortcut approach: Band-aids that create more problems later

Learning Value:

  • Deep understanding of the system for future features
  • Debugging methodology that applies to other complex problems
  • Confidence to tackle “impossible” technical challenges

What This Means for Technical Product Managers

The beautiful thing about working with AI as a TPM is that you finally get to use both sides of your brain - the systematic problem-solving side AND the technical curiosity side - without stepping on anyone’s toes.

In a team environment:

  • Engineer: “Stay in your lane, PM.”
  • Reality: They’re right, and you should listen.

In a solo building environment:

  • AI: “What would you like me to help you investigate?”
  • Reality: You can explore technical solutions to your heart’s content.

The key insight: Your TPM training in breaking down complex product problems is exactly the skill you need to guide AI effectively. Don’t abandon that systematic thinking just because you’re working with code instead of roadmaps.

The Practical Framework

When you hit a technical wall with AI:

  1. Stop and decompose - What are the individual components?
  2. Test each piece - Which specific part is failing?
  3. Isolate the failure - Can you reproduce the problem in the smallest possible way?
  4. Ask targeted questions - Get AI to help with the specific failing piece
  5. Reassemble systematically - Put the working pieces back together

This is the same process you use when a product launch goes sideways or when stakeholder requirements don’t make sense. The only difference is you’re applying it to code instead of business logic.

The bottom line: Your puzzle-solving brain is your competitive advantage as a solo builder. Don’t try to turn it off just because you’re working with AI. Instead, use it to ask better questions and break down problems more systematically.

Sometimes the best technical solution comes from applying product management thinking to engineering problems. And with AI as your infinitely patient coding partner, you finally get to scratch that technical itch without anyone telling you to stay in your lane.

Read the technical deep-dive: When the “Impossible” Bug Becomes Your Greatest Victory: Fixing VoiceCatcher’s Pause Detection for the complete implementation details of how this systematic approach uncovered three interconnected bugs.