Why Great Developers Automate Everything Instead of Doing It Twice

It was 11:47 PM on a Tuesday, and I was renaming the same 40 files for the third time that month.

Same pattern. Same folder. Same mind-numbing process of right-click, rename, right-click, rename. Forty times. Again.

Somewhere around file 23, a thought hit me like a bucket of cold water: I have written code that controls servers, parses APIs, and automates entire pipelines and here I am, manually renaming files like it’s 1998.

That night didn’t make me a better coder. It made me a smarter one. And that difference matters more than people think.

The Two-Minute Rule That Changes Everything

Here’s a question that separates good developers from great ones: “Will I do this again?”

Not “is this task hard.” Not “do I have time right now.” Just: will this exact task, or something close to it, show up again in a week, a month, six months from now?

If the answer is yes, even a quiet maybe, that’s your cue to stop and automate it.

I know what you’re thinking. “But writing the automation script takes longer than just doing the task!” Sometimes, sure. The first time. But you’re not paying for one use. You’re paying once and using it forever.

Here’s the math nobody tells you:

# Manual task: 5 minutes, repeated 50 times a year
manual_cost = 5 * 50  # = 250 minutes

# Automated task: 20 minutes to build, 10 seconds to run
automation_cost = 20 + (50 * (10/60))  # = ~28 minutes

That’s the difference between losing four hours a year and losing twenty-five minutes. Once.

The File-Renaming Script That Saved My Sanity

After that Tuesday night, I wrote a script in about fifteen minutes. It’s not fancy. It doesn’t need to be.

import os

folder = "downloads"
prefix = "report_2026"

for index, filename in enumerate(os.listdir(folder), start=1):
    extension = filename.split(".")[-1]
    new_name = f"{prefix}_{index:03d}.{extension}"
    os.rename(
        os.path.join(folder, filename),
        os.path.join(folder, new_name)
    )

That’s it. Fifteen lines. I’ve used variations of this script probably 200 times since. It has paid for itself roughly 199 times over.

This is the part people miss about automation: you don’t need to build something impressive. You need to build something that works, and then never think about the problem again.

Why Smart People Still Avoid Automation

I’ve worked with genuinely brilliant developers who still do repetitive things by hand. Not because they can’t automate because of a sneaky little trap I call the “it’s faster to just do it” trap.

And here’s the annoying truth: in the moment, it usually IS faster to just do it. That’s exactly why the trap works. You’re never comparing “five minutes now” against “the next fifty times this happens.” You’re only ever comparing it against “twenty minutes to write a script right now,” and right now always wins.

This is the same reason people don’t floss, don’t save for retirement, and don’t update their resumes until they’re already job hunting. Humans are terrible at weighing small recurring costs against one-time effort. Developers are humans too. We just have better tools to fix the bias, if we choose to use them.

“Automation isn’t about laziness. It’s about being lazy on purpose, with intention, so you have energy left for the problems that actually deserve your brain.”

That’s not a famous quote. It’s just something I scribbled in my notes app after one too many late nights. But I stand by it.

Three Things Worth Automating This Week

You don’t need a custom AI pipeline or a Kubernetes cluster to start. Most automation wins are embarrassingly simple. Here are three places to look first.

1. Anything you copy-paste more than twice. If you’ve copied the same boilerplate, the same git commands, or the same email reply more than twice, write a snippet, alias, or template for it.

# Add this to your .bashrc or .zshrc
alias gpush='git add . && git commit -m "update" && git push'

Three keystrokes instead of three commands. Small, but it adds up fast.

2. Anything you check manually on a schedule. Checking a website for price drops? Watching for a file to appear in a folder? Refreshing a dashboard every morning? A script can watch it for you and only bother you when something actually changes.

3. Anything that follows an “if this, then that” pattern. If a new email arrives with an invoice attached, save it to a folder. If a test fails, send a Slack message. If a file gets added, back it up. These patterns practically beg to be automated, and most take under an hour to set up with basic scripting.

The Real Skill Isn’t Coding, It’s Noticing

Here’s the thing nobody puts on a resume: the most valuable skill in automation isn’t the Python. It’s the noticing.

It’s catching yourself mid-task and asking, “Wait, haven’t I done this before?” That tiny moment of self-awareness is worth more than knowing twelve frameworks. Because frameworks change. Languages change. But the habit of spotting repetition? That sticks with you for your entire career.

Great developers aren’t necessarily the ones who know the most syntax. They’re the ones who get annoyed by doing the same thing twice and instead of sighing and doing it a third time, they build something so they never have to think about it again.

Start Small, Start Annoyed

You don’t need a grand automation strategy. You need one annoying, repetitive task and thirty minutes of free time.

Pick the thing that makes you sigh the loudest. The file renaming, the data entry, the copy-pasting, the manual checking. Automate just that one thing this week.

Then notice how good it feels to never do it manually again.

That feeling, more than any tutorial or course, is what turns “I know how to code” into “I know how to make my life easier with code.” And honestly? That’s the whole point.