The Programming Language Death Spiral - How Small Languages Die in the Age of AI

The programming language death spiral has been top of mind for me as I shift my primary language from F# (a top 50 lang) to C# (a top 5 lang).

I first discussed this phenomenon back in 2023 in the State of F# as the greatest existential threat to the language and ecosystem.

Big Languages have a virtuous cycle

The basic premise is:

• Lots of companies use mainstream languages
• Lots of jobs are available in them
• Lots of projects are built in them - as part of work, from ppl who know them, funded by these companies
• Lots of people learn them - as they can make money and onboarding is ~easy
• New companies are built in these languages - on the ecosystem, by the people that know them

This is a virtuous cycle.

• More companies mean more jobs / funding
• More jobs / funding mean more projects / resources
• More projects / resources means more people learn them
• More people learning them mean more companies are built with them

Plus companies are often slow to move - it's very costly to overhaul a whole system to a new technology / language so often once a company uses one, that thing sticks around for a long time. This means it continues getting funding, maintaining jobs, and improving the ecosystem long into the future. Examples of these include the COBOL and FORTRAN mainframes still running many large companies today.

Small languages have a vicious cycle - a death spiral

• Few companies use it meaning less jobs / funding
• Few jobs / funding available for it means less projects / resources available for it
• Few projects / resources means less people learn it
• Few people learning it means less companies built with it

As much as we'd like the best theoretical technology to win, humans don't always act rationally or maybe they do but there's a lot of other influences on their decision.

• Why use thing A when thing B makes money?
• Why use thing A when thing B is easier to onboard to / debug?
• Why learn thing A when I'm already getting paid to learn thing B?

Of course this isn't a static cycle. When new tools come around, they can escape the small language death spiral and take market share away from other big players. But those tools typically must be much better than their predecessors or have some edge vs the others - a killer feature that makes it worthwhile to invest in the language even if the potential payoff is years in the future.

I don't know HOW much better they need to be but I'd posit it needs to feel 2-5x better for engineers to warrant a shift AND it needs to be as good or better at accomplishing the task if it doesn't have a killer feature for the usecase.

Examples of new languages popping up that chip away at incumbent's virtuous cycles:

• TypeScript bringing some sanity in the form of types to the chaos that is JavaScript. Also the types are really good (if not always real). (Plug for F# which the TS type system was based on).
• Go making performant, memory-managed system-level programming accessible to the masses due to its simple design (overly simple in my opinion) - taking market share from projects that might be built in lower level C, C++, C#, Java, and even higher level Python, Ruby,
• Rust making highly performant, memory safe coding possible with guardrails in the type system which nerdsniped a whole generation of the type, performance, and low-level obsessed programmers - taking market share from low level langs like C, C++, and many who were into more niche languages with cool type systems like Haskell
• Kotlin slowly chipping away at Java with its more expressive, less boilerplatey type system and ergonomics

AI amplifies these adoption cycles

AI is a big shift in how we build software:

• Essentially replaced programming reference sites like Stack Overflow
• Can build small, well-defined features reliably
• Slowly improving at building larger, more complex features

It's not perfect but it's changing the way a large portion of the industry builds software and that's really impressive in the short time it's been on the scene.

Source: GitHut 2.0

AI coding proficiency is currently directly tied to training data. Top 10 langs have 10-100x more code examples and docs online than those outside it. This means that the AIs will have more training data to work on for gathering patterns, best practices, and knowledge of available tools.

When I compare C# (3.329%) and F# (0.107%) by activity, we see a ~30x difference. This isn't quite equal to available training data but it is a reasonable proxy.

Plus AI companies will have a higher monetary incentive to benchmark and improve in those languages. Large companies like Microsoft and Google will fund research teams and AI model providers to improve training on languages they use and promote - C#, TypeScript, Go, and Python being likely contenders. Extend this to the SP500 and there will be a lot of money invested in AI models to improve software generation in the langs those cos are using and, largely, those cos are using top 10 mainstream languages and therefore will be the ones getting majority investment.

Essentially we can expect AI to amplify the network effects already present in the programming language ecosystem.

Source: A Survey on LLM-based Code Generation for Low-Resource and Domain-Specific Programming Languages

When we compare AI coding today in large vs small langs, we can expect a 2-3x difference in code "quality". This gap gets wider depending on the gap in usage and if a lang is small enough, it may not have critical mass of training data to be able to code in it at all.

Here's an anecdotal experience from someone trying to use AI to code F#: "none of the models are very good at generating modern, idiomatic F#", "None of them generated useful, working code. To get any of it working, I had to do way-too-much syntax fixing, and then way-too-much debugging." - Scott Arbeit

As companies and the industry shift to use more AI in their workflows, AI is going to become a greater force multiplier. Those languages that don't keep up will be fighting an increasingly uphill battle for adoption.

There's still hope for small languages

If F# (or any other niche language) wants to stay relevant in the age of LLMs, we need to see a lot more good, working code online.

Strong types are good guardrails but training data seems to be the biggest differentiator in quality.

More code, more data, more quality.

— Hamilton Greene 🐷🦔 (@SIRHAMY) November 20, 2025

Small languages can make a comeback but it is an uphill battle.

They basically need:

• More public code examples
• More blog posts
• More prodding AI cos to benchmark, tweak, and train for their languages

And who knows? There may be some structural improvements on the horizon.

• If AI ever achieves reasoning, it may be able to train and correct itself - particularly because it can test itself against a real compiler and inputs / outputs
• We may find new scaffolding techniques for generating "skill libraries" that AIs can reference to boost their proficiency in languages their base model wasn't trained for. If these can be built with AI then this could be a scalable solution for all langs.

But the onus is on the few users of the small languages. No large co is going to do this for them - they can't make a business case to even use the language, much less fund the open source projects / maintainers for tech they don't rely on.

We should also be a bit wary of the AI training data bit rot. There have been attempts to use AI to translate rare human languages before and while there's some success, they often miss enough to potentially corrupt their own training data in the future. This means the more stuff created with it, the worse it gets. Programming languages are slightly different in that they can be objectively tested with compilers and input/output but smth to be aware of.

Next

The programming language death spiral has been around a long time. AI just amplifies it.

I don't think this necessarily means you should avoid small languages. If you love or are interested in a niche technology, I think you should dive in. You'll certainly learn something and likely enjoy the process even if you don't stick with it long term. Voting with your actions is one of the best things you can do to keep it around.

But I'm also a weird person with weird interests - I program for fun. A lot of people don't so I think we need to be cognizant of this paradigm and realize that this is how the market currently acts. If you want to change it, this is what you're up against.

After writing this, I realized this has similar properties to the OO vs functional paradigm (OO is more mainstream, functional more niche). Good video on this is Why Isn't Functional Programming the Norm? – Richard Feldman

If you liked this post you might also like:

• If AI can code, what will Software Engineers do?
• Stop Vibe Coding, Start Power Coding - How To Write Quality Software Faster With Agentic AI
• How I Actually Code with AI as a Senior Software Engineer