Some engineers pride themselves on playing on hard mode.

They’ll scoff when a teammate reaches for an ORM, a serverless runtime, or an AI assistant because “real engineers know what’s happening under the hood.”

Here’s the truth: software has always been the art of standing on someone else’s breakthroughs. Knowing the layers beneath an abstraction is valuable, but refusing to stand on those shoulders is self-sabotage.

There are no awards for playing on hard mode. Just ship.

Abstraction is the default, not the exception

COBOL abstracted away punch cards.

C abstracted away assembly.

Python abstracted away manual memory management.

Every generation’s cheat code becomes the next generation’s baseline. Declaring today’s tools “unworthy” doesn’t make you rigorous; it makes you the main character in a sixty-year-old rerun.

Struggle ≠ Value

Old-school engineers love to flex their pain:

  • “I once deployed a monolith with Bash and Perl!”
  • “We didn’t need Docker; we installed everything manually in prod.”
  • “I wrote a full web app before React even existed!”

Neat. None of that suffering makes the product better. Using Docker, CDK, Justfile, Tailwind, Rails, pick your abstraction, doesn’t make you soft; it makes you efficient. Nobody hands out extra credit for solving a problem the hard way.

Knowledge ≠ Drudgery

Understanding file descriptors doesn’t obligate you to re-implement fopen each morning. Deep knowledge should empower you to move faster, not chain you to the basement. Use abstractions as leverage; break the glass only when you actually need to.

“Back in my day…”

Here come the war stories:

  • “We had to fit entire programs into 512 KB of RAM.”
  • “We hand-rolled every API route in Perl and we liked it!”
  • “Young devs today are too dependent on Django and Rails.”

You did more with less. Respect.

But if you’re still acting like Supabase is cheating or Rails makes devs lazy, you’re not being wise, you’re being obsolete. I bet those same lazy devs also cheat by using a dishwasher.

Modern tools like Firebase, Playwright, and Bun exist for a reason: they get us to done faster.

Customers pay for outcomes, not heroics

Your users don’t award bonus points because you handcrafted every SQL statement or wrote CSS from scratch. They click, swipe, and pay for features that work. They judge latency, not lineage. We’re not building temples to elegance; we’re building products.

The Scale Mirage

Here’s the inevitable objection:

“If you stack too many abstractions, your code gets bloated and inefficient!”

Sure. At hyperscale, shaving off 10ms or a few hundred megabytes can save real money. And if you’re running millions of transactions a second, yeah, you’ll want to care.

But let’s be real: most teams are not hyperscale. They’re pre-revenue. Pre-launch. Pre-anyone-giving-a-shit.

For 99% of systems, the overhead of modern abstractions is irrelevant. And the teams that do hit scale? They’ll have the time, money, and engineering talent to dig into the layers and optimize. That’s a good problem to have.

Don’t build like you’re Google when you don’t even have customers. Don’t sacrifice speed for some hypothetical future where your app becomes a global service.

Get it working, ship it fast, and optimize if, and only if, it starts to matter.

AI Coding Tools: Better, Faster, and Good Enough

AI coding tools are the latest thing engineers love to shit on.

They’ll sneer at Claude or o3-generated code like it came from a freshman CS student. “It’s not idiomatic.” “It’s inefficient.” “It’s not how I would write it.” Cool. But it works. And it took 90 seconds, not 3 days and a Reddit argument about design patterns.

Used well, AI coding assistants do write better code, because they write it faster. Boilerplate, tests, docs, API scaffolding, config; you get it immediately. And if the output isn’t perfect? It’s still a head start. You’re editing, not inventing.

And if the code is just okay, but the feature ships today instead of next sprint? That’s not a loss. That’s a win.

Meanwhile, the “real engineers” will still be hand-tuning Vim macros and mocking AI devs, while their competitors with half the headcount and twice the speed, eat their lunch.

AI tools aren’t cheating. They’re the new compiler. Get comfortable with this.

Stand on the shoulders, then reach higher

Abstractions aren’t crutches; they’re force multipliers.

You’re not paid to prove you can swing a stone axe. You’re paid to deliver value. Let the abstractions carry the weight they’re designed for and spend your energy where it matters: product, polish, and people.

There are no medals for shunning abstractions. Ship the thing and move on.