Tips for becoming an efficient developer

You spend countless hours troubleshooting a script, only to realize that a simple?—?verbose flag could have given you the exact error details you need to debug your situation. You sift through numerous Stack Overflow threads when the official documentation has the answer right from the start. Or even worse, you waste half your day on monotonous tasks that could be automated in a matter of minutes.

I’ve been there, you are not alone! We’ve all experienced this at some point. However, being an effective developer isn’t about putting in more hours?—?it’s about being more strategic with your time. I’ll give you a few actionable strategies that enhance your workflow, save time, and more importantly: write sick-ass code that will change the world for the better.

Verbose outputs

Ever spent way too long debugging something, only to realize the issue was something simple?—?like the wrong environment, a missing context, or an incorrect path? Instead of guessing, let the tool tell you what’s wrong. Most command-line tools if not all come with a verbose mode (--verbose or -v), which provides detailed logs on what’s happening under the hood.

For example, I once ran a database migration with EF Core that kept failing without a clear error message. Running the command with -v revealed that it was trying to run the migration script with the wrong context. A quick context switch and problem solved.

Same with Flutter. You will not know how much the verbose mode saved me in the early days of flutter development. Especially when you are new to a framework, it’s hard to understand the lingo of the error message.

Most tools will provide you enough information about the issue you might encounter but in a few cases, it is also not very rare if you are working on a medium to large scale project. But if you ever face an issue with a cryptic error message, then definitely check if it has a verbose, debug, or trace mode. It might just save you hours of head-scratching.

RTFM before asking for?help

We’ve all done it?—?hit an error, copy-paste it into Google, and dive into a Stack Overflow thread with a dozen conflicting answers. While community forums are helpful, official documentation is often the fastest way to find the right solution.

Why? Because docs are written by the people who built the tool. They contain accurate, up-to-date, and context-specific information?—?unlike some outdated Stack Overflow answers that might no longer apply.

I hear you crying about documentation being hard to search through unlike forums. That’s where tools like ChatGPT or any other text-hungry dragons understand and provide a solution for you.

So, before diving into random blog posts, make it a habit to check the official docs first. You’ll get better answers, faster, and with fewer surprises down the road, and most of all you’ll understand the what and why of the issue and why a specific issue works.

Forums are helpful, but understanding the docs first is better as it will give you the the idea of what you are dealing with before finding answers.

Use IDE Shortcuts for Day-to-Day Tasks

If you’re still manually clicking through menus to navigate files, refactor code, or debug, you’re wasting precious time. Your IDE is packed with shortcuts that can speed up your workflow?—?you just need to learn them.

Imagine this: You’re fixing a bug and need to jump between multiple functions. Instead of scrolling endlessly, you could use:

• Ctrl + Click (or F12) to jump to a function’s definition.
• Ctrl + Shift + T to reopen a recently closed file.
• Ctrl + D to duplicate a line instead of copy-pasting.
• Ctrl + \ to quickly move to the end of that one function which spans across two 4k monitors.

And that’s just the basics. Most IDEs let you customize shortcuts or even create macros for repetitive tasks. All you have to do is look up for a way to do things faster when you’re about to do a task, and you’ll work faster with less friction.

Your IDE extensions can also extend the things you can do in your IDE a lot more.?

Automate repetitive tasks to Save Time (Eventually)

Why spend 5 minutes doing something manually when you can spend 5 hours writing a script to do it for you? ??

Be honest with me— you’ve done this, I know it. Every developer has fallen into the automation rabbit hole at some point. You start with a simple script to rename a few files… and suddenly, it’s a full-fledged, over-engineered workflow with logs, error handling, and a CI/CD pipeline. But in the long run, automation actually pays off.

Common tasks you can automate (so you can “save time”?later):

• Running the same commands every day??—?Create shell aliases (alias gs="git status") to cut down keystrokes.
• Still manually testing your API??—?Write a simple script instead of clicking through Postman every time.
• Spending too much time deploying??—?Set up a CI/CD pipeline to do it while you sip coffee.
• Tired of fixing messy code??—?Automate formatting with prettier, black, or eslint --fix.

Sure, sometimes automation takes longer than doing the task manually (at first), but once it’s in place, you’ll never have to think about it again. Future You will thank you. Probably.

And sometimes, your automation won’t be as helpful as you imagined?—?but that’s okay. The real reward isn’t just efficiency; it’s the fun you had along the way and the great story you’ll get to tell the next woman you meet. She may not be impressed, but at least you’ll have a solid laugh about that time you spent 10 hours automating a 5-minute task. ??

Master Your?Debugger

If your idea of debugging is adding print() statements everywhere and hoping for the best, I’m gonna pray for you. And I’m not even religious—but for you, I’ll make an exception. Sure, it works… until your logs turn into an unreadable mess. Let’s talk about your upgrade! ??

Most IDEs (like VS Code, JetBrains, and even Chrome DevTools) come with powerful debugging features?—?yet many devs don’t use them. Take some time to learn your debugger and you’ll spend less time guessing and more time actually fixing issues.

Remember: Debuggers don’t just save time?—?they save sanity. ??

Learn to Use Git?Properly

If your Git workflow consists only of git add?., git commit -m "fixed stuff", and git push, we need to talk.

Some Git tricks that will change your?life:

• Interactive rebase (git rebase -i) – Clean up your commit history like a pro. No more “final-final-fix2” commits. (Don't do it on a branch that is others are using.)
• Git bisect (git bisect start) – Find the exact commit that introduced a bug instead of guessing.
• Git worktrees (git worktree add <new-branch>) – Work on multiple branches without constant switching. Ever tried to switch branches, only for Git to basically flip you off with a warning about uncommitted changes? With worktrees, that nightmare is over. No more stashing, no more losing work?—?just seamless multitasking.
• Stash like a ninja (git stash, git stash pop) – Save your uncommitted work and restore it when needed.

Git can feel overwhelming at first, but mastering just a few advanced commands will save you hours of frustration. Your future self (and your teammates) will thank you.

Use Task Management Tools

Relying on your brain to track all your tasks is a recipe for “Wait… what was I supposed to do again?” moments. A simple task management tool can save you from your own forgetfulness and help you focus on what actually matters.

Why you should use?one:

• Reduces mental clutter?—?Offload tasks so your brain can focus on writing code.
• Helps prioritize work?—?No more jumping between random tasks like a lost thread in a multi-threaded program.
• Keeps you accountable?—?Seeing unchecked tasks can guilt-trip you into being productive.

There is a sea of tools to do just this, but I use notion which helps me add some sweet automation to it. Try one and see which suits you and stick to it. Even if you’re a solo developer, tracking tasks prevents context-switching disasters and keeps you moving efficiently. Because let’s face it?—?“I’ll remember it later” is the biggest lie we tell ourselves.

Being efficient isn’t about typing faster?—?it’s about avoiding unnecessary struggles. Debug smarter, Git like a pro, and stop trusting your brain to remember tasks (it won’t).

The less time you spend fixing avoidable mistakes, the more time you have for real coding?—?or, let’s be honest, scrolling memes. So go forth, optimize, and make life easier for future you. ??

Stay Curious. Adios ??

This article was originally written on Medium.