The complete profile — published free, in full, so you can judge the depth before buying anything. There’s also a free student version →
Pivotum Degree Risk Index — Fall 2026 Edition
This profile is free. We publish one in full so you can judge the depth before buying anything. It is the same length, structure and standard as every paid profile in the index.
You're likely reading this before your child is. That's normal, and it's worth pausing on how you use it.
Don't lead with the scores. If you open the conversation with a risk number, one of two things happens: they get frightened and shut down, or they get defensive about a decision they've already made. Neither produces a better choice.
The better approach: read this yourself first, then share it with them as information you both get to react to, not as a verdict you've reached.
What this is. A facts document, not a recommendation. We've set out what's known, where the evidence is contested, and where we might be wrong.
Three things to keep in mind:
A practical note: there's a separate short version written directly to them. Send them that one.
And one thing specific to computer science. This is the profile most likely to cause an argument, because the advice your child has heard their entire life — learn to code, do something with computers — is the advice this document questions. Handle that carefully. A teenager who has built an identity around being the technical one does not need to be told they were wrong. They need to understand that the field split, and which part of it to aim for.
Computer science is not dying. Its entrance is.
Recent computer science graduates in the United States face an unemployment rate of 6.1% — higher than art history at 3.0%, English at 4.9%, and performing arts at 2.7%. Meanwhile the Bureau of Labor Statistics projects software developer employment to grow 15% between 2024 and 2034, roughly five times the average across all occupations.
Both of those numbers are real, and the contradiction between them is the entire story.
An entry-level developer scores 8.1 out of 10 for AI exposure. A senior engineer or architect scores 5.4. Embedded and safety-critical work scores 4.7.
| Track | 2023 | 2025 | Fall 2026 | 3-yr movement | Band |
|---|---|---|---|---|---|
| Embedded / safety-critical systems | 4.0 | 4.3 | 4.7 | +0.7 | Moderate |
| Security engineering | 4.6 | 5.0 | 5.3 | +0.7 | Moderate |
| Senior engineer / architect | 4.6 | 5.0 | 5.4 | +0.8 | Moderate |
| ML / AI engineering | 5.0 | 5.5 | 6.0 | +1.0 | Moderate |
| Backend / infrastructure | 5.8 | 6.4 | 6.8 | +1.0 | Moderate–High |
| Frontend / application development | 6.5 | 7.1 | 7.6 | +1.1 | High |
| Entry-level developer | 6.3 | 7.4 | 8.1 | +1.8 | High |
Scores run 1–10, where 10 is most at risk. For context: the median profession in this edition sits around 5.5, bedside nursing scores 2.8, a service electrician 2.5, and licensed engineering 4.0.
Read the table this way: nothing in software scores below 4.7, and the entry rung is the second-highest score in the entire index. The field is protected at the top by judgment and accountability, and by nothing at all at the bottom.
Here's how an entry-level developer answers them.
More than any other professional work we score, and by a distance.
Writing functions from a specification. Boilerplate and scaffolding. Unit tests. Standard CRUD applications. Bug fixing on well-understood code. Documentation. Code review of routine changes.
That is a substantially complete description of a junior developer's week in 2019.
What resists: architectural judgment, debugging something nobody has seen before, deciding what to build, and owning a system when it fails at 3am.
The worst entry-path erosion we measure anywhere in this index.
Stanford's Digital Economy Lab, working with ADP payroll data covering millions of workers, found that entry-level software engineering postings in the United States fell 67% between 2023 and 2024. That's payroll data, not a survey.
The share of tech jobs requiring three years of experience or less fell from 43% in 2018 to 28% in 2024. Big Tech new-graduate hiring is down more than 50% from 2019 levels, and new graduates now account for roughly 7% of Big Tech hires.
None of it. Zero, permanently.
Software is text in, text out — which is both why it can be done from anywhere and why nothing physical protects it.
At senior level yes; at entry level almost not at all.
A principal engineer is trusted with architectural decisions and answers for them. A junior developer produces code that someone else reviews, merges and owns.
No. Nothing anywhere.
There is no software licence, no professional registration, no reserved activity. Compare licensed engineering, where the PE stamp is a legal monopoly, or nursing, where scope of practice is written into statute.
Two of our six factors sit at effectively zero for everyone in software, at every level of seniority, permanently. No individual action changes that.
At senior level frequently; at junior level rarely.
Designing a system that will handle unpredictable load is novel work. Implementing a well-specified feature is not.
This is the section that matters most, because the two headline numbers point in opposite directions and most coverage picks one.
The pessimistic number: 6.1% unemployment among recent CS graduates, 7.5% among computer engineering graduates — both above the 5.7% average across all recent graduates, and well above several humanities majors.
The optimistic number: 15% projected growth in software developer employment through 2034, with around 129,200 openings annually across the whole economy.
Both are true, and they describe different populations.
The profession is growing. The entry point to the profession has contracted sharply. When experienced developers say they still get recruiter messages, and new graduates say they've sent two hundred applications, they are both describing the market accurately — just not the same market.
Four forces stacked at once, and only one of them is AI:
We score AI exposure, and we'd be overstating our own framework if we let it take credit for all of this. A meaningful share of the entry-level collapse is cyclical and market-driven. What our score captures is that the content of junior work — not just its quantity — is what changed.
And the pay is still there, which is why students keep choosing it. New York Fed data puts CS early-career median pay at $87,000 and mid-career at $120,000, ahead of mathematics and most engineering disciplines. The upside didn't move. The entrance did.
Entry-level developer: 6.3 → 7.4 → 8.1. Up 1.8 points in three years — the second-fastest movement in this entire index, behind only junior law.
Senior architect: 4.6 → 5.0 → 5.4. Up 0.8.
The gap widened from 1.7 points to 2.7. Software isn't sinking. It's splitting — and it split faster than any profession we measure except law.
What moved: automatability rose steeply, and entry-path erosion rose faster still. Both factors moved together, which is unusual and is why this score climbed so quickly.
What didn't move: physical and regulatory protection sat at effectively zero throughout. They were never there to lose.
| Protection | Strength today | Durability | Where the pressure is coming from |
|---|---|---|---|
| Judgment under novelty | Real at senior level | Eroding | Genuine architectural novelty resists automation; routine design does not. |
| Human trust / accountability | Real at senior level | Durable | Someone must own the system when it fails. Commercially rooted rather than legal. |
| Regulatory / licensing | None | n/a | No licence exists. The exception is safety-critical work, which is why it scores best. |
| Physical / embodied | None | n/a | Software has never had this and never will. |
The honest read. Software has two of the four protections, both seniority-dependent, neither inherited from the profession. A doctor is protected on day one by a licence. A developer is protected only once they are trusted with something.
That is the core problem: the protection has to be earned, and the route to earning it is precisely what contracted.
| Was the job | Is becoming the job |
|---|---|
| Writing the function | Specifying it, then reviewing what was generated |
| Learning by writing bad code and being corrected | Learning by reviewing generated code — which teaches differently |
| Implementing a well-defined ticket | Deciding whether the ticket is the right thing to build |
| Debugging your own mistakes | Debugging mistakes you didn't make and can't remember making |
| Junior → mid → senior over years | Fewer junior seats, higher bar for the first one |
The row that should worry the profession is the second. Generations of engineers built judgment by writing something badly, watching it break, and fixing it. Reviewing generated code may build judgment too — but nobody knows yet whether it builds it as well, and the industry is running the experiment on an entire cohort without a control group.
Notably absent: speed of implementation, breadth of syntax knowledge, and volume of code produced. These were the traditional markers of a strong junior developer and are the fastest-depreciating things on the list.
The work is genuinely excellent, and it's worth saying so given the tone of everything above. Software is one of the few fields where a person can build something real, alone, with no capital and no permission.
Getting the first job, which is the dominant risk and covered above.
Continuous obsolescence. The specific tools change every few years. This is energising for some people and exhausting for others, and it never stops.
Interview processes are unusually punishing — multi-round technical interviews with a median search of seven to nine months and, by some estimates, 200–400 applications per offer in the current market.
The work is invisible when it goes well and highly visible when it doesn't.
Software tends to suit people who:
It's harder for people who:
Supply is high and unconstrained. CS is among the most-taken degrees and nothing caps numbers. Combined with the entry contraction, that's a crowded funnel.
Experienced engineers are doing fine. The market is bifurcated, not depressed.
Demand is genuinely growing at the aggregate level — 15% projected growth is real, and it's spread across healthcare, logistics, finance, defence and traditional enterprises rather than concentrated in the companies everyone applies to. Those employers see far fewer applicants per opening.
Here is the paradox worth naming, because it's the most counterintuitive finding in this index: being close to AI does not protect you from it. A data analyst is not protected by understanding AI, any more than a copywriter is protected by understanding language. Exposure is set by the shape of the work — structured inputs, text output, no physical presence, no licensed accountability — and software answers yes to all four.
So the advantage isn't in knowing about AI. It's in what a person does with that.
1. Verify. Knowing when generated code is subtly wrong in ways that compile and pass tests. This is the most valuable and least teachable skill in the field right now, and it only works on top of fundamentals you actually built yourself.
2. Specify. Framing a problem precisely enough that the output is usable. The skill has shifted upstream from implementation to specification.
3. Debug what you didn't write. Increasingly the default condition, and materially harder than debugging your own work.
4. Judge architecture. Deciding what a system should be, which is the thing generation cannot do because it requires knowing the constraints that aren't in the ticket.
5. Own something running. Everything in this profile points at accountability. Anything that puts a graduate closer to a system they answer for moves them up the scale.
Before the degree: build something real and ship it. Not a tutorial project — something with users, however few. In a field with no credential, demonstrable work is the credential, and almost nobody your age has any.
During: take systems, networks, operating systems and compilers seriously rather than treating them as hurdles. Those are the fundamentals that verification depends on. Get internships early; conversion rates are falling but they remain the single strongest signal.
Aim deliberately at the protected end: embedded and safety-critical, security, ML engineering, or software in a regulated domain. These score between 4.7 and 6.0 rather than 8.1, and they're where the accountability lives.
| Route | Notes |
|---|---|
| CS degree at a strong program | Still the main route. Fundamentals matter more than framework coverage. |
| CS with a domain — health, energy, finance, defence | The domain is the protection. These employers see far fewer applicants. |
| Software engineering apprenticeship | Expanding, paid, and solves the experience problem directly. Seriously underused. |
| Embedded / electronics-adjacent routes | Score best in the field, and consistently under-chosen. |
| Bootcamps | Weakest position in the current market — they optimise for the entry-level roles that contracted most. |
Genuinely broad: software engineering, security, ML and data infrastructure, embedded and robotics, technical product management, developer relations, technical consulting, engineering leadership, and founding something.
The pattern is the same as everywhere in this index: roles where someone owns a running system score better than roles that produce components of one.
1. Fundamentals over frameworks. Systems, operating systems, networks, compilers, algorithms. Frameworks change; fundamentals are what verification rests on.
2. Real internship or co-op placement — and the conversion rate. Ask what proportion convert to full-time offers. Nationally that figure has fallen to around 53% from nearly 58%.
3. Does the curriculum teach working with AI tools — and checking them? A program banning them is training for a job that no longer exists. One teaching them uncritically is worse.
4. First-destination outcomes with job titles, not employment rates.
5. Specialization pathways in security, embedded, or ML — the protected end of the field.
On outcomes:
On placement:
On the curriculum:
Red flags: outcomes quoted only as employment rate; a curriculum organised around currently-fashionable frameworks; no internship provision; evasiveness about conversion rates.
The Labor Market for Recent College Graduates — Federal Reserve Bank of New York. The source of the 6.1% figure, plus early- and mid-career pay by major. Free, quarterly, and from a central bank. Look computer science up against nursing and licensed engineering before deciding anything.
Computer science grads are struggling to find work — CNN. The comparison that made the data travel: CS graduates at 6.1% unemployment against art history at 3.0%.
The Computer Science Unemployment Rate, Explained With Real Numbers — the clearest treatment of the contradiction at the centre of this profile: 6.1% unemployment sitting alongside 15% projected growth, and why both are true.
The counterargument — read this one:
Bureau of Labor Statistics: Software Developers
The strongest case against our 8.1 is the government's own projection: software developer employment growing 15% from 2024 to 2034, about five times the average for all occupations, with roughly 129,200 openings annually. If AI were structurally eliminating software work, that is not what the ten-year projection would look like.
Where we land: we think this is right about the profession and silent about the entrance. Our 8.1 is a score for entry-level work specifically, and our senior score of 5.4 is much closer to what the BLS projection implies. The two claims are compatible: a growing profession can have a contracting entry funnel, and that is exactly what the Stanford payroll data shows. But if entry-level postings recover toward their 2022 levels, our score is wrong and we'll lower it. That's the specific thing we're watching.
Computer science is not a bad choice. It is a bad default.
For twenty years it was the safe recommendation you could make to a teenager without knowing anything about them. That is what has stopped being true — not because the field is dying, but because the gap between its best and worst outcomes has widened faster than almost anything else we measure.
The protected end is real — embedded and safety-critical at 4.7, security at 5.3, senior architecture at 5.4, ML engineering at 6.0. Good work, well paid, genuinely durable.
The entry rung is the problem, and it's severe. Entry-level postings down 67% on payroll data. Big Tech graduate hiring down more than half. The share of roles open to under-three- years experience falling from 43% to 28%.
So the useful advice isn't "don't do CS." It's: aim deliberately at the protected end from the start rather than assuming you'll drift there, take fundamentals seriously because verification depends on them, build something real with users before you apply anywhere, and look hard at apprenticeships and domain-paired routes.
And it's worth saying what the risk score can't measure. Software is one of very few careers where someone can build a working thing, alone, with nothing but a laptop and time — and where nobody's permission is required to try. That is rare, and it's still true.
This is analysis and informed judgment about a fast-moving situation, not a guarantee or a prediction. For computer science specifically, we've flagged that a meaningful share of the entry-level contraction is cyclical and market-driven rather than caused by AI — and that our framework would be overstating itself to claim otherwise.
Scores for 2023 and 2025 are retrospectively calculated using the current methodology. Scores measure exposure to what AI can already do — not how much any particular employer has deployed.
This profile is free. The other twenty-six are not.
If it was useful, the full profiles for nursing, medicine, law, business and psychology are the same length and standard — and cover the careers most families are weighing against this one. 1 profile $19 · 3 for $29 · 5 for $39.