CS Grads Now Have Higher Unemployment Than Fine Arts Majors. What Happened?

For twenty years, the computer science degree was the closest thing American higher education had to a sure bet. Parents pushed their kids toward it, politicians built policy around it, and universities expanded departments to meet demand that seemed structurally permanent. Then the New York Fed published its latest College Labor Market data, and the sure bet inverted: recent computer science graduates now face 6.1% unemployment and computer engineering graduates 7.5%, against roughly 4.8% for all recent graduates. Read that again with the comparison the internet immediately seized on — at 7.5%, fine arts majors are now more employed than computer engineers. The punchline writes itself. The explanation does not, and getting it right matters enormously for the students deciding what to study and the companies deciding whether to hire them.

The Numbers, Without the Memes

Start with what the data actually says, because the discourse has been running ahead of it. The New York Fed's College Labor Market series tracks outcomes for recent graduates — degree holders early in their careers — by major. In the latest release, computer science sits at 6.1% unemployment and computer engineering at 7.5%, both well above the ~4.8% average across all recent graduates. These are not the worst numbers in the table's history for any major, but they are shocking for these majors, which spent two decades clustered comfortably below the average.

The broader graduate market is soft too, which is part of the story: recent-graduate unemployment overall hit 5.7% in Q4 2025, worse than at any point during the 2008 financial crisis, and underemployment — graduates working jobs that do not require a degree — reached 42.5%, the highest since 2020. But the soft market does not explain the inversion. In every previous downturn, technical majors suffered less than the average. This time they are suffering more, which means something specific is happening to technical entry-level work rather than to graduates in general.

One compositional caveat belongs on the record before the argument proceeds. CS graduating classes ballooned through the late 2010s and early 2020s — the majors' unemployment rates are now measured against the largest cohorts in their history, graduating into the smallest entry-level market in a decade. Some of the inversion is therefore a denominator story: more graduates chasing fewer openings will raise the rate even if each individual graduate is no less employable than before. But the caveat only reframes the question; it does not dissolve it. The cohorts grew because the market told them to. Something changed on the demand side after the invitation went out, and the rest of the data points at what.

The Entry-Level Vise

That something specific shows up unmistakably in the entry-level hiring data. Handshake, which sits on top of the university-to-employer pipeline, reports entry-level software engineering roles down 30% year over year. The competition for what remains has reached numbers that would have sounded invented five years ago: tech internship postings now draw an average of 273 applications each. An internship — the on-ramp's on-ramp — has become more selective than most full-time jobs used to be.

Behind those numbers is a change in what employers believe about junior work itself. A 2024 SHRM survey found 70% of hiring managers saying AI can do the work they would assign to an intern, and — more striking — 57% saying they trust AI output more than work produced by recent graduates. Whether those beliefs are accurate is almost beside the point; hiring decisions run on beliefs. When a majority of the people who control entry-level requisitions think a subscription outperforms a salary, the requisitions stop being opened.

We have traced this dynamic before from the employer side: in our analysis of the missing rung, junior developer roles fell roughly 20% from 2024 while senior engineers at the same companies received raises. The NY Fed data is the same phenomenon measured from the graduate side. Companies did not stop valuing engineering; they stopped valuing the apprenticeship stage of it, and the people standing on that stage are the ones showing up in the unemployment statistics.

Did AI Do This? The Honest Answer Is: Contested

The instinctive explanation — AI ate the entry-level jobs — has serious academic support and serious academic opposition, and intellectual honesty requires presenting both. The strongest evidence for the AI explanation is the Stanford Digital Economy Lab's November 2025 study, "Canaries in the Coal Mine?", by Erik Brynjolfsson, Bharat Chandar, and Ruyu Chen. Working with ADP payroll records covering 3.5 to 5 million workers — actual employment data, not surveys or postings — they found that employment for young workers in the occupations most exposed to generative AI has declined measurably since late 2022, while employment for older workers in the same occupations and young workers in less-exposed occupations held up. Software development is among the most exposed occupations in their classification. The canary metaphor is the authors' own: the young, in the exposed jobs, are the first to feel the gas.

The counter-evidence is not flimsy. A Federal Reserve study examining more than a million firms found no relationship between a firm's AI adoption and reductions in its job postings — the firms adopting AI most aggressively were not the ones cutting entry-level hiring. The Stanford Review, among others, has pressed the skeptical case: AI is a "convenient scapegoat" for a hiring contraction that is better explained by interest rates, the unwind of pandemic overhiring, and a sector digesting the worst overexpansion in its history. The dot-com parallel is instructive — CS grads faced a brutal market in 2002 and 2003 too, no AI required, and enrollment crashed in response just as it is starting to now.

The most defensible synthesis is that both forces are real and they compound. The macro contraction created the conditions — hiring freezes, efficiency mandates, an excuse to experiment — and AI changed what happened inside those conditions. In previous downturns, a hiring freeze deferred junior hiring; companies resumed it when budgets recovered because the work still needed doing. This time, during the freeze, teams discovered that AI tools could absorb much of the work juniors used to do, and the SHRM numbers show that discovery hardening into belief. The freeze may have started the fire, but AI is why it is not going out on the usual schedule.

What the Doom Narrative Gets Wrong

Now the part the memes leave out. The median starting salary for CS graduates who do land jobs persists at roughly $80,000 — essentially unmoved through the entire contraction. That is not what a dying field looks like; it is what a field with a broken matching market looks like. Demand has not collapsed so much as it has become violently selective. Employers are not paying less for entry-level engineering talent. They are paying the same amount for a much narrower definition of it.

