The programming language after Kotlin – with the creator of Kotlin

The Pragmatic Engineer

0:00

-1:44:10

The programming language after Kotlin – with the creator of Kotlin

Andrey Breslav, creator of Kotlin and founder of CodeSpeak, shares lessons from designing Kotlin and why he’s building a new language to keep humans in control in the age of AI.

Gergely Orosz

Feb 12, 2026

Stream the latest episode

Listen and watch now on YouTube, Spotify, and Apple. See the episode transcript at the top of this page, and timestamps for the episode at the bottom.

Brought to You by

• Statsig — ⁠ The unified platform for flags, analytics, experiments, and more. Stop switching between different tools, and have them all in one place. Check out Statsig.

• Sonar – The makers of SonarQube, the industry standard for automated code review. Join me online at the Sonar Summit on March 3rd, where I and other eng leaders and devs will share practical strategies for the AI era.

• WorkOS – Everything you need to make your app enterprise ready. Ready-built infrastructure you can use, like SSO for enterprise buyers, MCP auth for agentic workflows, or protection against free trial abuse with Radar. Check out WorkOS.

In this episode

Andrey Breslav is the creator of Kotlin and the founder of CodeSpeak, a new programming language that aims to reduce boilerplate by replacing trivial code with concise, plain-English descriptions. He led Kotlin’s design at JetBrains through its early releases, shaping both the language and its compiler as Kotlin grew into a core part of the Android ecosystem.

In this episode, we talk about what it takes to design and evolve a programming language in production. We discuss the influences behind Kotlin, the tradeoffs that shaped it, and why interoperability with Java became so central to its success.

Andrey also explains why he is building CodeSpeak as a response to growing code complexity in an era of LLM agents. He believes keeping humans in control of the software development lifecycle will matter even more as AI becomes more capable. Andrey also closed our converstion with a message to software engineers sceptical about AI:

“There is quite a bit of skill to using these AI coding tools. You can learn it, you can get a lot better at it. Do not necessarily believe everyone on Twitter: some people claim crazy things! Still, you can be very productive with these things when you use them well, and it’s absolutely worth investing into that.
In the future, it will still be engineers building complex systems. Keep that in mind: it’s not like we all go to nothing.”

10 rarely mentioned details about the history of Kotlin, and Andrey’s thoughts on the next big programming language

Here are 10 things that were new to me on the history of Kotlin, and ideas from Andrey I paid special attention to:

1. Kotlin was born because Java stagnated for six years. By 2010, the last major Java release was Java 5 (2004). Java 6 (released in 2006) made zero language changes, Java 7 (released in 2011) made minor ones, and lambdas didn’t arrive until 2014. Meanwhile C# had lambdas, properties, and more — creating a clear market opening.

2. Kotlin’s first version was not a compiler: it was an IDE plugin. In a smart move, Andrey decided to build an IDE plugin that utilized IntelliJ’s parsing infrastructure first. This let Andrey demo the language interactively before anything could compile.! As he recalled: “I could show off the language as if it existed because it had some tooling, but I couldn’t compile anything.”

3. The initial Kotlin team was almost entirely made up of new grads. Andrey hired some of his former university students to work on Kotlin. Many became core contributors who built foundational parts of the language. I found this story inspiring: it’s a reminder that you don’t need lots of experience to build durable things, as long as you are a fast learner.

4. Kotlin used a parser hack from C# to keep angle brackets for generics, and solved a “mathematically unresolvable” grammar ambiguity. The < symbol is both “less than” and “generic type.”

Kotlin took inspiration from C# for its generics implementation

Java worked around it awkwardly (requiring a dot prefix), Scala used square brackets. Kotlin and C# simply disambiguate ad hoc in the parser, keeping familiar syntax.

5. Smart casts were inspired by an obscure language called Gosu. Smart casts is a pleasant language feature in Kotlin, which is rare to see in other typesafe languages: after an if (x is String) check, Kotlin automatically treats x as String inside the branch — eliminating the redundant cast that litters Java code.

Under the hood, this language feature hides a pretty complicated algorithm, but it eliminates enormous amounts of noise.

6. Omitting the ternary operator is Andrey’s biggest design regret. This is the ternary operator, present in most languages:

In Kotlin, Andrey removed it because if was already an expression, freeing up ? and : for nullable types and type annotations made sense. But if, as an expression, turned out to be verbose. Andrey noted: “by the time I agreed [that removing the operator was a mistake], it was too late because you can’t retrofit the ternary operator in the current syntax.”

7. Kotlin adding Android support was accidenta. An Android developer literally asked the team "does Kotlin work on Android?," the Kotlin team checked, and theirtoolchain crashed. The Android tools were stricter than the JVM because Android developers "actually read the spec" (ha!) Ironically, this strictness made Android a great testing environment for validating Kotlin's bytecode correctness, and it was the reason the Kotlin team fixed up Kotlin to also compile on the stricter Android JVM.

8. Andrey is building a new programming language, but one based on English. CodeSpeak is neither a formal language, nor just prompting. It’s designed for engineers, not casual users, and aims to shrink typical application code by roughly 10x. What remains is “the essence of software engineering” — only the things the human uniquely knows about what needs to happen, because “everything else, the machine knows as well.”

9. 2026 will be the year of the IDE comeback vs terminal-based tools. While Andrey praised Claude Code as “a complete breakthrough of what you can do in a terminal,” but argued that we can work better, as devs, inside specialized environments. He expects new development environments built from the ground up for agent-first workflows.

10. There’s demand to teach how to use AI coding skills better. As Andrey told me: “There are people who can prompt it much better than others. They cannot always articulate why their prompts work better, but you can learn it.”

Andrey also urged all software engineers to push past initial skepticism and invest in learning, while ignoring the most outrageous social media claims on the future of software engineering.