DEV Community: Salar Khan

Listen up vibe coders, and basement wizards, this is for all of you.

Salar Khan — Sat, 24 May 2025 12:40:30 +0000

Salar Khan

May 24 '25

Stop Freaking Out—Your Career Isn’t Dead, You’re Just Avoiding the Hard Stuff

#llm #programming #beginners #mentorship

Comments

4 min read

Stop Freaking Out—Your Career Isn’t Dead, You’re Just Avoiding the Hard Stuff

Salar Khan — Sat, 24 May 2025 02:47:16 +0000

Advice for any developer who’s wondering whether to binge-watch another framework course or finally learn how TCP actually shakes hands.

“In a world where an LLM can blurt out 500 lines of boiler-plate in three seconds, what the hell am I supposed to do?”
— every developer on Slack at 2 a.m.

Welcome to the Great Developer Freak-Out of 2025. The hype machine says AI will soon write, test, deploy, and maybe even fire you while you binge-watch another JavaScript course you’ll never finish. Framework FOMO is raging, Twitter hot-takes are screaming, and half the LinkedIn gurus are promising that “ideas are the new code.”

Spoiler: they’re wrong. And so are the doomsayers insisting we need to go full basement-wizard, building our own kernels from punch-cards “or else.”

If you want the short answer, here it is:

AI kills busywork. It multiplies real expertise.
If you’ve been padding your résumé with shallow stuff, it’s time to grow up.
If you’ve got chops in the fundamentals, congratulations—your leverage just got absurd.

Let’s unpack that in a blunt, a little sweary, but (hopefully) useful style.

1 The Myth of “No-Code Everything”

LLMs can already crank out a React CRUD app faster than you can complain about the JSX. But when that app needs to scale, secure payments, or survive a Black-Friday traffic spike, guess what? The real problems show up in kernel logs, TLS handshakes, and cache-invalidation hell—places the shiny chatbot still gets lost.

AI kills the obvious. It stumbles on the invisible.
And the invisible lives in Computer Architecture, OS internals, Networks, and Security.

Yes, GitHub Copilot is finishing your for loops. Yes, GPT-whatever can scaffold a CRUD app faster than you can open a fresh VS Code window. No, the universe didn’t just solve distributed consensus, memory safety, or the dark art of not DDoS-ing your own micro-services.

AI is superhuman at autocomplete. It’s a toddler at architecture. That discrepancy widens as you move down the stack:

Layer	AI Skill	Human Skill Premium
CSS tweaks & pizza-button components	Godlike	🟡 Low
API glue & CRUD scaffolding	Great	🟠 Medium
Distributed systems, performance tuning, security hardening	Meh	🔴 Massive

Get it? The low-ceiling chores vanish. The stuff that keeps your pager buzzing at 3 a.m.? That’s still on you.

2 The Boring Truth: Basics Scale, Buzzwords Don't

Remember CS101 topics you skipped?

CS Building-Block	Why It Pays Off in 2025
Computer Architecture	Shave 5 ms off a GPU kernel and save your startup a six-figure cloud bill.
Operating Systems & Concurrency	Stop the “why is the site on fire?” 3 a.m. incident.
Networking	Latency math beats yet-another-JS-framework every time.
Security	AI still spits out SQL-injection if you aren’t watching.

You don’t escape these topics with AI; you get punished harder for not knowing them, because you’ll trust an LLM that sounds right until it quietly corrupts terabytes of customer data.

3 Receipts, Not Vibes

Hard numbers for the next time your cousin insists “AI took all the jobs.”

Speed boost: Controlled studies show GitHub Copilot users finish coding tasks up to 55 % faster. (The GitHub Blog)
Bug boost: Audits from NYU and multiple 2024 security papers find 25 % – 65 % of LLM-generated snippets contain exploitable flaws, especially around threads and I/O. (WIRED, SpringerLink)
Market signal: The U.S. Bureau of Labor Statistics projects 13 % growth for network/cloud architects through 2033—well above the average tech role. (Bureau of Labor Statistics)

Translation: AI is murdering toil, not talent. The bar just moved up the stack.

4 Your Five-Step Survival Plan

Audit Your Foundations
If you can’t diagram a three-way TCP handshake—or you forgot what a page fault is—schedule a weekend deep-dive. “Computer Networking: A Top-Down Approach” still slaps.
Pair With AI—Don’t Idolize It
Treat Copilot like gcc with opinions: great at syntax, clueless about semantics. Always ask, “Why is this safe?”
Dig One Layer Deeper Than Your Comfort Zone
FE dev? Trace the browser event loop. BE dev? Follow a syscall with strace and watch your container talk to cgroups.
Ship Small, Observe Hard
Automate deploy-and-test so you see knock-on effects. Half the learning happens in metrics dashboards, not the IDE.
Choose Problems, Not Frameworks
React vs. Svelte matters less than “Can users check-out in under a second?” Own the goal, swap the tool when it stops helping.

5 Relevance in One (Rude) Sentence

Stay the human who understands the invisible dragons AI can’t see—rather than the human who glues together another TODO-app tutorial.

6 Parting Shot

