For two decades the story of language adoption was a story about people. Languages won because they were pleasant to write, fast to learn, or already installed where you needed them. Python beat Perl on readability. JavaScript won the browser by default. Human comfort was always the deciding force.
That story may be ending.
According to GitHub's Octoverse data, TypeScript overtook both Python and JavaScript to become the most-used language on the platform, growing roughly 66% year over year to about 2.63 million contributors. Octoverse is a lagging indicator, so treat the exact ranking as a snapshot rather than a permanent verdict. But the direction is hard to dismiss.
The inversion
Most people read this as developers finally coming around to types. I think something else is happening: the adoption curve may now be driven less by what humans prefer to write and more by what machines can reliably verify.
Plenty of developers love types for the autocomplete and the safety, and plenty merely tolerate the annotations. Taste is split. If human ergonomics were the only force in play, the dynamic languages would not be losing ground as fast, because they remain quicker to scribble and lighter to read. Yet the trend is moving the other way, and it is moving fastest in exactly the period when AI coding assistants went mainstream.
A single year of Octoverse data does not prove causation. But there is a plausible mechanism.
Why a model prefers a contract
An AI assistant generating or refactoring code is operating with a finite context window and no ability to run the program in its head. When it edits a function, it has to guess what the surrounding code expects. In a dynamically typed file, that guess is often unverifiable until runtime, which for an agent means it may never get checked at all before the change ships.
A typed language closes that gap. The type signature is a contract the model can read directly. When the assistant renames a field or changes a return shape, the type checker turns a silent semantic error into a loud, local, machine-readable failure. The model gets a fast feedback signal it can act on without human intervention.
Concretely, consider an agent asked to rename a property userId to accountId across a service:
- In untyped JavaScript or Python, the agent has to find every reference by pattern matching on a string. Miss one access buried in a callback or a dynamically keyed object, and the bug surfaces only when that path runs in production.
- In TypeScript, the rename produces compiler errors at every stale reference. The agent now has an exact list of sites to fix and a definition of done it can check against.
The type system here does little for the human and a lot for the machine. That is the shift.
The convenience loop
Here is the loop that may be forming. Whatever reduces friction for the AI assistant gets used more by the assistant. An assistant working in a typed codebase produces typed code that the next assistant can extend more safely. The ecosystem accretes around the format machines handle best, and humans inherit that default whether or not it matches their personal taste. The caveat is that models tend to match the style of the file they are in, so the loop strengthens existing typed projects more than it converts pure JavaScript or Python ones unaided.
If this is real, the consequence is mildly uncomfortable. Languages may start optimizing for legibility to models rather than to people. Explicit contracts and exhaustive cases are not there to make the code pretty for a reader. They are guardrails that keep an agent from hallucinating its way through a refactor.
TypeScript also benefits from the maturity of its tooling, the size of the JavaScript ecosystem it sits on top of, and years of organic momentum that predate coding agents. Some of the contributor growth is almost certainly people and projects that would have moved regardless of AI. So machine legibility is, at most, one strong force among several rather than a proven primary cause.
What would change my mind
The convenience-loop thesis is testable, at least loosely. If it holds, you would expect:
- AI-generated pull requests to skew more heavily toward typed languages than human-authored ones in the same repositories.
- Dynamically typed ecosystems to invest more in optional type layers specifically to stay legible to agents, rather than for human reasons.
- New language features to be justified increasingly by tooling and verification rather than by writing comfort.
If instead TypeScript's lead flattens once the novelty of agentic coding settles, or if a dynamic language with strong runtime tooling holds its ground, the human-ergonomics story is still doing most of the work and this framing is overfit to one data point.
The takeaway
The narrow claim: strongly typed languages give AI assistants something dynamic languages cannot, a contract the model can verify without running the code. That single property is plausibly enough to bend adoption, and one year of GitHub data is consistent with it bending.
The larger claim, that machine readability has already replaced human preference as the main driver of language choice, is a bet, not a finding. It is a bet worth watching, but not yet a fact to repeat.
Either way, if you are choosing a stack for a codebase that AI tools will touch heavily, the asymmetry is worth taking seriously. The guardrails were always for the humans. Now they may be mostly for the machines, and we are the ones living inside the rails.