They Don’t Teach This in Tutorials…

7 Productivity Hacks I Learned from a Principal Software Engineer!

What separates average developers from great ones isn’t just skill — it’s how they work. These 7 habits transformed the way I code, communicate, and lead.

Photo by 卡晨 on Unsplash

Not a Medium Member? “Read for Free”

Early in my dev career, I thought productivity meant typing fast or memorizing keyboard shortcuts. That changed when I started shadowing a Principal Software Engineer at my company — someone who delivered massive features, led teams, and still left work by 6 PM.

I didn’t ask for mentorship. I just watched. Listened. Took notes.

And what I discovered were small, repeatable habits that made a big difference. Some of these hacks were counterintuitive. Others were so simple, I wondered why I hadn’t started earlier.

Why I Stopped Using class in Kotlin (And What I Use Instead)

Here are the 7 productivity gems that stuck with me.

1). Use Your Calendar Like You Use Your Code Editor

“If your day isn’t planned, your work won’t go anywhere.”

They treated their calendar seriously — like part of their toolkit. They blocked time to actually get work done without distractions.

Here’s what they did:

• 9–11 AM every day was quiet, focused work time (no meetings, no Slack pings)
• Friday afternoons were just for planning and cleaning up
• Daily standups were quick — just 15 minutes. No long, boring meetings.

What I started doing:
Now I put my most important, creative work before lunch, when my brain is fresh. I save easier stuff — like emails and code reviews — for later in the day.

2). Work on the Right Problem, Not the Hardest One

I once spent 3 days obsessively optimizing a loader animation. My mentor? They focused on solving a data sync issue affecting thousands of users.

“Impact matters more than cleverness.”

How they prioritized:

• Ask: “Who benefits if I finish this today?”
• Rank tasks by user value, not ego
• Delay or delegate the rest

Lesson: Don’t confuse “busy” with “valuable.”

3). Create Your Own Toolbox of Reusable Stuff

“If you do something more than twice, don’t repeat it — save it.”

This engineer didn’t waste time rebuilding the same things again and again. They had ready-to-go templates and shortcuts for the boring stuff.

Think of it like how Android devs reuse:

• Jetpack Compose UI components — like a custom PrimaryButton() or ErrorDialog() you can use in any screen
• Helper functions — like isNetworkAvailable() or formatDate() that you don’t want to write every time
• Android Studio Live Templates — for boilerplate code like remember { mutableStateOf() } or LaunchedEffect

What I did:

I made a folder called dev-snippets/ and started saving anything that felt repeatable — like that showSnackbar() function or a reusable loading screen. Over time, this toolkit saved me hours and made new features much faster to build.

4). Write README Files for Your Brain

“If I solve it today and forget it in a week, I’ll just waste time solving it again.”

They documented:

• How to run a complex script
• Gotchas around a 3rd-party API
• Decisions made and why

Not in Notion. Not in some dusty wiki. Right next to the code, in plain English.

What I copied: I now maintain lightweight README.mds in every key directory, with notes to future-me.

5). Don’t Reply to Everything Right Away

Here’s what surprised me: this senior engineer didn’t rush to respond on Slack/Teams every time a message popped up.

“If it’s really urgent, just call me.”

They had clear rules for when to check messages:

• Checked Slack/Teams only 2 or 3 times a day
• Gave feedback on code reviews without jumping on live calls
• Sent weekly updates, instead of constant back-and-forth chatting

Why this works:
They got more time to focus on real work, and didn’t feel overwhelmed by constant notifications or pressure to reply instantly.

Takeaway:
Not everything needs an instant response. Create space to think and build — it makes a huge difference.

6). Debug Like a Detective, Not a Magician

This engineer didn’t solve bugs with some secret trick — they just followed a smart, step-by-step approach.

Here’s how they did it:

• Start with logs — check what’s actually happening
• Try to reproduce the bug — make it happen again
• Follow a checklist:

1. Logs
2. App state
3. API calls
4. Any outside services (like Firebase, Stripe, etc.)

“Most bugs are simple. Think of it like solving a mystery — not pulling a rabbit out of a hat.”

Cool trick they used:
They talked through the problem out loud — sometimes just explaining it helped them spot the mistake. (It’s called rubber duck debugging… and it totally works!)

7). Don’t Chase 100% Productivity. Chase 80% Consistency.

This one blew my mind.

“Some days you’ll write 500 lines. Other days you’ll delete 2 lines and solve a week-long bug. Both are wins.”

They didn’t burn out. They didn’t chase perfection. But their consistency made them unstoppable.

What I learned: Rest isn’t a reward. It’s part of the system.

Conclusion

There’s no shortage of productivity apps or systems out there. But none of them matter if your habits aren’t aligned.

These 7 hacks weren’t learned in some bootcamp or course. They were learned by watching a developer who consistently delivered impact, clarity, and calm — not just code.

If I had to boil it down?

Structure your time, simplify your tools, and always ask: “What’s the highest-value thing I can do right now?”

Understanding Annotations in Jetpack Compose: Beyond Just @Composable