The selectivity has a clear shape: specialists are outperforming generalists across every dataset that distinguishes them. Graduates with demonstrable depth in AI tooling and infrastructure, cloud and platform engineering, embedded systems, or security are clearing the market at rates that look like 2019. What stopped clearing is the undifferentiated middle — the generalist CS degree plus a framework tutorial portfolio, the profile that the 2010s absorbed by the hundred thousand. That profile competed against other juniors before. Now it competes against AI tooling in the mind of the SHRM survey's 70%, and it loses.

Meanwhile the hiring process itself has been destabilized by the same technology, in ways that hurt new graduates disproportionately. The traditional algorithmic screen — the one thing a diligent student could reliably prepare for — has lost its signal value now that models solve LeetCode problems in seconds, a collapse we dissected in our analysis of how AI broke the coding interview. The grind-LeetCode path rewarded exactly the kind of preparation students could do without industry access. Its replacement — judgment-heavy, experience-flavored evaluation — favors candidates who already have what new graduates by definition lack.

The Enrollment Whiplash Is Coming

Markets for education overcorrect with a vengeance, because the people making enrollment decisions are reacting to today's headlines while buying an asset that matures in four to six years. Forrester now predicts a 20% decline in CS enrollments — students reading the fine-arts-majors-are-more-employed discourse and choosing accordingly. The last time this happened, after the dot-com crash, CS enrollment fell by roughly half, bottomed around 2007, and delivered its graduates into the strongest tech labor market in history. The students who enrolled into the fear graduated into the boom.

This is the structural argument we made in our analysis of the junior developer career crisis, and the NY Fed data is its grim confirmation in aggregate: companies that refuse to hire juniors because "AI can do junior work" are the same companies that will spend the early 2030s complaining they cannot find experienced engineers. The career ladder is a supply chain. Cutting its first stage does not save the cost of the later stages; it defers the cost, with interest, to a future hiring market that will have pricing power.

Advice for Students: Play the Market That Exists

If you are a student or recent graduate, the data suggests a strategy more specific than "learn to code harder." First, specialize early and visibly. The market is paying for depth in AI tooling, cloud infrastructure, embedded systems, and security; it is not paying for a fourth identical CRUD portfolio project. One genuinely deep artifact — a deployed system with real users, a meaningful open-source contribution, original work in a specialized domain — beats breadth every time in a 273-applicants-per-posting market, because the filter is no longer "can code" but "can do something the tools cannot."

Treat experience acquisition as the actual degree requirement, with coursework as the supporting material. The graduates clearing this market almost all share one trait: they did not wait for the credential to start working. Research labs, open-source maintainership, freelance contracts, co-ops at unfashionable companies — every one of these produces the thing the 273-applicant filter is actually screening for, which is evidence of functioning in a real engineering context rather than a pedagogical one. The internship math is brutal, but internships are not the only source of the asset internships used to provide.

Second, build verification skills deliberately, because the job you are interviewing for is increasingly supervisory. Practice reviewing AI-generated code for the subtle failures — the plausible-but-wrong API usage, the security hole, the edge case the model never considered. Counterintuitively, this means doing substantial work without AI during your training years: you cannot audit what you could never have built. Third, widen the search beyond the tech industry. The NY Fed numbers measure majors, not destinations, and the firms still hiring graduates in volume are banks, manufacturers, healthcare systems, and government — places the layoff headlines never mention because they were never overhired.

Advice for Companies: You Are Cutting the Wrong Cost

For engineering leaders, the calculus deserves more scrutiny than it is getting. The case for not hiring juniors rests on a static comparison: AI does intern-level work at intern-level quality for a fraction of the cost. Granted. But the comparison prices the junior's first-year output, which was never the point of hiring juniors. The point was the second-through-tenth-year output of someone who knows your systems, your domain, and your failure history — an asset AI does not produce and the external market is about to stop producing too.

The leverage move is not to resume 2021-style bulk hiring. It is to redesign the junior role for the AI era: smaller cohorts, hired deliberately, trained as verification-first engineers who learn the codebase by auditing and testing agent output under senior review rather than by grinding tickets. Teams running this model report juniors reaching useful independence faster than under the old apprenticeship, because reviewing a high volume of machine-generated code — with a senior checking the reviews — turns out to be a concentrated curriculum in exactly the judgment the new market pays for. The companies that figure this out get the 2030s seniors at 2020s prices. Everyone else gets the auction.

Conclusion: The Degree Didn't Break. The On-Ramp Did.

So what happened? Not the death of the computer science degree. The $80K median salary, the specialist hiring rates, and the record global developer employment all say the underlying asset retains value. What broke is the on-ramp: the broad, forgiving entry-level market that converted any reasonably diligent CS graduate into a working engineer. It was crushed between a macro contraction that froze hiring and an AI capability jump that gave employers a believable — whether or not fully accurate — substitute for the apprenticeship stage. The Stanford and Fed studies will keep arguing about the attribution. The 273 applicants per internship are living the result either way.

For students, the rational response is specialization, verification skill, and a wider map — not flight from the field, which the dot-com precedent suggests is precisely mistimed. For companies, the rational response is to notice that the bench is being cut industry-wide at the same moment enrollment is forecast to fall 20%, and that seniority cannot be procured on demand in 2032 if no one manufactures it in 2026. Fine arts majors out-employing computer engineers is a headline. The senior engineer shortage being assembled behind it is the story.