It’s been almost a year since I changed jobs. While I was packing up to leave my last company, a Korean phrase kept running through my head: if it was good, it’s a memory; if it was bad, it’s experience. For someone closing a long chapter, no consolation felt more accurate. These days I write it the other way around. If it was good, it’s experience. If it was bad, it’s just a memory.
I’ve spent years in startups, working through different roles. Bad decisions and lucky breaks alike, in roughly equal measure. Which ones stick longer in my head? The painful ones, of course—the more they hurt, the longer I chew on them. If I sat down to write a memoir, ten failure scenes would surface before any of the good ones. But looking back, the side that actually helped me in the next chapter was the other one.
Years ago I was put on a task force to pivot our product into an ad platform. We coded into the early hours every night. What we built became one of the company’s main growth engines. For a long time I remembered it as a hard but good time. We were lucky. The timing was right. We had the right people, and we worked harder than we ever had before. But luck, timing, and the right people don’t come back twice. You can pour the same effort into the next thing and still not get the same result. Left as a memory, that’s where it ends.
Much later, working on a different project, I caught a moment where a single scene from those days touched the success of the new one. A particular decision. A particular line of code. A particular offhand remark from a customer. I pulled one out and asked it again: Why this order? What was I looking at? What made it possible? When the structure shows through the place I’d flattened into “the good times,” memory finally gets edited into experience you can grow from.
The same dissection could have worked on the failures from those days. A wrong decision. A signal missed in a meeting. A reason a customer walked away. Pull one out, ask it again: Why did it slide that way? What was I missing? What failed to stop it? But no matter how honestly you look, what comes out is a list: next time, don’t do this. It keeps you from stepping on the same trap twice. It doesn’t move you forward. If dissecting good memories is addition, dissecting bad ones is subtraction.
This is much like what a developer does when writing test code. The longer your career, the more exception handlers and defensive code you write—naturally. But the thing that actually has to pass in production is the must-succeed scenario, the happy path. It’s the road users walk every day. It’s the one flow the business runs on. When that road is alive, that’s when the product makes real value. Dissecting failures is closer to refactoring. Necessary, but it doesn’t move the product forward by itself. Dissecting successes is like the happy path test. You have to be able to reproduce this path on purpose—not by luck—so the same result can come out in the next chapter.
The problem is that we keep letting the good scenes flow past. Happy paths are running fine, we figure, so they don’t need attention. The real urgent problem, we easily come to believe, must be on the bad path. So most careers I’ve watched pile up exception handlers and defensive code, while the path that actually has to pass is full of holes.
Around the same time I was thinking about this, I read Park So-ryung’s Failure Is Something You Pass Through—a book that dissects ten wrong decisions across ten years of running Publy, a Korean content startup. The courage to pull painful scenes out and look at them with that kind of honesty is rare and worth honoring. We need books like that. They’re the reason fewer people fall into the same trap twice. But the work we should be doing more often is on the other side: dissecting ten of the good scenes with the same depth.
So these days I write it like this. Look closely at the good. Let the bad flow. Failures are something to pass through. Successes are something to reproduce.
#Further Reading
- Failure Is Something You Pass Through by Park So-ryung. Dissects ten wrong decisions from ten years running Publy with rare honesty. This essay is an attempt to write its exact mirror image: dissecting ten good scenes with the same depth.
- Thinking in Bets by Annie Duke. Names the bias of judging decisions by their results: resulting. We let good outcomes drift past while picking apart bad ones—the exact asymmetry this essay is about. Duke arrives at the same conclusion from the probabilistic thinking of the poker table.
- High Output Management by Andy Grove. Intel’s late CEO wrote this management classic. The core concept is managerial leverage—invest your time in activities where small inputs amplify into outsized outputs. Dissecting one successful pattern so you can reproduce it later is the highest-leverage retrospective there is.
- The Score Takes Care of Itself by Bill Walsh. The tool that turned the San Francisco 49ers into an NFL dynasty was Walsh’s Standard of Performance—a manual codifying what excellence looked like at every position. The clearest example I know of turning a happy path into an institutional asset.