Open this lesson in your favourite AI. It'll walk you through the why, explain the demo, and quiz you on the try-it list.
Cohen wrote the eleven sins from a hardware perspective in 2015. Three additional patterns kill software products specifically. These aren't in the book — they're what I've watched destroy software companies through the late 2010s and 2020s. Adding them here makes Cohen's list complete for both hardware and software builders.
Three modern software-specific sins.
Use these three in order. Each builds on the one before.
Explain in one paragraph each of the three software-specific sins (#12-14) and why they're different from Cohen's original 11.
Walk me through how Sin #13 (Jira-driven roadmaps) cascades into shipping the wrong product over an 18-month period.
Given a 50-person software product team where all 3 software-specific sins are live, what's the order of intervention and why?
SIN #12 (SOFTWARE): SHIPPING AHEAD OF INTEGRATION TESTS
The pattern:
Engineering culture says: 'CI passes = good to ship.'
CI tests each service in isolation.
No tests across service boundaries.
Production: services A + B work; A + B + C breaks subtly.
Why it's the modern hardware-Sin-#1 equivalent:
Microservices made unit tests easy. They made integration tests hard.
Teams skip the hard part. End-to-end tests are flaky → team disables them.
Now: every prod incident is the first integration test.
Cure:
- Contract tests at every service boundary (Pact, Avro).
- One end-to-end test per critical user journey, kept green.
- "Deployed but not yet exercised by real traffic" is not "shipped."
- Synthetic prober runs the critical journey every 60s in prod.
SIN #13 (SOFTWARE): JIRA-DRIVEN ROADMAPS
The pattern:
Team treats Jira/Linear as the source of truth.
Roadmap = "everything in this Jira label."
No prioritization above ticket level.
PM becomes ticket janitor, not strategist.
Why it kills products:
- No coherent thesis. Just a backlog.
- Sprint scope determined by what's "ready" not what's important.
- Strategic shifts can't propagate down (the tickets stay).
- 18 months in: shipped 200 tickets, no compelling product.
Cure:
- Roadmap above tickets: vision → bets → initiatives → tickets.
- Each ticket connects to one initiative; each initiative to one bet.
- 'Why are we doing this' must be answerable in one sentence,
not 'because it's in the backlog.'
- Quarterly roadmap reviews kill stale initiatives.
SIN #14 (SOFTWARE): 'WE'LL FIX IT POST-LAUNCH' DEBT
The pattern:
Launch pressure. Cut corners with the promise "we'll fix it after."
Cut item #1: error handling.
Cut item #2: instrumentation.
Cut item #3: documentation.
Cut item #4: tests.
All of these become permanent.
Why it kills products:
- Cumulative tech debt compounds. v2 features take 3x longer.
- Engineering attrition: nobody wants to maintain that codebase.
- Customer trust erodes: bugs in production accumulate, ship velocity
drops, customers leave.
Cure:
- 20-30% capacity dedicated to debt repayment, every cycle, non-negotiable.
- Definition of done includes: tests, instrumentation, runbook, docs.
- 'We'll fix it post-launch' is banned phrase; replace with explicit
'this debt is owed to date X.'
- Real debt register, like any financial liability.
THE 14-SIN LIST:
Cohen's 11 (hardware-rooted, universal):
1. Late testing
2. Assuming we know what users want
3. Assuming users know what they want
4. No comprehensive requirements
5. No project plan
6. No clear responsibility
7. Not addressing regulations
8. New-feature-itis (scope creep)
9. Not knowing when to quit polishing
10. Not planning to fail
11. Tech-not-product
My additions for software:
12. Shipping ahead of integration tests
13. Jira-driven roadmaps
14. 'We'll fix it post-launch' debt
Together: 14 patterns that kill products.
HARDWARE BUILDERS: focus on Cohen's 11.
SOFTWARE BUILDERS: focus on all 14.
THIS MODULE'S FOCUS:
Self-diagnosis. Pick your top 3 most-likely-live sins out of 14.
Address those 3 before anything else.