Breaking down the task that scares you

There's a specific kind of ticket that makes my stomach drop. Not the hard ones, hard is fine. It's the ambiguous ones. "Migrate billing to the new provider." "Add multi-tenancy." Four words that hide a month of unknowns, and every time I've opened one of these I've felt the same pull: to stall, to reorganize my desk, to do literally any other ticket first.

I've learned that the fear isn't about difficulty. It's about not being able to see the shape of the thing. And you don't fix "I can't see it" by staring harder. You fix it by cutting it up until each piece is something you've done before.

The fear is uncertainty, not size

A big task you understand isn't scary, it's just long. You can see the pieces, you know roughly how each one goes, you just have to do them. What actually triggers the dread is the part you can't see: the new provider's API you've never touched, the legacy code nobody understands, the "how does auth even work here" question you've been avoiding.

So the first move isn't to plan the whole thing. It's to find the single scariest unknown and attack that first, while everything else waits. (This is the cousin of estimating in ranges, the width of your estimate and the size of your fear come from the exact same place: the parts you haven't seen yet.)

Kill the biggest unknown first with a spike

A spike is throwaway code whose only job is to answer a question. Not to ship, not to be clean, just to convert "I have no idea if this is even possible" into "okay, now I know."

When I had to migrate billing, the thing keeping me up wasn't the hundred small tasks. It was one question: does the new provider's webhook actually give us enough to reconcile a payment? So before planning anything, I spent half a day wiring the ugliest possible test, hardcoded keys, one endpoint, print the payload. Deleted it after. But now the scariest unknown was dead, and the rest of the work went from a fog to a list.

Slice into shippable pieces, not layers

Here's the mistake I made for years: I'd break a big task by layer. First all the migrations, then all the models, then all the controllers, then wire up the UI. It feels organized. It's a trap. You have nothing that works until the very end, so you get no feedback, no proof, and no morale for two weeks, and if the estimate was wrong you find out far too late to react.

The better cut is vertical: each slice is a thin, complete path that actually works end to end, even if it does almost nothing.

1. All DB migrations
2. All models + relationships
3. All controllers
4. All the UI
5. Wire it together + pray

-> nothing works until step 5

1. One provider, one plan, hardcoded -> a real charge succeeds
2. Same path, real plan data from DB
3. Add webhook -> mark paid
4. Add the second plan
5. Handle failures + refunds

-> something real works after step 1

The right column ships something true on day one, a single charge that actually goes through. Ugly, narrow, hardcoded, but real. Everything after that is widening a path that already works, which is a completely different feeling from building four disconnected layers and hoping they meet.

Each slice should teach you something

The best slices aren't just small, they're ordered so the early ones resolve the biggest risks. If the whole thing might fail because of one integration, that integration is slice one, not slice five. You want to be wrong early, while being wrong is cheap and there's still time to change course.

That's the real payoff of slicing a scary task: you're not just making it smaller, you're rearranging it so the questions that could sink the whole project get answered first, when you can still do something about the answer.

The mindset

A task feels scary in proportion to how much of it you can't see. You can't make yourself braver, but you can make the task smaller and clearer until there's nothing left to be scared of, just a list of things you already know how to do.

So when the four-word ticket lands and your stomach drops, don't push through the fear and don't stall. Name the scariest unknown, spend a few hours killing it, then slice what's left into thin paths that each work on their own. The dread was never about the work. It was about the fog. Cut the fog and the work is just work.