Every few months, the web dev world collectively decides we’re all doing things wrong again.
Right now it’s:
AI everywhere
Rust everywhere
WebAssembly everywhere
Low-code “replacing developers” everywhere
Recruiters see these words on resumes all day.
So instead of listing them, I tried something radical.
I asked: What did these trends actually teach me as an engineer?
AI Didn’t Turn Me Into a 10x Dev
It Turned Me Into a Better Reviewer
AI can write code faster than I can.
That’s fine.
What it can’t do is explain why the code is shaped the way it is.
Using AI taught me three things fast:
- If I can’t review it, I shouldn’t ship it
- “It works” is not a quality bar
- Bad systems + AI = faster disasters
AI didn’t replace my job.
It made thinking non-optional.
Rust and WebAssembly Taught Me Humility
Rust promised safety.
The compiler delivered emotional damage first.
WebAssembly promised performance.
Tooling reminded me reality exists.
What I learned:
- Performance is useless if users don’t feel it
- Safety is great once you understand the cost
- Shiny tech doesn’t save unclear design
Trends are fun.
Shipping is sobering.
Low-Code Didn’t Kill My Skills
It Killed My Excuses
Low-code removed the boring parts.
Which meant I couldn’t hide behind boilerplate anymore.
What was left?
- Architecture decisions
- Data flow
- Edge cases
- Things breaking at 2 AM Low-code didn’t reduce my value. It raised the bar.
What I Actually Optimize For Now
Instead of chasing tools, I optimize for:
- Code someone else can understand
- Systems that survive change
- Decisions that age well
- Fewer “we’ll fix it later” moments
I still learn new tech.
I just don’t confuse novelty with progress.
For Recruiters (HEYYYYYYY)
Anyone can list stacks.
What teams really need are engineers who:
- Learn fast without breaking things
- Ask annoying but important questions
- Think in systems, not snippets
- Can explain their code without sweating
That’s the kind of engineer I’m trying to be.
If that sounds useful, we’ll probably get along.
Top comments (3)
Really solid perspective—this shows maturity beyond chasing buzzwords, and I like how you focus on what these trends actually change in how you think and build. That mindset is exactly what creates resilient systems and engineers teams can trust, and it’s the kind of approach I genuinely value and want to work with.👍
Great response.🎉
AI is surprisingly good at explaining the structure of code—things like patterns, idioms, and why a certain approach is common in the ecosystem.
What it doesn’t have is the lived context behind a specific decision: the constraints, the tradeoffs, the messy real‑world pressures that shape a solution.
So I see it this way:
AI explains the pattern. Humans explain the situation.
Both matter. Both are useful. And together they make the work easier, not smaller.