Days in the Life of Mo

At some point in my career, I stopped asking “Why is my code broken?” and started asking a much deeper question:

Why am I broken?

That’s when I realized developers, much like humans (because unfortunately we are), have needs. Very specific ones. And if those needs are not met, nothing else matters. You can talk to me about clean architecture and scalability all you want, but if my environment isn’t set up? I’m not emotionally available for that conversation.

Psychologist Abraham Maslow proposed that humans have a hierarchy of needs; food, safety, belonging, self-actualization, and the idea is simple: if your basic needs aren’t met, you’re not ascending to your highest potential anytime soon.

Developers are no different. We just replace food with coffee and emotional safety with a stable internet connection.

So here it is. Not peer-reviewed. Definitely felt.

Level 1: Survival Mode

This is the foundation. The fragile ground everything else sits on.

• A working laptop
• Internet that doesn’t disappear during meetings
• Coffee. Tea. Water. Something.
• An IDE that opens without throwing attitude

If any of these fail, productivity collapses immediately. You can’t debug a system while your fan sounds like it’s trying to leave this earth. Studies on developer productivity consistently show that environmental friction; slow machines, bad tooling, significantly impacts focus and output (see research summarized by Stack Overflow and Microsoft’s developer productivity reports).

At this level, we are not ambitious. We are simply trying to exist.

Level 2: Safety and Stability

Now the code can run… but can it run again?

• Version control that works
• Backups you trust
• A build pipeline that doesn’t break when you look at it
• Code that compiles today the same way it did yesterday

This is where fear lives. Fear of deleting the wrong file. Fear of pushing on a Friday. Fear of touching “legacy code” written by someone who vanished in 2017.

Maslow talked about safety as predictability and control. For developers, that translates to systems we can rely on, and research from Google’s DORA reports backs this up: stable systems and good DevOps practices reduce burnout and improve performance.

Level 3: Belonging

Ah yes. Community. Validation. Someone else who understands your pain.

• A teammate who replies “same” when things break
• Code reviews that don’t feel like public executions
• Slack messages that include emojis instead of passive aggression
• Knowing you’re not the only one confused

Developers thrive when they feel psychologically safe, a concept Google famously identified as the number one factor in high-performing teams. When you feel safe asking “Is this stupid?” without consequences, growth happens.

Until then, we quietly Google things we definitely should know by now.

Level 4: Esteem

This is where confidence starts forming.

• Your PR gets approved without comments
• Your solution becomes the solution
• Someone says, “Can you take a look at this?”
• You explain a concept and it actually lands

Esteem isn’t about ego. It’s about competence being recognized. Research in workplace psychology consistently shows that recognition is a major driver of motivation; and developers are no exception. We pretend we don’t care, but we absolutely do.

This is also the level where imposter syndrome likes to hang out. Loudly.

Level 5: Self-Actualization (or Whatever This Is)

Very few developers live here full-time.

This is the phase where:

• You refactor for fun
• You write code and it feels… clean
• You mentor others without panic
• You build things that feel meaningful

You’re no longer just solving problems; you’re shaping systems, improving processes, and maybe even enjoying yourself a little. Maslow described this as fulfilling one’s potential. For developers, it’s when the work feels aligned, intentional, and human.

And then your internet drops.

And you’re back at Level 1.

---

Before You Go

If you enjoy thoughtful, slightly unhinged reflections on developer life; the kind that sit somewhere between code and coffee-fueled introspection, subscribe to the blog. I write about building software, breaking it, and occasionally learning something in between.