TypeScript Overtakes Python: How AI Is Reshaping Language Choice

TL;DR

• TypeScript surged 66% year-over-year to become GitHub's most-used language in 2025, overtaking both JavaScript and Python
• AI tools perform better with statically typed languages, creating a feedback loop where type safety becomes an AI-compatibility decision
• Bash scripting jumped 206% in AI-generated projects—AI makes painful languages tolerable by automating the drudgery
• Language choice is shifting from personal preference to "which stack gives me and the model the most leverage"

The Big Picture

Everyone talks about AI making developers faster. Fewer people are noticing that AI is changing which languages developers pick before they write a single line.

TypeScript just overtook Python as the most-used language on GitHub—a 66% year-over-year jump and the biggest language shift in over a decade. But this isn't a story about TypeScript winning. It's about AI creating a new selection pressure that didn't exist two years ago.

Idan Gazit, who leads GitHub Next (the team behind Copilot), puts it bluntly: "AI isn't just changing how we write code. It's starting to change what we choose to build with in the first place."

The last generation of developer tooling was about where code runs—cloud, containers, CI/CD pipelines. This generation is about what code is made of, and why those choices suddenly carry different weight. When your AI assistant is better at TypeScript than Haskell, that's not a neutral fact. It's a behavioral nudge that compounds across millions of projects.

How It Works

Developers don't switch languages for philosophy. They switch when something makes their work meaningfully faster or less risky. And increasingly, "easier" means "how well will AI tools support this language."

Statically typed languages give AI models more structure to reason about during code generation. They also give developers faster feedback loops when validating AI-generated code. If Copilot suggests a function that expects a string but you're passing a number, TypeScript catches it immediately. Python won't complain until runtime—if you're lucky.

"If an AI tool is going to generate code for me, I want a fast way to know whether that code is correct," Gazit says. "Explicit types give me that safety net."

This creates a feedback loop. AI models train on public code. TypeScript and Python dominate public repositories. Models get better at those languages. Developers notice the quality gap. They choose TypeScript or Python for new projects. The cycle reinforces itself.

But it's not just about type safety. It's about training data volume. "If the model has seen a trillion examples of TypeScript and only thousands of Haskell, it's just going to be better at TypeScript," Gazit explains. "That changes the incentive before you even start coding."

Before AI, picking a language meant weighing runtime performance, library ecosystem, and personal fluency. After AI, a new constraint appears: How much lift will the model give me if I choose this language?

Python isn't losing this race—it's winning in its own lane. It remains the dominant language for machine learning, data science, and model training. Why? Because the ecosystem is unmatched. PyTorch, TensorFlow, scikit-learn, pandas—these are wheels you don't need to reinvent. TypeScript isn't winning against Python. Each is winning in the situations where it's the right tool for the job, and where AI makes it more valuable.

The real surprise in GitHub's Octoverse data wasn't TypeScript or Python. It was Bash. Shell scripting saw a 206% year-over-year growth in AI-generated projects. Why would anyone choose Bash in 2025?

Because AI makes painful languages tolerable.

"Very few developers love writing Bash," Gazit says. "But everybody needs it. It's the duct tape of software. And now that I can ask an agent to write the unpleasant parts for me, I can use the right tool for the job without weighing that tradeoff."

If AI automates the drudgery layer of programming, the question stops being "Is this language enjoyable?" and becomes "Should I use it when I don't have to write the code myself?" That's a fundamentally different calculus. It means languages that were previously avoided due to poor ergonomics—Bash, regex-heavy Perl scripts, even COBOL for legacy maintenance—suddenly become viable options when an AI agent handles the syntax.

What This Changes For Developers

Enterprises aren't asking "Should we adopt AI?" anymore. They're asking "What happens after we do?" And the answer is reshaping what "senior engineer" means.

Before AI, skill was measured by lines of code shipped. After AI, it's measured by validation, architecture, and debugging. Junior developers now ship faster than seniors can review. Senior developers spend less time writing the hardest code and more time judging it.

This creates second-order effects that most teams aren't prepared for. Tooling used to be a matter of taste—your IDE, your linter, your build setup. Now tooling defines the surface area AI can operate on. Pick the wrong stack and you limit or block agentic assistance entirely.

Typed languages accelerate this shift. The stronger the safety rails, the more work can be handed to automation. That's why writing clear agents.md files and structured code review instructions matters more than ever—you're not just documenting for humans anymore. You're defining the contract between your team and the AI tools that augment it.

The definition of "good code" is also shifting. Code that's easy for AI to generate isn't always code that's easy for humans to maintain. But code that's easy for AI to validate—through types, tests, and explicit contracts—tends to be both. That's the sweet spot teams are hunting for.

The Next Horizon

Today, language choice matters because runtimes are fragmented. Browsers require JavaScript. Models need Python. Firmware expects C. But that's already eroding.

WebAssembly is starting to change the rules. If any language can target Wasm and run everywhere, that removes one key consideration when picking your stack. Combine that with AI-generated code and you get a plausible future: developer writes in Rust (or Go, or Python), AI generates code in that language, compiler targets Wasm, the same code runs on web, edge, cloud, local sandbox.

That's not a TypeScript-wins future. It's a portability-wins future. Languages may end up competing less on syntax and more on ecosystem leverage: package depth, tooling maturity, model familiarity, debugging ergonomics.

We're not fully in that world yet. But the early signals—from AI-driven tooling to Wasm-powered portability—suggest it's coming faster than most teams expect.

What You Should Actually Do

This isn't a "learn TypeScript now" post. Here's what the data actually tells you:

Typed languages are rising because AI benefits from structure. If you're starting a new project and plan to use AI assistance heavily, static typing gives you faster validation loops. That's not ideology—it's ergonomics.

Python stays dominant in AI because ecosystems outlast fashions. If you're building anything ML-adjacent, Python's library ecosystem is still unmatched. TypeScript won't change that.

Shell scripts are up 206% because AI removes pain barriers, not just productivity barriers. Don't avoid a language just because it's unpleasant to write. If AI can handle the syntax, use the right tool for the job.

Enterprises adopting AI fast means the definition of "senior engineer" is changing next. Your value isn't in writing boilerplate anymore. It's in architecture, validation, and knowing when the AI is wrong.

WebAssembly maturing means language loyalty gets replaced by language interoperability. Don't over-invest in a single language's runtime. Invest in ecosystems and portability.

The Bottom Line

Use TypeScript if you're building web apps, need strong IDE support, and want AI tools to catch errors fast. Use Python if you're in data science, ML, or need the deepest library ecosystem. Use Bash (via AI) if you need glue code and don't want to write it yourself. Skip the language wars entirely if you're betting on WebAssembly—portability will matter more than syntax in three years.

The real risk isn't picking the "wrong" language. It's optimizing for loyalty instead of leverage. The languages that survive the next decade won't be the ones developers love most. They'll be the ones that give developers and machines the most shared advantage.

Source: GitHub Blog