AI Is Reshaping Language Choice Before Developers Write a Line
Discussion of AI in software development usually centers on productivity: faster pull requests, automated tests, autocomplete. But Idan Gazit, who leads GitHub Next—the team behind Copilot and GitHub's long-range R&D—argues the more consequential shift happens before any code is written. AI isn't just changing how developers write code; it's changing what languages they choose to write it in.
That signal is visible in GitHub's 2025 Octoverse report. TypeScript overtook JavaScript and Python as the most-used language on GitHub, with a 66% year-over-year surge—the largest language movement in over a decade. But this isn't a story of TypeScript beating Python. It's evidence that AI is beginning to influence language adoption patterns.
Why Typed Languages Are Winning With AI Assistance
Developers rarely switch languages for philosophical reasons. They switch when a choice makes their work meaningfully faster, simpler, or less risky. Increasingly, "easier" is tied to how well AI tools support a given language. Gazit sees a clear pattern: statically typed languages offer structural advantages when AI is generating code.
"If an AI tool is going to generate code for me, I want a fast way to know whether that code is correct. Explicit types give me that safety net."
— Idan Gazit, head of GitHub Next
Typed languages reduce hallucination surface area and provide models more structure to reason about during generation. The behavioral data supports this:
- AI models perform better on languages that expose correctness information, like type systems
- Developers using AI tools are likelier to choose typed languages for new projects
- Language choice increasingly becomes an AI-compatibility decision rather than pure preference
This creates a feedback loop. AI models are strongest in popular languages—TypeScript, Python, Java, Go—which reinforces their dominance. "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 says. Language selection now includes a new question: how much lift will the model provide if I pick this stack?
That doesn't mean TypeScript is winning against Python. Python remains dominant for machine learning, data science, and model training. "Those are wheels I don't need to reinvent," Gazit notes. Each language wins where it's the right tool, and AI amplifies that advantage.
The Surprising Winners: Shell and "Duct Tape" Languages
One of the most unexpected Octoverse signals concerned Bash. Shell scripting saw +206% year-over-year growth in AI-generated projects. The explanation: AI makes painful languages tolerable.
"Very few developers love writing Bash. 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."
When AI handles drudgery, the question stops being "Is this language enjoyable?" and becomes "Should I use it when I don't have to write the code myself?"
Enterprise Adoption and Second-Order Effects
Enterprises have moved past the "should we adopt AI?" question. They're now asking what happens after adoption. Gazit sees clear value: junior developers ramp faster, senior developers spend less time on toil and more on architecture.
| Before AI | After AI |
| Skill measured by lines of code | Skill measured by validation, architecture, debugging |
| Juniors slow to ship | Juniors ship faster than seniors can review |
| Senior devs write the hardest code | Senior devs now judge the hardest code |
| Tooling was mostly a matter of taste—IDEs, linters, build setups, etc. | Tooling now defines the surface area AI can operate on: the wrong stack can block or limit agentic assistance |
This dynamic accelerates with typed languages—stronger safety rails mean more work can be safely handed to automation.
The Portability Horizon
Language choice still matters today because runtimes are fragmented: browsers require JavaScript, models need Python, firmware expects C. That constraint is eroding.
"WebAssembly is starting to change the rules," Gazit says. "If any language can target Wasm and run everywhere, that removes one key consideration when picking your stack."
Combine Wasm with AI-generated code and a plausible future emerges:
- Developer writes in Rust, Go, or Python
- AI generates code in that language
- Compiler targets Wasm
- Same code runs on web, edge, cloud, local sandbox
This isn't a TypeScript-wins future—it's a portability-wins future, building on containerization's success over the past decade. Languages may compete less on syntax and more on ecosystem leverage: package depth, tooling maturity, model familiarity, debugging ergonomics.
What Developers Should Take From This
The practical signals from the data:
| Shift | What it really means |
| Typed languages rising | AI benefits from structure |
| Python stays dominant in AI | Ecosystems outlast language/framework fashions |
| Shell scripts up +206% | AI removes pain barriers, not just productivity barriers |
| Enterprises adopting AI fast | The definition of “senior engineer” is changing next |
| WebAssembly maturing | Language loyalty gets replaced by language interoperability |
The takeaway isn't about switching stacks. It's about optimizing for leverage, not loyalty. Languages and tools 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. The shift is less about which language is objectively best and more about which language—combined with AI assistance—delivers the most capable development environment.
