Every week I watch my son grind for an entry level programming role. He has graduated. He writes C++ that leaves me stunned. And still he is stuck answering screening questions like “do you know ReactJS” from people who can barely parse their own script.
It was not this brutal when we came through. A side project, a spark of curiosity, and someone would give you a shot. Now the filter is a stack of buzzwords. Not fundamentals. Not engineering. Just the fashion of the month.
The Infrastructure Nobody Sees
This is the absurdity. The industry still runs on C, C++, the infrastructure no one sees. Operating systems. Compilers. The engines under everything. The game engines, the embedded systems, the networking stacks, the firmware that keeps planes in the air and cars on the road. That code does not care about your component library.
Yet we screen the next generation on whether they have memorized a frontend library API call. We confuse tool familiarity with talent. A recruiter who cannot explain what a pointer does will reject a candidate who can write a memory allocator, because the resume did not mention React.
We lost the ability to measure raw ability and replaced it with keyword matching.
The screening process is not filtering for engineers. It is filtering for people who look like engineers on paper. There is a difference, and it is getting wider every year.
The Grind Nobody Sees Either
He keeps coding anyway. Builds projects no recruiter will ever see. Unreal Engine work in C++ that handles state machines, physics interactions, procedural generation. The kind of engineering that requires you to understand memory, threading, and architecture at a level most web developers never touch.
None of that fits in a checkbox.
The candidates who spend their time building deep technical skill are the same candidates who have the least time to optimise their resumes for automated filters. The system punishes depth and rewards surface area.
That grind is what survives past trends. React will be something else in five years. The fundamentals of systems programming will still be there. Pointers do not go out of fashion. Memory management does not get deprecated. Concurrency is not a framework you swap out when the community moves on.
How Did We Get Here
Somewhere along the way, hiring stopped being about finding people who can think and started being about finding people who match a template. The template changes every eighteen months. The thinking does not.
Part of it is scale. When you get a thousand applications for one role, you need a filter. But the filter we built is stupid. It matches strings, not capability. It rewards the candidate who spent a weekend adding keywords to their LinkedIn over the one who spent six months building something real.
Part of it is fear. Hiring managers do not want to explain a bad hire. So they hire safe. Safe means familiar stack, familiar background, familiar vocabulary. Safe means the person who can talk about hooks and state management in the interview, even if they cannot reason about a system under load.
How did we get to a place where someone who can write real systems code gets asked to parrot framework trivia instead?// The question that haunts me
The answer is uncomfortable. We got here because the people doing the filtering are not qualified to evaluate what they are filtering. They are matching patterns, not assessing engineers. And until that changes, talent will keep slipping through the cracks while mediocrity walks through the front door with the right keywords on a PDF.
// SENSOR_DATA_OVERLAY: FIELD_INTENSITY 0.92Hz
// "The design isn't just a shell; it's a sensory interface for the model's weights."
