What the numbers actually tell us — and what it means for JavaScript-only codebases still running in production.
In August 2025, TypeScript quietly crossed a line that nobody had managed in over a decade. For the first time ever, a statically typed superset of JavaScript became the most-used programming language on GitHub — overtaking both Python and plain JavaScript in the same month. GitHub called it “the most significant language shift in more than a decade.” That’s not marketing. The data backs it up.
So, what actually happened? And — more importantly — what does it mean for the teams that are still shipping JavaScript-only codebases in 2026? Let’s break it down honestly, without the hype.
The Numbers in Plain English
According to GitHub’s Octoverse 2025 report, TypeScript finished August 2025 with 2,636,006 monthly active contributors — edging Python by roughly 42,000 developers. That might sound tight, but the rate of acceleration tells the real story: TypeScript added over a million new contributors in a single year, representing 66.6% growth.
Meanwhile, Python — still the unquestioned king of AI and data science — grew by 850,000 contributors (+48% YoY), and JavaScript added around 427,000 (+25% YoY). All three languages grew. TypeScript simply grew faster.
GitHub Contributor Growth by Language — 2025 vs 2024
It’s also worth noting what this metric measures. GitHub counts distinct monthly contributors — real people actively writing code — not survey responses, job postings, or install counts. As MG Software points out, that makes it arguably the most grounded signal for where developer effort actually goes. The TIOBE Index still ranks Python #1 and Stack Overflow surveys still show JavaScript at 66% overall usage — but those measure different things. GitHub measures the code being written right now.
Three Forces That Actually Drove This
TypeScript didn’t win by accident. Three distinct tailwinds converged in 2025, and together they made the difference.
1. AI-Assisted Development Needs Types
This is, without a doubt, the biggest driver — and it’s newer than most people realize. A 2025 academic study cited by Visual Studio Magazine found that 94% of compilation errors produced by large language models are type-check failures. In other words, when GitHub Copilot, Cursor, or ChatGPT writes your code, it regularly gets types wrong. TypeScript catches those mistakes before a single line hits production.
GitHub Developer Advocate Andrea Griffiths describes this as a “convenience loop”: AI tools work better with TypeScript, so developers flock to it, which creates more TypeScript training data, which makes AI tools even better at TypeScript — and on it goes. Moreover, 80% of new developers on GitHub used Copilot within their first week. Those newcomers started with the language that AI-assisted workflows favour. That’s not a coincidence; it’s a structural feedback loop.
Worth knowing: TypeScript’s static type annotations give AI models clear guardrails. When a variable is declared as string, the model immediately knows to exclude every operation that doesn’t apply to strings. JavaScript’s dynamic, anything-goes flexibility is, ironically, harder for AI to navigate safely.
2. Framework Defaults Did the Heavy Lifting
The second force is more mundane, but just as powerful. In 2025, practically every major frontend framework now scaffolds new projects in TypeScript by default: Next.js 15, Angular 18, SvelteKit 2, Astro 3, Qwik, SolidStart, and Remix all do it out of the box. When you run npx create-next-app today, you start with TypeScript — not because you chose it, but because the tool chose it for you.
That default matters enormously. Most developers don’t fight defaults. They ship with what the scaffold gives them. And when the scaffold says TypeScript, TypeScript is what gets committed to GitHub. Furthermore, 80% of new repositories in 2025 used just six core languages — Python, JavaScript, TypeScript, Java, C++, and C# — and TypeScript’s default-on status across the JS ecosystem means it captures a massive portion of new project creation.
3. A Decade of Gradual Adoption Finally Compounded
TypeScript has been around since 2012. However, it spent years as “the thing serious teams use.” Then it crossed a tipping point somewhere around 2022–2023, as enterprise adoption reached critical mass. By 2025, 78% of enterprise teams were using TypeScript as their primary language, and that institutional momentum finally showed up at scale in the contributor data.
Patreon’s engineering blog recently documented a seven-year migration of 11,000 files and over one million lines of code from JavaScript to TypeScript — finishing in early 2026. Their journey illustrates exactly how enterprise-scale adoptions work: slow organic growth for years, then rapid acceleration once AI tooling matured. A lot of teams’ migration clocks rang at roughly the same time in 2025.
But Let’s Be Honest About What This Doesn’t Mean
Before we get carried away, a few things deserve a reality check.
Python is not losing. It grew by nearly 850,000 contributors in the same period. It still powers roughly 50% of all AI repositories on GitHub, and its ecosystem — PyTorch, TensorFlow, pandas, NumPy — is entirely unmatched for model training and data science. TypeScript and Python aren’t competing; they’re complementary. The emerging pattern is: Python for the model layer, TypeScript for everything the user touches.
JavaScript isn’t dead either. It still runs on billions of devices, powers the web at runtime, and remains the language TypeScript compiles down to. The JavaScript/TypeScript ecosystem combined still outscales Python by total activity. What’s changed is that the authored code is increasingly TypeScript, not JavaScript.
Language Comparison: Monthly Contributors — August 2025
The contributor gap is smaller than the narrative suggests. TypeScript beat Python by around 42,000 contributors — out of 2.6 million. That’s a margin of roughly 1.6%. Dominant, yes. Unstoppable, probably. But it’s not a landslide, and Python has consistently shown it can accelerate when it needs to.
How the Top Languages Stack Up
| Language | Monthly Contributors (Aug 2025) | YoY Growth | New Contributors Added | Primary Domain |
|---|---|---|---|---|
| TypeScript #1 | 2,636,006 | +66.6% | +1,050,000 | Web apps, APIs, full-stack |
| Python #2 | ~2,594,000 | +48% | +850,000 | AI/ML, data science |
| JavaScript #3 | ~2,150,000 est. | +25% | +427,000 | Web, scripting, prototypes |
| Java #4 | — | +20% | +100,000+ | Enterprise backend, Android |
| C# #5 | — | +22% | +100,000+ | Enterprise, game dev (.NET) |
Source: GitHub Octoverse 2025. JavaScript absolute contributor count is an estimate derived from reported growth rate and previous data.
What This Means for JavaScript-Only Codebases
Here’s the practical part. If your team is still running a significant JavaScript-only codebase in production, you’re not unusual — but you are increasingly in the minority, and the gap between your tooling experience and TypeScript teams’ is widening. So, what should you actually do?
The Case for Migrating (and It’s Compelling)
The evidence on bug reduction is consistent across many real-world cases. Airbnb famously found that 38% of their production bugs would have been caught by TypeScript’s compiler. A SaaS migration case study documented on csabin.com.np reported that runtime errors “vanished,” and large-scale changes became significantly safer. Abbacus Technologies estimate that a mid-sized SaaS company spending $100k/year on bug fixes could save $30k annually after migration — enough to cover training and migration costs within the first year.
There’s also an AI tooling angle that’s hard to ignore. If your developers are using Copilot, Cursor, or similar tools, TypeScript makes those tools measurably more accurate. Type annotations give the model context that plain JavaScript simply can’t provide.
The Honest Case Against Rushing It
However, not every migration story is a success. A candid post-mortem on Medium from late 2025 titled “We Rewrote 50,000 Lines from JavaScript to TypeScript. It Wasn’t Worth It.” is worth reading. The team found that without fixing underlying architectural problems first, TypeScript just added complexity on top of mess. They ended up with type definitions full of any, complex generics nobody understood, and slower development velocity for months.
Important caveat: TypeScript doesn’t fix bad architecture. If your JavaScript codebase has deeper structural problems — tangled dependencies, no testing, unclear data flows — migrating to TypeScript surfaces those problems rather than solving them. Address the fundamentals first.
A Practical Starting Point
If you decide to move forward, the official TypeScript migration guide recommends an incremental approach rather than a full rewrite. You can enable TypeScript’s allowJs option to let .ts and .js files coexist in the same project, then migrate file by file — starting with utility functions and shared models before touching core business logic. Here’s the basic setup to get that started on an existing Node.js project:
# 1. Install TypeScript and type definitions for Node.js npm install --save-dev typescript @types/node # 2. Generate a tsconfig.json with sensible defaults npx tsc --init # 3. Add allowJs to your tsconfig so .js and .ts files coexist: # Open tsconfig.json and set: # "allowJs": true, # "strict": false ← start loose, tighten later # "outDir": "./dist" # 4. Rename one low-risk file (e.g. a utility) from .js to .ts # Then run the compiler to see what it flags: npx tsc --noEmit
This approach means your app keeps running throughout the migration. You migrate what makes sense when it makes sense, rather than betting everything on a big-bang rewrite. For larger codebases, tools like Airbnb’s ts-migrate can automate the initial conversion and insert placeholder $TSFixMe annotations where types can’t be inferred — giving you a working TypeScript codebase to improve over time.
Migration Effort at a Glance
| Codebase Size | Estimated Timeline | Strategy | Risk Level |
|---|---|---|---|
| Small (<5k LOC) | 2–4 weeks | Direct conversion | Low |
| Medium (5k–50k LOC) | 1–3 months | Incremental, module by module | Medium |
| Large (50k–200k LOC) | 3–9 months | Phased with ts-migrate tooling | Medium-High |
| Enterprise (>200k LOC) | 1–3+ years | Dedicated task force + AI tooling | High (but manageable) |
Estimates sourced from Wojciechowski, Abbacus Technologies, and Patreon Engineering.
The Bigger Picture: What This Says About the JS Ecosystem
TypeScript hitting #1 on GitHub isn’t really a story about one language beating another. It’s a story about how AI-assisted development is reshaping the entire toolchain — and doing so faster than almost anyone predicted.
Think about it this way: the same underlying event (the rise of AI coding assistants) is fuelling TypeScript’s growth and Python’s growth simultaneously, just through different mechanisms. Python grows because developers are building AI models and pipelines. TypeScript grows because developers are building the applications and APIs that sit on top of those models — and they need type safety to keep AI-generated code under control.
“The most significant language shift in more than a decade” isn’t just about TypeScript. It’s a signal that AI is now influencing not just how fast code gets written, but which languages developers choose to write it in at all.
— GitHub Octoverse 2025
The consequence for the JavaScript ecosystem is clear: JavaScript isn’t going away, but the expectation for new projects has definitively shifted. As Wojciechowski notes, “It’s no longer a debate about ‘whether’ to use TypeScript, but ‘when’ to switch.” For teams still on plain JavaScript, the question isn’t whether the ecosystem is moving. It clearly is. The question is whether your project’s specific circumstances make migration worth the cost right now, or whether you should ship first and migrate deliberately.
What We’ve Learned
- TypeScript reached 2.63 million monthly contributors on GitHub in August 2025, overtaking both Python and JavaScript for the first time — a 66.6% YoY surge driven by AI tooling, framework defaults, and compounding enterprise adoption.
- The AI connection is real and structural: 94% of LLM-generated compilation errors are type failures, making TypeScript’s static typing directly valuable for teams using AI coding assistants.
- Python and JavaScript aren’t losing — they’re both still growing strongly. The story here is specialisation: Python owns the AI model layer; TypeScript owns the application and API layer built on top of it.
- Migration is worth it for most production teams, but not without caveats. TypeScript surfaces architectural problems rather than solving them, so address fundamentals first and migrate incrementally rather than all at once.
- Framework defaults and the “convenience loop” of AI tooling mean that TypeScript is now the path of least resistance for new JavaScript projects — whether developers consciously chose it or not.
- For JS-only codebases, the honest advice is: plan your migration timeline, start with new files and shared utilities, and resist the urge to rush the whole thing at once.
