If you've been following how developers use AI assistants, you might have noticed an interesting trend: many are starting to prefer strongly typed languages. Moreover, we aren't talking about “religious wars” in the style of “static vs. dynamic”, but about purely practical considerations.
What is actually happening
GitHub published a note discussing how AI tools influence the choice of programming language. The main idea is this: when you write code with an AI assistant, strong typing starts to act as a more reliable system of checks and balances.
Simply put, typed languages like TypeScript, Rust, or Go help AI assistants generate more predictable and secure code. And this is not a theoretical advantage – developers are noticing the difference in real work.
Why types help AI work better
Imagine that you ask an AI assistant to write a function. If the language is strongly typed, the model has clear guideposts: what data comes in, what goes out, what can be done with objects, and what cannot. It is like road markings – they prevent you from driving into the ditch.
In dynamically typed languages like Python or JavaScript, there is no such insurance. The AI might generate code that looks reasonable but, in practice, passes the wrong data structure or calls a method on an object of the wrong type. Errors surface later, often during execution.
Types work as an extra layer of verification. They force the AI to be more precise and help you spot errors faster, even at the coding stage, rather than when the application is already running.
It is not just about safety
Strong typing is useful not only for preventing errors. It also improves the readability of the code generated by AI. When you see types in a function signature, it is immediately clear what it accepts and what it returns. You do not need to guess or dive into the documentation.
This is especially important when you are working with an AI assistant in rapid iteration mode: asking it to change something, finish writing, or refactor. Types help maintain context and prevent losing the thread of what is happening.
Furthermore, typed code is easier to maintain in the long run. If AI generated a snippet of logic for you six months ago and you are coming back to it now, the presence of types greatly simplifies understanding what exactly is going on.
The shift toward TypeScript and other languages
GitHub notes that developers are increasingly choosing languages like TypeScript instead of pure JavaScript, especially when actively using AI tools. TypeScript provides the flexibility of JavaScript but adds a type system that makes working with AI assistants more comfortable.
The same applies to Rust, Go, and other languages with strong typing. They are becoming more popular not because it is trendy, but because they combine better with a workflow where part of the code is written by AI.
This does not mean that dynamic languages will disappear or become useless. But if you work with an AI assistant and want to minimize the number of unexpected bugs, typing is your friend.
And what about developers?
Interestingly, this trend changes not only the choice of tools but also the approach to writing code itself. Developers are starting to think more about contracts between functions, about what data is passed and how it is processed.
AI assistants, in essence, are bringing us back to more conscious design. When you write code manually, you can cut corners somewhere, rely on implicit agreements, or simply hope that everything works. With AI, that trick won't work – if you haven't defined clear types, the model might go down an unexpected path.
This, by the way, is a nice side effect. Typing makes code not only safer for AI but also clearer for the humans who will read and maintain it.
Not a panacea, but a trend
Of course, strong typing does not solve all problems. AI can still generate logically incorrect code that formally adheres to types but does not do what is needed. Types are not magic, but a tool that reduces the probability of a certain class of errors.
But the trend is undeniable: developers who actively use AI assistants are increasingly choosing languages with strong typing. This is not a revolution, but an evolution of the workflow. AI is changing how we write code, and along with that, the set of tools that prove most convenient is also changing.
In short: typing helps AI make fewer mistakes, and developers spend less time debugging. And this is a sufficient reason to consider switching to TypeScript or another typed language if you work a lot with AI assistants.
