The Programming Language After Kotlin – with the Creator of Kotlin

The Pragmatic Engineer
Host: Gergely Orosz
Guest: Andrey (Andrei) Breslav, Creator of Kotlin
Date: February 12, 2026

Overview

In this deep-dive episode, Gergely Orosz interviews Andrey Breslav, the creator of Kotlin—one of the fastest-growing programming languages worldwide. Breslav unpacks the story behind Kotlin's creation, the technical and organizational battles fought along the way, key language design choices (and regrets!), and why interoperability with Java nearly killed the project. The conversation then pivots to Breslav’s radical new endeavor: CodeSpeak, a programming language for an AI-centric era, using English as the foundation and targeting the dramatic shifts in software development brought by AI coding agents. This episode is packed with pragmatic wisdom, cautionary tales, and future-gazing insight for engineers and tech leaders alike.

Key Discussion Points & Insights

1. The Origin of Kotlin: From Academia to JetBrains

• Andrey’s Early Path: Academic background in language theory and DSLs, detoured by Borland's collapse and teaching stints.
• Serendipitous Invitation: JetBrains reached out initially thinking Breslav would help with their DSL tooling (MPS), unaware it would instead lead to building an entirely new language.
• Cultural Shock & Decision: “My first reaction was: you don’t do a new language, you don’t need it.” ([03:50])
• Context for Kotlin: Java’s stagnation (Java 5 released in 2004, almost no meaningful changes through 2010), contrasted with advances in Scala, Groovy, C#.
• Why Not Just Use Scala/Groovy?: Scala perceived as too complex and slow, Groovy too dynamic and hard to tool. JetBrains believed they had the credibility and user base to fill the gap.

2. Language Design by Committee and Copying from Giants

• Early Brainstorming: Lots of whiteboard sessions, user-pain-driven feature lists, internal presentations with “puzzle pieces” for potential features.
• Explicit Pragmatism: “We are not doing academic research here. If we don’t invent anything new, that’s a good thing.” ([33:12] - Andrey)
• Borrowing from Others: Extensions from C#, smart casts from Gosu, data classes and primary constructors from Scala, Groovy’s builder pattern, syntactic ideas from C, and more.
  • “We really learned from lots and lots of languages, and it was always the point.” ([31:30])
• Regrets: Not including the ternary operator:

  "This is the saddest story in the design of Kotlin. I didn't realize how much people liked it... By the time I agreed, it was too late." ([44:44])

3. Building for Java Interop—A Herculean Undertaking

• A Project Within a Project: Kotlin’s success hinged on seamless integration with the vast Java ecosystem—allowing projects to adopt Kotlin piecemeal, and use Java libraries out of the box.
  • “If someone offers you a job to create a system that interoperates transparently with another huge system you don’t control, ask for a lot of money.” ([45:14])
• Technical Details: Tricky compiler strategies to make Kotlin and Java sources mutually visible, complicated “type trickery” for collections and nullability, handling version migrations.
• Null Safety: Inspired by Roman Yelizarov's feedback, took years to get right; became a core differentiator.
  • “Dealing with null references... Tony Hoare called it the billion dollar mistake.” ([28:56])

4. Team, Project Management, and Release Lessons

• Team Composition: Started by recruiting Breslav’s own students and fresh grads, with only a few veterans.
  • “Looking back, I was young and stupid... everyone on the team was a student, apart from a few [JetBrains] veterans” ([56:00])
• Schedule Delusions: The release was always “a year from now” and took six years (2010-2016).
• Release Process: Relentless emphasis on backward compatibility, open issue tracking, extensive deprecation cycles, and even prototyping “messages from the future” in binaries for partial compatibility in upgrades.

5. Kotlin's Rise—The Android Inflection Point

• Accidental Mobile Revolution: Initially targeted Java backend and desktop, not Android. Discovered Android suitability almost by accident.
• Android’s “Java Problem”: Slow VM upgrades kept Android developers stuck with outdated Java, making Kotlin’s modern features attractive.
• Swift’s Influence: The Apple ecosystem’s move to Swift put additional pressure on Android devs for a modern language.
• Google's Surprise Embrace: Google’s announcement at I/O 2017 (after some nail-biting legal and engineering work) led to explosive adoption growth for Kotlin.

6. CodeSpeak: A New Language for the AI Age

• Premise: AI agents have made “boilerplate code” obsolete—what if a language was designed for expressing intent, not minutiae?
• Design Approach: Based on English, not a fully formal language, leveraging LLMs at its core—engineers specify intent, LLMs synthesize implementation.
  • “It’s a programming language that’s supposed to be used by engineers, but it uses LLMs heavily.” ([81:46])
• Why Not Build a Language for LLMs Directly?: LLMs are trained on vast human/human-language data, not new artificial grammars; the solution is a “language for humans, not for models.” ([84:31], [93:53])
• Practicalities: Enormous focus on automated/agent-driven testing, reviews, and preserving the “intent layer” alongside the code for future engineers.

