Forem: azril hakim

Linux Is Not User-Friendly — And That’s Exactly Why I Use It

azril hakim — Tue, 13 Jan 2026 17:03:55 +0000

TL;DR:
Linux isn’t user-friendly in the “it hides complexity from you” way. Even the most beginner-friendly distros only soften the entry. At its core, Linux expects responsibility, understanding, and intent — and that honesty is exactly why I daily-drive it.

Let’s clear the bullshit early:
Linux is not user-friendly.

And before someone jumps in yelling “BUT ZORIN! BUT MINT! BUT POP!_OS!” — relax. We’ll get there.

I didn’t switch to Linux to feel superior, ideological, or open-source enlightened.
I switched because I got sick of operating systems that pretend nothing is wrong while everything is on fire underneath.

Linux doesn’t do that.
Linux tells you straight up: this broke, here’s why, deal with it.

I respect that.

User-Friendly Often Means “Don’t Ask Questions”

Modern operating systems are obsessed with being pleasant.
Click here. Don’t touch that. This setting is “managed.” Trust us.

Until something breaks.

Then the advice is always the same:

reboot
reinstall
wait for an update
or accept that “it’s just how it works”

That’s not friendly.
That’s opaque.

Linux doesn’t hide the mess.
It puts it right in front of you — logs, errors, configs, permissions, everything exposed.

No lies. No fake smiles.

“User-Friendly” Linux Distros Don’t Change Linux — They Delay It

Yes, distros like Linux Mint, Zorin OS, Pop!_OS, Elementary OS exist.

They are friendlier — on the surface.

They:

ship sane defaults
add GUI tools
smooth installation
reduce early friction
hide the terminal until you need it

But here’s the part people don’t like hearing:

They don’t change Linux’s philosophy.
They just postpone your first real encounter with it.

When something breaks outside the happy path — and it will — Linux still expects you to:

read error messages
check logs
understand permissions
touch config files
use the terminal

At that moment, the OS stops being “friendly” and starts being honest.

And that honesty is the point.

Linux Treats You Like an Adult

Linux assumes something radical:

You are responsible for your system.

That scares a lot of people.

But once you accept it, everything becomes clearer:

you know what’s running
you know what starts on boot
you know what has network access
you know where files live and why

Nothing is magic.
Nothing is hidden “for your own good.”

The OS stops babysitting you and starts obeying you.

Linux Isn’t Hard — It’s Just Unfamiliar

Linux isn’t hard.
It’s explicit.

The terminal doesn’t exist to intimidate you.
It exists to remove ambiguity.

It doesn’t guess what you want.
It waits for you to say it clearly.

One command. One outcome.
No guessing. No silent behavior.

Once you stop expecting Linux to read your mind, it becomes predictable.
And predictability beats friendliness every single time.

Daily-Driving Linux Changed How I Think

Using Linux every day forced me to understand:

how processes really work
why permissions matter
how the filesystem is structured
how dependencies actually behave

That knowledge spills everywhere:

development
servers
Docker
debugging
system design

Linux didn’t just change my OS.
It rewired how I think about software.

Is Linux for Everyone? Absolutely Not.

If you want:

zero responsibility
no configuration
no reading errors
everything to “just work” forever

Linux will piss you off.

And that’s fine.

But if you want:

control over comfort
transparency over polish
tools instead of toys

Linux makes sense.

Final Thought

Linux isn’t user-friendly.
It’s honest.

It doesn’t protect you from reality.
It exposes it.

And once you get used to that level of honesty,
every other OS starts to feel like it’s quietly lying to you.

Building With AI Made Me Realize How Often We Don’t Understand Our Own Code

azril hakim — Sun, 11 Jan 2026 17:38:21 +0000

The first time I used AI seriously for coding, I didn’t feel replaced.
I felt exposed.

Not because the AI was smarter than me — but because it kept asking questions my own code couldn’t answer.

That experience changed how I see both AI and software development.
AI doesn’t replace developers. It reveals how clearly we think about our work.

“It Works” Isn’t the Same as “It’s Understood”

Many of us evaluate code with a simple metric:

Does it work?

If the answer is yes, we move on.
But working code doesn’t always mean well-understood code.

When you involve AI — asking it to refactor, optimize, or extend an existing system — it immediately asks questions like:

What is the goal here?
What constraints should be respected?
What tradeoffs were intentionally made?

If those answers aren’t clear, the limitations surface quickly.

AI Fills the Gaps We Leave Undefined

A common criticism of AI tools is that they “hallucinate.”
In practice, what often happens is more subtle.

When we give vague instructions like:

“Refactor this”
“Make it scalable”
“Improve performance”

…without defining intent or constraints, we’re asking the AI to make assumptions on our behalf.

