The 2026 Tech Hiring Paradox: Same Market, Opposite Signals

The tech job market right now makes no sense — at least on the surface.

Over 55,000 tech workers have been laid off in early 2026 across 171 companies. The sector unemployment rate has climbed to 5.8%, a level not seen since the dot-com collapse. Amazon alone cut 16,000 jobs. And yet: software engineer job postings are up 11% year over year. CompTIA is flagging a hiring rebound. AI/ML engineer titles are proliferating at a rate that suggests companies can't staff these functions fast enough.

Both of these things are true at once, and if your sourcing strategy wasn't built for this, you're probably feeling it: either drowning in mediocre inbound applications or struggling to close the specific engineers you actually need.

"Cut and redirect" isn't a recovery. It's a rotation.

The dominant pattern in 2026 tech layoffs has a name: cut and redirect. Companies aren't stepping back from engineering investment. They're rotating headcount away from traditional software development roles and toward AI infrastructure, ML platform engineering, and whatever roles have "AI" somewhere in the job description. Roughly 20% of layoffs this year were explicitly attributed to AI and automation by the companies themselves, up from less than 8% in 2025.

This matters because the pool of available engineers has changed in character, not just in size. There are a lot of displaced developers in the market who were doing solid work but got caught in a structural shift at their company. There's also a smaller, harder-to-find group who are still actively employed and shipping consistently: the people not on LinkedIn refreshing their profiles because they're too busy actually building.

Which pool you're drawing from matters more than it did three years ago.

Why resume-based screening fails in a flooded market

When 55,000 people get laid off, a lot of them update their resumes at the same time. Job boards flood. LinkedIn DMs from sourcers become noise. Recruiters I've spoken with at mid-market companies report that volume is way up but quality-to-quantity ratio has dropped: they're spending more time to close the same number of hires.

The problem is structural. Resume-based screening was never great at separating real engineering ability from polished self-presentation, but in a normal market the signal-to-noise ratio was manageable. In a flooded market, it collapses. A layoff from a major tech company tells you almost nothing. It could mean this person was on a team that built excellent infrastructure and got caught in a headcount restructure. It could also mean they were coasting on FAANG brand equity for three years. The resume doesn't distinguish between those.

This is where contribution-based hiring stops being a nice-to-have.

What "skills-based hiring" actually means for engineering roles

There's a lot of talk about skills-based hiring in 2026. The data behind it is real: 94% of employers say skills-based approaches are more predictive of on-the-job performance than resume screening, and companies using them fill positions about 25% faster. Job postings requiring a four-year degree have dropped 33% since 2019.

But for engineering specifically, "skills-based hiring" needs to mean more than a take-home coding test. The most reliable signal isn't what someone says they can do, or what they demonstrate in a two-hour assessment. It's what they've actually shipped, reviewed, maintained, and debugged over time.

GitHub contribution history gets at this reasonably well. Not the vanity metrics (stars, followers, repository count) but the substantive activity: commit patterns, pull request quality, code review behavior, consistency of contribution across months and years. An engineer who has been steadily shipping meaningful PRs to a production codebase for two years is telling you something a resume cannot.

The problem with raw GitHub data is that it's dense and time-consuming to read. A recruiter looking at someone's contribution graph has no easy way to know if those 400 commits represent meaningful engineering or minor documentation updates. This is what tools like riem.ai are built for: analyzing actual contribution content across 30M+ monthly GitHub events to surface engineers based on what they've built, not just that they've been active.

There's another layer here that's easy to overlook. Not all GitHub activity is equal, and the differences matter for hiring decisions. Someone who opens pull requests, gets substantive code review, addresses reviewer feedback, and ships to main is demonstrating something real about how they work. Someone who pushes commits directly to their own repos without any review loop is showing you a much narrower slice. Engineers who participate in collaborative review cycles on active projects are the people who tend to ramp up faster, communicate better during incidents, and integrate into teams without friction. That's harder to see on a resume, and it shows up clearly in contribution history if you know where to look.

The engineers nobody else is looking at

Here's what I think is the actual opportunity in this market, and most recruiters are missing it.

The engineers hardest to find right now are the ones who haven't been laid off. Fully employed. Probably not browsing job boards. Didn't touch their LinkedIn profile in the last 90 days. They're building things. Their GitHub is full of real work. They're exactly who you want.

These engineers are invisible to traditional sourcing because traditional sourcing is reactive. You post a job, wait for applications, or trawl LinkedIn for people who signal openness. None of those channels get you to someone who's quietly doing excellent work and hasn't thought about leaving yet.

Proactive sourcing from contribution data is the alternative. Instead of "who is available?", you ask "who has actually built the kind of system we need, and would it be worth starting a conversation?" That second question is harder to answer. The answer matters a lot more.

High-quality code contributions plus low social visibility: that's the profile of someone your competitors haven't found yet. In a market where everyone is fishing the same pool of recently-displaced engineers, the recruiter who can identify the quietly-excellent-and-employed candidate is going to consistently close better hires.

Adjusting your process for this market

A few practical shifts worth making:

Treat your inbound and outbound channels as genuinely separate pipelines. Right now, inbound skews heavily toward recently displaced engineers. That's not disqualifying. But the evaluation criteria should be different, the urgency is different, and mixing them together will create confusion in your process and probably cause you to miss good people in both pools.

Move contribution signals earlier. If you're waiting until after a phone screen to look at someone's GitHub or past work, you're doing it backwards. For candidates who have public work history, that history should be informing who you reach out to in the first place, not serving as an afterthought once they're already in the funnel.

Spend real time on outreach. This sounds obvious and almost nobody actually does it. "I came across your profile" is not outreach. "I noticed you've been contributing to [specific project] and we're building something similar" is outreach. Engineers can detect generic recruiter messages immediately, and the response rates reflect that. Outreach personalized from actual commit data generates substantially higher reply rates than any standard template.

Don't over-index on the AI skills premium. Yes, AI/ML roles are commanding a premium and companies are scrambling to fill them. But most engineering work in 2026 is still backend systems, infrastructure, data pipelines, and application development. The engineers who do that work reliably and who can show it in their contribution history are in real demand too, and often less aggressively competed for than the AI specialists everyone is chasing right now.

The market won't sort itself out neatly

The 2026 tech market will keep being contradictory. Companies will keep rotating headcount, layoff announcements will keep appearing alongside hiring pushes, and the number of available engineers won't map cleanly onto hiring difficulty. Trying to time it or wait for it to stabilize is a losing strategy.

What won't change is that the engineers doing the most interesting work are usually not the ones shouting about it. They're shipping, not posting. They're reviewing pull requests, not updating their LinkedIn summaries. The market chaos is actually useful cover for finding them: your competitors are busy managing the inbound flood, running generic outreach sequences, and waiting for the "best" candidates to appear. Meanwhile, the contribution record of anyone who's been seriously building for the last two years is sitting in public, readable by anyone who knows how to look.

The teams that do well in this aren't the ones with the biggest sourcing budgets. They're the ones who got better at asking the right question: not "who is available?" but "who has actually built what we need?" Building a workflow that answers that second question quickly is the highest-leverage change most recruiting teams can make right now.