We live in a world that's basically optimized to make us comfortable. Every app, every algorithm, every "one-click checkout" is designed to make life easier right now.
But here's something I've learned after years of coding: the easiest choices rarely lead to anywhere interesting.
A weird cricket analogy that actually makes sense
So I was watching cricket the other day (stay with me, I promise this is relevant). Sanju Samson was having a terrible game while Ishan Kishan was absolutely crushing it. Everyone watching was like "dude, just swap them already!"
But the team didn't. They stuck with Samson. And at first I thought they were being stubborn, but then I realized - they're playing a completely different game than what we're watching. They're thinking about team chemistry, long-term strategy, player confidence. All the stuff that doesn't show up on the scoreboard today but matters a ton six months from now.
And that's basically every important choice in software development too.
Like when you're deciding whether to:
- Actually refactor that mess or just ship it and "deal with it later" (we never do)
- Write tests or just pray it works in prod
- Read the docs or copy-paste from Stack Overflow and hope for the best
- Use TypeScript or stay in JavaScript land (yeah I said it)
The first option always feels slower in the moment. But six months later? You're either grateful or cursing past-you.
Let's talk about developer dopamine addiction
Okay so this is something nobody really talks about but we're all guilty of it.
We're addicted to quick hits:
- Refreshing GitHub stars on our repos every 10 minutes
- Checking if that Stack Overflow answer got upvoted
- Opening Twitter between compiles (or is it X now? I can't keep up)
- Starting new side projects instead of finishing the seven we already have
- Tutorial hell - just ONE more course and then I'll definitely build something
- Getting lost in HackerNews at 3pm when we should be debugging
Here's the uncomfortable truth: most of us have completely lost the ability to sit with one hard problem for an hour straight.
We can't deep dive into a gnarly bug when Slack is going off. We can't think through a system design when we're checking our phone every 5 minutes. We've turned into consumers of code instead of creators.
And look, I'm not judging. I'm literally describing myself six months ago.
The fix isn't what you think
You can't just willpower your way out of dopamine addiction. Trust me, I tried. What actually works is getting addicted to better things.
Instead of being addicted to social media, get addicted to solving hard problems. Instead of chasing GitHub stars, get addicted to writing code that makes you proud. Instead of hoarding tutorials, get addicted to actually shipping stuff.
The beautiful part? Good habits compound just like bad ones. Except in the right direction.
When I started spending my mornings solving LeetCode problems instead of scrolling Twitter, I didn't magically become a 10x developer overnight. But after three months? I was noticeably better at thinking through algorithms. After six months? I was helping other people solve problems I used to struggle with.
The real secret of "10x developers"
Hot take: 10x developers aren't actually 10 times smarter than everyone else.
They just have better systems.
Every truly productive developer I know has some version of this:
Morning: Hit the gym (because sitting at a desk for 8 hours is terrible for you)
Early work block: Deep work, no Slack, no meetings, just code
Mid-day: Code reviews, helping teammates, actually being human
Afternoon: Another focused block for hard problems
Late afternoon: Learning new stuff, reading docs, staying current
Evening: Plan tomorrow, write down what went well and what didn't
Notice what's not there? Deciding whether to work out. Debating whether to learn today. Wondering if they should check social media "real quick."
The decisions are already made. They just execute.
Structure isn't boring. Structure is how you free up mental energy for the things that actually matter.
When everything breaks (because it will)
Real talk: your code will break. Your PR will get rejected. You'll ship a bug that costs the company money. You'll have days where you feel like you have no idea what you're doing.
I once deployed on a Friday at 4:30pm. I know, I know. It broke production. I spent my entire weekend fixing it while my friends were out having fun. Not my finest moment.
But here's what I learned: you can't control outcomes. You can only control what you do every day.
The Bhagavad Gita has this idea (bear with me): "You're not entitled to the fruits of your actions, only the actions themselves."
For developers, this means:
You control:
- Writing clean code
- Learning every day
- Helping your teammates
- Showing up consistently
You don't control:
- Getting promoted
- Your project getting approved
- Your PR getting merged quickly
- Getting recognized for your work
Focus on what you control. Let go of what you can't. Seriously, this mindset shift changed my entire career.
Seven things that actually work
Forget motivation. Build systems. Here's what's worked for me:
1. Define your actual process
Bad goal: "I want to get better at system design"
Good system: Every day for 30 days, read one chapter of "Designing Data-Intensive Applications," implement one small piece of what you learned, write a short explanation in your own words.
See the difference? One is vague hope. The other is a recipe.
2. Ask yourself one question before every choice
"Is this good for the next hour or good for the next year?"
That's it. That's the whole framework.
Scrolling Reddit? Good for the next hour (if that).
Reading PostgreSQL docs? Boring now, powerful forever.
Another YouTube tutorial? Feels productive, isn't.
Actually building that side project? Hard now, portfolio forever.
3. Keep a mistakes log (not for bugs, for life)
I have a notes file where I write down every time I make a choice that I know isn't serving me:
"Watched coding tutorials for 3 hours instead of coding - felt productive but built literally nothing"
"Stayed up until 2am scrolling - next day was useless, wrote terrible code"
"Said yes to a meeting during my deep work block - destroyed my flow, shipped nothing"
I review this every Sunday. Patterns become obvious real quick.
4. Get obsessive about filling knowledge gaps
Everyone sucks at something. The difference between junior and senior isn't talent - it's whether you systematically fix your weak spots.
Bad at algorithms? Do one LeetCode problem every morning for 90 days.
Weak on system design? Read one architecture blog post daily.
Don't understand Docker? Build three projects using it.
Knowledge compounds faster than you think.
5. Teach everything you learn
Want to really understand something? Try explaining it to someone else.
Write blog posts. Review junior dev PRs with real feedback. Answer Stack Overflow questions. Give talks at meetups.
Teaching forces you to understand things deeply. Plus you build a reputation and network at the same time. Win-win-win.
6. Your thoughts matter more than you think
When production breaks at 2am, your internal dialogue matters.
Instead of: "I'm so stupid, I always mess things up"
Try: "Okay, this is a tough problem, but I can figure it out"
Instead of: "Everyone else is so much better than me"
Try: "I'm competing with yesterday's version of me, not them"
Instead of: "My code got rejected, I must suck"
Try: "Feedback is how I get better"
This isn't toxic positivity. It's choosing useful thoughts over useless ones.
7. Keep your routine when life gets hard
Anyone can be disciplined when they're motivated and things are going well.
The real test is keeping your routine when:
- Production is on fire
- You got a bad performance review
- Your PR was rejected for the third time
- You're dealing with imposter syndrome
- Life is just hard
This is when your structure saves you. You don't have to decide whether to work out or learn or sleep properly. You just do it because that's what you do.
The compound effect that changes everything
Here's some napkin math that blew my mind:
If you get just 1% better at something every day, after a year you're not 365% better. You're 37x better. That's how compounding works.
One LeetCode problem won't make you an algorithms expert. But 200 will.
One blog post won't build your personal brand. But 50 will.
One day of focused work won't make you senior. But 1,000 will.
The hard choices feel tiny in the moment. That's exactly why most people don't make them.
Everyone wants the senior title NOW. The big salary NOW. The respect NOW.
But that's not how any of this works. Real growth is slow, quiet, and built from thousands of small decisions that don't feel like they matter.
Who are you becoming?
Five years from now you'll be a completely different engineer. The only question is: what kind?
The developer who chose comfort is comfortable but stagnant. Same skills, same salary range, same problems.
The developer who chose growth is constantly evolving, valuable, and solving interesting problems.
You choose. Every day. In every small decision.
Just start
Look, I could write another 5000 words but at some point you just gotta do something.
Pick ONE thing:
- Block 2 hours tomorrow for deep work, no Slack, no phone
- Sign up for the gym (seriously, your back will thank you)
- Start that side project you've been thinking about
- Write your first blog post
- Delete social media apps from your phone for one week
- Do one LeetCode problem before work tomorrow
Do it now. Not tomorrow. Not next week. Now.
Your future self - the one making good money, working on cool stuff, respected by their team - that person is built from the choices you make today.
Don't let them down.
Real talk in the comments
What's the hardest choice you made as a developer that actually paid off later? Or what habit are you trying to build right now?
I'll go first: deleting Twitter from my phone was SO hard but my productivity literally doubled. No cap.
Your turn 👇
Top comments (0)