This is a bit of a heartfelt plea — an altruistic one.
It won’t be long.
I know what it feels like to hear this kind of message when you have years of experience in dynamic programming (e.g., PHP). I've been there.
It can sound condescending or unnecessary.
But things are accelerating today.
With the widespread adoption of AI-assisted coding tools — GitHub Copilot, Codeium, Amazon Q, and many others — software development is undergoing a profound transformation. Teams ship faster, prototypes multiply, and access to code is becoming increasingly democratized.
But this acceleration comes with a major risk: the generation of incorrect, fragile, or ambiguous code.
In this context, type safety becomes a fundamental pillar again — not only to prevent bugs, but also to guide and constrain generative systems. In fact, this is the moment when it is no longer optional. Even Python, the star of AI (n.b. not because it lacks types, but because it allows extremely concise code to design AI models), is fighting to survive, by strengthening its typing and making human–machine interactions safer.
Python is concise, but it struggles to become truly safe (and it may achieve it).
Other languages are safer, but more verbose.
The future may belong to languages that are both concise and safe. I'm not going to give you a list; all you need is a prompt line in ChatGPT to find out. The reason is that I don't want to give you the impression that I'm promoting a particular language. I want to stick to the main point.
Models generate plausible code, not correct code
AI models produce statistically coherent solutions — but not necessarily accurate ones.
Type systems act as a structural safeguard by enforcing:
- interface contracts
- data structure consistency
- valid operations
Typed code helps the AI converge toward correct solutions by narrowing the space of possible errors. Until they reach (one of) the solution(s). Like a funnel. Just sit, wait for it to reach a successful build, check and correct the diff, and commit. That's it. 90% of the time, that's the only thing to do now. It allows you to focus on the code that is truly unique to you.
Typing improves human–AI collaboration
By providing a formal structure, type safety:
- helps the AI better understand the developer’s intent
- reduces off-scope suggestions
- improves readability and maintainability
In languages like TypeScript, Rust or Haskell, the assistant becomes far more reliable because it relies on precise semantic signals, not just textual patterns.
Will types stifle your creativity, sometimes? No. It's quite the opposite, actually. You can do whatever your brain decides to do on a whim, precisely because you know that if something goes wrong, you'll find out quickly. And you can prototype quickly with your AI, now.
Robustness becomes critical as development accelerates
Software production is intensifying: more commits, more iterations, more experiments.
Without strong typing, silent inconsistencies accumulate — and then explode.
Type safety acts as a safety net by:
- surfacing errors at compile-time
- preventing inconsistent states
- drastically reducing bugs in production
And unit tests are not an appropriate answer to typos in your code.
AI will not run your test suite every time it makes a change. When you write a book, you call on an editor to correct mistakes; you don't wait to be read by the entire world before correcting them.
Today’s development landscape combines microservices, distributed APIs, cloud functions, event schemas, typed databases, network interfaces…
In such a complex environment — where AI now writes, modifies, or generates many of these components — static type safety becomes the shared language between humans, machines, and tools. They are the specs.
Typing as a way to make business logic explicit
Business logic is your company’s true value.
It is the jewel you need to protect.
AI models do not understand business logic intrinsically; they infer it from context.
Well-designed types make this logic explicit, and give the AI a clear contract to follow.
This prevents drift, especially during refactors or changes to your data model.
You really don’t want AI to weaken this core layer. Right?
Conclusion
Type safety is not a luxury — it is an essential condition for building reliable software in the age of automated generation.
If you think it won't be useful to you, that's fine. But you must have made an informed decision. Think twice.
Because you may discover just how useful these ideas can be in your daily work. Because it's not only about types, it's about what they tell you about the inner workings of your code (e.g. Hindley–Milner, GHC...)
I sincerely hope you do.
It is your seatbelt.
Yes, you can ship without it, just like you can drive without buckling up.
But AI is a powerful engine, and your car now goes much faster.
And one day, you may regret not wearing your seatbelt.
By then, it may be too late (burnout, difficult maintenance, impossible documentation, etc.).
So, if you see the benefits, buckle up.
Your future self will thank you.
Have a nice trip.
Top comments (0)