Brains. Bugs. Dopamine. how to trick yourself into loving code again

Section 1: Coding shouldn’t feel like a chore

I used to open my terminal like it was a cursed object.

Not because I hated coding. But because everything around coding the stale IDEs, the soul-sapping Slack threads, the 48-hour Jira tickets titled “fix minor layout issue,” the endless “nit: rename this to something more semantic” comments felt like a punishment for picking this career.

At one point, I seriously considered quitting tech to farm potatoes in rural Estonia. I had the tab open. Real estate looked promising.

But I stayed. Not out of passion, but obligation. You know the drill: sunk cost fallacy, rent, maybe the faint hope that someday I’d actually enjoy this again.

And then… something tiny happened.

I changed my terminal font. Added a prompt theme. Threw in some color-coded branches just to see if it looked cooler.

It wasn’t a productivity move. It was an “I’m bored, let me tinker” move.

But when I made a commit just a throwaway test one and saw that sweet, glowing green ✓ main → origin/main scroll across the screen… I grinned.

For the first time in weeks.

It wasn’t the project that gave me joy. It was the process. The little feedback hit. The satisfying output. The illusion of progress and how real it felt in that moment.

And that’s when it clicked:
Maybe the trick to loving code again isn’t fixing the work.
Maybe it’s fixing the way we experience the work.

Section 2: The moment i fell in love with a green checkmark

You remember your first real “aha” coding moment?

Mine wasn’t building an app. It wasn’t shipping a feature. It wasn’t even solving a tough bug.

It was pushing a commit and seeing a green checkmark.

I had just finished customizing my terminal with a nerdy little prompt some color, some branch name magic, maybe a Unicode symbol or two. Nothing revolutionary. Just… vibes.

I typed git commit -m "test commit"
Then git push origin main
And when the output came back that beautiful, glowing green “✓ main → origin/main” I stared at it like I’d just won something.

It felt clean. It felt official. It felt finished.
I didn’t know what I’d done exactly, but my brain went:

“Good job. You did a thing. Here’s a dopamine pellet.”

I hadn’t felt that in a while.

And that’s when it hit me: maybe I didn’t need my codebase to be groundbreaking. Maybe I didn’t need to “follow my passion.” Maybe I just needed to feel done more often even if it was a lie I told myself through fonts and checkmarks.

It wasn’t about being productive.
It was about feeling productive.

And that feeling?
It became the fuel for everything else I did next.

Section 3: Farming dopamine with micro-wins

At some point, I stopped coding to ship features.

I started coding to feel something.

And nothing hits quite like a commit followed by a perfect push no merge conflicts, no broken tests, no passive-aggressive review comments. Just that sweet green line saying you did a thing.

So I leaned in.

I started breaking everything down into the tiniest, most commit-worthy chunks imaginable.
Not because it was efficient but because it felt good.

• Fixed a typo in a comment? Commit.
• Renamed a variable? Commit.
• Deleted unused code? Commit. Push. Victory dance.

It turned into a system. A game. I wasn’t just moving code I was triggering micro-rewards, over and over, like a trained rat in a dopamine lab I built myself.

Eventually, I started writing my commits like achievements:

• refactor: finally renamed that cursed function 💀
• docs: added a comment so future-me doesn’t suffer
• fix: i don’t know why it works but it does, let’s go

Suddenly, I wanted to code again. Not because the project was exciting. It wasn’t. It was a CRUD app with dreams.

But because every small step felt like progress even if the actual feature wasn’t close to done.

Pro dev tip: If motivation won’t come to you, build a system where any action gives you a reward.

A tiny glow-up. A silly commit message. A new branch name that makes you laugh.

You don’t need a manager to validate your work if your terminal throws you a party every time you hit git push.

Section 4: Ci pipelines: not devops, but vibes

I used to loathe DevOps.

The mere sight of main.yml made my eye twitch. YAML indentation errors? A personal attack. I once spent 45 minutes debugging a failed deploy that turned out to be caused by a rogue tab character. A tab character.