7. AI and the Future of Software Engineering

• Current Phase: “Early days of a new era”—AI coding agents change the game for code generation, but introduce challenges for reviews, preserving intent, and quality verification.
• Workflow Shift:
  • “You talk to an agent in human language. It generates code. You commit that code. But that conversation—your actual intent—disappears.” ([103:38])
• Big Problems: Code review and understanding become more vital; trusting the models is not enough.
• Essential vs. Accidental Complexity: AI will reduce “accidental complexity” (implementation minutiae), but the “essential complexity” of what should be built will remain an engineering (human) challenge.

8. Advice to Engineers in an AI World

• Don’t Panic About AI: Hype cycles will pass; engineering (not rote coding) will remain central.
  • “A lot of things can be stressful in the moment, but some will be rolled back.” ([100:09])
• Steepen Your Skills: Prioritize becoming highly productive with new tools. “It’s absolutely worth it to invest time into learning these tools and get good at it.” ([100:15])
• For New Grads: Seek deep understanding—“go as deep as you can as a younger person... This helps a lot.” ([102:24])

Notable Quotes

• On building on others’ ideas:

  “We are not trying to invent anything. If we don't get to invent anything, it’s a good thing, not a bad thing.” – Andrey ([33:12])

• On Java and null safety:

  “Tony Hoare called it the billion dollar mistake... When we look at all the runtime errors we have in Java code, NullPointerExceptions will be at the top.” – Andrey ([28:56])

• On interoperability:

  “If someone offers you a job to create a system that interoperates transparently with another huge system you don’t control, ask for a lot of money. It’s a very tricky deal to figure this out.” – Andrey ([45:14])

• On AI and human roles:

  “If all the software engineering work is done by models, it means humans don’t have any say in that. This is called technological singularity… That is not what I’m building CodeSpeak for. Nobody should build any projects for that future.” – Andrey ([94:07])

• On the intent gap in AI workflows:

  “You communicate with the machine in human language, but work with your teammates in code. The intent disappears.” – Gergely ([103:46])

key Timestamps

| Timestamp | Segment | Content | |-----------|----------------------|-------------------------------------------------------------| | 01:19 | Andrey's Background | Early academic trajectory, start at JetBrains | | 04:37 | Kotlin Context | Why new language over Scala/Groovy; Java's stagnation | | 12:06 | First Technical Design | Language features, early design by committee | | 17:22 | Crazy Ideas | Dropped features (multiple inheritance, pattern matching) | | 21:03 | Naming Kotlin | From “Jet” to “Kotlin” | | 24:36 | Main Kotlin Features | Null safety, conciseness, readability | | 30:01 | Null Safety | Origin, design, and the “billion dollar mistake” | | 31:30 | Learning from Others | Shoulders of giants; major language influences | | 44:44 | Ternary Operator Regret | Andrey’s design regret | | 45:14 | Java Interop | Technical hurdles, backward compatibility | | 55:11 | Project Timeline | Team scaling, management, release cadence | | 67:16 | Kotlin's Audience | Android’s unanticipated centrality; Google’s embrace | | 78:29 | CodeSpeak | Programming for the AI era—intent, English, LLMs | | 88:19 | The Future | AI agents, code review, the changing nature of programming | | 99:29 | Advice | Navigating the AI era as a software engineer |

Memorable Moments

• Naming Headaches: The internal code name was “Jet”, but trademark clashes required a search for something more unique (“Project Kotlin” stuck to avoid last-minute regret).
• Kotlin’s “Big Break”: Google’s official Android embrace was a literal overnight success, blowing past internal KPI dreams of “100,000 users” to millions.
• Practical Wisdom: Repeated emphasis on “reading is more important than writing code,” and that all the code ever written will—sooner or later—encounter any possible edge case.

Additional Nuggets & Recommendations

• Book Recommendation:
  • “Zen and the Art of Motorcycle Maintenance”

    “A very good book... about technology and how to deal with real systems, but also a very good novel.” – Andrey ([102:59])

• Favorite Tools (non-digital):
  • “Earmuffs. Incredibly good.” ([102:51])

Closing Reflections

Andrey Breslav’s journey—from JVM’s “boilerplate madness” to building Kotlin into a mainstream language, and now to inventing human-centric programming for the LLM era—offers pragmatic, hard-won lessons on technical design, team building, backward compatibility, and the inexorable expansion of the engineer’s role. As AI changes the very fabric of programming, his insistence on preserving intent and building for humans stands as a timely and critical call to action.

Whether you’re a Kotlin fan, language designer, or simply navigating the new world of AI-inflected software engineering, this episode is a treasure trove of insight.

[Listen or subscribe to The Pragmatic Engineer podcast for more episodes like this.]