AI doesn’t struggle with ambiguity — it responds to it.
The output reflects the clarity (or lack of it) in the input.

Prompting Is Mostly About Thinking Clearly

There’s a lot of discussion around “prompt engineering,” but in day-to-day development, good prompts usually come down to clear reasoning.

Effective prompts tend to answer:

What problem are we solving?
What must not change?
What constraints matter?
What tradeoffs are acceptable?

If writing a prompt feels difficult, it’s often because those questions haven’t been answered yet — not because the wording isn’t clever enough.

AI Encourages Better Explanations

One unexpected benefit of working with AI is how often it forces clarification.

When extending or modifying code, AI naturally pushes back with questions:

Why is this structured this way?
Why is this state shared?
Why is this synchronous or asynchronous?
What assumptions does this depend on?

Answering those questions improves the codebase — whether the AI is involved or not.

Why This Is a Positive Shift

Used thoughtfully, AI encourages better habits:

Clearer intent
Explicit constraints
Better documentation
More deliberate design decisions

It discourages vague, assumption-heavy development and rewards clarity.

In that sense, AI works less like a replacement and more like a continuous review loop — one that responds immediately to how well we articulate our thinking.

The Skill Gap AI Makes Visible

The biggest gap AI highlights isn’t about:

Syntax
Framework familiarity
Memorizing APIs

It’s about:

Systems thinking
Understanding tradeoffs
Explaining decisions clearly
Knowing why something exists

Those skills compound. AI simply makes them more visible.

Final Thought

AI didn’t make me a better developer.

It made me more aware of the difference between code that works
and code I actually understand.

And that awareness has been far more valuable than any autocomplete.

Most Developer Productivity Tools Are Just Procrastination With Better UX

azril hakim — Thu, 08 Jan 2026 20:37:29 +0000

Let me start by snitching on myself.

I’ve spent hours tweaking productivity systems.
Renaming folders.
Reorganizing notes.
Refactoring my “second brain.”

Obsidian graphs looking clean as hell.
Notion dashboards aesthetic.
Todo lists perfectly structured.

And somehow… nothing important shipped.

That’s when it hit me:
Most productivity tools don’t make developers productive.
They make us feel productive — which is way more dangerous.

The Lie We Keep Buying

The lie is simple:

“If I just find the right tool, everything will click.”

So we chase:

A better note-taking app
A cleaner task manager
A smarter system
A new workflow video on YouTube

And every time, there’s a short dopamine hit:

“Damn, this setup is clean.”

But clean setups don’t ship code.
Execution does.

Tools promise clarity.
What they actually give is comfort.

Productivity Tools Are Safe — That’s the Problem

Real work is uncomfortable:

Writing ugly first drafts
Shipping half-polished features
Letting users touch your work
Being seen before you’re “ready”

Productivity tools protect us from that discomfort.

Instead of shipping, we:

Reorganize notes
Rewrite goals
Redesign systems
Optimize plans we haven’t executed once

It feels responsible.
It feels smart.

It’s still avoidance.

The Trap: Planning as a Disguise for Fear

Here’s the pattern I noticed (and maybe you’ll hate this because it’s true):

Planning feels productive
Execution feels risky
Tools let us stay in planning mode forever

We tell ourselves:

“I’m not procrastinating, I’m preparing.”

Bullshit.

If preparation never turns into output, it’s just procrastination wearing a nicer UI.

What Actually Changed Things for Me

Things didn’t change when I found a better tool.

They changed when:

I built stuff for real people
I had external pressure
I knew someone else would see the result

Shipping a product — even a small, ugly one — killed the illusion instantly.

Suddenly:

Notes became irrelevant
Motivation didn’t matter
Systems shrank to the bare minimum

Output forced clarity.
Not the other way around.

My Personal Rules Now (Steal These)

I still use tools. I’m not anti-tool.

I’m anti-tool worship.

These are the rules I live by now:

If a tool needs weekly “maintenance”, it’s a red flag
Tools should disappear during execution, not demand attention.
One system only — ugly is fine
If I need a tutorial to use my own system, it’s already failed.
Execution time > organization time
If I spent more time organizing than building, I fucked up.
Shipping beats clarity
Clarity comes after action, not before.
If it doesn’t help me ship this week, it doesn’t matter
Long-term systems that never touch reality are just fantasies.

The Hard Truth Most Devs Avoid

Most developers don’t need:

Better productivity tools
Smarter systems
More motivation

They need:

Fewer excuses
Less hiding
More unfinished work shipped into the world

The work is supposed to feel boring sometimes.
Confusing.
Uncomfortable.

If your productivity setup feels amazing but nothing ships — it’s not helping you.
It’s protecting you.

And protection is the enemy of progress.