There's a bug I sat with for six hours once. Not because it was hard — looking back, it was maybe fifteen minutes of actual work — but because I refused to walk away from it. I kept telling myself I was close. I wasn't. I was just tired and stubborn, scrolling the same forty lines of code over and over, hoping the fifth read-through would surface something the first four missed.
It didn't. What finally worked was closing the laptop, making tea, and staring at the wall for ten minutes. The fix arrived somewhere between the kettle boiling and the first sip. Not because my brain was doing anything mystical. It just finally had room to.
I used to think that was a fluke. A one-off. Then I started noticing it everywhere, not just in code.
For a long time, I ran my life like a production incident. Something breaks, you drop everything, you fix it now, you don't sleep until it's resolved. That mindset works fine for actual production incidents — servers on fire don't wait for your energy levels to recover. But somewhere along the way I started applying that same urgency to things that were never actually urgent. A disagreement with a friend. A messy draft. A decision about what to build next. Things that would have been better served by a walk and a night's sleep got the full emergency treatment instead, and I wondered why I felt like I was running on fumes by Thursday.
The truth I kept avoiding is that most problems don't need to be solved. They need to be sat with until the solution becomes obvious on its own. That's an uncomfortable thing to admit if you've built any part of your identity around being the person who fixes things fast. Speed feels like competence. Slowness feels like falling behind. But I've started to notice that a lot of what looks like speed is really just anxiety wearing a productive costume.
I think about this a lot now when I'm debugging. There's a specific kind of tunnel vision that sets in after you've been staring at a problem too long — you stop seeing the code and start seeing what you expect the code to say. Your eyes slide right over the missing semicolon, the off-by-one error, the variable you never actually reassigned, because your brain has already decided what's there. Stepping away isn't procrastination in that moment. It's the only way to reset the pattern-matching that's failing you.
The same thing happens with harder problems. The ones that don't have a stack trace. Whether to leave a job. How to have a conversation you've been avoiding. What to actually do with a Saturday that has no plans attached to it. I used to sit with a notebook trying to force clarity out of these questions through sheer effort, like clarity was a muscle I could just flex harder. It isn't. It's more like a photograph developing — it needs time in the right conditions, and no amount of staring at the blank paper speeds that up.
What changed for me wasn't some big insight. It was smaller and dumber than that: I started giving myself permission to close the tab. Not forever. Just for now. I'd write down where I was stuck, in plain language, and then I'd go do something else — cook, walk, read something unrelated, sleep on it. Almost every time, the answer showed up later, uninvited, while I was doing something that had nothing to do with the problem. In the shower. On a walk. Half-asleep at eleven at night.
There's a name for this in psychology — incubation, the idea that your brain keeps working on a problem in the background even after you've consciously moved on. I didn't know that term when I started doing this. I just noticed it kept happening and eventually stopped fighting it. Now it's part of how I work, not something I feel guilty about. If I'm stuck for more than twenty minutes on something that isn't actually on fire, I stop. That's the whole rule. Twenty minutes, then step away.
It's a hard habit to defend to people who measure effort in hours logged. Walking away from a problem doesn't look like progress. There's no commit, no visible output, nothing you can point to and say "see, I was working." But I've shipped more, and burned out less, since I started trusting the slow fix over the forced one. The code still gets written. The hard conversations still happen. They just happen after I've let the problem breathe a little, instead of while I'm choking it with attention it doesn't need.
Not everything worth solving needs to be solved today. Some of it just needs to be left alone long enough to solve itself.