MeerMost

How I Stopped Freezing Up When Facing a Big Task

Back when I needed to build a big app screen or an unfamiliar integration, I'd freeze. I'd open the editor, stare at an empty file, and have no idea where to start. Then one of two things happened. Either chaotic code I'd be embarrassed to reread later, or two hours on YouTube under the pretext of "I need to get my head around this." These days I work differently. The change turned out to be simple, but it took me a long time to get there.

Symptoms

If this sounds familiar, you've been there:

  • You open the file, type the first line, delete it
  • Five or six Google tab switches in five minutes
  • An hour into coding, you feel like "this is all wrong, I'll start over"
  • You wish someone would just tell you exactly what to do
  • Every tiny decision slows you down. Where to put the file, what to name a variable, whether to use a library

This isn't laziness. It's cognitive overload. Your head is trying to keep the goal, the architecture, the syntax, the names, and the edge cases in focus all at once. Each one takes resources, and when they all hit at once, your brain just gives out.

The quote that stuck with me

Ilya Krasinsky once said: "We can't afford long releases; they're infinitely expensive." I was working on my first product at the time, and that line hit a sore spot.

Long releases aren't just slow. When I spend two weeks on a single task, I lose the spark I had in the first two days. Decisions that seemed obvious at the start raise doubts by the end. Context washes away, and you burn a quarter of the workday just getting back to where you left off yesterday.

That's where my personal rule came from. If a founder can build things hands-on, testing a hypothesis costs them several times less. Not because they're not paying a developer. But because the gap between "came up with an idea" and "saw how users reacted" is days, not months.

To build fast with your own hands, you have to stop getting stuck. That's where decomposition comes in.

The method

It sounds trite, which is why I ignored it for a long time.

Before I open the editor, I open a note and write out the steps.

Not a Notion plan with tags and estimates. Not a Jira ticket. Just a bulleted list wherever I happen to be. The goal is to offload what your brain is trying to hold onto while you're writing code.

I keep writing steps until they get too obvious. That's the stopping criterion. If the next step sounds like "call function X with these parameters," there's no point writing more. From there it's code time.

Writing the steps is where the important part happens. Unknowns surface. I catch myself asking "how exactly does this server return data?", "do I need an animation here?", "what if the user has no internet?" Each question either becomes its own bullet or a task like "check with the client" or "look it up in the docs."

After 15-30 minutes of decomposition, I understand the task fundamentally better. And I approach the code with a concrete first step instead of wondering where to even start.

An example from a real project

Let me walk through one task from a client project, No Sugar Challenge. The job was to build a personalized onboarding system with scoring. The user goes through four groups of questions, their answers are used to calculate personal parameters, and then the app builds daily tasks for them.

Normally I'd open a new OnboardingViewModel.swift file and start writing the class. And get stuck on the second line.

Instead, I opened a note and wrote:

  1. Describe the structure: one question group, a set of Question items, each question with an answer type and a weight
  2. Decide how to store the in-progress answers. In the ViewModel's memory or in Core Data
  3. The user parameters we calculate from the answers: calorie target, typical schedule, motivation level. Where are these formulas defined?
  4. Scoring. Each answer has a weight; at the end of a group we sum them up and map them to a parameter
  5. Dynamic blockers. Some answers should block follow-up questions (e.g., "no allergies" — skip the allergens block)
  6. Exiting onboarding. Where we go next, what we save
  7. Persistence. What lives in Firestore (event-driven, see the project architecture) and what lives locally
  8. Tests. Which edge cases matter: skipping a question, an exception answer, going back to a previous step

Once I wrote this down, three things became clear:

  • Question is better modeled as an enum with associated values for the answer type
  • I don't know the scoring formulas — that's a question for the client, and it's not my place to make them up
  • Dynamic blockers are a separate task with independent logic and should live in their own service

After that I did two things. I sent the question about the formulas to the client and sat down to write code. The first two hours flew by on the Question and Answer structures plus simple question routing. By the end of the first day I had a working onboarding flow on static test data. No blockers, no scoring, but a working skeleton.

If I'd started out "as usual," I'd have spent the first two hours thinking, then built a class with answers as a string dictionary, then gone back to refactor. By the end of the day I'd have half of what I have now.

When You Don't Need Decomposition

Sometimes decomposition gets in the way. If the task is a simple style tweak, a copy change, or an image swap, just sit down and do it. Writing out steps like "find the file, open it, change it, save it" is bureaucracy.

Here's roughly where I draw the line. If I have a clear picture in my head of the result and I know the first action, I just go. If either one is missing, I open a note.

Decomposition also works poorly on research tasks. When I'm getting to grips with a new technology — say, PassKit for Apple Wallet for the first time — I can't put together a plan, because I don't know enough to write one. In those cases I work in reverse. I poke around in the code, figure out one small piece, then another, and only then do I sit down and write a plan: "now I know enough to do this for real."

On Estimating Time

I use the same method to give a client a timeline. Without decomposition I say "three days," and it's almost always a lie. With decomposition I look at my list of 8-15 items, estimate each one in hours, add them up, multiply by 1.5 (because I forgot something), and get an honest estimate.

I've been keeping a time tracker for two years, and it backs this up. Tasks I broke down in advance usually finish within the estimate or faster. Tasks without decomposition stretch out two to three times on average.

What to Take Away From This

If you ever freeze up in front of a task, try something simple:

  1. Close your code editor. Open a text note.
  2. Write the goal in one line: what the result should be.
  3. Lay out 8-15 steps up to the point where the next step is "open the file and write X."
  4. As you write, flag questions and unknowns as separate items.
  5. Once the list is done, send the questions to whoever can answer them (the client, the team lead, the docs). Don't block on them — start with the items that don't depend on anyone.
  6. Open your editor and work through the list.

After five tasks done this way, you'll stop getting stuck. After twenty, you'll estimate timelines more honestly than 80% of developers who "eyeball it."

And the main thing: this isn't about productivity. It's about being able to work calmly, without the feeling that you're drowning in the unknown.

What's Next

Need to build a product without drawn-out releases and code chaos? Estimate your timeline or get in touch, and we'll dig into your task before it turns into a three-month sprint.

All articles

Related articles

Your own VPN service: how to build it and what you need to launch
Business

Your own VPN service: how to build it and what you need to launch

How to build your own VPN service to sell: the client, configs, a backend with payments, support. Why stock configs don't survive in Russia, and what the App Store requires.

10 min read
I've Kept a Work-Time Spreadsheet for 2 Years. Here's What It Showed
Business

I've Kept a Work-Time Spreadsheet for 2 Years. Here's What It Showed

Two years of time tracking as a solo developer. The main takeaway: past 6 hours a day, happiness levels drop. Why 4 hours of focus beat 8 hours of routine.

7 min read
How to choose features for a mobile MVP and get it to launch
DevelopmentVideo

How to choose features for a mobile MVP and get it to launch

How to decide what belongs in the first version of a mobile app and what can wait until after launch.

1 min read