AI is the ultimate leverage amplifier.
If you’re shallow, it exposes you.
If you’re solid, it crowns you.

So quit doomscrolling. Crack that OS book. Then point your shiny new AI bazooka at problems that actually matter. Future-you (and your cloud bill) will thank you.

References

GitHub Blog Research, Quantifying Copilot’s Impact on Developer Productivity (2022). (The GitHub Blog)
NYU Tandon & Columbia Engineers, An Empirical Cybersecurity Evaluation of GitHub Copilot-Generated Code (2021). (WIRED)
Basso et al., You Still Have to Study: On the Security of LLM-Generated Code (Springer, 2025). (SpringerLink)
U.S. Bureau of Labor Statistics, Computer Network Architects Occupational Outlook (2025). (Bureau of Labor Statistics)

Why Your Code Doesn't Need to Be a Pristine Cathedral (and Other Lies Clean Code Told You)

Salar Khan — Mon, 12 May 2025 00:02:03 +0000

Let’s get something out of the way first: clean code is not a religion. It’s not a moral compass. It’s not the divine blueprint handed down from the software gods. It’s a tool. And like any tool, it can help you build beautiful things—or, if used like a brain-dead zealot, it can waste your time faster than a two-hour Zoom meeting about "synergy."

You're not here to write code that looks like it belongs in a museum. You're here to solve problems.

And the cold, brutal truth?

Sometimes solving problems means writing code that’s ugly. Messy. Full of shortcuts. And that’s okay.

In fact, that might be better.

But before you flip your desk and scream, “Blasphemy!” let’s dig into why.

💥 Cognitive Load Is the Real Villain, Not "Unclean" Code

Your brain—yes, that wrinkly meatball in your skull—is not optimized for obsessing over the Single Responsibility Principle like some neurotic monk. Your brain wants to do one thing: not be overwhelmed.

In cognitive psychology, there’s this lovely concept called cognitive load. It’s how much mental effort it takes to process information. The more load, the more your brain goes:

“Nope, f**k this,”

...and checks out.

When you’re organizing or refactoring code, your real job isn’t to make it look like it belongs in a programming textbook—it’s to reduce the cognitive load for whoever touches that code next (especially if that’s Future You, hungover on cold brew and existential dread).

Code that’s overly “clean” but scattered across 17 tiny files and 14 abstraction layers? 🧠 High cognitive load.
Code that’s “ugly” but understandable in five seconds? 🎁 A gift from the gods of sanity.

🪑 Abstractions Are Like IKEA Furniture: Use Sparingly, Assemble Carefully

Look, abstractions are useful. Nobody wants to repeat the same code like some digital Groundhog Day. But here’s the kicker:

Most developers treat abstractions like collectibles.

They create interfaces for their interfaces, repositories for their repositories, until you’re ten layers deep and can’t remember why you started programming in the first place.

From a cognitive standpoint, each layer of abstraction adds a mental hop. Your working memory—bless its tiny capacity—can only juggle so many things before it drops the ball and says, “I’m out.”

So ask yourself:

Are you abstracting to clarify, or are you abstracting to flex?

Because if it’s the latter, congratulations—you’ve become the software version of a guy who only talks in gym metaphors and wears protein powder like cologne.

🎯 Context Matters More Than Consistency

Here’s where most clean code cultists lose the plot: they believe the rules apply universally.

Always abstract.
Always DRY.
Always separate concerns.

As if software was a holy text and not a fluid, messy, living thing.

Psychology calls this contextual reasoning. It means your brain makes better decisions when it considers the specific situation rather than blindly following rules.

Want a good example?

Sometimes duplicating a few lines of code makes your logic clearer.
Sometimes having everything in one module helps you move faster.

Good code adapts. Great developers know when to break the rules.

🧠 Flexibility Is a Feature, Not a Flaw

There’s a certain breed of developer who thinks flexibility is a sign of weakness. They’ll slap your wrist for inconsistent spacing but won’t bat an eye at a function that takes eight arguments and triggers a mild panic attack.

Don’t be that person.

Psychologically, flexibility is linked to creative problem solving. Rigid minds cling to rules because they’re scared shitless of ambiguity.

But if you want to actually innovate—write code that solves hard problems in interesting ways—you need to get comfortable with a little chaos.

Refactor when it makes sense.
Abstract when it helps.
Ignore rules when they’re slowing you down.

And yes, sometimes that means your code won’t win a standing ovation from the Clean Code purists. That’s fine. You’re not writing for them.

You’re writing for progress.

🧭 The Real Question Isn’t “Is This Clean?” It’s “Does This Make Sense?”

At the end of the day, you’re not here to win the Refactoring Olympics.

You’re here to write code that works, that’s understandable, and that doesn’t turn your brain into mashed potatoes every time you revisit it.

So next time you’re knee-deep in a codebase wondering whether to break that file into smaller pieces, or whether to DRY that block, stop and ask the only question that matters:

“Does this help or does this hurt my brain?”

If it helps—do it.

If it hurts—don't.

And if you're not sure? Flip a coin and move on.

You’ve got better things to do than worship the Church of Clean Code.