At that point, I didn’t hate DevOps. I feared it.

But then one evening fully sleep-deprived, running on terminal aesthetics and self-pity I set up a basic GitHub Actions pipeline for a side project.

Four steps:

• build
• lint
• test
• deploy

I committed a change and pushed.
One by one, those tiny green checks started lighting up in the GitHub UI.
Build
Lint
Test
Deploy

I sat there, genuinely moved. Like I had just witnessed a little orchestra perform a song written in Bash.

It didn’t matter that the project was tiny. Or that nobody would use it. Or that the deploy step just echoed “done” to the console.
I had made a machine that applauded my effort.

So I started building more pipelines not for necessity, but for the feeling.

Even for throwaway weekend projects.
Even for markdown-only repos.
Even for to-do apps that would never leave localhost.

Why?

Because progress is hard to measure.
But green boxes are easy to love.

I didn’t suddenly become productive. I became addicted to the illusion of momentum. And sometimes that’s all you need to keep going.

Real productivity is rare. But feeling productive? That’s a renewable resource.

YAML is still cursed. But now it’s my curse. And it delivers dopamine on command.

Section 5: Every tool is a game if you mess with it enough

Here’s a secret: almost every boring dev tool can be turned into a video game.

You just need to lie to yourself creatively enough.

It started small. I added a fake “productivity score” to my terminal prompt just a random number that went up every time I ran a Git command. Completely useless. Entirely made-up.
But my brain?

“Wow. We’re doing numbers now. We must be crushing it.”

Then I installed a terminal theme that reacted to my branch name with color changes. When I worked on feature/something-cool, it glowed blue. When I switched to hotfix/oh-no, it turned red like a boss fight was about to begin.

Next came the editor tweaks.
Dark theme on Mondays.
Light theme on Fridays.
Tokyo Night for when I’m in deep focus mode.
Cyberpunk for when I’ve stopped caring and just want vibes.

I once built a task tracker that threw literal confetti when I checked something off.
Was it overkill? Yes.
Did it help me finish my work? Also yes.
Did I rebuild it three times just to fine-tune the confetti physics? Absolutely.

If it makes the dumb stuff feel rewarding, it’s not dumb. It’s design.

Tests? I only care because my IDE shows a green animation when they pass.
Docs? I write them because I added a sticker emoji next to every new section.
Commits? They’re mini quests now. I title them like RPG missions:

• feat: Tame the Dropdown Beast
• refactor: Cleanse the CSS of Forgotten Styles
• fix: End the infinite loading spinner’s reign of terror

You don’t need to be disciplined if you’re entertained.

So I made the tools fun.
I tricked the game loop.
And guess what? I got better at coding because I wanted to keep playing.

Section 6: Discipline is overrated. feedback isn’t

There’s this myth in tech that if you’re not waking up at 5 a.m. and building the next unicorn before breakfast, you’re somehow failing.

Nah. I tried that. I was tired and sad. And my unicorn had a null pointer exception.

What actually worked?
Feedback.
Fast. Visual. Tiny. Dumb. Glorious.

Because discipline is what you rely on when a task gives you nothing back.

But coding? Coding is weirdly built for feedback if you bother to set it up.

• Run a test: see a
• Push code: get a terminal high-five
• Trigger CI: watch a digital waterfall of green checks
• Open your app: see a UI element move because you made it

That’s not productivity. That’s brain candy.

So I doubled down.
If something sucked, I gave it a reward wrapper.

• Hate writing tests? Add a sound effect for each passing one. (Mine goes ka-ching don’t judge.)
• Hate refactoring? Use a VS Code extension that throws virtual confetti when you save.
• Hate deployments? Add a Slack webhook that says “ You did it, nerd.”

None of this made me “better” in a traditional sense.
It made me return to the keyboard.
Willingly. Happily. Repeatedly.

Feedback doesn’t need to be useful it just needs to be visible.

