TypeScript Is Now #1 on GitHub—and AI Is Why

What Happened

According to GitHub's Octoverse 2025 report, TypeScript overtook both Python and JavaScript in August 2025 to become the most-used language on GitHub. More than one million developers adopted TypeScript in 2025 alone—a 66% year-over-year surge—bringing the active contributor count to 2.63 million. GitHub called it "the most significant language shift in more than a decade."

The more interesting question isn't what happened, but why—and what it means for how we build software in 2026.

The Convenience Loop

TypeScript's growth isn't purely organic. It's being accelerated by a self-reinforcing feedback loop between AI coding tools and typed languages.

The mechanics are straightforward:

1. AI tools generate TypeScript competently
2. TypeScript projects feel lower-friction with AI assistance
3. Developers prefer TypeScript for AI-assisted projects
4. More TypeScript code enters GitHub and training datasets
5. LLMs get better at TypeScript
6. Go to step 1

When AI makes a language feel frictionless, developers gravitate toward it. That creates more training data, which makes AI better at the language, which reduces friction further. The loop compounds.

The same dynamic appears in Python's dominance of AI/ML repositories—it's not just that Python is the best language for data science, it's that AI is trained primarily on Python ML code, making AI-generated Python ML code more reliable, making developers choose Python for ML. TypeScript is running the same loop on the application side.

Why TypeScript and AI Pair Well

There's a concrete technical reason behind the loop: type errors catch AI mistakes automatically.

GitHub's data shows that 94% of compilation errors in LLM-generated code are type-check failures. When Claude or Copilot generates code that misuses an interface, passes the wrong type to a function, or accesses a property that doesn't exist, TypeScript catches it immediately at compile time. In JavaScript, that same error might not surface until it hits production.

// TypeScript catches this AI-generated mistake at compile time
interface User {
  id: number;
  name: string;
  email: string;
}
 
function sendWelcome(user: User) {
  // TS2339: Property 'mail' does not exist on type 'User'
  // TypeScript flags this immediately — JS would silently fail at runtime
  mailer.send(user.mail, "Welcome!");
}

Beyond error catching, type definitions give AI tools richer context about code intent. When an AI reads your interface Order { items: OrderItem[]; total: number; currency: "JPY" | "USD"; }, it understands the domain model with precision. In JavaScript, it has to infer structure from variable names and usage patterns—which works, but with more ambiguity.

The Framework Default Effect

A structural factor reinforcing TypeScript adoption: nearly every major frontend framework now scaffolds TypeScript by default.

Next.js, SvelteKit, Qwik, Astro, Remix—when you run their project generators, TypeScript is the default. Developers who start a new project aren't choosing TypeScript; they're choosing not to switch away from TypeScript.

# Every major framework: TypeScript is now the default scaffold
npx create-next-app@latest my-app
# ✓ Would you like to use TypeScript? … Yes (default)
 
npx sv create my-app
# ✓ Add type checking with TypeScript? … Yes (default)

This changes the adoption curve fundamentally. The barrier to TypeScript is no longer "learn a new tool." It's the friction of deliberately opting out.

TypeScript vs. JavaScript: The Right Tool for Each Job

TypeScript's rise doesn't end JavaScript. The two have settled into distinct use cases.

TypeScript wins where types become specs—multi-person teams maintaining code over months or years. It's particularly strong when AI is writing code that humans review, because the type system provides an automated quality gate that reduces review burden.

Practical Patterns for AI + TypeScript

If you're building with AI tools in a TypeScript project, a few practices make the AI significantly more accurate.

Write types before implementation
Define interfaces and type signatures before asking AI to implement anything. The types act as a specification that constrains and guides the AI's output.

// Define the contract first—then ask AI to implement
interface PaymentProcessor {
  charge(
    amount: number,
    currency: "JPY" | "USD" | "EUR",
    customerId: string
  ): Promise<{ success: boolean; transactionId: string }>;
  
  refund(
    transactionId: string,
    amount?: number
  ): Promise<{ success: boolean; refundId: string }>;
}
 
// With this interface defined, AI-generated implementations
// will satisfy the contract or fail the type check—not silently misbehave

Enable strict mode
strict: true in tsconfig.json turns on the full battery of TypeScript checks. AI-generated code under strict mode has fewer subtle type bugs because the checker enforces more invariants.

{
  "compilerOptions": {
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "exactOptionalPropertyTypes": true
  }
}

Use Zod for runtime boundaries
TypeScript types disappear at runtime. For API responses and external data, pair TypeScript types with Zod schemas to validate at the boundary—and generate the TypeScript type from the schema.

import { z } from "zod";
 
const OrderSchema = z.object({
  id: z.string(),
  total: z.number().positive(),
  currency: z.enum(["JPY", "USD", "EUR"]),
  items: z.array(z.object({
    sku: z.string(),
    quantity: z.number().int().positive(),
  })),
});
 
type Order = z.infer<typeof OrderSchema>; // TypeScript type from schema

The Python Comparison

It's worth noting what this shift means relative to Python. Python remains #1 in AI/ML repositories—Claude, Torch, transformers, scikit-learn, all live in Python. The "hybrid stack" (TypeScript for applications, Python for models and data) is now the default architecture for AI-powered products.

TypeScript didn't win everywhere. It won in the application layer where types provide real value. Python held its ground in the ML layer where rapid experimentation and library ecosystem matter more than type safety.

Our Take

TypeScript's trajectory reflects something specific about AI-assisted development: when AI handles boilerplate and routine code, the value of the human layer shifts toward specification. Types are specification. That's why typed languages win as AI coding tools improve.

At webhani, we've recommended TypeScript as the default for new projects for years—not because it's fashionable, but because types reduce defect rates in long-lived codebases. What's changed is that AI tools have made the TypeScript investment pay off faster. The cost of adoption is lower (AI helps with migration and boilerplate), and the benefit is higher (AI-generated code is more reliable under type constraints).

Teams still running significant JavaScript codebases should evaluate migration seriously. AI tools are available to assist with the mechanical conversion, reducing the primary cost barrier. The window where "staying on JavaScript" made economic sense is narrowing.

Summary

• TypeScript became GitHub's most-used language in August 2025, with 66% YoY growth
• A self-reinforcing AI convenience loop is driving adoption: AI is better at TypeScript, so TypeScript projects feel lower-friction, which creates more TypeScript training data, which improves AI TypeScript output
• 94% of LLM-generated compilation errors are type-check failures—TypeScript catches them automatically
• Major frameworks now default to TypeScript scaffolding, removing the adoption friction
• The hybrid stack (TypeScript for apps, Python for ML) is the standard for AI-powered products
• AI makes the TypeScript migration cost lower while raising the benefit ceiling