That’s why I care more about the feeling of productivity than the actual velocity metrics.

If my CI pipeline smiles at me, I’m in.

Section 7: Delusion: the ultimate motivator

Every project I’ve ever finished started with a lie.

“I could build this in a weekend.”

Reader, I could not build it in a weekend.

What started as a one-page dashboard ended with me learning what a reverse proxy is, fighting CORS demons at 2am, and writing my own state management system because I “didn’t want to install Redux.”

But by the time I realized how deep I was, it was too late. I cared.

That’s the magic of delusion.

You tell yourself a story so confidently“this is easy,” “just a quick tool,” “no big deal”and by the time reality shows up with bug reports and scope creep, you’re already emotionally invested.

You keep going because now it’s your dumb, bloated, slightly broken baby.

Motivation rarely shows up at the beginning. It sneaks in after you’ve already committed to the bit.

This is how side projects get built.
Not with careful planning.
But with naive optimism, a caffeine binge, and GitHub Copilot whispering sweet completions into your editor at 3:27 a.m.

And the best part? Even when you “fail” even when the project ends in a folder labeled archive you still learned something.

So don’t wait until you’re ready.
Start while you’re wrong.
Start while you’re underestimating everything.
Start while the dopamine is cheap and the illusions are strong.

Because once you’re in it, you’ll finish it.
Or you’ll fail funny. Both are wins.

Section 8: wrap-up productivity isn’t effort. it’s emotion.

Here’s what I’ve learned after tricking my brain with commit messages, terminal themes, and GitHub Actions confetti:

You don’t need to suffer to write good code.
You don’t need to “grind” to make progress.
And you definitely don’t need to wait for some mythical burst of motivation to get started.

What you need what most of us need is simple:

Visible rewards. Tiny wins. Feedback that feels good.

That’s it.

• A terminal that celebrates your push.
• A pipeline that claps for your linting.
• A theme that makes your editor feel yours again.
• A fake productivity counter that lies… but keeps you moving.

We spend so much time trying to become disciplined machines, when all we really need is a few small reasons to keep going.

You’re not broken.
You’re just bored.
And boredom is fixable with a little creativity and a lot of green checkmarks.

So no, you don’t need a 5 a.m. routine, a Notion second-brain, or a pomodoro timer with monk mode.
You need joy.
You need feedback.
You need reasons to smile when you type git push.

If it helps you ship code, it’s not silly. It’s strategy.

Now go build something.
Then commit.
Then push.
And smile like you just beat the boss level.

Conclusion: Your brain is not the bug your workflow is

You’re not broken for feeling stuck.
You’re not lazy for procrastinating every time a Jira ticket lands.
You’re not alone for wanting a little celebration when your code doesn’t explode.

In a world where everything feels like grind culture and burnout bait, building little pockets of joy into your workflow isn’t just clever it’s essential.

So forget discipline.
Forget guilt.
Forget waiting for the perfect tool, team, or tech stack.

Start now.
Hack your dopamine.
Color your terminal.
Celebrate the dumb wins.

Because when you design a feedback loop that makes you feel good, you accidentally become the kind of dev who keeps shipping.

And the truth is: that’s all you really need.

Go forth. Confetti awaits.

Helpful links & resources

Here’s a little starter pack to help you build your dopamine-driven dev playground:

• Oh My Zsh terminal themes, plugins, and custom prompts https://ohmyz.sh
• VS Code Themes change your coding vibe like it’s a playlist https://marketplace.visualstudio.com/vscode
• GitHub Actions get that sweet green check automation https://docs.github.com/en/actions
• Jest for test results with emoji-level joy https://jestjs.io
• VS Code Confetti Extension yes, this exists https://marketplace.visualstudio.com/items?itemName=Gruntfuggly.todo-tree
• Fig / Warp / iTerm2 terminals that actually respect your eyes and sanity https://fig.io | https://warp.dev | https://iterm2.com