2026-03-12 08:00:01
Why it Sucks to Work in AI in China + Open Source with Kevin Xu
Kevin Xu of Interconnected Blog and Capital, as well as Jordan Schneider from China Talk here.
We’re going to workshop my take that it is way less fun to work in the Chinese AI ecosystem than the Western AI ecosystem.
And then we’re going to dive into Kevin’s opus, exploring the past 20 years of open source technology in China.
So I guess I’m here to kick it off.
The general gist of the take is that if you are at:
the amount of compute you have access to to do your super cool research is an order of magnitude or two higher.
The level of business pressure that you are under is high, but the upside is just also an order of magnitude or two more positive for you as an individual contributor, as a founder, as someone playing in the broader ecosystem.
If you’re in the West, in contrast, the Chinese new entrance to the field, the 01.AIs and Minimaxes and even DeepSeeks of the world have not had anything remotely close to the type of success that OpenAI, Anthropic, or even the sort of tier two AI startups that have been founded over the past few years have been able to deliver.
So the pressure is enormous.
It’s kind of indefinite because you haven’t, even though you are making the best models in your country, it’s not that’s transforming into revenue in the tens of millions of dollars.
Kevin, we should get into the Alibaba firing resignation of Lin Junyang too then, since you mentioned the “cushy job at Alibaba”, which really only lasts about a couple of quarters.
I think that has been dealt to China tech in general, probably as soon as export control and tech sanctions and then China’s own crackdown became the norm that everybody in China has to operate in.
And AI doesn’t change that AI probably accentuates a lot of those challenges as far as lower ceiling, but also less resources with just about as much expectation for the output and the traction and the metrics.
And I think the latest personnel change over at Alibaba’s Qwen team, this just happened a few days ago, is the latest manifestation.
I think China tech or China AI, maybe, especially in the open source world, has maybe enjoyed quite a year of, I wouldn’t say euphoria, but at least a lot of really welcomed and perhaps long overdue traction, attention, not just from within China, but all over the world.
And whether that actually continues this year is a huge question mark.
And what has happened over on the Quen team may be the first sign that the economics and the expectations of all these decently well-funded labs in China, but nowhere near as well-resourced as the open AIs of the world and the open AIs of the world are still crying out for even more resources.
So you do have this dynamic of higher cost, but higher reward on the Silicon Valley side.
And the China side is just a very different set of hands that you still have to play.
I would say one thing that I mentioned near the end of my so-called opus of the history of China’s open source ecosystem, it’s 6,000 words long.
It’s probably way too long.
I don’t expect anyone to read the whole damn thing.
But near the end, I wanted to articulate one thing, which is that open source as a strategy to expand is likely one of the best, if not the only avenue in which a lot of Chinese entrepreneurs, tech entrepreneurs have at their disposal these days to really go beyond their own border.
And everybody wants to expand overseas, despite the sanctions, the geopolitical tension, the different barriers to go into different markets.
The desire and the passion and the energy has not stopped.
In fact, it probably only gotten more intense, partly because the domestic economic situation, frankly, hasn’t really improved dramatically.
So there’s only so much you can get out of the domestic pie.
They have to go overseas.
And open source is one of these ways where their own technology, at least the open source, the AI labs, can be seen and evaluated and being kicked and tested without the geopolitical stuff.
And all the toxicity of the China label as a brand for, a quarter, a quarter or two before you start to work on commercial relationships.
And so there is a very practical reason to open sourcing everything, despite the economics being initially not that great, because it’s one of the few vectors where you can break out of your market, your whole market into different markets.
Yeah, let’s do a little compare and contrast between China tech crackdown and what we just saw with Anthropic and the Department of Defense, because I think that kind of underlines another difference in the sort of ambition that you can have as a founder in this world.
I mean, Dario wants to shape the future trajectory of humankind.
I don’t think that’s really underplaying the vision that he’s put out in his first essays now that have turned into little novellas with the latest one that came in the new funding round. And kind of the idea that first, I think a Chinese founder could be that kind of loud and ambitious and discordant with the sort of general narrative about what the government thinks AI should be used for.
And then the, look, we talk about America has military civil fusion as well on certain dimensions, but the idea of a Chinese lab saying no in a dramatic and public way like this would just not happen.
People have learned that lesson: this is not the way to sort of have what would have been the equivalent of Dario writing that memo and it coming out in the public? It would just be someone crashes out on WeChat Moments and it gets screenshotted and sent to things.
And then three days later, all their social media disappears and they’re probably gone somewhere and maybe not coming back, ever, or at least for a good while, which is kind of what famously happens with Zhang Yiming and the crackdown on some of the ByteDance products, which weren’t even trying to reshape the face of the society’s relationship.
Just low brow humor was what Zhang Yiming’s initial wire that got tripped.
They just had fights and nudity and that’s all it, that’s all it took. Not saying no to doing autonomous weapons.
So, that’s less fun. You can’t make as much money. You can’t play machine God. And I think it’s an interesting thing.
It’s an interesting point, Kevin, about how doing open source is maybe one of the few ways you can express yourself ideologically in the Chinese technology ecosystem that by doing, but by working on these projects and releasing your technology to the world, that comes with a sort of ideological valence, which as you pointed out, starting in 2021 is something that the government sort of saw.
What you end up having to do is actually a very classically liberal democratic governance process, where you get a bunch of people who have a lot of stake in the project’s future. So, you decide on a set of priorities, you decide on a set of priorities, you vote on a lot of things, you usually have a technical committee, you can just look up any of your favorite open source foundations, whether it’s a Linux foundation, whether it’s a cloud native computing foundation, which is a sub, a subsidiary of the Linux foundation, the Apache software foundation.
All these open source bodies have these democratic processes and transparency and openness built into it that a lot of the AI generation of founders in China have likely lived with and grew up in for a long time as they study and level up their own technical chops.
Because everybody learned from open source in the universities, no one buys a proprietary piece of Oracle software to learn about databases, right?
That’s just ridiculous.
And now they’re expressing it in different ways. And it’s funny, you mentioned that as another vector, right? To express their own identity, not just as a way to go abroad from a business perspective.
The first generation of founders, this is like the Zhang Yiming generation of founders. There are several people who also work in open source world and databases as well. They’re very liberal. They’ve all had traces on Weibo of expressions and opinions expressed about the state of their country that has nothing to do with the technology that they’re building. And now all of that has disappeared, right?
And I think the newer generation of AI founders, one thing I paid a lot of close attention to is not so much the fact that they open source anything at all, but the way they are doing it is increasingly more sophisticated and more exposed to different ways that Western communities are being built.
One example that I cited is Moonshot’s founder, Yang Zhilin, who in their shop makes a Kimi series of models. And it’s really interesting to see him coming out of his engineer shell and engage with the Reddit community during one of Kimi’s launches directly to talk with the community. It’s very Sam Altman-like as far as how exposed and accessible he is, right? To whoever wants to talk about Kimi or give him crap about Kimi. You have to have a pretty strong, thick skin, but also a good sense of humor to do Reddit really well. That is the kind of thing that the previous generation of founders, the Zhang Yiming generation, hasn’t quite cracked. But Yang Zhilin’s generation, I think, is cracking right now. He also did this, direct-to-camera release of Kimi k2.5, I think, which is very different from a lot of how Chinese models or Chinese products in general are being released. Manus did similar things for their product as well. All these things built on top of what I wrote in my piece, which is two decades plus of open source history that evolved from taking and consuming and just using free software for their own needs. And there’s still a lot of that going on and not enough giving back, unfortunately. But over time, the maturity has really evolved as far as contributing, but also engaging with a wider community to actually take in feedback, to prioritize feedback, letting people vote on certain elements of the roadmap, which is super, super common in the open source world. And the Chinese founders who engage in that world are frankly not that different.
So, in my view, those are the most, quote, Western part, the most, quote, Western portion of the Chinese tech community.
They’re also ones that are, of course, super aligned with the government. And we can talk about those as well. That’s kind of a different cloth. Well, I mean, Yang Zhilin’s an interesting one. He’s yet to agree to come on China Talk yet. TBD on that, guys. But he did a PhD in the U.S., right? And I don’t think that, I don’t know if there is any other, well, I guess the Pinduoduo CEO has an American degree from Duke or something. But aside from that, I don’t think any one of these top people have English as strong as, well, I mean, Jack Ma’s kind of an exception. But the fact that he lived here or worked at Meta and Google for a while is sort of illustrative of that. And, but, and yeah, his doing it, doing a YouTube video in English was definitely a step.
Kevin, why don’t you talk a little bit about the need for, or, or why these, kind of, everyone below Alibaba feels like they need to have kind of global adoption of their models. I think even Alibaba needs it. And I think that’s one of the reasons why the personnel change. But to more directly answer your question, the Chinese technique, the Chinese IT ecosystem as a business environment has been piss poor forever and continues to be piss poor. And what I mean by that is people just don’t spend enough money buying software solutions when they can hire five people to hack something on their own.
The business environments between the software makers, whether it’s a SaaS solution or AI model and sell it to would be buyers, whether it’s an SOE or a tech company or local government or a bank or whatever. That exchange in value has never grown to the level where you just could actually make a decent profit margin off of that. It’s incredibly, incredibly hard to make money off of code. So for any Chinese technology company where the core of your product is software, you have to go abroad at some point. You look for markets where there is a stronger penchant to pay for technology versus paying for people to hack your technology or to just jigger your technology into something you want. You never want to pay enough or you’re just going to pay some service contract, but you never want to pay a good subscription, all this sort of stuff.
So with that context in mind, the latest generation of AI labs from China, at the end of the day, they’re selling a model that’s packaged either in an API or packaged in some sort of a vertical chatbot or agent solution, TBD, what the form factor would be yet. And the only way they can really make good money is to go to a market:
where buying software is just not as scrutinized, where you can really scale that model, right? So they really don’t have a good option. It’s a very tough hand dealt when you’re a tech founder in China trying to make technology products to be sold and make a big company out of it.
And open source is this vector where you can at least get people to try yourself without, again, the toxicity I said, and kind of see it on the merit. And the playbook of packaging open source things to commercial software that you will subscribe to or pay for, that playbook has been played quite a few times in the U.S. market, especially in the cloud, the hyperscalers, packaging open source databases to be consumed on AWS. And most of the Chinese vendors and companies have really internalized how that playbook is run as well, which is why, if you want to turn it to present day, why Kimi and Minimax and now Tencent Cloud and every other cloud under the sun in China is packaging Llama almost immediately as a hosted solution to be consumed by the masses or whatnot.
“And that’s just a very simple open source to commercial playbook.”
And it’s more surprising to me that less U.S. players are doing that. We can speculate on why. But that playbook is very well run and well internalized on the Chinese ecosystem.
Yeah, China never figured out SaaS or was never interested in SaaS. And the sort of companies that ended up selling software ended up kind of being almost all forward deployed engineers without back ends of a thing to leverage.
It was just, OK, you’re just going to hire some software engineers and we’re not going to pay them a lot because in China, you don’t get paid a lot as a software engineer versus an entire economy being used to buying software, which then OpenAI and Anthropic can sort of leverage into and turn into — I mean, it’s three quarters of their business now is enterprise as opposed to consumer.
So not really having that as the thing that’s going to power your business means that you have to go to these B tier and C tier business models as opposed to just making the thing and selling enormous amounts of credits for it.
And then Anthropic now having Anthropic and OpenAI having forward deployed engineers is a nice thing, a nice extension as opposed to the core business, which is a lot more straightforward: keep building better models and keep selling tokens and try to get them cheaper and faster.
And it’s interesting. I think there was a moment in the Chinese tech ecosystem where buying software could become more scalable. It was trending that way all the way up until the tech crackdown—not so much on the Jack Ma side of things, but cracking down on education tech companies, cracking down gaming for a little while there.
Before that, there was a period where engineers were actually getting expensive in China enough where paying for the solution as opposed to paying for the body to make the solution might have been worth it economically. And then the crackdown just released a bunch of engineers into the market who are unemployed overnight and they need jobs.
So all the companies who weren’t going to pay because of the labor supply, let’s just say, just got a big boost of supply. So, oh, never mind. We’ve got all these engineers we can hire for cheap. Forget about paying a subscription for your stupid little CRM or something like that.
And so it’s funny if you want to replay that history, if the crackdown hasn’t happened, what would have happened to the software industry in China is another interesting branch that we will never get to really live, but we can speculate.
“That’s fascinating.”
Kevin, can you talk a little bit about the consumer fight domestically in China?
I mean, I’m a lot less close to the consumer side, to be honest with you. My investment is in the infrastructure side, the B2B side, the enterprise side. I would say most of the revenue is coming from consumer apps or APIs that power other consumer apps.
I think the consumer landscape in China is always a bit more—you can call it vibrant, you can call it fast moving—you can call it there might even be a higher willingness to pay on the consumer front. We were joking earlier in our live stream about gifting on live streaming platforms and whatnot. That’s a very well-baked business platform that is very to consumer in China for a very long time.
So I think the fight is there, but again, the market is just walled off. If you make the best Chinese speaking or the best chatbot, whatever consumer app for the Chinese market, the way you can really go abroad with that is hard, not impossible. TikTok has shown some ability to scale beyond that. If you find some commonality or common denominator to scale, right?
But as far as who’s up, who’s down, obviously Doubao from ByteDance seems to be the one. It’s a ChatGPT equivalent as far as the consumer level of both awareness, but also usage. Alibaba is actually quite behind, even though there might be nominally number two with whatever, the Qwen branded chat app that they’re releasing just very recently.
Another reason why maybe they’re much more commercially focused is because they’re losing that market share. While the cloud infrastructure B2B side is still going to be a very tough business for them to grow both domestically and abroad.
One of the interesting things about how this is going to evolve is we’ve recently got news that chat GPT is spending less effort on the shopping side of things. They had a big launch six months ago. I used it once or twice. It really wasn’t great. So maybe it deserved to die.
ByteDance and Alibaba sell a lot of stuff, sell outrageous amounts of things.
I have faith in the kind of Taobao and Douyin teams to make that happen.
And I think the WeChat, Tencent team too, for sure.
“They’re doing that as well, right?”
So it’s just it’ll be interesting because the kind of paths of highest revenue of just selling API access to enterprise isn’t really open to China.
That the sort of engineering hours that would have pursued those sorts of tier two things, as you said, the kind of open source bundling model or this shopping stuff.
We’re just going to get we’re going to get stuff.
Even if the Chinese labs aren’t making the frontier pushing models, we will still have interesting applications that the Chinese ecosystem is going to pursue sooner and with more energy than in the West.
And I think it is not a technical limitation on the models that is not letting ChatGPT or Claude help me pick out my new nail clipper or whatever.
“It’s just that it’s not enough.”
It’s not a high enough ROI decision to spend kind of management engineering hours on.
And it may be for that or other applications in the Chinese ecosystem.
Yeah, my speculation right now is that no matter how which direction the model game between the two sides evolve in the next year or two years or three years, the business environment or the trajectory of tech business in general will more or less stay the same in the sense that Alibaba or ByteDance or WeChat, Tencent will probably figure out agentic commerce, let’s just say, before Google and OpenAI does.
For sure, it will live within their own wall garden, but they will figure out that experience before while the U.S. side or the Western world will still race ahead when it comes to enterprise adoption because of all the dynamic that we just talked about, which is exactly the dynamic that we had 10 years ago or 15 years ago when it comes to which side is better at what.
And one last thing I would say about open source, which is that it isn’t just a B2B packaging play that is fairly natural.
The thing with open source is that it touches the developer more directly right away.
There is a vector in which it could touch the other kinds of consumer application or just landed application, practical application a little bit quicker than closed source kind of beautifully packaged but inaccessible models.
I kind of name check unitary in my long piece as a robotics firm that also open source their own VLA model.
So the hardware OEM side of things in China are also in the open source game to get their software packaged out there, to get more people interested in their platform if their vector into the market is actually to make the hardware really, really good, whether it’s quality or affordability or whatnot.
So open source could play in the consumer side, but it typically doesn’t play as well in the consumer tech side, but it could play well in the hardware side.
And that could be another thing that you see more offshoots in the Chinese ecosystem from the hardware vendors of the world.
What else do you want to talk about, Kevin?
Do you want to do it?
Do we talk about are you done with your conjecture about China?
Not less fun.
I thought it would be more personal than just the industry.
Oh, I mean, I think it’s a personal, I don’t know, personal.
It’s just, did you have a more personal take?
No, it was just, I mean, it’s tough, right? It’s a hard hand.
Well, I mean, like you just have, it’s, it’s, you have less money, more competition. It’s more intense. Upside is lower. Kind of political walls are way tighter closing in. You can’t be, you can’t aspire to become like a master of the universe in the way that you can in the West.
I mean, what, what, what, what, let’s, let’s talk to the other sides. What’s the upside?
You get to distill models. Everybody can do anything about it. Everybody gets to distill models.
I, I don’t know. What else is an upset? I guess you’re.
Yeah.
Right. There’s no upside. If you, if you have the ovarian lottery choice to be born 10 years ago and you’re a tech entrepreneur in your genes, which world you want to be born in. I think it’s 10 out of 10. You want to be born in the United States. There’s no question about it.
That that is a fork in a row. And it’s really unfortunate, right? Given the quality of, I don’t know, innovation or just grit, I think, to have to work within that much constraint and to still put out what you can put out to the world.
I think it’s admirable, but admorbidity only gets you so far when it comes to market cap.
And, you know, we’ll see how that goes.
And yeah, I don’t know if you want to talk about the whole Alibaba fiasco. I think it’s TBD where that’s going. But again, it’s just another episode, I think, of the whole difficult. Yeah, let’s do it. Well, let’s just, I mean, just to, just to kind of level set: Tencent market cap, $600 billion. Alibaba market cap is somewhere around that is 325 billion dollars. So those firms have been at it a long time.
If they were, I mean, the closest, the closest comps are in the multi trillion dollar range in the U.S. and little OpenAI and Anthropic have already, or on the, or on pace to surpass. Both of them having existed for three and let’s say 10 years, but we don’t really count the opening after 10 years.
So it’s not fair at some level that you can have just as sharp engineers doing, working just as hard, probably harder to be honest. And not, not having the same kind of ability to technical outcomes or overall compensation, global impact.
Yeah. Yeah. Should we address viewer questions? I feel that’s part of the job of a live streamer. Thoughts on XAI implosion from Daniel.
I stay fairly close to early stage investors on both sides of the aisle or both sides of the, I don’t know, ocean. And frankly, XAI’s financials and trajectory as a business is pretty terrible. And has been terrible since the get go, regardless of how you feel about the models and what it can do.
So really folding XAI within SpaceX and you kind of lump Twitter X in there too, as a conglomerate concern is one, the best way for the initial investors to have a good story or a good ending out of the XAI investment, which has always been pretty aggressive from the get go, given how much they’ve built.
And this is not to comment on the Colossus data centers, which I do think is quite a feat of physical accomplishment that only the Elons of the world can really push through to make it happen. Happens to be three hours from where I live at that. So very cool to see that happen near me, but as a business, right? As a concern, it will be very hard to survive on its own without more or less hiding in a giant conglomerate and kind of do what it does and see what they can do.
Right. I mean, we can ask the same thing for Gemini as well. We don’t know the P and L for Gemini as a, the vision. So in a sense, the independent model makers always have a little bit of a tougher time, maybe justifying the worth, but if they’re really doing well, I do think they probably deserve the valuation that they’re getting, which, again, and you can’t decide whether that is the right number or not.
Yeah. I don’t think the Gemini comparison is fair. The sort of the corporate thing that Gemini can plug into to boost growth is pretty enormous on its own. Compared to X, it would be pretty embarrassing if you were Google and you didn’t figure out how to use your giant models to make less, more money. And as, yeah, as you said, okay, we’re plugging it into X. I mean.
And what? And, well, I guess Tesla for the robots question mark, right? That’s a much more speculative, speculative thing than make the ads come up better on Google searches and YouTube. So. Yeah. Yeah.
Anyways, how is Minimax worth more than Baidu? Baidu’s got terrible vibes. I think they’ve just got terrible vibes for decades. Baidu, so yeah, this is maybe less about if Minimax is overvalued versus Baidu’s undervalued, right? You can kind of do both sides. I don’t know how you feel about it, Jordan, but Baidu’s probably undervalued from a pure financial perspective, but it just has kind of whiffed on almost everything up to this point.
Like literally everything, even including, I would say self-driving, which you’re fairly early into, from a platform perspective or robo taxi perspective, the model they were, I guess you can say early into, but it just isn’t the kind of shop that can deliver, unfortunately, based on the promises.
And Minimax, I do think it’s probably slightly overvalued in my opinion. I think there just aren’t that many ways to bet on a pure AI lab and both Minimax and Zhipu are the only ones out there in the public market right now, listed in Hong Kong.
So there’s probably a little bit of froth there as well, because if you look at the end of the day, Minimax gross margin has improved from 12% to 25% from its very first earnings report.
It is a doubling of improvement, but the base is quite low and the current state is still lower.
And that’s the thing on all these labs. It’s not like the open AI gross margin at this moment, at least it’s that much better, right? It’s in the forties, 30, forties range, depending on the business. So these are all very hard business to run, actually.
For some number, they’re both around 40, 45, 45 billion USD, which is, again, a failure for an A16Z. Maybe not a failure. We’d probably be happy with that in a 10 year fund, but still. What else is there to discuss?
Oh yeah, Alibaba implosion. We did a little bit of it earlier. “Why don’t you, why don’t you close the circle on that one, Kevin?”
I think for those of you who haven’t caught the news, there was a pretty public resignation of one of the tech leaders of the Qwen model team, Lin Junyang.
And he also has quite the big reputation within Alibaba for being the youngest P10 engineer, P10 being a very high senior engineering level that you don’t reach in your early thirties, right? I think it’s roughly where he is right now. It has open AI. Sam got fired by how it played out a little bit on Twitter. Of course, while China is actually asleep, which is super fascinating. Then a few other people also resigned. There was an all-hands meeting that happened with the CEO of Alibaba, who was also the CEO of Alibaba Cloud, Eddie Wu, to address the whole situation.
I wrote a little bit about it on the interconnected newsletter, but I think how this translates into financial results is TBD. I do think this is both somewhat idiosyncratic to Alibaba’s corporate culture, which is they’re very kind of anti sort of God figure, at least in the ranking files.
And I think Lin probably got to that level of celebrity, especially in the Western world as the only person or the most accessible and visible person that anybody from the West who interacts with the Qwen team. You basically talk to him and that he’s very good at being accessible, very helpful, generally a very good open source evangelist, not to mention really technical person as well.
So nothing against him whatsoever. But my way of thinking about the situation is the old JFK line, which is that is no longer about what Alibaba can do for Qwen is about what Qwen can do. For Alibaba. And I think that that is the strategic shift that we’re going to see as far as where can Qwen plug in to lift up the rest of the entire Alibaba ecosystem when it comes to shopping, consumer app, obviously the cloud. And I think Qwen probably vastly exceeded its expectation as well from the way it started.
I cannot believe the whole team is only about 100 people before the whole personnel change happened. It’s sort of a you’re a victim of your own success in a lot of ways. And then the top just comes in and sort of grabs it.
Here’s an interesting comp: Mira leaves open AI, brings 10 of her best friends, gets to raise $2 billion at a $12 billion valuation, has basically done. Has published nothing a year later, gets one megawatt of compute, signs a deal with Jensen, and is now raising at a $50 billion valuation.
If you take the Qwen team and bring them outside and put the hat out to the Chinese domestic ecosystem.
So you don’t want to do a Manus and I guess they kind of already are in Singapore. Maybe it’s a slightly different thing, but Kevin, why don’t you play out the two paths?
Or else let’s do the global thing, but as a not Chinese company.
You mean if the crew that left Qwen wants to do their version of the thinking machine as a startup or as a Neolab, that’s the new term. It’s a Neolab. If they want to, what are the pathways for Neolab success? If you have the street cred and track record of the Qwen team, but you want to make it on your own today?
“I literally have no answer for what could be the successful outcome of a Neolab.”
It’s so crazy. We see the new Yang LeCun Neolab raising a billion dollars right off the bat as well. But that’s a $3 billion valuation. I feel like you could probably pull off domestically in China. You might get enough people to take a flyer on you for that, but not at the thinking labs. No, not at all. I think the 01.AI / MiniMax exit story or the going public story is probably the best comp for any investor looking at persuading the Qwen, where is it?
I want to think of a Fairchild, the trader is, I don’t know how many left the traders for five to start their own Neolab in China. That’s probably your best get alcohol from a financial perspective, right? But I think having that reputation that he has garnered could give you a really big jumpstart. And this is probably the last check that anybody, at least within China, but maybe even globally will write into a Neolab.
I don’t think there’s a good Neolab story at the Yann LeCun level, at the Mira Murati level that could really garner both that much money, that much attention with relatively little to have shown for up to this point. And I think the Qwen team actually was going to have a Singapore team as well. That was one of the things that was maybe on the table that got shelved because of this personnel change.
So my best guess is that they’re going to decant to Singapore and do Manus 2.0, but even cleaner, and see how that goes.
Well, it’s a really interesting question: if all this team wants to do is open source AI, and they are in Singapore, so not at all China adjacent, there’s no kind of export control risk, which Manus kind of had to deal with for a hot minute. Is that a viable business? Is that something investors would be excited about if you have a team which is very deeply ideologically committed to just making open source models?
Right. I think a lot of open source founders, quite frankly, start out that way. This isn’t, again, an AI thing. This is an open source thing. I’ve seen at least three generations of pure open source founders who got incredible traction with their open source databases, observability tool, whatever you want to bake, make open source in the cloud stack. Right now we’re in the AI world. And then you raise money and the moment you raise money, you slowly, but surely come to realize that you have to build a business.
So it really comes down to how malleable — let’s just play this out in full characters — that Lin Jun Yang is going to be the CEO. He’s going to be the figurehead, right? He’s going to be the Dario of this new lab; how good he is going to be as a CEO. He will be a CEO. He will not be a tech lead of a division within a giant corporation that has his own set of problems. Will he do that? Right. And if he can, then yeah, they’ll figure out a way to commercialize it somehow.
I think I have faith in figuring that out. Again, the playbook isn’t a mystery, but the timing and where you start to jigger and address those things is going to be very, very hard. And no one has really quite played that perfectly. I don’t think even a Red Hat — at the end of the day, it got sold to IBM, fantastic. Congratulations, but that’s about it.
But we should have a little bookie market. So the odds that he shows up at Meta revives Llama. He could get hired away. Exactly. Just go up to the Man of Singapore office that has Meta badges and just call it a day. He gets all the compute he wants, hangs out with Alex Wong. That’ll be fun. I think that’s an outcome.
We can probably rule out Anthropic. I think we can, I don’t know. This guy doesn’t seem like he. Well, Anthropic never wanted to open source anything in the first place. Even I try to straddle both worlds and try to be nice to everybody. But Anthropic was just “no.”
Well, what’s funny, I do want to talk about this a little bit. We wrote a piece for China Talk, exploring the ups and downs of Anthropic’s rep within China. And we had this fan, we had this fascinating swing with on the one hand, everyone was hating on them because they released that report saying that all the Chinese firms had been doing distillation of their models.
“oh, how dare you, you guys stole all this other IP. Don’t you dare give us any crap.”
And then a week later they have this giant blow up with the department of war and they’re like, “oh, wow.” Dario standing up for humanity, stopping the Terminator from taking over the world.
Which, incidentally, is an analogy that a PLA official shouted out, saying:
“we don’t want Terminator to happen.”
I don’t know. It’s kind of a fun wrinkle. I think he was persona non grata number one, for all of his stances around export controls and whatnot.
But felt like he gained a few a few popularity points with the whole Pentagon kerfuffle domestically.
You can just see it from the Claude download chart. It’s finally at number one after being at, what, number 17 for ever.
Well, everybody I know, not to say that’s indicative for a big sample size, who is part of the Chinese ecosystem. They love using Claude. Most of them are engineers, who I know. They love Claude code. They love the product that’s coming out of Anthropic. I think that is a good way to understand the practicality of people who work in the tech world or the business world in China. Is that, from an ideological perspective, you probably don’t like what the guy who made the product said about your country or what you do, or whatnot. But a good product is a good product and I’ll still use it, and it’s still very, very popular.
And it’s, I don’t even know how that usage falls in an Anthropic financial statement. Do they even have a revenue line that says PRC on it? Because they’re definitely getting usage. I just don’t know how that actually works from an account, a receivable, or accounting perspective.
Well, it’s all Asia Pacific. It’s all coming through Japan and Korea, right?
What’s funny is they’ve really tried not to, they had this whole blog post saying
“we’re going to try to really shut down all the, all the accounts.”
And both, both OpenAI and Anthropic have since published reports saying, we caught some Chinese state hackers slipping, revealing that they were trying to find exploits or whatnot using our models instead of domestic or open source ones. But I don’t know, it’s hard to regulate this sort of thing.
VPNs can be really good. The thing about VPNs is at a certain point, if it’s really that important, you can just control someone’s computer who’s in Japan. How are they going to know? I guess, are they going to ban everyone who’s using simplified Chinese to use their models? I don’t necessarily think so. And if you’re not going to do that, then to a certain extent, especially with individual users, where there’s a will, when there’s a will, there’s a way.
Maybe with the kind of, you can at some point get a hand on the distillation stuff. It seemed the way they were writing it up, it wasn’t super sophisticated and it was kind of obvious. And the question is then how sophisticated can you get on the distillation side to a bit of a bit of a kind of mouse game between the Chinese and Western model makers.
I think it all has to do with traffic pattern, right? A normal person or even an engineer using cloud from China to do some normal engineering or side project will just look different on the observability level than a distillation campaign or a run or what have you. And that’s what any cybersecurity person needs to do for something that has as much traction to figure out the difference. And not just blanket ban or blanket allow whatever happens on your platform.
So yeah. Cool. All right. We’re good. Maybe we should call it there. This was fun.
“Everyone subscribe to sale.”
If you work at a large organization, reach out. you get a big bulk subscription to all of the greatest AI content on Substack. I read sale.com read sale.com, but this was fun. Thanks everyone for joining today. Thanks everybody for joining.
2026-03-06 08:00:01
听众朋友们大家好，欢迎收听这一期的不合时宜，我是主播王庆。那今天，我们想来聊一个近期在新闻上也比较受关注的话题，也就是这个德国的总理朔尔茨最近来访问了中国，然后也由此引发了一些不然有意思的讨论。
那今天，非常荣幸地请到了我们节目的三位老朋友，去年大约是同一个时候来到我们节目聊过德国话题以及中德关系的三位记者专家观察家：
到《不合时宜》，然后跟王庆一起，而且这次是跟两个老朋友一起了，重新探讨关于中国政治的话题。
感谢王庆，特别高兴能够再次来到节目做客，我觉得这个话题特别重要，特别让我高兴的是能够跟我们三位老朋友一块儿重新讨论关于德国的话题。
他大部分时间是给一间叫做China Table的德国媒体工作，China Table在德国的媒体当中是专事跟中国有关报道的一间媒体，近年来逐渐获得了越来越多的关注度和影响力。非常欢迎Lio。
大家好，很高兴有机会再次讨论，也有点荣幸，因为你现在已经说了我是老朋友，第二次参加《不合时宜》的团队，很高兴。
对，非常感谢三位，感觉非常开心，有机会跟老朋友们一起来返场聊一个我们一年之前聊过的话题的延续。我记得大概去年也是差不多这个时候，三月份的时候，朔尔茨刚刚当选德国的总理，然后当时也有很多猜测，这对德国政坛、对中德关系可能会意味着什么。如今一年过去，我们也是感慨世界局势千变万化。就在我们录制这期节目的今天，我们大家可能或多或少都有在关注伊朗的话题，感觉今年才过去了两个月，新闻头条已经换了一波又一波。
伊朗的话题我们今天应该不会展开，但我想它也为我们今天聊这个话题设置了一个背景色：在如此变化剧烈的国际局势当中，我们应该怎么样去理解中德关系，以及怎么样去理解德国。我先说一下朔尔茨访华的这件事。在过去这一周，朔尔茨率领了一个很大规模的代表团，对中国进行了一次访问。社交媒体上有很多有趣的片段，其中一个就是朔尔茨去杭州的宇树科技，去观看机器人的集体舞蹈，去参观故宫，以及他回到德国之后也发表了一个让人非常印象深刻的演讲。
这次访华的背景，一方面是中德的贸易正在进入一个新的阶段；另一方面，特朗普执政一年之后，美欧关系出现了一些非常剧烈的变化，从乌克兰到格陵兰，美欧关系变化之下，欧洲也包括德国在寻找一些全球范围内的新的锚点。中国作为德国最大的贸易伙伴，也成为了非常受关注的焦点。
中德之间当然仍然有非常大的不同，但我觉得随着这次访问以及接下来可能开展的一系列合作来看，也许是一个新的篇章的开始。首先把一个基本问题抛给各位：你们各自对于朔尔茨这次访华的观感是怎样的？你们印象最深的点有哪些？
从我的观察来看，这一次的来访在一开始或来访之前，双方之间的感觉是有一些紧张，有一点互相试探、想要破冰的感觉。但在行程真正触发之后，特别是朔尔茨在出行之前有了那个谈话之后，整个基调和轻松度开始慢慢展现出来。等到了北京之后，在企业家的互动环节后，第一天的晚上情况就开始逐渐轻松；到了第二天，整个行程在杭州以及企业家的参访，气氛活跃了很多。大概是一个从比较紧的状态，一直到大家互相接触之后产生一定的信任的状态。
我觉得很重要的一点是，对德国方面来说之前他们心里没有底，但我知道德国总理府为这次拜访做了很多事前功课。而且无论是在慕尼黑安全会议，还是来访前的各种预热活动上，都是有很多预热性的行为。换到中方视角，中方也是做好了很好的功课。比如说，中方在朔尔茨出行之前的谈话之后准备了一个非常惊喜的大单，”最多是120个空客飞机的这样一个大单”，作为一个惊喜。所以中方也很懂，对朔尔茨现在在德国要进行改革，你必须带有一定成果回德国，中方也是做好了非常好的功课。
总结来说，这一次来访对双方都是非常满意的。对中方来说，朔尔茨没有再提“系统性竞争对手”这一点，就让中方已很满意了。
我个人和理性批判老师的观感或判断还是蛮一致的。总而言之，朔尔茨来华比我想象的更顺利。他来华之前，第一，双方都有点紧张；第二，德国国内有很多声音想要说服朔尔茨对中国采取更对抗性的心态或表现。主要从经济角度来看，德国国内现在讨论的有一个很焦虑的问题是贸易顺差：德国对中国的出口越来越少，而德国经济高度依赖出口。
所以很多人说朔尔茨来华主要是要向中方提出很多诉求，关于平等的贸易关系。我觉得朔尔茨最后选择的办法是先把跟中国领导的关系搞好，毕竟是他第一次来华，而且来得比较晚，他现在担任总理已经一年多才来。所以他这次没办法带来很多诉求，还是要先建立一种良好关系。我确实也觉得他做的功课比较扎实。来华之前的那个星期，他就邀请了几位中国专家到德国总理府，聆听他们的看法。
但我觉得虽然他在访华时表现得对中国关系比较友好，但长期要搞好与中国的政治和经济关系仍是一个很大挑战。很多媒体在他来华之后说，虽然他可能第一印象不错，但之后还是会有很多留下来的工作。
如果谈到这次朔尔茨访华，我个人最关注的一点是这次访华本身传达出的信号：将来的中德关系如何发展。新的总理首次访华，他所传达的对华关系政策是会继续延续之前的政策，还是会出现转变？总体来看，中方媒体对这次访华抱着比较正面的态度，做出了很多正面评价，看起来中德关系进入了一个新的春天。
德国媒体总体关注度也非常高。不管是从媒体报道还是朔尔茨本人的态度来看，他都是从以价值观为导向的对华政策，变成更务实的对华政策。尤其在过去几年，欧盟对华有比较清晰的定义：系统性竞争对手、竞争者以及合作伙伴。这次朔尔茨访华时，他很清晰地选择了关键词——竞争。如果分析这三个词，他选择了中间一个比较中立的位置，他没有把姿态放得非常低，说“我们就只是合作者”，但他也完全没有提“系统性竞争对手”这个词。
所以我觉得务实是这次访问的关键词。一方面代表这次访问本身的态度，他带来了庞大的经济团队来寻求合作；另一方面也代表总体上德国现在以及将来欧洲对华的态度。
另一个方面是，朔尔茨上一次访华是25年前，他当时还是基民盟的议会党团主席，这25年间他没有来过中国。这次他做了密集的准备，一方面是中国和德国非常需要彼此，在当前复杂的地缘政治环境下；另一方面也表明他对中国其实很不了解。他虽然是非常重视并有很强的商业背景，但如果对比他对美国的了解（因为他马上就要访问美国），他对美国的了解与对中国的了解对比非常明显：他对美国非常了解，而且是坚定的跨大西洋关系支持者。这次来华其中一个重要目的就是获得对中国最直观的感受，了解中国发展到今天是什么样子，他们在哪些方面中德可以合作。另一个关键词是学习，虽然他可能没有直接用这个词，但他们的态度是这样的：从曾经德国有点像老师的状态，转换成合作者，甚至在一些方面要向中国学习。像专家们会说，德国企业到中国像“进健身房一样”，要迅速地学习，如何把一个产品的开发期从三四年缩短到一年甚至半年。
所以可以看到现在德国媒体和高层访华时的态度在某种程度上是一个转变，我觉得这是比较关键的印象。
沿着刚才孙谦分享的德国对中国态度的阶段性变化，特别是合作甚至学习这一点，我想到两个在社交媒体上传播较广的片段。一是朔尔茨去了杭州的语术科技，观看了机器人的集体舞蹈；那个舞蹈是今年春晚时流传较广的一个节目。朔尔茨到现场观看并表示赞叹。那个场景不仅在中文媒体上被广泛传播，我也在推特等国际社交媒体平台上看到了非常激烈的讨论。
如果从朔尔茨本人对中国的态度而言，他过去25年间都没有来过中国，对中国处于相对不太了解的状态，这可以解释他回到德国后发表演讲，大意是觉得中国的工作强度和工作心态有很多德国需要学习的地方，觉得德国现在的工作与生活平衡模式可能需要反思。这样解释我能理解他长期未到中国，见到眼前的一切带来的冲击。
我也想问各位对朔尔茨这次访华代表团的观感。朔尔茨带来了大规模的商界代表团，主要包括汽车行业和一些工业巨头。想问你们对这次代表团的分析：代表团的构成体现了怎样的优先级？你们觉得政界和商界关注的话题在对华政策上是否有差异？
我应该从两个层面回答：第一个层面，我们必须看到朔尔茨到目前为止一年多时间在欧洲起的主要作用，他不是一个经济总理，他是一个外交总理。他做的很多事情都是在外交层面。这次到中国他带的商务代表团庞大，规模差不多和默克尔当年相当。我们在机场接待的也是我国海关总署，这说明双方已挺有默契，把这次来访定义在经济合作框架下。我觉得这是他很聪明的地方，也是中方很聪明的地方。不能说中德之间没有政治问题，当然有很多政治话题可继续讨论，但对现在的德国来说非常需要的是经济话题。两者是如此大的贸易伙伴，分别又是第二大和第三大经济体，这部分非常重要，需开诚布公交流。
第二个层面，从企业层面来说，朔尔茨在2003年离开政坛后，也在各大投资银行和大公司担任董事会成员，他对经济界的所求所需心知肚明。同时我们也必须说德国的行业协会、机械工业协会、汽车工业协会以及德国驻中国的商会… 在他临行之前也都是做了很多的功课的，包括他们甚至也有一些的公开的希望，就是说总理能够帮助他们达成什么方面，这一批的商界的人士，他们活跃在中国的不同的德国公司里面，但是他们在上一届政府的时候，他们的个人感觉是，他们无法把自己的这些观点能够传导到总理府里面去，虽然朔尔茨总理也没有完全的100%的全部吸收进他们的主意，但是至少我们可以看到，他讨论的主题上面就能反映出来，他或者他的团队已经阅读过他们这些行业协会或者工业协会的这些研究吧。
另外一点就是这个企业代表团，其实大家仔细看的话，中方也给朔尔茨总理准备了一个和中国企业家的对谈，我觉得无论是中方而言，而是德方而言，都是想要借助于这样一次高层次的见面，在公司和公司的合作上能够有所突破，比如说我自己也知道，就是说有一家德国公司，他们就是通过了这一次的高平台的这样的见面，和中国企业建立不少的联系，比如说马上就会有一些他们之间的一些合作，慢慢地在新闻当中大家就会看得到了，所以我也会觉得从这个层面上来说，这样的交流还是比较务实的。
我觉得首先朔尔茨总理准备把那么大的一个企业的代表团来华，反映出他在国内面对的最大的一个困惑，因为德国经济现在其实经营的没有那么好，我们基本上没有经济增长，然后很多人还是对经济的未来有一些焦虑，所以我觉得大部分德国的民众，其实他们对中德关系，没有他们自己想要看到的一个方向，他们主要是想要看到德国经济要做得更好，然后我觉得朔尔茨如果他要连任，他要把他在德国国内的支持度拉得更高一点，那他还是要向德国一般的民众表现出，他能把经济搞得更好一点。
我觉得这可能是主要的一个处罚点吧，然后我会觉得他带一个那么大的企业代表团，也会带来一点误解，因为从中国的角度来看，你可以觉得哪些企业都想要跟中国做好生意，政府也要推动中德之间的好生意，但其实很多公司他们参加那个代表团，主要是因为他们面对很大的问题，可能最大的问题是那个稀土的出口管制，所以其实德国有很多企业，他们对那个稀土的供应还是非常焦虑的，然后也有一些其他的平等竞争的一些问题，所以我觉得他们想要来陪伴，朔尔茨访华也主要是为了提出这些问题，但是我还会觉得像那个理性批判老师说的那个企业的例子，我觉得他还是会带来一些成果吧。
现在就是中德关系的一个新春天什么的，我觉得中国媒体会多强调这一点，但是从德国的角度来看，虽然朔尔茨来华是比较顺利的，但是主要是在经济竞争这个层面还是会有很大的挑战。
“Leo,我想稍微可能问一个follow up的问题”
以你的了解来看，在德国媒体会怎么样去描述说商界和政界如此大的代表团，觉得中国这件事情，比如说是更会觉得这是一种基于现实主义的一种妥协，还是觉得它是一种成熟的体现，以及你所了解到的政府和商界还有民间对于访华相关的这个事情，有一些态度上的差别吗?
我会觉得有一些媒体他们提出的也是，某次带来那么大的一个企业代表团会给中国带来一种误解，因为可能中国那一方真的会觉得，中德关系现在进入了一个新的春天，然后会很快的变得更好，然后从德方带来那么大的一个代表团并不是这个意思，这是很多媒体提出的一点。
我觉得从商界的角度来看，其实那些不同的企业他们也有不同的利益，因为有一些企业主要是大企业，可能BASF或者大中这种大汽车的公司，他们在中国国内有很多投资，中国国内的市场对他们来说也很重要，所以其实他们想要的就是，还是把政治跟经济上的关系变得更良好，更和平稳定。
但是还有很多其他的企业主要是这种小型企业，还有中型企业，他们在德国国内有他们的工厂，然后其实他们最大的问题是，他们非常依赖出口，他们没有办法完全去中国投资，所以他们需要保障自己的出口市场，保障他们自己的未来，然后我觉得这两个不同企业的团体之间，有很大的一个利益的矛盾，因为一个其实是想要在中国有更多投资，有更多的合作，然后那些小型跟中型企业，他们至少有一些还是想要一种经济的保护主义，在欧洲的层面，因为他们说我们先要保护我们欧洲的市场。
我想先接着这个，就是你问Leo这个问题，我先补充一下，然后再回到你之前那个问题，就这次MOS带着经济代表团来，其中一个很大的诉求，就是因为德国在很长一段时间里面，中国是它做大的一个出口市场，但是人民币在过去的几年，其实它是一直持续的在一个比较低值的这么一个状态，其实对于中国的产品出口到其他国家的市场，是非常便捷的，但是这也导致了当德国商品出口到中国的时候，本身它就面临了一些产品的竞争力的挑战，对吧，比如说在汽车行业，电动车这个市场的冲击，它本身就受到一些挑战情况之下，然后人民币如果还持续的保持在一个比较低值的状态之下，这对于德国这样一个以出口为主导的经济体来说是非常困难的，所以这次MOS他言辞不是非常的激烈，但这个是其中一个很核心的诉求。
我在那个访问结束之后采访了伍德克，他是当年欧盟商会就是驻中国的一个主席，然后他也是当时朔尔茨访华之前请到总理府进行晚餐，然后吃饭的这其中五个人之一，然后他次取出的观点就是，这就是其实中德贸易中一个硬伤，然后这只是其中一个硬伤，还有就是中德必然在一些领域是有竞争关系的，就导致中国是不愿意后退的，比如说中国不能说，我为了让德国对中国的贸易逆差减少，我就减少向欧洲和德国的出口，因为这个不符合中国的利益，那么德国当然也是会争取自己的利益，就是说在竞争关系状态之下，虽然中国和德国都非常希望，也非常需要和彼此合作，但存在这种竞争关系的时候，是不是能够妥协呢?
就比如说像人民币贬值这件事情，以及包括中国存在的一些情况，比如说产能过剩，他就是有这个需求，一定要把商品出口出去，那德国本身他面对他自己的挑战的时候，他能不能有这个能力把商品，比如说中国市场现在就是需要电动车，那他还通过什么样的方式来进行，然后像一些德国的大企业，他正在转型嘛，他就是在中国为中国市场生产，比如说像奔驰啊，比如说像大众啊这样的企业，他已经考虑说我在中国建厂，通过现在中国已经有的比如说大数据的这种集成规模，来训练我的产品生产能力，然后在这种情况下，在中国为中国市场生产，但是呢，中国生产虽然他可能对这个企业是有帮助的，但是他不能够为德国本身创造就业岗位，所以这些都是一些矛盾，即使双方都有共同的议员，但这个客观挑战确实是存在的。
然后另一方面就是你刚才提到这个问题，我们如果看这次访问的代表团的话，大部分还是那些在中国有很强的这个历练的这些代表团，但是呢，即使就是我们耳熟能详的这些公司，比如说梅塞德斯，比如说大众，拜尔西门子，我们也可以看到，他们在寻求的这个方向也在变化，就是从曾经更传统的一些工业制造，更多像人工智能啊，先进的机械制造啊，新能源汽车生物技术这些领域更多的发展，然后包括这次还有一个模块团队，是清洁能源和绿色环保的这个团队，这个方面也有变化。
我还想补充一点就是说，德国国内怎么看这次访问呢，之前刘和李欣频老师都有提到，比如说有一个感觉是，这次是一个经济总理的身份来，然后呢，朔尔茨呢在德国面临的非常大的压力就是搞好经济，他刚刚上台的时候，包括受到右翼冲击的时候，他要强调价值观是非常重要的，但是当某种程度上讲，当朔尔茨所在的这个执政联盟，已经了向崛起的右翼做出了一些妥协，比如说移民议题很重要的时候，反而他也不能够完全的靠移民和难民这个议题来，获取新的这个支持率的时候，然后这个AfD（选择党）失去了独特的优势的时候，因为中间党派已经也向右靠了，然后这个时候大家都意识到，发展才是硬道理，只有搞好经济，你才能坐稳执政党这个位子，所以我觉得他的务实也不是突然转变的，那当他首要任务是抓经济，首要任务是抓生产的时候，然后他又在要访华的这个关头，我觉得很天然的事情就是，经济变成了一个重中之重的这么一个议题，然后国内可能毕竟他代表的是一个保守党派，他是执政党，然后代表了很大一部分人的利益，比如说商界的利益，肯定是有很大一部分人是满意的，但是在政治光谱上偏左的这些党派，他一定会反对，他说你朔尔茨对中国不够强硬，这个声音一定是有的，比如说中国的人群问题有没有得到改善， 有没有问这个问题，包括乌克兰的议题，虽然比重很小，但是欧洲和德国希望中国在乌克兰议题上对俄罗斯施压，这永远是欧洲和德国人最关注的一个政治议题，就这些东西他一定还是有人会去追问的，所以一定也是有些人他是不满意朔尔茨这次访华的这个态度的。
六也提到了这个春天这个说法，其实是在中国比较盛行的一个说法，我个人也觉得呢，就只是一个破冰的刚刚开始，还很难说到是春天，因为中德之间的这些刚刚像宋老师提到的这些比较深层次的问题，还是一直会存在的，而且不是现在存在，会是存在很长的时间，因为经济结构决定的，中国呢肯定是希望能够打造一个全产业链的工业强国，这样的一个未来的地位的，那德国也是一个工业强国，那跟过去的三十年非常不一样的地方就是，现在中德之间的经济结构上面是有点错配的，在很多的领域当中呢，大家是要互相竞争的，这样的一个关系，而且呢这个会持续很久的时间。
但是关键的问题呢，就是至少德国和现在的这一任的美国政府非常不一样的地方，就是说大家还是希望能够在遵守共同的规则之下互相竞争，我们要把竞争变成一个良性的竞争，恶性的这种竞争方式，无论是对于具体的国家来说是有伤害性的，那对于整个世界的贸易来说也是有巨大的伤害性的，这是第一点。
第二点呢就是，孙老师也提到了就是说，德国国内的对于这个莫茲的批判，说实话呢，无论是行前还是行后呢，批判都还是存在的，比如说呢，右翼的最大的批判呢，就是他们觉得莫茲呢，你去中国，你就是会完全的按照人家的agenda来走，也就是说你会被别人融入他们的体系当中去，当然了，从这一次访问的最后的结果来看，还是基本上是互惠互虑的，但是呢，那批批评的人呢，还是会这么坚持的，那对于左翼的这些批判呢，刚刚孙老师已经介绍了很多了，他还是肯定是固有的传统的这些类似的问题啊，当然这些问题也很重要了啊，但是呢，就是这种批判是会一直存在的。
所以呢，我觉得呢，未来的这些问题不是一时半会儿能够解决的，需要公司层面的互相竞争，互相合作，能不能有一些共同的发展的项目，通过这个时间来进行释缓的，那当然现在美国政府，给欧洲的盟友们带来的这个不确定性感，实在是太强了，下周他可能又要去访问美国了，但是这个访问美国呢，我觉得特朗普留给他失望的空间应该还是蛮多的，所以呢，在这种压力之下呢，两大工业国那肯定是要能够先要稳住，能够保持一个良性的竞争，然后再看看有什么合作的地方，我觉得这个是非常重要的。
那我觉得可以把话题再稍微往几个关键产业，就再延伸一下，我们刚才也已经多次提到，汽车产业相关的一些问题，因为汽车产业其实也一直是中德贸量吧，做主要的一个来源，也一直是中德外交之间的一个焦点，那在更早些的时候我们也提到，在过去啊，德国是长期被视为是一个这种工业强国，当然现在也是，但只不过在这个位置上稍微变得有点微妙，特别是在进入了这个新能源转型之后，老牌的汽车强国，德国也面临汽车行业的一些转型的这种压力，那现在也有一些这个研究数据表明啊，就是德国对中国的这个汽车出口，在过去这一年，2025年，其实是有一个明显的下滑，那同时呢，中国这个市场也在开展一些价格战，然后关税这样的一些外在的因素，也都在某种程度上去挤压到了德国车企的生存的一个空间。
我也想问一问各位，就是对于中德在汽车相关的贸易及外交关系的现状的一个这种评价，就你们觉得现在的这个关键词可能会是什么，在过去这种，比如说德国向中国出口汽车，中国作为德国的市场，这样的一个情况。 在未来是不是会成为律史? 那德国自己呢? 一方面需要去兼顾这个车企的竞争力的问题，需要去兼顾就业的问题，但同时德国其实也面临比如说气候转型、能源转型的相关的问题。那电动汽车它带来的这些新的挑战，现在在德国是一种什么样的存在?
也许我可以抛砖引玉，稍微先开始说一下。我觉得过去的，特别是从疫情开始吧，当然中国新能源汽车不断的崛起。在过去的四五年时间当中呢，的确呢，德国企业BBA，包括加上Volkswagen在中国的这个销量呢，的确是在逐渐的往下走，市场份额呢，也在逐渐的往下走。
当然中国的这个汽车行业的发展呢，也是早年呢，有很多人进行规划、进行发展。比如说中国并不是特别擅长变速箱技术，并不是特别擅长做这个压缩比特别高的燃油发动机，所以呢，中国过渡到一个比较倾向于混合动力、或者电力汽车的这个方向上，这也是中国尝试发挥自己的自主的优势吧、或者技术的优势。
我记得德国的一台电视曾经在上海做过一个街头的访谈，然后印象非常深刻的就是记者有问这个中国的年轻的消费者，”你是不是还会买一个Volkswagen的大众汽车的车”，然后那个女孩子立刻就反馈说，”那好像是我爸爸开的车”。然后这个段子呢，就回到了德国，变成了一个传播的非常广的一个段子吧，德国人也自嘲这个Volkswagen是Papas Auto，这个爸爸的车。
但是呢，我们也还是能够看得到，中国的这些传统的燃油汽车，他们其实是还是有比较多的优势的，比如说它的底盘技术，比如说它的对于安全的这些严格的要求。第二点倾向呢，就是说我能看得到2026年到未来的四五年当中，会出现很多的传统的核资燃油车企业，plus中国的智能方案，这种合作的模式在中国市场的广泛的出现。比如说我们在奥迪的新出的A6L，这些车型当中已经看到了这种合作的方式。
所以在过去的两三年当中，当然这些传统的德国车企在中国市场，是有一定的失势的情况，但是呢，从2026年的年初开始，这些德国的企业也在努力的能够适应本土的使用的场景，再加上自己本身所拥有的内燃机方面的变速箱方面的各种的优势，能够做出更适合中国消费者的这些产品，会越来越多的出现在这个市场上。
对，我可能要先承认一下，我自己没有假招，我不会开车，所以我不知道我这个方面话语权多么大，但是我还是会从经济的一个角度试试去分析一下。
德国就是大家会期待说一个成年人是会开车，还是不会开车有一个这种社会平均值的期待吗? 我觉得现在已经没有。主要是如果你是在城市长大的，因为德国公共交通还不错，但是我觉得还是比较少见的一个情况，因为很多人会在可能高中毕业之后就做自己的那个假照。对，我那时候有点懒惰。
我确实觉得在德国这种对汽车产业的那个衰落的一种焦虑，它还是蛮大的。对我们来说，这可能真的跟国家的一个身份认同感是连接起来的。可能对我来说不太是这样的，但对很多其他人来说是的。已经可能会有一些评论家，有一些蛮可怕的一些事项，比如说斯图加特会变成下一个低特律。
对我来说，我真的能判断德国汽车产业的衰落对德国经济的影响会多么严重，还是很难的。但是有一些人说它会非常的严重，可能五年或者十年之后，几百万人可能没有工作了，然后对德国经济结构还是会有很大的问题。这个问题在长期中的关系也还是会扮演一个很大的一个角色。
按照我的了解在中国市场那些最大的一些电动体制的公司，比如说BRD，他们基本上已经不太依赖那个补贴作为竞争的一个手段。虽然他们还会受一些补贴，但是他们自己竞争上就是非常非常强的。但可能在地方上，在很多比较小型的一些跟汽车产业有关的一些企业，他们受到的补贴还是很多的，这还是会比较影响重的一些贸易关系。
我觉得最终这么解决这个问题也蛮困难的，因为从德国的角度来看，当然你可以说要减少这些补贴，但现在中国的经济状况也不是那么乐观的，可能还是会有蛮多公司，他们也依赖这种补贴生存下来。所以如果你真的要从一个人的角度去解决这些贸易问题，我觉得这两个国家之间还是有一点矛盾。
然后我还说最后一点，就是可能一年或者两年以来，德国跟全欧盟在那个汽车产业跟中国的竞争，有一些被抛在后面的感觉。本来的目标其实是到2035年，已经要把所有的那些软油汽车的生产停掉。它已经放松了一些对未来新能源汽车的产业方向的目标。
所以其实现在欧洲的方向是可能五年之后，或者十年之后还是会有很多的软油汽车。所以我觉得现在可能欧洲的希望是可以在欧盟市场国内使定一个比较安全的供应，然后一个产业关系。但这个可能未来也会因为汽车行业、欧盟的经济保护措施、这种关税之类的会很严重的，因为我们还是要保护好自己的那个汽车产业。
我觉得两位老师确实说的已经很全面了，然后我想补充一些观察。首先我觉得谈到这个问题，我们可以问两个问题:
中国电动车现在领先很大程度上在于很强的供应链和成本的优势，然后以及中国有产量和市场的规模的优势，所以它就带来了很快的迭代速度，产生的创新能力是非常的强的。但是呢它背后第一是有很强的市场补贴。六老师提了接下来欧洲会不会打价格战，欧洲会不会也反过来进行补贴，比如说欧洲在将来会有一个更成熟的整个泛欧洲的资本市场的话，那欧洲是不是有能力某种程度上进行反制呢?
还有就是有一个专家这么形容，”中国现在生产的是带着轮子的智能手机”，就是说中国现在电动汽车的优势是软件、是这种生态体验，比如说智能坐舱，背后还有按摩的，然后整个屏幕像一个电影院一样，这种感受。比如说中国你说什么是豪车，就这个是中国的，尤其是新生代，软件的这个系统是新生代非常重视的一个体验。
但是这个东西是不是以后会改变呢? 德国的这个汽车如果在软件上提升了之后，然后德国的这种豪华车的这个品牌资产，它依然是在的，比如说它的这个尽力心，它整个这个封闭的能力，比如说50%你走到90%是容易的，中国车企是可以做到的，但是你想从90%再提升到95%的这个5%的这个豪华程度，其实德国的车还是有可以守的这个地方的。
然后所以我觉得在电动车和包括燃油车，以及将来的德国车在迅速发展自己的电动车的能力之上的时候，德国和中国各有自己的一部分优势，竞争的同时其实也是有合作的可能性的，但具体怎么合作，短期呢要看欧盟的关税、需求，长期会看德国和中国自己是怎么发展的。
然后很有意思就是，就在这么多年来，如果说德国车想要卖到中国，我们都知道它是必须是合资企业。那合资企业呢，德国车其实它一直是存在一种技术转移的。就比如说我们的车要在中国进行生产，那就意味着这个产业链大部分是在中国的，然后这个也是现在德国车企面临的一个很大的问题。
即使你掌握了一些核心技术，但是当所有的零部件，包括把这个车组装起来的能力，包括比如说座椅，然后方向盘，这些很小的东西，它整个这个整车的产业链都是在中国的。整个这个整车的产业链整合能力最强的也是中国。有时候大家只觉得这个最高科技的创新是发生在德国，然后你在某种程度下能够保护自己的一些核心技术，但是你在生产的过程当中，在这个产业链的过程当中，它是有很多微小的创新的，然后这些微小的创新全部发生在中国。
所以说现在一些德国的车企它说，我们要转变一些政策，我们要原来是在德国生产，然后出口到世界各地，现在更多的是我要在中国生产，然后让中国使用，甚至把中国生产出来的车卖到其他地方。这个企业在短期内，其实你从利润上看你是不会降低的，你还是能够赚和之前一样的钱。
但是呢，首先你把产业链全部集中到中国的时候，这个工业在长期发展，你有没有这个竞争力，这是一个问题。因为存在很多这种技术转移和产业链内部的微小的创新，然后这些全部都发生在中国。你培训出来的合国的工程师这些都在中国，人力资源也都在中国，然后这是德国车企可能他们最担心的一点，就是将来要面对的失掉这个产业链的竞争力。
然后另一方面就是车企它其实还是个企业嘛，它虽然会说我要为德国创造就业的需求，但是实际上他们第一想要追求的还是自己的企业的利润。所以德国政府也有时候也会有点难，就是你们还是要回到德国来啊，我们还是要努力吸引这个外资到德国啊等等等等。
但是你想要外资流到德国，然后你想要吸引其他国家的企业到德国设厂，创造更多的劳动岗位的话，你首先要有个适宜投资的这么一个环境。那现在德国在某种程度上在很多方面对于投资者来说不是很有吸引力的，包括他的官僚体制的问题、基础设施的问题等等等等。
所以这是德国的功课，如果他这个功课不做好，他很难吸引到海外的投资。但是这个问题德国本身也是非常清楚的，也在很努力的希望能够解决，然后莫茨本身对这个是最了解的，所以他在抱怨嘛，不仅在抱怨说为什么德国人这么没有生产力，居然还要四天工作制，而且他没来中国之前，他就抱怨过说德国人太能请病假了，他对这一点他其实是很清楚的，所以他也在非常努力的推动这件事情。
在这儿我稍微补充一下，我个人觉得这些中国电动汽车起来之后，至少起到了一个良性的作用，就是倒逼那些传统的中德合资的这些企业。我可以给一个切身的这个例子，早年的时候我刚在中国买第一辆车的时候，我去过4S店，进去了之后，销售人员说，”今天没试驾，我们这儿都是看了车就买的”。那中国的新能源汽车起来了之后，这两年你再去这些店，哪怕是那些所谓的顶车汽车品牌的那些店，销售都是非常非常积极的。
所以这种倒逼的这种，我觉得还是非常有意义的。第二点就是我觉得中国汽车行业千万不要因为现在的这些电动汽车发展了起来之后，有任何的自我的满足或者自我的骄傲的成分在这个当中。因为我们的内燃机技术上面差距还是非常巨大的。
而中国呢，是一个非常地大物博的国家，南北之间这个气温又差这么多，一旦到了东北，一旦到了新疆，都是需要靠传统的内燃机来支持我们这个国家的引擎不断向前发展的。这里面还有一个非常重要的点，就是如果大家仔细去看中国汽车向海外销售，特别是向第三世界国家销售的话，销售的主力均不是电动汽车，因为第三世界国家他们需要的也还是燃油机为基础，或者柴油机为基础的汽车，而不是电动车。
所以中国汽车行业需要发展的地方还挺多的，这个地方呢，也当然中国和德国可以继续合作，这里有很多的合作的空间。刚刚孙老师还提到一个德国的官僚主义那个话题，我觉得光这个话题我们至少可以谈一集的节目。像我这种在德国工作，德国又一路念书，真的是太知道这个德国的官僚主义。
像总理提到的那个，我个人都不觉得所谓的个人员工、四天五天的这个工作效率的问题是一个主要的问题。因为我有一段时间是在德国早起要去上班的，到了那火车站，我能看得到那火车站里面全是德国人，就是要跨城去上班的那些人。德国人是很勤奋的，德国人的工作效率其实也还是可以的。但是我觉得真正限制德国的发展的是官僚主义，真正的问题是在这儿。
要把这些官僚主义能够全头去除，是一个非常困难的问题，只有在德国长期生活过的人才有这种切身的这种体验。我们今天提到也是好几次的这个关于德国焦虑的一个问题，有关于汽车的焦虑、关于身份的焦虑、关于这个竞争力的焦虑。虽然我自己没有长期在德国生活过，但是这些年也去了德国不少次，然后我也从一个访客的角度观察到，德国生活现在一些这种感觉摩擦很多的地方。比如一个例子就是德铁，大家在过去就会觉得德国是工业世界的一个霸主，是优质基建的一个榜样，但是毕竟这些年一旦说到这个铁路通勤，德铁就往往被视为是一个极度不靠谱。 如果它比如说晚点一个小时，你就应该感恩戴德了这样的一些笑话，然后甚至在跟它的欧洲同行比起来，都是有一点在下滑的状态，所以我觉得这个可能也是一个切口吧， 说的是那莫茨讲到的那种，关于德国的生产力竞争力的一个焦虑，在社会的一些微观层面、细节层面是有所体现的。
另一个细节我也想分享一下的是，今年一月份其实当时我跟李欣频，我们一起见面喝了次酒，然后当时我们就提到一个现象，就是过去的时候中国的留学生在德国，每次从德国回国探亲的时候，会从德国买一些德国本地，或者欧洲本地的东西作为这个伴手礼，或者那个时候也有一些这个留学生在长期从事代购这样的行业，也就是你从国内去欧洲的时候箱子是空的，但是你从欧洲回到国内的时候，你的那个箱子是满的，但这几年我们也有一些朋友就是会发现，这个趋势好像倒过来了。
你从欧洲回到国内的时候，其实并不需要带很多东西，因为在国内都可以买到，反而是从国内再回到欧洲的时候，这个箱子往往是买的，比如说一些日常生活用品、家具用品，就是一些小的东西，那种可以让你的生活变得很方便的东西，有时候甚至可能是一个电锅、一个按摩枕、一个这种家具的小物件，反而你在从国内回到欧洲的时候，需要用一整个箱子去把这些物件塞满。
这两个小细节也是感觉说，在过去的这些年里，其实真的不光是在地缘政治的层面，也包括普通人的生活的层面，大家现在好像开始感受到一种反向的焦虑。我也想把这个问题再抛给几位，在你们看来，中国现在的这种状况在哪一些层面上可能触动了德国已经存在的一些焦虑，这些焦虑当中，有哪一些是投射的，其实事实并不是这样子，然后有哪一些焦虑其实是应该有一些现实的锚点，应该采取行动的。
我觉得要不我先说吧，因为刚才我记得是你最开始提到的焦虑这个词。
好的，而且可能我还是在德国活得最长的一个人，比如说德铁的问题，我觉得这个问题我现在快三十了，它其实一直有存在，我上初中高中的时候，已经有这种关于德铁的笑话。当然我们都在想，可能这个还是有一种恶化，但我觉得这种官僚体系，而且关于这种莫名其妙的、效率不高的生活中的一些现象，这个我一直都很熟悉，我觉得差别就是世界有好几个国家，然后中国就是最年轻的例子，他们就赶上了。
我觉得这种经济上的焦虑它是相对的，以前我们在德国国内会有一些抱怨，但是我们还是不会怕，我们自己的一些产业真的会被抛在后面，我们的职业岗位真的会受那么大的威胁。这种现在的经济上的焦虑是有根据的，我也不是很清楚要怎么解决，因为我也会觉得这是一个很自然的过程，西方的国家他们不能一直在那个世界经济最高的一个层面，我觉得只是本来是一个有点不逻辑的假设，为什么德国比较小的一个国家，为什么他的经济在国际出口上要那么庞大的?
所以在一个方面我会觉得可能西方他就要跟自己和解一下，我们在世界上的一个相对的衰落是不可避免的，而且它是一个自然的东西。我个人也不会觉得有问题，因为我可以向世界其他的国家学习什么，或者有一种更开放的一个态度，也会让我的世界变得更大、更有意思。
我觉得问题可能就是如果这真的会导致我们的生活品质甩落，然后很多工作之位失去。这个我还真的不是很清楚，最后的结果对我们来说会多么糟糕，然后我觉得还是在政治上就像中的这种两个大的国家之间要找到一种平衡，不要让我们想对的一个衰落变成一种非常绝对的衰落，因为我觉得这个对大家来说都不是很有利的。
第二点就是我觉得一个焦虑的来源是战争跟那个地缘政治的动乱跟不确定性。乌克兰离我们还比较近，我们也会直接受影响，会接受难民，然后很多德国人可能跟乌克兰或者其他东欧国家有一些个人的关系，这个还是影响会很大的。
我觉得可能我们现在已经慢慢习惯了我们住在一个动乱的世界里面，然后我们也没有办法忽视，这就是事实，可能这也是一种需要慢慢去接受的一个事实，然后慢慢要在这种动乱中找到一个新的平衡，我会觉得也有点难，但是也没有办法吧，这大概可能是我的一些想法。
对，我觉得Leo刚才提到一个表述还挺有意思的，你说这个西方的衰落或至少相对衰落在我们这个时代可能是不可避免的，所以西方人可能也包括德国人需要找到一种与此和解的方法。那我也想把这个问题抛给我们的另外两位嘉宾，就你们觉得从中国的角度来说，中国人需要和解的可能是什么? 以及作为一个在中德之间游走的人，你们会怎么样看待在过去这些年可能好像出现的一种中德之间的动态的平衡，包括德国的焦虑，中国当然也有自己的焦虑，然后那个焦虑可能是什么，特别是在相对于德国的位置上?
我分成两个层面吧：
安全上的焦虑，那肯定是我们从慕尼黑安全会议上面就已经能够看得出来了，对吧? 去年的慕尼黑安全会议，那个美国的副总统那攻击力度是非常强的，对吧? 今年美国的国务卿稍微缓和那么一点点，但是对于德国的政治家或者政治精英来说，他们已经是非常明确了，这个时代的列车开走就是开走了，当下的美国是肯定没有办法给德国以及其他的欧洲盟友再提供过往的这种跨大西洋关系为基础上的这种安全的保护了，欧洲人必须要靠自己。
其实Leo也提到，刚刚说这个世界上没有一个国家可以长期一直保持他的霸权的地位嘛，我们生活的这个世界其实就是美国的霸权在慢慢的衰落过程当中，这个其实是所谓的朔尔茨提到过的这个新的常态的平衡。在这样的情况下，其他的欧洲盟友又没有多少可以进行负担然后再把欧洲再军事化的能力，这个负担其实就是落在了德国身上了，这种焦虑其实是对于德国的政治精英来说是非常非常大的。
因为在欧洲的本土上的这种攻防，它不会是所谓的这种核战争的这种形式呈现的，它都是像萨拉米一样的这种形式，萨拉米切片的形式，它其实是要有一定的常规部队作为基础的，如果没有常规部队作为基础的话，它是没有办法遏制另外一方采取萨拉米战术的，所以这一点是对于德国来说是非常大的安全上的焦虑。
经济上的焦虑呢，首先第一点，如果我明天见朔尔茨总理的话，我就会跟他说，就是你先把德铁花大价钱好好地搞好，因为为什么德铁这个东西是关于一个民族的精神的问题。接触的可能都是柏林之前的这些德国人，他们是非常尊重时间的准确性，我们说好14点，我14点就一定会出现，但是你现在这个时代，我感觉德国年轻人就已经开始有点接受了“对不起，我迟到了”“这个德铁的关系，我今天来不了了”——原来是一个高效率的民族，是一个追求守时的民族，有一点点因为这个东西变得有点松松垮垮下来了，这对于民族的精神是很伤害的。
第二点，是要把能源价格打下来，你才能把这些德国的企业、制造业的企业能够留在德国。工人的效率是很难很难提升的，因为这是一个大家要讲究休息，德国人周末是要娱乐要看足球的民族，对吧，工人效率和东亚国家相比来说较低的这个情况不是现在出现的，这是在早在皮耶希的时代，在那个时代的大众集团他们就已经有这个问题了，他们想要学丰田，能够达到日本工人的这种高的工作效率，他们也向丰田学习或者怎么样，但是实际上也只能打个八折来实现，所以这是一个基于自由准则而建立起来的一个民族规范、民族文化，也是没有办法再把这个工人效率拉爆，关键还是能源价格一定要打下来。
因为我有个年轻人也打交道，AI的时代像完全杀不住的一匹猎马，就这样直面地冲到了我们年轻人的面前，无论是对于德国年轻人来说，对于中国年轻人来说，你很难找得到第一份工作，这个是当下无论是德国年轻人还是中国年轻人都面临着一个非常非常巨大的挑战。中国现在很多人的焦虑也跟德国人一样在寻找机会，但是机会并没有这么多，中国社会需要年轻人来创业，德国太需要年轻人来创业了，现在德国的年轻人也跟中国年轻人一样，想考工、找一个稳定的工作，也不像以前那样这么自信、愿意挑战自己。
所以我觉得，无论是中国还是德国，大家都有各自的焦虑，但是我们要至少保持有效的沟通，这种竞争至少保持在良心的轨道上，为这些各国的国民至少能够创造一个自我实现的土壤。
如果我们谈这两个国家的焦虑，不管是国家的人还是国家作为一个政体，我觉得中国的焦虑和德国焦虑还是挺不一样的。作为中国人，对于这种各式的焦虑应该是很熟悉的，我们熟悉的是什么，自己的工作、自己的孩子、自己的家庭，是这种个人式的焦虑。
我觉得在德国谈到的这种焦虑感，还是一种国家层次的焦虑。当然，两位老师刚才提到关于德铁这个，现在如今我觉得对于德国铁路的吐槽，已经代替了大家对于天气的吐槽。就以前抱怨天气，现在抱怨德铁，但它为什么很重要，就除了李欣频老师之前提到的这个民族精神之外，第二点就是德国现在的物价疯狂的上涨，你作为一个民众，你的体感就是你的钱袋子变薄了，然后这两件事情是非常日常的事情，它是交织在你日复一日的生活当中的事情。
当你觉得说，我买什么东西都变贵了，我会觉得不敢花钱的时候，我也不敢用电，因为能源又非常贵。像俄乌战争刚刚爆发的时候，我会说，我回到家的时候，我房子很冷，然后再加上公交又不准时了，今天又有人罢工，然后我明天又没法去上班，就是它非常密集地交织在你的日常生活当中，它给人一种感觉，就感觉这个国家好像摇摇欲坠的，尤其是跟之前形成了鲜明的对比。
但是事实上，比如说刚才请你说到一些我们要购买什么样的商品的问题，包括我们周围的同温层，我觉得是存在一些生存者偏差的，就是我们会觉得说在这些年来，我们的购买力强了很多，就比如说回国吃喝玩乐都很爽，因为价格很便宜，然后物品又非常多样，物品多样这件事情是客观存在的。但是购买力是不是真的变强了，如果说觉得中国人的购买力已经超过德国了，或者是德国自己觉得说我的购买力已经低于中国了，我觉得这可能就是一种虚幻的幻象，因为德国人的平均购买力绝对是明显高于中国的。
当然在具体的消费领域，正是因为中国在日常的生活成本包括电动车、包括能源方面更具优势，但是德国有时候是在更隐性的方面，比如说社会保障、比如说高端的消费能力、失业救济、养老金、教育成本，这些方面它在一些可能更体制化、更大，但其实某种程度上讲，对于一个中国家庭来讲，负担更大的这些制度都还是在的。
所以我个人的感觉是，我们中国人担心的最大那些事情，比如说住房、养老、上学，我们的焦虑都投入在这些领域，它耗费了你的很多精力。德国人的焦虑在说我们国家怎么发展，但他们其实自己过得还可以，这个焦虑不是一种生存性的焦虑，而是说我今天日子过得没有那么舒心，所以我觉得这个焦虑的传递是挺不一样的。
当然，德国人本身我觉得人均也更关心政治的，当他有参政议政的能力的时候，他就会焦虑了我自己的生活之外，再加上他可能也更清闲一些，他没有为谋生而四处奔走非常疲惫的时候，他就会更关心我们这个国家和社会走向哪里，包括他的媒体也一直在告诉他，这个我们现在国家面临了什么样的困难，我们面临了什么样的困境，我们真的不行了。
我觉得即使是在替代国家进行焦虑的时候，这个国家的焦虑和一个个人的焦虑是很像的，都是没有安全感的时候会焦虑，不管是经济上的安全感还是军事上的安全感，他面对这个动荡的世界却无力掌握走向的时候会焦虑，德国是挺典型的这种状态。 他虽然在经济界是很强的， 那他由于军事实力的缺乏， 包括他经济领域的强， 他也是有依赖性的， 对吧， 他当年依赖俄罗斯的这个低廉的能源， 然后以及巨额的像其他国家的出口， 他不仅依赖美国， 然后他也依赖中国在经济上， 很强的依赖性， 然后在安全上更是非常的依赖美国。 这就导致了他在非常动乱的时候， 其实自己能够迅速调整自己的能力很弱， 然后当他面对这种自己无法掌控很多东西的时候， 他一定使这个焦虑感就会非常的强。
我就说两位受得特别好， 然后我能感受到， 虽然我们的焦虑在一个政治制度前面， 还是会有一些不一样， 关于国家的一些焦虑， 但如果你从个人的角度来看， 自己的生活还是会有很多共同点。 我觉得这还是会让我感觉到， 中国跟德国这两个国家之间， 有更多的一种社会上的一些交流跟对话， 可能也会有点想让我们感觉到， 我们在最终也不是那么不一样的， 我们还是面临很多一些相似的问题， 所以我会觉得很有意思。 如果我们从国家制度处罚， 我们会觉得我们那么不一样， 我们就像两个世界一样， 但是从人的角度就完全不一样。
我们刚刚有聊到过这个话题， 说一直有一个概念， 就是分类嘛，
所谓的民主国家， 非民主国家， 对吧， 20世纪60年代有这种说法， 有一些专家写的书， 这个世界上为什么有战争， 他说是因为国家制度的不同。
所谓的这些人认为就是说这个所谓的好国家， 就是民主国家， 所谓的坏国家， 就是非民主的国家或者怎么样。 但是在这个时代， 大家会发现， 具体到个人来说， 大家其实是共享很多的同样的问题的。 而且呢， 我也会觉得呢， 所谓的民主， 非民主在这个权力政治回归的时代当中呢， 这种分类呢， 也变得越来越不重要了。 我们能够看得见的是， 未来20年或者30年的时间， 它是又是一个非常明显的权力政治回归的这样一个节奏。
什么叫权力政治回归呢， 就是过去的靠这种分类来建立盟友关系的这种方式呢， 从特朗普2.0开始， 基本上也已经分崩离析了， 对吧。 大家看到的更多的是， 美国呢， 也是尽可能的获得他们能获得的这些资源， 来维持自己的霸权地位， 但是美国的盟友们呢， 其实也是非常非常不适应这种剧烈的变化的。 那所以在这种大的变革的格局之下呢， 更多的归类的讨论其实也意义不大了。 更多的， 还是要有更多的国际合作， 更多的就像你说的这个民间的交流， 社会的合作， 年轻人的交流， 这些东西呢， 能够互相增进彼此之间的理解， 也能在下一代当中， 不会再有这么大的ideology上的分歧吧。
我觉得， 大家都希望这个社会是和谐的， 然后也希望在不同中寻找相同， 然后仿佛看到了， 跨越国界， 我们还有一些人性上的相似， 然后让我们更好对抗这个动荡的世界。 但是某种程度上讲， 像例如刚才说的， 虽然都是年轻人， 然后德国人和中国人也有很多共同的焦虑， 但是我反而觉得， 至少是我的经验， 以及我身边的人， 在欧洲长大的孩子和在东亚长大的孩子， 是有一种本质的这种对安全感的不同的。 就即使有， 比如说提到面对AI的时候， 然后面对社会的老龄化， 然后比较高的失业率的时候， 是有一些共同支出的， 但是我们在闲聊的时候也会说， 感觉说， 德国的年轻人非常有底气， 想gap year就gap year， 想做一份什么样的工作， 就去做一份什么样的工作， 然后中国人呢， 永远有一种底层的不完全感， 然后要变成了一种自屈立， 然后再卷自己也再卷别人。 这个我觉得即使是有一些相同之处， 但我一直的感觉就是， 会有一个非常深层次的不同， 这一点我想回应一下。
另一点呢， 我们从现在往后看， 是不是世界会变成更多极化的时间， 是不是各国的这个对外的政策都会变得更务实， 我觉得这个东西我也要打一个问号。 现在我们确实能看到， 欧盟的内部， 尤其是技术官僚们， 然后包括德国在内， 他们是希望走一个更务实的路线的， 因为现在经济发展是重中之重。 他们也会说， 比如说我们跟中国有分歧， 跟土耳其有分歧， 跟我们政治体制不完全相同的这个国家， 有分歧的时候， 我们把分歧搁置， 或者我们把分歧固定在这个分歧的领域， 在其他领域， 我们还是要深度合作。 但是如果我们看整个慕安会的这个氛围的话，说要建立欧洲防务自主，它在防御什么？它其实防御的还是中国跟俄罗斯。即使这次朔尔茨访华，它带来的是一种要合作的信号， 要抱团的信号， 我们要抛弃偏见， 抛弃我们的分歧， 整体合作。 但是在关键的安防领域， 还是一种持续着这样一种某种意义上的冷战思维， 还是持续着这种不同的阵营之间要互相防御的这么一个状态。
而且恰恰是因为， 由于俄乌战争产生的这种强烈的不安全感， 然后这种不安全感是针对谁的呢？ 这种不安全感针对的恰恰是政治体制不同的这些国家。 然后包括现在伊朗的议题正在迅速的扩散嘛， 这个也是两大阵营之间的某种程度上的爆发的剧烈的冲突嘛。 至于由于特朗普上台之后， 显得好像这种阵营之间的边界被模糊化了， 但是还要打一个问号， 虽然特朗普是民选出来的， 但是特朗普对美国已经造成了很深层次的伤害， 但是特朗普总有一天是要下去的。 大家对现在的美国虽然已经很失望很失望， 但是对美国体制的还是有一种底层的信任， 它是有一个迭代机制的， 它是有一个制衡机制的。 我就想补充这两点。
我觉得孙老师说的这个角度也是非常好的， 因为我也觉得很多的这些ideology的三层次的这种分歧， 它不是靠一代人两代人能够解决的。 实际上显而易见这个防守要防守谁， 大家都是心知肚明的， 对吧。 但是我觉得我们这代人至少能够做的， 是努力尝试在阶级的拓展自己的国力， 拓展自己的产业的发展的同时， 能够尽量的按照这个游戏规则来玩。 这个能够为下一代的中国人， 中国的年轻人， 中国的国际形象奠定一个非常重要的基础。 哪怕按照规则来玩， 玩起来比较累， 哪怕按照规则来玩， 玩起来速度没有这么快， 但是我们至少是按照规则来的。 而且呢有什么问题呢， 努力尝试通过仲裁的方式来解决， 而不是用这种punishment的这种方式来解决， 要努力地尝试把这些分歧能够留在理性的框架上。 我觉得通过这样的方式呢， 可能会通过一代到两代人呢， 慢慢地弥合这种不信任。
对， 我其实刚才听完之后也有很多这个想要回应或者echo的地方， 但可能也很难在比较短的时间内去把它展开来讲， 所以我就想这里不然就留一个悬念。 我们看看也许明年如果同样的时间， 还有别的机会的话， 可以请大家再来做一次反场的节目。 我自己的一个感受， 这个点我还挺想表达一下的， 我其实还是大体上统一， 李清平凡老师对于说， 现在世界的这种旧格局是在崩溃， 然后一种某种意义上的强权政治和从业法则在回归， 就这样一个大趋势。 我觉得中美之间其实是在进入一种有意或者无意的是在把对方卷到这样的一种竞争当中的状态里。 包括现在美国其实我感触也挺深的， 美国对于中国的那种状态是中国是要崛起来跟美国去争霸主的这么一个心态， 所以美国虽然可能在全世界发言内有很多敌人， 但是中国是最主要的那一个。 我觉得这个趋势线其实在美国有一个跨党派的共识。
那在这样一个眼见着中美之间， 其实是会进入一个所谓的这个City的陷阱的过程当中， 我觉得其他的国家是有一个选择在的。 至于说选什么是不是一定要选边站， 如果不选边站的话， 有一个什么样的可能， 我觉得这种可能性是需要单个的国家去探索的。 回到说为什么我觉得中德关系非常的特殊， 也是因为我觉得德国治愈中国， 它既有这种旧的意识形态的分歧， 但它也有一些在新的格局当中继续去合作的可能。 那这个可能不管中德双方是不是愿意， 你的这个贸易量在哪儿， 你各自承担的这种角色和你在各自的区位的这种定位在哪里， 互相想要去谈判的时候都有一些砝码， 都有一些可以去leverage的东西。 那这个其实我觉得并不是所有世界上的国家现在都具备这样的资产或者资源， 或者这样的意愿和能力。
所以我会觉得我自己在看待中德关系的时候的一个私心， 确实是觉得中德之间是有可能可以去探索出一条， 在旧世界旧秩序崩坏的情况之下， 不光是中德也为比如说中欧之间的其他的国家， 以及甚至世界上很多其他的这种， 用加拿大总理他在达沃斯的这个讲话上的一个概念叫做中等国家， 我觉得是可以去探索出一些新的模式和新的这种路径的。 然后德国真的是为数不多可能有这样的位置可以去探索这样路径的国家之一， 所以我个人会还挺期待去看到中德之间更多的互动， 不管说是民间还是说政界商界层面的互动， 因为我相信更多的可能性也只有在更多的互动中才会出现。 那当然这个过程中也会要求双方都具有这种开放的心态， 具有良好的意愿， 然后也会需要更多的对话。
所以再次感谢。 我们也可以约定一下吧， 也许到明年的这个时间， 可以再来组织这样的一场聚会， 这样的一场讨论。 好的， 谢谢大家， 明年肯定要见面。 对， 而且我感受到大家浓浓的那个生存欲， 对这个世界抱有一种美好的期待， 在我们这么混乱的情况之下， 我从你们三个身上都看到了一种， 我还是希望这个世界朝更好的方向去发展， 如果说这个世界能够向更好的方向发展， 我们应该做手。 所以我从你们身上都感受到了这种能量。
优优独播剧场——YoYo Television Series Exclusive
优优独播剧场——YoYo Television Series Exclusive
2026-02-20 08:00:01
The Book Club: Wuthering Heights
Hello, everybody. It’s Dominic here from The Rest is History, and I’m here to tell you about a thrilling new show that we have been working on here at Goalhanger. It is called The Book Club, and it is presented by me…
And me, Tabitha Syrett. And it will be coming out every Tuesday, and each week we delve into some of the greatest, the most fascinating, the most intriguing books of all time. And it’ll alternate every week between something a bit older, more classical, so for instance, Wuthering Heights, and then something maybe newer and a bit more contemporary, so The Secret History by Donna Tartt, or Never Let Me Go by Kazuo Ishiguro. And we will be digging into the kind of secret hidden stories behind the story. We’ll be uncovering the truth about the author themselves. We’ll be delving into the context, the history behind the book, and also kind of unravelling the book itself a bit for you.
Yeah, so to explain the background to this, Tabi and I have been working together on The Rest is History for three glorious years, Tabi. Feels like 30, but it’s actually only been three. And we’d often be nattering about books when we’re off doing our Rest is History tours and whatnot. And we decided that we would do a little bonus series for members of The Rest is History Club, didn’t we? So we did The Hobbit, and In Cold Blood, and The Handmaid’s Tale, and so on and so forth. And we were, I think the technical term is blown away by the reaction to that from the club members.
We were absolutely thrilled. Yeah, we were over the moon. And so we have spent the last couple of months putting together an exciting list of episodes for you. So we start with, of course, Wuthering Heights, the truth behind this iconic, famously kind of overwrought story, and obviously reflecting a little bit on the new movie. Then we do Never Let Me Go by Kazuo Ishiguro. And then what comes next, Dominic?
So we’ve got:
So in two days’ time, we’re recording an episode of your favourite book, I think, of all time. No? Sarah J. Maas’s A Court of Thorns and Roses.
Oh, come on. Don’t pretend that wasn’t your idea.
So this is my first foray into the world of romance. So basically, each week, we’re doing a different book. And it’s a little bit like The Rest is History. We will be talking about the author and their lives and the social context, when the book was written and so on. But also, it’s a little bit more personal, I suppose, because we’re also talking about our own reactions to the books. We’re having arguments about which characters we liked and which we didn’t. You have a unique identity, don’t you? Because you’re simultaneously, ludicrously well-read. Painfully well-read. But also, dreadful judgment. And I think that’s a really unusual combination.
And it creates a fascinating tension within the show, because you are very poorly read and have bad takes. So the combination of those two things together creates just dynamite. It’s amazing.
So to remind you, it’s out every Tuesday. So it’s in the gap between Rest is History episodes. It’s a different book each week. We will advertise the books in advance as much as possible, won’t we, Tabby, so people can read or not read as they see fit. Because basically, the beauty of this show is if you’ve read the book, brilliant, you’ll enjoy the conversation. If you haven’t read the books and have no intention of reading them, that’s great, because we did the reading for you. So you’ll appear incredibly well-read when you go to dinner parties. There’s no doubt you do, being Rest is History people.
So it’s every Tuesday. It’s the book club. And we’ve actually got a clip for you, haven’t we? We do. As a massive treat. We have a clip for you from our first episode of the book club, Wuthering Heights. So we hope you enjoy it.
Wuthering Heights by Emily Bronte, published in 1847. It's set in 1801, but it's looking back even before that.
Wuthering Heights by Emily Bronte, published in 1847. It’s set in 1801, but it’s looking back even before that. And Tabby, it’s one of the absolute canonical classics. And it’s actually regarded, isn’t it, as one of the great romantic novels.
It absolutely is. For instance, in the very famous 1939 Laurence Olivier film about it, they advertised it as the greatest love story of our time or of any time. And as you say, it’s an absolute classic. And it’s particularly famous because of its depictions of kind of wild moors, simmering tensions, unbridled emotions. And of course, this very, very famous love story at the heart of it all between Cathy, Catherine Earnshaw, and the kind of iconic, laconic, romantic hero, Heathcliff.
And you, I mean, you’ve been going on about Wuthering Heights for ages. I remember when, even before we were doing the show.
Yeah.
You saying it was one of your absolute favourite books. And am I not right in thinking that you used to read it?
Oh, no.
You used to read it every single year? “Yeah. But let me justify that.”
For 20 years. I want to explain myself. I basically read it first when I was about 12. And I thought it was just, devastatingly romantic, heartbreaking. I loved the love story. I loved Catherine Earnshaw, the heroine of the book, because I thought she was kind of fiery and beautiful and elegant. And then, as you say, I kind of put it on a pedestal and I would read it every year until I was about 17. A sort of sad teenage miser.
I stopped after that for a long time. And then, so this was my first time rereading it since I was 17. And so I was very intrigued to see what I thought about it this time. And my view on it has definitely changed. But before we get into all that, and before we get into what you think of it, I think we should give a brief outline of what Wuthering Heights is about. It tells the story of these two families, the Earnshaws and the Lintons, and they live very near each other across the Yorkshire moors. And it’s kind of about the tangled relationships between them. And these relationships are particularly tangled in large parts, thanks to the machinations of the iconic Heathcliff. And the plot is driven by his kind of crusade of vengeance. And Heathcliff is a foundling taken in by the Earnshaws as a young boy and is treated very badly by his stepbrother, but falls in love with, at a very young age, his stepsister, Catherine. There’s something of the Greek tragedy to it because it’s kind of these cycles of revenge going round and round and round.
So it falls into two halves, really. The first half is about, it’s Cathy and Heathcliff, basically. So Catherine or Cathy, she’s torn between slightly drippy husband, Edgar, and then harsh, much wilder, more violent Heathcliff, who is kind of her soulmate. And then the second half of the book is about her daughter, who confusingly,
“would it have killed Emily Bronte to give her a different name?”
Yes, it clearly would, because she’s also called Cathy. I think we could basically, just for the purposes of this, we can just call her young Cathy, old Cathy. Exactly. So young Cathy is living with Edgar, her father, in this civilised house called Thrushcross Grange. And then she ends up coming across Wuthering Heights, and she’s dragged back into Heathcliff’s world and the sort of mad stuff that is going on there. For those people who haven’t read it, and I’m guessing there’s quite a few people listening to this who haven’t read it, we won’t give it all away right now. But basically, there are going to be, I mean, it’s a book show, there’s about to be spoilers.
“Yeah, absolutely.”
But just on the way it starts, it gives you a clue to how the book works, basically. Because we began with that reading, we’re being told this story by a guy called Mr Lockwood. Mr Lockwood has rented Thrushcross Grange, so years after the events that are being described. And he’s a Londoner, isn’t he? So he’s out of his depth on the moors of Yorkshire. And because of that, because of the fact that he is a Londoner and quite sort of civilised or whatever, he adds a bit of comedy to it, because he kind of goes into this house, he goes to meet his landlord. And his landlord is Heathcliff, who lives at Wuthering Heights across the moors from Thrushcross Grange.
And it’s like he basically walks into an asylum and it’s like shadows everywhere. He keeps tripping over dead rabbits. He’s slobbered on by vast wolfhounds. And he’s utterly bemused by everything and everyone he encounters there. And there’s this kind of grotesque cast of characters that he meets at the heights. Anyway, so he ends up getting snowed in for the night, much to his distress. And he is put to bed in this room. And he finds a ledge in the room covered with writing. And it’s a name repeated in all kinds of characters, large and small. And it says Catherine Earnshaw here. And then it varies to Catherine Heathcliff. And then again to Catherine Linton. And so he then starts to read this Catherine’s diary. And this triggers the mad nightmare from the opening reading, which I think I injected with so much dramatic flair.
“Nice that you’re complimenting yourself yet again.” “Again, yeah.”
So basically, it’s a very, very violent scene. The child’s face slipping through the window. And actually, what he tries to do, Mr Lockwood, is he tries to basically slit the child’s wrist on some broken glass, which is, I mean, you would think, God, that’s a bit much in a Victorian novel. But of course, that sets the tone because there’s a lot more of this kind of violence and abuse to Come in the book. It’s a very, very nightmarish scene because it is a nightmare.
It is. And it’s very odd because Heathcliff comes into the room and he’s so angry. There’s a mad desperation to him. And it’s he has caught Lockwood dreaming the dream that he ought to be dreaming about this girl, Catherine. And we at this stage don’t know why. We don’t understand the relationship between them.
Yeah. So Lockwood has had this flipping weird experience staying in this hotel. I was about to say this hotel. You’d never stay at it. It makes Fawlty Towers look that or it’s.
Yeah, I’d actually rather stay at a hostel than that.
Anyway, he’s been staying at Heathcliff’s house. It’s full of all these mad people. There’s a lot of stuff with broken glass and ghosts. And when he goes back to his own house, he finds out that the housekeeper there, who’s called Nellie.
Nellie Dean.
Yeah, she used to work for the Earnshaws at Wuthering Heights. And she knows the whole story behind this because Lockwood is as lost as we are. And so she says basically,
“well, I will tell you the story.”
Yeah, it’s not exactly the kind of recuperative, pleasant tale that I think he was hoping for amidst his illness.
Exactly. So to cut a very long story and complicated story short, there’s these two characters, Heathcliff and Catherine Earnshaw, who later becomes Catherine Linton, who is now dead. And Heathcliff was the foundling and Cathy was his kind of adopted sister.
Yeah.
And they had this incredibly tortured and intense relationship. She married this bloke, Edgar Linton, who lived across the Moors. Heathcliff was driven sort of mad with rage. He ends up eloping with Edgar’s sister, Isabella.
Yeah.
Who’s massively fallen in love with him, but soon realizes she’s made a terrible mistake.
Yeah. And that’s kind of interesting because Isabella falls in love with him in the way that I think a lot of audiences now fall in love with Heathcliff without having read the book.
Yeah.
It’s the idea of him. It’s the Byronic heroic idea of him.
Exactly. She thinks he’s incredibly glamorous.
Yeah. And romantic. Little does she know.
She has a child irritatingly called Linton.
It makes you hate Emily Bronte.
Yeah. You could have thought of a different name. Maybe you just thought you’d use the surname again. Brilliant. Meanwhile, Cathy’s had a daughter with Edgar Linton, who she calls Cathy.
Cathy.
Yeah.
So, I mean, this is a huge part of the story is the doubling of names.
But it’s deliberate, I think.
Yeah, of course, it’s completely deliberate.
It’s the compulsive repetition. It shows you that you’re trapped in these dark webs of hatred and obligation and it goes on and on and on.
It’s what you were saying about the Greek tragedy thing. It’s basically the idea of the bitterness and the hatred and the jealousy being passed down through the generations.
Yeah. It makes you think, though, given the violence of it and how complicated it all is, it makes you wonder, what is going on in the mind from which it sprung, the strange mystery of Emily Bronte.
That’s a very nice segue, Tabby, into talking about Emily Bronte, right?
But first of all, I mean, should we talk about another fevered, imaginative writer? What’s your take on Wuthering Heights?
So I read Jane Eyre a few years ago for the first time, loved it, and then I thought, I’ll read another Bronte. And I read Wuthering Heights and I thought, oh, disappointing.
It’s not as good as Jane Eyre. Because I didn’t really get into the kind of fever dream side of things. I frankly did get a little bit lost. And I thought to myself, this is going to be very self-incriminating. I thought to myself, this is a bit of a book for teenage girls.
Oh, he went there.
It’s the book that a sad and lonely teenage girl would read every year, Tabby. No, but actually, I’ve changed my mind.
Oh, wow.
I will reveal all at the end of the episode, but I’ve completely changed my mind about it.
That’s exciting.
Before we do that, let’s get into Emily Bronte herself, because critics used to call her the Sphinx of the Moors, because she was such an enigma, such a riddle. We know so little of her inner life. And so that, of course, plays into the Bronte industry and the Bronte legend, because it’s meant that obsessed readers can project onto Emily Bronte whatever they like. However, there is obviously clearly a historical person here behind the kind of layers of wild myth and legend. Yeah.
So Tabby, you’ve done a bit of digging, haven’t you, into Emily Bronte’s life?
In large part, because of that thing, the kind of the myth, I kind of wanted to see how much reality there was to it. So Emily, she’s the fifth of six Bronte children. And she’s born in Thornton in Bradford in July 1818. And then when she’s, I think, almost two, they moved To a place called Haworth in the Pennines. And her father, Patrick, is the local curate.
And then she’s struck by the first of these three kind of early tragedies that will darken her early life, because her mother Maria dies of cancer when Emily’s about three. And then she and her older sisters, including Charlotte Bronte of Jane Eyre fame, they’re sent to this school for clergymen’s daughters, when she’s not yet six, and they’re treated really, really badly. And this school is actually the inspiration for Lowood in Jane Eyre, the kind of terrible school where it all starts.
And then while there, two of Emily’s older sisters die. So before the age of seven, she loses two sisters and a mother. And then, so there’s only four children left. And it’s Charlotte, it’s Emily, it’s Bramwell, their only brother, and then Anne, who’s also an author.
Anne’s always a bit of an afterthought, isn’t she? She is always. I always think that’s a bit harsh, though, because I really like the tenant of Wildfell Hall. Right. But she, she’s definitely not as famous or as impressive as the others, probably. Anyway, so they’re educated at home at the Parsonage by their father and their aunt, Elizabeth. And definitely a bit of a weird household, I would say.
People think of them isolated. In like this haunted house. Cut off from the world. But that’s actually rubbish. They were very literary. They subscribed to sort of heavyweight literary journals. The house is full of classics. And it’s not surprising because their father, Reverend Bronte, was a very impressive, very, very clever man. He came from County Down in Ireland, and he was actually the son of a farmhand. And then because he was so intelligent, he managed to get himself to Cambridge to read theology. Although that said, he is a bit bonkers. Didn’t he catwalk around with a gun all the time? Like all loving fathers, he walked around with a loaded gun. And I actually think you could see the side effects of some of this madness in some of the odd characters of Wuthering Heights.
He doesn’t let them eat meat? He doesn’t let them eat? No. Not for moral reasons, because he thinks it’ll make them entitled and spoiled. Exactly. Exactly. So he’s a fun guy. He’s a good time. And he’s also very much kind of lets himself be an outsider in their community. He keeps his Irish accent, so he stands out. And he’s known to be quite cold, quite distant. And he’s starting to have these mad, kind of fiery rages. Right. So he’s a delightful fellow. It sounds great. But I think it’s no surprise then that his kids are quite odd too.
So for instance, a local woman told Elizabeth Gaskell when she was looking into the Brontes, that the Bronte children had no friends in the village. And I actually quite admire this, because I think similarly, on one occasion, they were invited to a party and they showed no knowledge of the games played by their peers. And I actually quite respect that, because my heart always sinks when I go to people’s houses and they say, oh, should we play cards? Should we play Scrabble? So I’m on their side with that.
You don’t like cards or Scrabble? No. See, I don’t actually like Scrabble. It’s so forced. It’s like the forced fun of it. Can we not just… Would you never play any form of game? Yeah, well, I’m press-ganged into it, because you don’t want to be… Well, all those people who were thinking about inviting you to their house to play Cluedo are now changing their minds.
So because of this, because of their reluctance to sign up to annoying, boring, forced games, the siblings do become very, very close, unnaturally close, perhaps. They create these fantasy worlds, don’t they? This is very you, actually. Is it Glass Town and Angria? Yes, Glass Town and Angria, yeah. And the really funny thing about it is, it’s not quite, kind of Lord of the Rings, because they have little soldiers in them, like they have the Duke of Wellington in them. And actually, it’s very telling about how exposed these children actually were to the wider world, how much they didn’t live under a rock in Yorkshire, because they’re kind of set all over the world.
It’s in the Pacific, isn’t it? The Pacific, exactly, exactly.
So Emily, you know, they’re obviously going to have to get a livelihood or whatever. Yeah, well, they have to earn some money, yeah. Right, so she becomes a teacher in Halifax, and that’s a shambles, isn’t it? This is where me and Emily part ways, I think.
“I genuinely prefer the dog to you, I hate you.”
She says to the kids at one point, and you will discover in due course why that’s such a frightening sentiment, and why these children were actually… If there’s any dogs listening to this podcast, stop listening. Anyway, so that doesn’t work out. So when she’s 24, she goes to Charlotte to a girl’s boarding School in Brussels, and she teaches music there. But yet again, she absolutely hates it. She’s very snobbish. She’s quite up herself. She says that, oh, I’ll only teach the children at the end of the day when I’m done with my own studies. And that’s the only time that they have a break or free time. So she cuts into their free time and was unsurprisingly very unpopular.
That’s poor. She was also very unfashionable. She refused to wear the Belgian fashions. Would not wear the latest Belgian fashions? No. But what could a Belgian fashion possibly be? Well, you wouldn’t understand such things because you’re not a fashionista like me.
I do, actually. I just don’t feel like sharing it right now. Okay, fine. Anyway, so because of this, and I find this so amusing, there was a student called Letitia Wheelwright, and she said of Emily Bronte,
“I simply disliked her from the first. Her tallish, ungainly, ill-dressed figure, always answering our jokes with, I wish to be as God made me.”
She actually sounds like a terrible person. Yeah. The great critic, Catherine Hughes, I was reading an article that she wrote about this book, and she described Emily Bronte as the patron saint of difficult women. You’re not going to be sat next to her at a dinner party because she wouldn’t go. She won’t go out. But if by some terrible mischance… You’re having a Bible reading or something. Her physical portrait, you can tell from that, she’s very unfashionable. And she’s also said to be tall and had big bones.
Big bones. Generally, when people say you’re big bones, they mean that… It’s not a good thing. Yeah, in an unflattering way, right? And actually, there’s a movie that they did called Emily with Emma McKay from Sex Education, and they very, very much play into this. She comes across as almost autistic, I think.
Right. And people said that about her, didn’t they? Yeah, well, people have diagnosed her since with autism or with anorexia and all these kinds of things, which people love to do with characters in the past. I always think that’s slightly dodgy. I’ll tell you one thing that’s very dodgy, though, actually. So you mentioned the business about dogs.
Yeah. As we’ll discuss, Wuthering Heights is a violent book. There is a lot of abuse of various kinds. It’s shockingly violent, actually. As well as mental. Yeah. And you might say, well, where does this come from in this sort of quite withdrawn, lonely, very bookish girl? And an answer is, she herself is quite violent. So she had this dog called Keeper, and she loves Keeper, doesn’t she? But one day, he climbs on her bed with muddy paws, and she reacts by punching him in the face. But not just once, but again.
And if you love dogs more than people, you’re in big trouble if you’re one of her students. I think we have to be slightly sympathetic towards Emily. You know, she’s grown up with, as far as we can tell, a very angry father, and she’s suffered a lot of loss at a young age, and she’s very isolated. So I do have a little bit of pity towards her in that respect. But the other thing that’s worth remembering is, is that, you know, because people, they almost canonise Emily Bronte as kind of like a feminist icon, and we’ll touch on that a bit more. You know, she has quite kind of high Tory politics, doesn’t she? She would have set the dog on suffragettes or whatever, which is not in keeping with the idea of her as this kind of free-spirited sphinx of the Moors.
So that was a clip from our very first episode of The Book Club from Wuthering Heights, and we hope you enjoyed it. To hear more, search The Book Club wherever you get your podcasts. Goodbye. Bye-bye.
2026-02-18 08:00:01
Mathematical Superintelligence: Harmonic’s Vlad & Tudor on IMO Gold & Theories of Everything
Hello, and welcome back to the Cognitive Revolution. The presenting sponsor of today’s episode is Granola. Regular listeners have heard me describe the blind spot finder recipe that I’m using on Granola to look back at my recent calls and help me identify angles and issues I might be neglecting.
I love that concept, but it’s also worth highlighting how Granola can help raise your team’s level of execution by supporting follow-through on a day-to-day basis. This morning, for example, I had two very practical calls in which I committed to a number of things. In the past, to be honest, there’s a good chance I’d have forgotten at least a couple of the things I said I’d do. But with Granola, I can easily run a to-do finder recipe and get a comprehensive list of everything I owe my teammates.
This is the sort of bread and butter use case that has driven Granola’s growth and inspired investment from execution-obsessed CEOs, including past guests Guillermo Rauch of Vercel and Amjad Massad of Replit.
See the link in our show notes to try my blind spot finder recipe and explore all of the ways that Granola can make your raw meeting notes awesome.
Now, today, my guests are Vlad Tenev and Tudor Achim, co-founders of Harmonic, an AI research lab dedicated to building mathematical superintelligence, and also the creators of Aristotle, an AI system that achieved gold medal-level performance at the 2025 International Mathematical Olympiad.
While OpenAI and Google DeepMind achieved similar performance by scaling reasoning in chain of thought, Harmonic stands out for their commitment to formally verifiable methods. This is because it generates candidate proofs in Lean, a programming language that serves as a proof-checking assistant by using a trusted kernel to confirm that every single step of reasoning follows from a few explicit premises and accepted logical rules.
Aristotle’s work can be automatically validated, and its performance is in principle limited only by the scale of compute available for reinforcement learning.
In an effort to better ground my own intuitions for mathematical superintelligence, we begin with a metaphysical discussion about:
From there, we turn to the Aristotle architecture that delivered IMO Gold performance. It consists of:
- A large transformer model that uses a Monte Carlo tree search strategy, reminiscent of systems like AlphaGo, to discover valid paths from point A to point B in mathematical reasoning space.
- A lemma guessing module that helps manage context and keep things on track by generating candidate waypoints between a given starting point and a potentially distant end goal.
- A specialized geometry module modeled on DeepMind's alpha geometry.
We also discuss the Aristotle API’s informal mode, which attempts to auto-formalize whatever the user asks it to prove.
We discuss what its responses to my admittedly silly requests imply about the boundary between statements that could in principle be mathematically proved, and those which are sufficiently factual or philosophical in nature so as to fall outside the scope of the system.
Examples include propositions like:
“all is love”
and
“Epstein didn’t kill himself”
In the final section, we discuss:
On this last point, I have to say, with so many grandiose AI promises flying around these days — from a country of geniuses in a data center, to a century of progress in five years, to curing all diseases in our natural lifetimes — it is rare that I am genuinely taken aback by a company’s vision for the future.
And yet, as you’ll hear, Tudor did manage to leave me at least momentarily speechless when he described a future of theoretical abundance in which all physical phenomena we observe have multiple competing coherent explanations, which can only be separated by increasingly exotic experiments.
If you’re like me, you’ll find this episode a useful opportunity to:
Vlad Tenev and Tudor Achim, co-founders of Harmonic, makers of Aristotle, and winners with an asterisk of the IMO gold in 2025.
Welcome to the Cognitive Revolution. Thanks for having us. Greetings and salutations. Thank you.
So this is going to be, I think, a fascinating conversation. It’s probably going to be more metaphysical than most of our episodes, but also there’s a lot of practicality because what you guys are doing certainly has aspirations to go beyond the pursuit of mathematical superintelligence.
Maybe just for starters, how do you guys understand what math is? That was something I was really wrestling with in preparing for this. And then, you know, that’s obviously very metaphysical. To make that a little bit more practical, what would you say are the core cognitive skills that people that are good at math really develop and excel at? And how do those skills do when we look at the performance of like the frontier large language models that all of our listeners are familiar with today?
“Yeah. Well, look, first, thanks for having us. It’s really great to be here.”
You know, when you ask, what is math? What is it useful for? What are the core cognitive skills? it gets like one of the core theses of our company, which is that mathematics is reasoning.
So a lot of people think of mathematics as this really esoteric thing. You know, you’re thinking maybe group theory, stuff you’ve seen in movies like Good Will Hunting, but mathematics at its core is the process by which humans understand the world by breaking their understanding down into small sequences of logical steps that other people can understand and verify for themselves.
So when you’re solving a physics problem or doing your taxes or thinking about what happened at the beginning of the universe, ultimately you have to have an explanation that is
And so when we talk about what it takes to be good at math, the question is what it does take to be good at reasoning. And so that’s, again, that ability to break this down into steps.
It turns out math is really useful for understanding the universe and building lots of engineering things, but ultimately it’s just about reasoning.
I watched your podcast that you did with Sequoia maybe 16 months ago or so now. And I recall Vlad’s story of like, basically,
“I thought that if I got good at math and I’d probably be good at other things and it sort of worked for me.”
So that’s like one way to, in a very practical sense, unpack the idea that math is reasoning. It certainly seems to help people generalize to at least related domains and be really effective, for example, in entrepreneurship.
But I’m not entirely clear still on like, are you making a more almost platonic claim there? It seems like there’s the very simple notion that like, okay, I should teach my kid a lot of math because then they’ll be smart generally. And again, that works for humans.
But is there something that you see as like a more fundamental law of the universe, sort of correspondence between what we are doing in math and what we are doing in these other domains? Because it doesn’t seem like we have the same sort of like verifiability in almost anything else.
We do have it a little bit in computer science, but even in physics, right? We’ve got like still very fundamental questions about
“I don’t think that stuff is at all agreed upon.”
So maybe you guys throw up your hands at this mystery too, or maybe you feel like you have kind of an intuition for what the answer is.
“Yeah, I can give you my perspective.”
I got into math through physics. So when I first came to Stanford as an undergrad, I had read Brian Greene’s The Elegant Universe, which was sort of like the first popular string theory book.
And when I was a kid, one of the earliest memories, one of the first full English books that I read was A Brief History of Time by Stephen Hawking. So I’ve always been interested in kind of the big questions, right?
Cause you know, back in the day, that was not obvious. You know, we thought electricity was separate from magnetism and it was just like a really big… I probably think one of the greatest achievements of science is figuring out that these two are actually two sides of the same coin really. And then, and then the big question is like, well, what’s going on with gravity? Is it, is it the same? Right.
And, in the middle of this, we found out that the weak force and the electromagnetic force were also splintered off of one electro-weak force. So it kind of feels like there was just one thing at the beginning and we have to understand what that thing is.
And what I found when I became a physics major at Stanford, and I started asking all of these questions, eventually they’d send me over to the math department. And they’re like,
“Well, in order to understand string theory, you have to understand all of these other things. Right. And if you want to understand general relativity, you’ve got to get into differential geometry.”
And so that’s how I became a pure math major and ended up doing a PhD. The impetus was actually trying to understand the real world through physics.
If you think about what’s the usefulness of physics, I mean, all of the big inventions that humanity has that really push us forward are kind of like physics inventions, really. I mean, when you think about:
They’re physics things.
So the real reason to do math is math is interesting and beautiful. There’s an art aspect of it, but it helps you. It helps you understand physics. Physics helps you understand engineering. And then you can create things that have huge value.
You were asking, how does math work in other fields where things are not as precise? I think math shows up just maybe a little more subtly than people think.
So there is this physicist, Eugene Wigner, who wrote a famous essay called the unreasonable effectiveness of mathematics, which was commenting on a really interesting phenomenon.
So Vlad mentioned differential geometry and special relativity. It turns out that when Einstein was creating that theory, he relied on these thought experiments from the 19th century around how to think about certain manifolds and their properties.
And that was actually the key tool that we use to explain what special relativity is, and then develop it for general relativity.
That’s a perfectly representative case because those thought experiments in the 19th century were almost preposterous. It made no sense to think about them because
“How could you possibly apply these concepts to the real three dimensional world?”
And then it turns out that it’s very useful for understanding the four dimensional world when you include time and curvature.
There are myriad examples like this.
If you consider number theory for a long time, that was really seen as an incredibly esoteric branch of math with no practical implications. But people pushed on that theory for a long time. And then it turns out that that’s the key tool you need to create a secure digital economy.
So now essentially all of human civilization has a digital economy, which is based on this branch of math.
So I think it’s almost the wrong question to ask,
“Well, I don’t know, there’s a lot of math out there. How is it useful?”
The point is you just do the math and then eventually some of it, not all of it, will be more useful than you possibly could have imagined.
So the investment in math is: it’s not just to build a really smart system. It’s to create a lot of new math that we can then figure out ways to apply later.
One interesting thing that the conversation reminded me of when you first asked,
“What is math? What does it look like?”
I think one of the reasons we got excited about applying AI to this domain is there are lots of different things that mathematicians do.
And I think we’re very excited about the prospect of AI accelerating the former. We think that’ll happen.
But the latter is something that AI is already really, really good at today and was good to some degree when we got the idea for Harmonic. You know, you look at GPT-4, which had just come out when we started and it excelled at just pulling information, doing these types of needle-in-a-haystack tasks of, can you just really quickly go through all the literature and pull things that might be relevant.
And I would say even if you can be an amazing mathematician, you’re in that category.
I think a lot of the work could be accelerated if you just knew all the math that was being done and could pick out the relevant things to an unsolved problem that you have at hand.
So I think the problem itself lends itself really well to what AI is already good at.
Hey, we’ll continue our interview in a moment after a word from our sponsors.
One of the best pieces of advice I can give to anyone who wants to stay on top of AI capabilities is to develop your own personal private benchmarks, challenging but familiar tasks that allow you to quickly evaluate new models.
For me, drafting the intro essays for this podcast has long been such a test.
I give models a PDF containing 50 intro essays that I previously wrote, plus a transcript of the current episode and a simple prompt.
And wouldn’t you know it, Claude has held the number one spot on my personal leaderboard for 99% of the days over the last couple of years, saving me countless hours.
But, as you’ve probably heard, Claude is the AI for minds that “don’t stop at good enough.”
It’s the collaborator that actually understands your entire workflow and thinks with you.
Whether you’re debugging code at midnight or strategizing your next business move, Claude extends your thinking to tackle the problems that matter.
And with Claude Code, I’m now taking writing support to a whole new level.
Claude has coded up its own tools to export, store, and index the last five years of my digital history — from the podcast, and from sources including Gmail, Slack, and iMessage.
And the result is that I can now ask Claude to draft just about anything for me.
For the recent live show, I gave it 20 names of possible guests, and asked it to:
Based on those, I asked it to draft a dozen personalized email invitations.
And to promote the show, I asked it to draft a thread, in my style, featuring prominent tweets from the six guests that booked a slot.
I do rewrite Claude’s drafts, not because they’re bad, but because it’s important to me to be able to fully stand behind everything I publish.
But still, this process, which took just a couple of prompts once I had the initial setup complete, easily saved me a full day’s worth of tedious information-gathering work and allowed me to focus on understanding our guests’ recent contributions and preparing for a meaningful conversation.
Truly amazing stuff.
Are you ready to tackle bigger problems?
Get started with Claude today at Claude.ai/TCR.
That’s Claude.ai/TCR.
And check out Claude Pro, which includes access to all of the features mentioned in today’s episode.
Once more, that’s Claude.ai/TCR.
AI agents may be revolutionizing software development, but most product teams are still nowhere near clearing their backlogs.
Until that changes, if it ever does, designers and marketers need a way to move at the pace of the market without waiting for engineers.
That’s where Framer comes in.
Framer is an enterprise-grade website builder that works like your team’s favorite design tool, giving business teams full ownership of your .com.
With Framer’s AI Wireframer and AI Workshop features, anyone can create page scaffolding and custom components without code in seconds.
And with:
it’s no wonder that speed, design, and data-obsessed companies like Perplexity, Miro, and Mixpanel run their websites on Framer.
Learn how you can get more from your .com from a Framer specialist or get started building for free today at Framer.com/Cognitive and get 30% off a Framer Pro annual plan.
That’s Framer.com/Cognitive for 30% off. Rules and restrictions may apply.
Okay, that’s quite helpful. I think, coming into this, I had focused my own mind on sort of two modes of math, I guess.
One being the kind of Einstein-like — obviously that’s a high-level example of a kind of eureka moment of having some insight that,
“hey, this highly abstract and, you know, seemingly perhaps like very esoteric formalism can actually unlock like major understanding.”
That’s kind of amazing. Very amazing.
And then there’s also this sort of grind-it-out, like I’ve got this thing that I want to prove, and I’m going to kind of, perhaps stumble my way even through the space of possible logical moves until I finally chart a path there. And then you’re adding another, a third layer, which is like problem selection in the first place, which I guess is pretty related to the Einstein thing, but certainly distinct in some ways.
Let’s take a minute before we get into the Aristotle system and how it works and how you’ve trained it and all that stuff to just talk about Lean.
Lean is basically a programming language that does this kind of very bit-by-bit logical maneuvering, right? Where you have certain assumptions coming in, you’re going to take these various steps, and the goal is to get to a certain outcome.
Tell us, because I’m just learning about this, in the context of preparing for this and a couple other podcasts, and I think most people don’t know anything about it.
So maybe give us a little bit of a more intuitive understanding of what Lean is. And I’d be keen to understand it on a little bit of a practical level to like:
So Lean, in my view, is the best programming language ever created.
In Lean, you can write any program you would write in Python or C or C++, but you can also express essentially any logical concept.
So if we’re okay getting into a bit of the details, it is a dependently typed programming language, which means that at compile time, you can express very complicated properties of the program that you can check before ever running it.
So on the one hand, you have on one end of the spectrum, you have something like JavaScript, where you can check basically nothing. And then on the other end, you have Lean.
But the really cool thing is you asked about axioms. So when Aristotle produces any output, it’s produced as annotated Lean code.
So there’s the programming language Lean, we write theorems, we write programs, we prove things. And there’s a lot of comments explaining to the person reading it what it’s doing.
But when we talk about proving things, you end up relying on three axioms, in addition to just the basic concept of the calculus of constructions, which is what the programming language is based on.
And just as an example to show what an axiom means: the axiom of choice —
“It’s not saying anything that would be controversial, it’s saying if you have a non-empty set, it’s possible to choose an element from it.”
And so from these three extremely basic axioms, it turns out you can build:
It’s all based on this core set of axioms.
And so the goal of a system that outputs Lean is to find interesting statements and programs then prove things that just depend on these axioms. And that’s really where the difficulty lies.
As you alluded to, sometimes you have to make big logical leaps, sometimes you have to grind through a lot of math, but both of those are essential. So you can’t really skip one of those steps.
But the Lean itself is just incredible. You can express so many ideas in it, you can prove so many things, and you can use it as a programming language too.
So it’s really up there for me in programming languages.
I started playing with Lean when Tudor and I started making a plan for this business, and we had a pretty early decision about whether we wanted to go formal and informal.
One thing that struck me about it is, as a former mathematician, I barely used the computer when I was doing math.
I was in my PhD in the late 2000s, and the only time you’d really be using a computer when doing math is when you wanted to type up your homework or your research paper or something.
But all the thinking about it would happen on a chalkboard or a whiteboard. All the collaboration about it would happen in person at these conferences or on a chalkboard in one’s office.
For a while, it was just like maybe mathematics would always be this pure thing that would just be kind of untouched by technology.
But what Lean has done is it transformed the mathematics from kind of like chalkboard and couch to now it’s in VS Code.
You know, you can do it in Cursive. You’re putting your math on GitHub, where now you can run these large collaboration projects.
So even when you subtract out AI, I think the Lean by itself without AI changed how people do mathematics, because now you’re seeing extremely prolific, famous mathematicians running these large projects where they’re collaborating with dozens of people around the world trying to do things like formalize research or formalize the proof of Fermat’s Last Theorem. And more and more and more of the folks are adopting Lean as like an accelerant.
So I think it’s changing how mathematics is being done and actually accelerates collaboration and accelerates progress and sort of like removes this notion of peer review.
If you’re a mathematician, if you’re a mathematician and you want to prove something, a big part is getting someone to read it and actually spend the time to tell you if it’s correct.
And so, you have the proof of Fermat’s last theorem, which took many, many years to be proved.
What happened was sort of this collection of people got together and when they all agreed that the proof was complete, it was sort of like ordained that the thing was proven.
And I think another thing formal does is it makes it so that that’s unnecessary.
Like if the proof checks and there’s no caveat that there’s no bug in the Lean kernel or how you’ve set up the statement, you obviate the need for manual human verification.
And the implications of that are pretty interesting too, right?
You have all of these potential citizen mathematicians who now with AI can solve unsolved problems and they don’t need to get anyone at a, you know, PhD program, a lean institution interested in their problem in order to tell that it’s correct.
They just have to have the Lean certificate and the proof is correct.
So, yeah, I think that’s a powerful thing.
If you think about journals, journals and math exist for this: it’s like the prestige of the review board tells you whether you should read something or trust it.
So I do that. The notion of trust is really changed fundamentally with tools like Lean.
Yeah. And I think that the open source software community has really solved this problem a long time ago.
So if you go on GitHub, one can simply open a pull request on some repository.
So now you’ve contributed.
That element of trust is not so present, you can just run the tests.
Also, when you talk about impact and prestige, you can look at the number of stars you have.
So if a repository is very popular, it gets forked a lot, it gets a lot of stars.
So you’ve disintermediated essentially any gatekeeper here, it’s totally open source, there’s no morning trust required, and there’s a measure of impact.
And so I think math is going to start going the same way.
Previously, mathematicians relied on their social networks to figure out:
But with Lean, you can have a big math project, anybody can come and contribute a proof.
And if Lean accepts it, then it’s right.
If a lot of other mathematicians start to depend on that result, we’re going to notice:
And so then you start to measure the prestige that way.
So it would be very interesting if Lean is the one tool that allows you to go from kind of the cathedral style of development where very closed networks, et cetera, to more bazaar style development where it’s kind of wild west.
But Lean is like the computational certificate that everything is correct.
I wish I understood a little bit better, had a more intuitive sense for what exactly is going on with Lean still.
This is going to be hard, I think.
But in doing my kind of research, one thing that stands out is the kernel is really small.
So, in terms of what you need to trust, it’s a pretty small amount of core code that has been thoroughly vetted many times by many people.
So there’s kind of that level of understanding.
I think I would still love to have a little bit better sense because when you mentioned the three axioms, for example, it’s a little weird for people outside the field to be like,
“Oh, there’s two that are kind of bizarre and technical. And then there’s this one that’s like if you have a non-empty set, you can choose an element from it.”
And I’m like, that seems like common sense, but why was that ever controversial?
Is there a way to describe the sort of space of legal moves in math or in Lean in sort of— I don’t usually like analogies.
I often try to set this up as an analogy-free zone, but because I’m—I think I and a lot of others are going to struggle with the very literal understanding, maybe this is a time for an exception to my no analogies rule.
Is there sort of like a— I don’t know, like a chess analogy or something where you could say, like, here’s the pieces and here are the legal moves that you can make to kind of give people a little bit of a better sense of what it actually means to move through these spaces?
I think the chess example is perfect. So a theorem in Lean is something like, given this starting configuration of a chessboard, it is possible to get to this configuration. And a proof of this theorem would be listing the sequence of moves. And what the kernel is doing in Lean is saying for every single move that you claim is valid, it’s checking, “hey, does this rule exist in my rulebook?”
So the theorem says you can get from A to B. The sequence of moves is, okay, here’s the sequence. And the kernel is just saying, “yes, this step is right, this step is right, this step is right.” And now I’ve confirmed that I’ve ended up in a target state. So Lean is doing that, but of course, the individual steps are different, they’re mathematical steps, and they depend on one or more of these three axioms.
The three axioms, although they’re technical, they’re very short. So if you write them down as mathematical statements, they’re under, I think, each of them is under a tweet in length. Like the axiom of choice definition in Lean is maybe 10 characters, and the other ones are maybe 100. So they’re not very complicated, they’re just a little bit annoying to write in math.
And then people say, okay, well, if we assume these axioms are true, and they’re also common sense, just like a bit more complicated. And we’ve checked every single step against those axioms, then we say the whole proof is correct.
Could you give like a few examples maybe of like the pieces and the moves? Obviously, we can’t come anywhere close to being exhaustive, but what are the primitives in terms of the…
I’ll give a mathematical but simpler example of a primitive. So let’s consider first-order logic.
So the deduction rules you have are:
So let’s say you have a proof that says: if I have A, and I know if A then B, and if B then C, the theorem says C is true.
And the proof of that says:
A is true,
I have if A then B, which means B is true,
And then I have the step B is true,
I know that if B then C,
And then I can conclude that C is true.
So this is a first-order logic, so it’s not quite the same as what we’re talking about in Lean. You can do more advanced types of logical statements there. But ultimately, that’s what’s happening.
I think it’s going to be hard to…
Essentially, the next step beyond that is just getting to Lean and the calculus of constructions and these axioms.
So there is one thing when I learned it. There’s actually…
People are also exploring use of Lean to teach math. And I think now it’s sort of like practical at the high school level, but you could see a world where it extends to like middle school and maybe even younger if someone’s precocious enough. But I think mathematics education will go from sort of like the chalkboard to the computer lab.
So there’s this thing called the natural number game where you learn Lean by deducing properties of like multiplication and addition basically. So for example, the commutative law, which is basically that
A plus B equals B plus A, right?
Or the distributive law, right?
A times quantity B plus C equals A times B plus B times C.
So you can sort of like discover and prove these fairly basic facts just using the core axioms and the Lean language.
So that’s a good way, you know, if anyone just wants to like, all right, what is this Lean thing? Why is it useful? But I’m not a research mathematician. Dip your feet into it. I think I would recommend that.
And that’s been extended to harder things too. I think there’s like the real analysis game now, which is if you want to learn real analysis, it’s very proof based. And it’s basically the foundation of calculus.
You can start with like basic facts about:
And then you can kind of keep proving more and more complex things.
That’s a great tip. I’m definitely going to bookmark the real numbers game and see if I can get my soon to be seven-year-old into it.
Hey, we’ll continue our interview in a moment after a word from our sponsors.
Want to accelerate software development by 500%? Meet Blitzy, the only autonomous code generation platform with infinite code context, purpose built for large, complex enterprise scale code bases.
While other AI coding tools provide snippets of code and struggle with context, Blitzy ingests millions of lines of code and orchestrates thousands of agents that reason for hours to map every line-level dependency.
With a complete contextual understanding of your code base, Blitzy is ready to be deployed at the beginning of every sprint, creating a bespoke agent plan and then autonomously generating enterprise grade premium quality code.
Grounded in a deep understanding of your existing code base, services and standards, Blitzy’s orchestration layer of cooperative agents thinks for hours to days, autonomously planning, building, improving and validating code. It executes spec and test driven development done at the speed of compute. The platform completes more than 80% of the work autonomously, typically weeks to months of work, while providing a clear action plan for the remaining human development.
Used for both large scale feature additions and modernization work, Blitzy is the secret weapon for Fortune 500 companies globally. Unlocking 5x engineering velocity and delivering months of engineering work in a matter of days.
You can hear directly about Blitzy from other Fortune 500 CTOs on the Modern CTO or CIO Classified podcasts. Or meet directly with the Blitzy team by visiting Blitzy.com. That’s B-L-I-T-Z-Y dot com.
Schedule a meeting with their AI solutions consultants to discuss enabling an AI native SDLC in your organization today.
The worst thing about automation is how often it breaks. You build a structured workflow, carefully map every field from step to step, and it works in testing. But when real data hits or something unexpected happens, the whole thing fails. What started as a time-saver is now a fire you have to put out.
Tasklet is different. It’s an AI agent that runs 24/7. Just describe what you want in plain English, send a daily briefing, triage support emails, or update your CRM. And whatever it is, Tasklet figures out how to make it happen.
Tasklet connects to more than 3,000 business tools out of the box, plus any API or MCP server. It can even use a computer to handle anything that can’t be done programmatically. Unlike ChatGPT, Tasklet actually does the work for you.
And unlike traditional automation software, it just works. No flowcharts, no tedious setup, no knowledge silos where only one person understands how it works.
Listen to my full interview with Tasklet founder and CEO, Andrew Lee. Try Tasklet for free at Tasklet.ai. And use code COGREV to get 50% off your first month of any paid plan. That’s code COGREV at Tasklet.ai.
And we haven’t really talked about Mathlib, but the Lean kernel is quite small. There’s an open source project called Mathlib, which you can kind of think of as the largest digital repository of mathematical knowledge.
So all of the, a lot of the famous theorems and results can be found in Mathlib, and those give you almost like additional complex moves or algorithms to prove your thing. So you can apply a theorem, and it’s almost like applying a function from a library. That can help you get to the goal.
Yeah, I think that people can understand what it is better. Just think of it like every math textbook in the world merged into one in a self-consistent way. So eventually, all of mathematical knowledge will be in this one repository.
And if you hit build on your computer, you’re going to be able to check it all from the foundations. If you have any question about any math concept, you just search for it, you click on go to definition, you can jump around. It’s really going to be the new foundation for math in the future. It’s pretty exciting.
I think mathematics is certainly going to change fundamentally—like how it’s done, how fast it moves. And I think to a large degree, it already has. And AI is just going to accelerate it.
The great thing about our timing is Harmonic really started when both of these things matured to a level of capability where you could start doing interesting stuff.
I think both of these matured to the level where you can start putting them together and doing really cool things. And I think we were just the first to see that. That’s how we came up with this concept of mathematical superintelligence, which really means the combination of formal verification and formal tools with artificial intelligence.
Funny story, as I was using Aristotle a little bit to try to wrap my head around all of this, I don’t have the sophistication to pose any really interesting problems. So one challenge that I gave it was to prove that two plus two equals four. And then I had to laugh when it came back, just citing something from Mathlib that was like, “this is already proved in Mathlib” for the, the theorem is literally like the two plus two equals four theorem. So I was like, it’s done. And I was like, yeah, that’s not exactly what I was looking for, but I guess I kind of got what I deserve there for asking it such a basic question.
Did you use the, were you using the web interface or the terminal UI? I started by having cloud code installed the terminal and then was using that a little bit. And then somehow it tipped me off to the fact that there was a web interface. And so I, then I, after that I’ve moved over to the web interface. Yeah, that came to the last week and they’re probably a little bit more appropriate for those types of questions.
I think we wanted to roll it out for on terminal, because I think it makes it a little bit more clear what the tool is great at. I mean, lots of things can answer two plus two equals four, but even I can answer that in the calculator.
Yeah.
And I think, I think for a while we were talking about like, how do we describe this, this, like what Aristotle is? I mean, it’s, it’s kind of like an amazing calculator where you can imagine you could just talk to your calculator. So it has:
You know, something like ChatGPT or Claude are very expressive, but sometimes you have to double check its work because it doesn’t always, you know, it doesn’t have the verification. But really the intent is to put those together.
And it turns out that the things, the first things that people really want to be sure about and to verify are like more complicated things. So I think the, you probably found this out, but the complicated things I think is where you really start to have aha moments when you’re using it.
Yeah, let’s get into Aristotle. And I appreciate the time spent in remedial education. I think it’s beneficial, not just for me, but hopefully everybody will now be able to kind of grok what we’re about to get into much better with that foundation that we’ve laid.
So Aristotle has three core parts. I’ll just kind of sketch them and then you can, you know, give me the double click on them.
First, there is this Monte Carlo tree search type thing. I kind of think of that as sort of an AlphaGo-like structure where we are systematically exploring the space of moves. I guess that’s where I got the chess analogy, right? Is that I kind of was making this equivalence between Aristotle, at least that part of Aristotle, and AlphaGo.
And so it’s kind of maybe I can make this move. And then there’s this learned scoring function that’s like,
“Okay, does that move seem promising? Does this path of, you know, does this branch of all possible moves that I could make, does it seem promising? Do I seem like I’m getting closer to my goal?”
And with that, you can kind of grind things out, run deep tree search, right?
The second part in some ways to me jumped out as even more interesting and kind of, I really want to dig into the metaphysics of it a bit, because this is the lemma-based informal reasoning system, which I take to be sort of saying,
“Okay, if I have some really big mountain to climb, and it’s maybe so big that I can’t just grind my way… it’s maybe becomes impractical to grind my way through like all these small localized steps.”
It’s sort of guessing like what’s the base camps that I would want to get to along the way that are like the really good way points such that if I can get there, then I know I’ve like, I’ve made it somewhere.
But that’s really interesting because it sort of strikes me a little bit more like a, like it behaves, it seems like a little bit more like a language model where it’s kind of guessing and not so formal. I mean, it says in the, in the technical report that it is an informal reasoning system.
And then there’s a third part, which we maybe don’t have time to go as deep on, which is specifically dedicated to geometry. Again, in the technical report, you described that as being like AlphaGeometry, which I think DeepMind developed.
So correct any misconceptions that I have there and give me the double click on what, like what more I should understand about how this thing works.
Sure. I think, I think you covered the components pretty accurately. So one thing I have to say is that, you know, we revamp our systems pretty often here. So I think Aristotle now looks quite different than Aristotle for the IMO. You know, I think a lot of things are consolidated and improved.
I think that you made this point about the Monte Carlo tree search being more of a grinder. I wouldn’t quite characterize it that way.
So the Monte Carlo tree search is actually doing a lot of inference on its own about high-level steps. So the levels that we’re talking about, they’re much closer to solving a challenging math problem than they are to prove that two squared equals four. So there’s a lot of reasoning that goes into them.
In some sense, it’s grinding once you get low enough in the search tree because you’re just closing out cases or easy subproblems. But it’s really solving harder problems on its own.
And so when we combined it with the informal reasoning system, you could almost think of it as a form of context management, actually. So ultimately, you need to end up with a lean proof, and that’s going to involve big steps and small steps. And it’s helpful when you’re focusing on the smaller steps to not have to remember the entire context of the bigger steps.
And so it turns out the informal reasoning system itself actually makes enormous quantities of mistakes. So one should not think of it as,
“oh, it’s a really smart human that’s laying out the steps to base camp.”
It’s more like a system that can propose lots of things that are wrong and don’t have to be formalizable or even correct. And you kind of try to assemble things from that.
So you can think of both of them as kind of doing the same thing, just at slightly different scales and complementing each other. And they’re actually all LLMs. So as we described in the tech report, the tree search itself is driven by language models.
Part of the language model is proposing steps. Part of it is scoring steps. But they work in concert to solve the lemmas and then eventually the full problems.
And as you mentioned, alpha geometry, it’s a slightly different system. We’re exploring kind of high-level steps and then trying to use an algorithm to grind through the rest of it. I think if we’re talking about systems grinding through a lot of math, I would say alpha geometry in the deductive reasoning system is really a grinder. So it’s really trying to find every possible conclusion of a geometry diagram.
I would say there’s not too much pattern recognition intelligence going on there. And that’s because geometry, if you think about it, is more constrained. You basically have points. You can basically start with points.
If you have three points, there’s only so many angles involved. Obviously, if you go to like 10 or 15 points, things blow up pretty quickly. But it also then becomes hard for humans to solve. And I think that’s why geometry was among the first class of competition problems to fall to AI and automation.
I think there’s also a couple of other components that might seem simple but are non-trivial that Aristotle, the system, does and are independently improving.
One is auto formalization: taking input that you provide in natural language and faithfully translating it into Lean in the best possible way. And I think, relative to our competitors, at least, I’m not aware of anything that’s as good at that as we are.
And also theory building: sometimes in the way of solving something, you have to create new theories and new structures that might not exist in mathlib. Aristotle has the capability of actually building that on the fly and incorporating that into the proving process.
Another funny anecdote, so that you’re referring to what I discovered is informal mode, right? Where I can provide—I think real users would not do this—but you can provide anything, any natural language input, just something that the system will then try to prove.
I asked it to prove all is love. And it came back and said,
“this is a philosophical statement and outside the scope of the Lean formalizer’s ability to prove.”
I also asked it to prove
“Epstein did not kill himself.”
And it came back and said,
“this is a statement about current events. And again, it’s sort of outside the Lean formalizer’s ability to prove.”
But yeah, I think this kind of gets back to this sort of metaphysical question that I find so perplexing around that translation from the messy real world of human affairs and intuitions to the formal definitions of,
“okay, this is actually the thing that we would want to prove.”
I did find that very, very interesting that you had such a thing at all. And I guess, well, do you have a sense for— I also do want to get into a little bit more details of just like technically how you created the models and all that stuff. But, you know, on my spectrum from 2 plus 2 equals 4 to all is love, is there, how do you think about the intuition for what the boundary is of what is inside the, what, because I, because I, again, when in listening to your previous interview with Sequoia folks, it seemed like you had the sense that eventually as the system and systems like this get capable enough that more and more things that are of interest every day people will start to become the sorts of things that they can do.
So like, how do you think about that boundary and how does that boundary expand over time?
I think the, the ultimate boundary of a system like Aristotle is in reasoning through any problem where people can also agree on what it means to be a valid sequence of reasoning steps. So right now you have math. That’s one obvious one. When we talk about mathematics being the same as reasoning, that chess example you gave is a perfect one. So you can express the logic of a chess game and then check it, right, and then reason about it.
I think one area that’s really going to touch a lot of people’s lives is it turns out you can use the same reasoning approaches to think about software. So when people write software, they write these things called:
And it’s kind of having the computer just run the program and check the output against what they expect. But that’s what they do after they’ve written the code.
It turns out that when engineers are writing code, they’re thinking logically:
“Okay, if I have this range in my input, I can think okay, as I go to this for loop at these if statements, it implies certain things about the output.”
And that itself is logical and mathematical reasoning. So we’re starting to see API users reason about programs in the same way that they can reason about math. People are writing cryptography implementations and then checking:
I think the same kind of input that will go to software will help take us to a bug-free software future.
Now, Vlad and I disagree a little bit. It’s not clear to me if we’ll be writing history essays or something — maybe there is a way to value them objectively. But I think the boundary is really in anything that’s quantitative and logical in nature.
Yeah, I think in the first version of Aristotle, it would actually formalize and build a theory for your all is love example. And it would give you a correct proof that it’s probably true.
I think it surprised us. People were asking all sorts of questions. We had people asking:
And Tudor mentioned computer science. So I think it’s actually surprised us how broad of a set of things it can successfully create a theory around and formalize.
I think the constraints we put were just, you know, when you’re building a product, you want to make sure that you deliver value. At this point, I don’t think we provide the most value if you want to write a history essay.
So we’re trying to nudge people to the point where they can discover what Aristotle is really, really good at as quickly and simply as possible. I think over time, you should expect that the surface area increases.
We start formalizing things. And I don’t think it’s inconceivable that at some point it pulls current events and news from the internet, puts out the axioms, and can sort of fact-check and make conclusions based on real-world events.
Not our focus right now, but I don’t think it’s a crazy thought.
I mean, I ask a question sometimes. I’m interested in astronomy, right? And I wanted to know:
“When’s the next full solar eclipse that I can see from within 50 miles of Palo Alto, California?”
The models usually struggle with this type of stuff because nobody’s asked that identical question out on the internet, so they can’t pull it. You actually have to do some math.
So you can imagine there’s a spectrum and there are questions like this that a model that can reason actually from first principles is going to be way better at.
Okay, let’s talk about just how you created this thing a little bit and how your experience, lessons learned, et cetera, kind of relate to some of the live questions more broadly in the AI space. I think you can take on faith that folks listening to this show will be familiar with things like reinforcement learning from verifiable rewards and stuff like that and certainly understand kind of how the ability to generate synthetic data feeds into a system like that and that’s, I’m sure, part of what you’re doing.
What more can you tell us in terms of like, would it make sense to start training something like this from some off-the-shelf pre-trained model or does that messiness that those, you know, LLMs start with corrupt or pollute your, the purity of the mathematical reasoning too much? Can you tell us anything about size of models, which could be parameters, could be tokens, whatever?
I’m interested in things like also, is there any role for taste in this process? Obviously, like mathematics, mathematicians are very interested in correct proofs, but they’re also interested in these eureka moments and the sort of sense of elegance of the proof, right? There’s a sense of the beauty that, you know, matters as much, I think, to many people as the correctness or maybe not as much, but, you know, it’s certainly heavily weighted.
And then I also noticed there’s test time training that’s part of this, and I think that’s, you know, a huge trend that I’m kind of watching in general.
So, you know, you can swing or take any of those pitches, but what do you think are kind of the most interesting next level of depth that people can use to inform their own AI worldview with?
Well, first, I have to say that if your audience knows about reinforcement learning from verifiable rewards, you’ve got a great audience.
“That’s not betting data.”
Yeah, that’s not. So, I think that is a safe assumption. Nobody was talking about that stuff, right? It was like science fiction almost, but it’s cool to see it entering the popular consciousness.
I want to address the taste question, because that actually, you know, strikes at a key thing that, you know, companies can decide on.
So, we get gold performance at the IMO, we have a very powerful system, and it was obvious we had to give it to people.
And there’s two ways you can do it.
That’s one way of expressing taste in the research map.
The other way, which we ultimately decided to do, and we think it’s been great for the community, is we said, well, we’re not going to be the ones to decide what’s important in math. We’re going to make Aristotle accessible to everyone.
And so, we opened up the API, the web interface, there’s a lot of great features coming.
And then, in this scenario, taste is expressed by the community by the revealed preference of what they submit to the API.
So, we don’t choose what kind of math they do.
We’re not saying, hey, Navier-Stokes is more important than P versus NP.
It’s the mathematicians that have the credits on the API to say, well, we care about X or some other thing.
And that’s why we’ve seen so much interest in:
And for a while, there are people doing a lot of interesting conjectures in graph theory on the platform.
And I think that that’s actually the right way for companies to engage with the community.
You know, you open the system and you let the people decide, you know, where they want to allocate those computer resources.
So, I think that’s an important decision. We’ve come on one side of it, but I think that’s the right long-term approach.
I think there’s a philosophical question there, too, which is, are we headed for a future where the AI labs themselves are going to generate all the discoveries?
Will the cure for cancer or diabetes look like a giant AI lab with a two gigawatt data center just churning on this problem? And then, you know, it comes out and they capture all the value?
Or does it look more like millions of people empowered with these tools working independently and collaborating and, you know, in that world, they’ll get the credit and the value will largely accrue to them?
And I think we believe that the second world is more interesting and it’s probably the one that’s more likely.
The first one is rather dystopian and less likely.
And I think we noticed that because when we rolled out Aristotle, you know, we had one view of what people would use it for, but then we started getting all of these, you know, Erdős problem results and things like that.
And it’s like, we’re not going to run on all the Erdős problems. We’re not going to do like computational learning theory, formalizations in house.
So I think the amount of cool things being done with it just explodes if you put it, if you make it generally available. So I think it’s not only right from a business strategy standpoint, but also like, I think that the world that we built, assuming this path, is a better world that I would like to live in.
So that speaks to taste in terms of problem selection.
But I was also just thinking in terms of, as you’re training the model, you’ve got the correctness signal, but maybe one sort of heuristic for elegance would be like just brevity.
Which is maybe one kind of way of trying to send an elegance-like signal through a deterministic mechanism. But I would be very interested to know if there is like a panel of mathematicians that you guys have reviewing solutions for elegance to try to make sure that this thing is not just a pure grinder long-term, but really has a more eureka flavor to it.
Well, brevity—if brevity is the definition of elegance—then our two plus two equals four proof probably takes the cake, right?
“I can’t get any shorter than that.”
I would feel bad for any mathematician’s job of us to compare AI proofs. That’s certainly not the job I’d want.
So we, we have never. It’s a big business these days across all domains:
Yeah, we have done essentially zero of that in the two years we’ve been around.
I think the metric we optimize for is the net present value of future proofs or computational costs of future proofs. And so that guards very naturally against certain phenomena.
When you’re solving easy problems early on in reinforcement learning, you absolutely can solve them with grinding. So you can say,
Let me just do brute force.
But you know that if you do that, it’s going to cause issues later because you haven’t learned how to do more complicated things.
In contrast, if you’re given two proofs that are not grinding, but one is drastically longer and more inefficient than the other, you prefer the more efficient one.
So there’s a tension there because you can get more efficient by grinding, but that messes you up in the future. So it’s a balance that our AI researchers strike based on their intuitions about what’ll be helpful long-term.
But we have never had panels of mathematicians do testing on proofs or anything like that. Really, you want to give your system as few priors as possible and just run reinforcement learning at scale.
There’s a famous essay called The Bitter Lesson, which I’m sure your viewers are familiar with. We really believe in that at Harmonic.
To get to your question about how we started: sometimes we’ll start from pre-trained models. Ultimately, you want to do whatever optimizes that net present value of future cost of proof. So pre-trained models are great for that.
I think at some point you might ask the question,
“Is that going to bias you too much towards how humans do math?”
And so you want to mix in reasoning systems that are not trained from human knowledge, right? They have more entropy and more complementary knowledge.
That kind of thing we always play with, but it hasn’t really been the living factor so far. I think that pre-trained models are a great starting point.
Cool. I guess one thing: Goodfire just announced today that they raised a bunch of money at a unicorn valuation. I was a very small-scale supporter of theirs, and it got me thinking.
This also connects to Vlad’s comment where you said the system can sort of invent new theory.
Obviously, one big thing people have said AIs can’t do, or AIs can never do—which is always a dangerous position to take—is that they can’t come up with new abstractions.
Sure, they can learn from what we have done and what we’ve encoded into language, but will they ever come up with their own abstractions? I think that’s not a very strong, increasingly hard position to defend.
But what is so interesting with Goodfire is they’re now starting to look at model internals and unlock new kinds of understanding based on looking at what the model has learned.
The famous one they just put out is like new markers of Alzheimer’s that people didn’t know about, but the model was able to figure out, and they were able to figure out what the model had learned by looking internally.
I’m kind of wondering:
I mean, one of the things that I’m very excited about is eventually Aristotle powering a spacecraft, right? Much like HAL 9000, but a benevolent one, one that doesn’t go crazy. So, yeah, I think eventually you’ll see it expanding into more real-world things.
I think the… I don’t know if you’re as excited about that. A safe HAL 9000. A safe HAL 9000, I think, would be very valuable.
You know, to your question on interpretability, I think that interpretability is often used as a proxy for trustworthiness. So, a lot of the reason that people explore interpretability technology is that they can make sure that the system does the right thing or aligns with the user’s intent.
So, when it comes to trustworthiness, we made the explicit decision at the very beginning of the company to focus on Lean. By outputting our reasoning in a formally verified way, that is the most interpretable possible output. So, the computer can check it. If the human wants to understand how the proof works, they just keep hitting “go to definition.”
It’s almost like navigating through a code base. There’s no more interpretable way to output math than in Lean, really. That’s the maximal version.
So, now the question is, okay, well, how interpretable is the model? I think, in the context of the bitter lesson, we just focus on letting the system do whatever it can to optimize for computationally cheap proofs of more and more complex things, with a caveat that it has to output in a way that’s verifiable.
I think down the road, we’re very curious, how does it do math? How is it so smart? And we’ll look into that. But for us, we’ve solved the trustworthiness question upfront by focusing on formally verified output.
Yeah. Okay. That’s quite interesting.
I do sort of feel like, I have this one kind of mental—mathematicians are famous for visualizing things—my kind of visualization of what is happening in a large model is sort of like shrink-wrapping reality.
Like, you’ve wrapped in plastic all of, you know, all internet data or all the kind of whatever domain it is that you’re trying to learn at scale, and you’re just sucking all the air out of it and gradually shrinking down to whatever, hopefully, is kind of the true structure.
And it strikes me that in math in particular, that structure might be amazingly simple. Or, there might be really interesting things to learn by running that process and then kind of cracking it open and seeing what is inside.
I would expect it to be maybe a lot more interpretable internally than something that has had to learn all internet data and can recite Wikipedia and all that sort of stuff.
I actually think that what these models are doing is interesting because they’re smashing together all of the techniques that all mathematicians have done before.
And so, while I haven’t seen the spark of superintelligence yet where it’s some breakthrough eureka idea that’s incomprehensible, I’d say that if you push it in, learning how the models do things, you kind of ask it to solve more and more complex problems and just see, like,
I think that’ll be a lot more interpretable and comprehensible than trying to dig through the way it’s structured—I might be wrong, but that’s probably where I’d start to interpret how it does things.
Yeah.
So does that mean maybe we can kind of look at different levels of difficulty of problem?
We’ve got the Erdős problems.
There’s definitely a phenomenon happening right now where people are using either Aristotle by itself, or—I’ve also seen a lot of examples, not that many, but increasingly more, of GPT 5.2 Pro to sort of generate a proof in token space, then bring it over to Aristotle for formalization.
Then there’s, of course, the IMO.
If I understand correctly, everybody who—and I think it was just three, right?—that you guys, OpenAI and DeepMind, got the gold level performance. I think everybody missed the same one question, which is really interesting to me.
I’d be interested in your thoughts on,
“why that—why so consistent?”
And then, of course, we’ve got these extreme problems where you would need this sort of move 37-like moment to solve them.
So maybe kind of sketch out,
I mean, I think – so on the IMO, the three labs that announced gold medal performance—us, DeepMind, and OpenAI—all missed question six. And I think that it wasn’t super surprising to us because question six is probably, I don’t know, 5x harder even for humans, right? It’s just a more complex question with lots of steps, and it requires this type of spatial reasoning that right now is more difficult to encode in formal systems.
We were running our system on it quite a bit, and we felt like we saw signs of life. So it’s definitely not inconceivable that before too long, question six is going to fall and be gobbled up just like the other questions. I mean, even one year before, questions three and five would have probably been well beyond reach for most of the models. So I think it does appear to be more or less a smooth exponential.
Yeah, I agree with that. I want to highlight that there’s two aspects of this.
So I think years ago, if you had asked someone, “Hey, could you automatically formalize a number theory paper in Lean or Rock or Isabel, these other languages?” you’d have been laughed out of any room of mathematicians you’d be in. And today, we are seeing people upload the full text of a math paper and run Aristotle a few times. We’re thinking of adding a Ralph button to just keep going, keep going, keep going. And then you get a formal version of it.
I think that phase transition has essentially come and gone now because of Aristotle. So in the next couple of years, as AI keeps improving, the fact that we can now formalize the AI’s arguments obviates the need for the humans to just be the verifiers, right, just sitting there and checking if some output is correct, to ones being the tastemakers. So we’re the ones setting what problems to work on if we’re happy with the techniques used. So that, I think, is the interesting transition that’s happened. So smooth exponential capabilities, but I think we’ve gone zero to one on verification.
I think that’s such a great point because I think there was some debate about this at the beginning.
And in a way, if you look at DeepMind, they started with formal, with AlphaProof, which was the silver medal-winning model back in 2024. It was a great result at that time, and that was a formal model. And then they went back to informal for Gemini this year, and I’m sure they ran AlphaProof. Maybe it was just that AlphaProof didn’t do as well. OpenAI, obviously, informal.
But if you think about, okay, let’s say we go to a world five years from now, and the autonomous math being done by AIs increases. Instead of five to ten-page proofs, you’re starting to produce 5,000-page proofs, which you should assume, right, as these models can autonomously reason more and get more efficient, they’ll produce longer and longer output per unit time. It’s going to be a proxy for complexity.
Who’s going to review that? Nobody’s reading a 5,000-page math proof. So I think it’s becoming even more clear that the future is formal because you have this problem of someone having to validate it and check it. And we want to make sure that the time to validate it and check doesn’t actually grow linearly with the complexity of the proof.
Yeah, that was really the founding thought experiment of harmonics.
So we asked ourselves in 2023:
- These models can do high school math poorly, but they could do elementary school math poorly a year ago.
- What happens in 10 years if we ask it to prove the Riemann hypothesis?
Any model will make an attempt at it and give you 100,000 pages of output, which you might as well throw in the trash for two reasons:
No, you just can’t wrap your head around what is going on in that proof.
And so there were two hypotheses, both of which have been proven out:
If you compare the resourcing we’ve had compared to the big labs, we’re punching well above our weight at the IMO. So I think, in our view, the debate on formal versus informal is settled. I mean, clearly, it’s going to be formal.
One can debate, okay, what’s the most efficient way to train a model? There’s some aspects to informal that are helpful, but I don’t think we’re ever going back to a world where we’re like, “oh, it’s just going to be informal from here on out.”
I think the interesting question, though, is to extend this to software, right? Because the same things actually hold for software that hold for math.
Let’s say AIs are getting to the point where they can autonomously work and create a software project over a period of a week or multiple weeks. You know, who was it? The cursor team ran this and generated like a Chromium-compatible browser, right? It was something like one and a half million lines of code. It was incredible.
So who’s going to read that code and find all the security vulnerabilities and the bugs? And is that code in the future that’s generated by AIs going to be in Python and Java anymore? Like, why would it be in Python and Java? Those are just languages optimized for human readability.
And, you know, if the answer, we think, to humans reading and trusting something or even an AI that the model is collaborating with checking something is the same. You want to make the cost of verification as low as possible. And that makes us believe that the future of software is formal as well. And more and more software will be written in formally verifiable languages.
Yeah. And I think, you know, Lean is our favorite language. It would be amazing if everyone can write in Lean. I think that as AI writes more and more code, it will be easier for people to accept that. But we’ll see.
And I’ll start with mission-critical, important stuff where bugs are much more serious and much more costly. And there’s a bunch of domains that already are doing formal verification for software, but they’re doing it in a very artisanal way.
You know, they’re hiring Lean or Rock or Isabel experts and kind of painstakingly formalizing stuff. So I think you’ll start to see it accelerating the work of those people first, but then it’ll just diffuse and you’ll see, like, formal vibe coding before too long.
Yeah, I love the term vibe-proving, by the way. Yeah, I think that vision is an incredibly compelling one. And, you know, it’s also one that I’m still kind of wrapping my head around.
For listeners who haven’t already heard it, I did one episode with Kathleen Fisher, who was at DARPA, and I think now has just moved to ARIA in the U.K. to lead their whole operation. And Byron Cook, who’s like a legend of the formal methods field at AWS. And, yeah, they’re kind of right there with you, you know, envisioning this world of basically totally verified, bug-free software, starting with mission-critical stuff, but potentially extending to everything over time.
I guess one – so I think that is super compelling.
The one kind of nagging – I don’t know if it’s a worry that I have or what exactly, but I’ll just frame it as a question – is, like, if we are training an AI to be superhuman at formal reasoning, within the formal reasoning system that we have,
how do we get new abstractions from that or how do we get a sort of Einstein kind of moment where, you know, like, it seems that at some point we all sort of thought the world was just naturally 3D and that was, like, obviously intuitive.
And then it’s kind of come to light, obviously now, that, like, well, that was an adaptive understanding of the world that served us well as monkeys, you know, and allowed us to survive. But it was at – at the end of the day, we now know that it’s, like, a lossy approximation of true physics.
And so I’m kind of like, do we have any room for doubt or worry that the math that we have now, as sophisticated as it has become, might also at some point prove to be not quite the right paradigm? And is there any way – if you’re training in this, like, purely formal way, is there any way sort of to punch your way out of the box as an Einstein did, right? He seems to have –
“The fourth wall.”
So he broke the fourth wall conceptually, but the key thing to remember is that he was able to describe his theory rigorously and formally in the framework of differential geometry.
So the point I was making earlier about math being reasoning is the point I’ll appeal to now, which is to say that no matter what complicated theory somebody might come up with to explain how the universe works in the future,
If it’s going to be based on a series of logical deductions that can be explained to someone else and checked independently, that is itself a logic that can be encoded with Lean or other languages like Lean and then verified. So, again, the axioms that Lean is based on are so minimal and just expressing just the most basic possible common sense about how reasoning should happen, like, one thing might fall from another, or if two things look the same, they are the same.
That’s the level of axiom we’re talking about. So I really don’t think there’s any conflict here. I think that one should just think about formal reasoning as an especially detailed version of informal reasoning that a computer can check automatically. There’s no limitation to it. Sometimes it might be a little more verbose than you’d want, right? So you want to write tactics and things to cut down on that, but there’s really no fundamental tension to turn into.
And I think there, you also, you know, might be thinking about Gödel’s incompleteness, like the fact that in any sort of axiomatic system, there’s statements that are true and unprovable. And there’s also statements that are undecidable, right? And independent. So there’s sort of like a bunch of edge cases here, but I think it doesn’t prevent us from making a lot of progress and proving actually the lion’s share of useful things. I mean, there could be things that are unprovable but true that are very, very useful to know as well. But, yeah, no way to know unless you explore the frontiers.
Do you think there’s always going to be a role for entropy of some sort in these systems? I mean, I think hallucinations are a key part of a reasoning system. Hallucinations are what allow a model to explore something that has never been encoded by a human before.
So, you know, when we run Aristotle, whether it was at the IMO or noun, it makes a lot of mistakes. It tries a lot of paths that don’t work. But that exploration is the very thing that lets you get to the right answer after enough attempts. So entropy is crucial. I think this whole notion of seeking fundamentally hallucination-free LMs doesn’t really make much sense.
Now, of course, you want to pair them with a system like Aristotle that can verify things in 10. But, no, I think entropy hallucinations are a key part of the training process for models like this. You’ve got to be able to pose false statements in order to prove that they’re false. Learn like humans. You know, you try a lot of room for humans. Some of the most creative humans are the ones that hallucinate the most.
So what’s kind of the latest progress on the path to superintelligence? You said you, and I think this is true of all good frontier AI companies, whether, you know, at the application layer or the model layer or anything, any hybrid of those, you know, you’re updating your systems frequently. It sounds like there’s kind of a convergence of some sort going on between the tree search part and the informal lemma guesser that you described in the technical report. What can you tell us about kind of what the trends are right now?
I think a lot of the—well, just to review the progress, right? So we started in 2023 and then in 2025 goal performance, the IMO, we topped out this Verena benchmark at the end of the year with our public API users started solving Airdish problems, right?
So I think there’s a very clear trend, right? And, and capabilities. I think the phase transition I mentioned has also happened.
So I think what’s next for harmonic and for the field at large is, you know, a couple of things.
Well, we can expect math live to grow. So math live is the, think of it like the Wikipedia for math that’s computationally certified. So as Aristotle makes it possible to auto formalize a lot of math, you can expect that users will start contributing a lot of pull requests to math live. And that makes it possible to solve more and more problems on top of that base.
I think when we look at how mathematicians are using our API, certainly people are starting to work on more important unsolved conjectures that a lot of people would care about.
So you can kind of think about conjectures as like,
“Okay, there’s a conjecture that’s technically been open, but nobody really cares about it.”
So it’s not like people are trying all the time, but now you might have some conjectures that, yeah, like a mathematician might try it once or twice a year, just take a shot at it. Maybe a hundred mathematicians would.
And then eventually, but the millennium prize problems where, you know, any mathematician would be happy to spend years on it if they might be able to solve it. So I think what you can expect from Aristotle and other systems is, you know, more and more problems get picked off. So it becomes easier to use it extends to software, as I mentioned.
So we have users using it to check, say, decretable software, whether in Lean or other languages.
And overall, if I had to pick out just one trend, it’s really just that formal reasoning goes more and more mainstream. So as more stuff is produced with AI, I think you’ll see complementarily more formal reasoning to kind of verify all of it.
And I think on the product side, we’ve gotten a lot of feedback coming in from the folks using it. Obviously, whenever you’ve got customers that are using a technology like this, they’re very passionate.
So there’s lots of ways in which they’re still complaining about things and improving the ergonomics of it, making it so that people don’t have to hop between so many different tools. And we could just solve their problem as simply as possible and at the lowest possible cost. You should see that continue to improve.
There have been updates to the system pretty much on a daily basis. Maybe you’ve seen some of them just as you’ve been kind of experimenting yourself. But that is going to continue. And you should expect that it gets exponentially more useful over time.
So maybe a good place to close is kind of the vision for what that looks like as you succeed. I mean, obviously, one thing is solving Millennium Prize problems. But I’d love to get a little bit more of kind of an intuitive understanding than that.
I mean, one dichotomy that kind of comes to mind is this very formal reasoning-based paradigm versus what I think of as intuitive physics. It does seem like models are very good at developing intuitive physics in kind of any number of spaces.
Right. Like folding a protein with a model is not something that’s done in a formal way. It’s just kind of something where whatever kind of mess of heuristics they learn, they can do a protein fold orders of magnitude faster than we would be able to do it.
And if we were going to do it through a sort of physics-based simulation approach, when we think of no limit to math and what a mathematical superintelligence looks like, I also think Eliezer, once famously—or at least famous to me—said:
“A real superintelligence in his mind could look at one still image and deduce all of physics from just the information contained in that one still image.”
That kind of also connects, I guess, to test time training.
What is your vision? You can bounce off any of those concepts, but what is your vision of how this thing evolves? Is it an ever bigger tower of formal statements? Is there some role of new kinds of intuition, new abstractions that emerge out of that that aren’t so strictly defined but potentially useful?
You know, what is this thing doing in 2030 once all the Millennium Prize problems are solved?
I think that by 2030, we will have theoretical explanations for everything, basically.
I mean, if you look at the history of science, there’s leaps of intellect and leaps of data:
Right now, there’s really been a shortage of people that are able to reason logically at the highest level.
So when you think about unifying general relativity and quantum mechanics, it’s just a very hard thing to do.
I think what you’ll see is really like anything that can be posed mathematically, which is what underlies all of science, we’re just going to get theories for everything that are self-consistent and make sense.
I think we’ll then go back into a regime where we’re data limited. So, we might have maybe five theories that unify QM and GR, and we’ll have to run very high energy experiments to figure out which one is right.
We’ll have to wait a while to build those colliders. But at the very least, we’re not going to be bottlenecked anymore on wondering, “Can we explain something?”
We’ll have a system that can explain anything perfectly correctly. So it really will be a renaissance of science. You just remove the intellectual bottleneck in everything.
So do I understand that correctly? Basically, you’re envisioning:
Yeah, because AI is not omniscient. Whether it’s our model or others, they’ll be able to reason about anything they can kind of ground in their own logical deduction rules.
But ultimately, there are aspects of the universe where you just have to run the experiment and find out how it really works.
Wow.
Just to be clear, I think there’s a lot of utility before you get there. If I have to analyze asymptotically where we get to that, that’s my point. Well, I mean, that’s, we’ve heard about centuries of scientific progress collapse into five years. That sounds like more like a few thousand years, perhaps, of scientific progress.
Also, that’s left will happen, and then you just have to get more data. But you’ll have a superintelligent system that can help you. Wow. Okay. That’s about as grand of a vision as I’ve heard anywhere.
Do you guys worry about the safety of these systems? It sounds like we haven’t talked about that really at all in this context, but I’ve done many explorations of different safety concerns.
You know, Eliezer, when he described the model, whatever AI he was kind of envisioning, when he described it, understanding all of physics from a single image, he also thought that was going to be super dangerous because it would be so powerful.
How do you guys think about that aspect of this whole, I mean, we’re talking about a lot of stuff in the next five years.
I mean, I think right now we’re not so worried about it because the outputs of our system are constrained.
I think that you’re likely to see, like, the first dangers will probably look a lot like cybersecurity incidents, right? Because, you know, you have the models that are making API calls and running autonomously, interacting with other systems.
So that both creates API level cybersecurity holes and the mechanisms to exploit those. So I think you’re likely to see a lot of those.
I think for our model, since it’s basically just the interface to the outside world is tightly constrained, and it’s not just going to fire off a request to your Gmail account or the iMessage APIs, we’re a little bit further away from that. But, you know, you can imagine we’re going to have to start taking that much more seriously when we do get to a point where we’re connecting the model to the outside world and it’s, you know, speaking in the interfaces are not just sort of like lean files being outputted.
Yeah, I do think constrained action space is certainly one of my favorite paradigms for keeping things under control. But I mean, there’s a full like molt book, molt bot thing that has been fascinating to watch. And, you know, I think we’re entering a strange new world for sure.
And I think the benefit is we’re probably not at the danger frontier. So we’ll have the opportunity to learn from others’ mistakes, and hopefully they don’t screw up too badly in order for us to learn.
Yeah, okay, fascinating stuff. This has been fascinating stuff, guys. I really think the approach is really interesting.
The vision for how far we can expect, or even somewhat entertain the possibility of being in 2030 is arresting, and both inspiring and for me, a little bit scary.
Anything else you want to leave people with before we break?
I think for me, and you kind of see this in the values that we put on our website of what we care about:
You know, that’s what we believe in and in the world that we’re helping — the future that we’re helping bring to life.
Yeah. And I think just to add to that, for me, when I started using Aristotle, it was very different to have an experience where the output’s always correct. And so I think if people haven’t experienced that before, they should just try it out. It’s a free to sign on for.
Cool.
Well, there’s, I’m sure there’ll be plenty of ways to monetize mathematical superintelligence when the time comes. We might do ads, you know.
Yeah. I can’t wait for that.
All right. We’ll do those anthropic ads to life.
Fascinating stuff, guys. I really look forward to watching your progress. Thanks for both the remedial education and a grand vision today. It’s really extraordinary. What a time to be alive.
Vlad Tenev and Tudor Akeem, co-founders of Harmonic. Thank you both for being part of the cognitive revolution.
Thanks for having me. Pleasure to be with you.
If you’re finding value in the show, we’d appreciate it if you’d take a moment to share it with friends, post online, write a review on Apple Podcasts or Spotify, or just leave us a comment on YouTube.
Of course, we always welcome your feedback, guests and topic suggestions, and sponsorship inquiries, either via our website, cognitiverevolution.ai, or by DMing me on your favorite social network. The cognitive revolution is part of the Turpentine Network, a network of podcasts, which is now part of a16z where experts talk technology, business, economics, geopolitics, culture, and more.
We’re produced by AI Podcasting. If you’re looking for podcast production help for everything from the moment you stop recording to the moment your audience starts listening, check them out and see my endorsement at AI podcast.ing.
And thank you to everyone who listens for being part of the cognitive revolution.
2026-02-12 08:00:01
The programming language after Kotlin – with the creator of Kotlin
Why would anyone create a new programming language today if AI can already write most of your code? Andrey Breslav has an interesting answer.
Andrey Breslav is the creator of Kotlin, a language that runs on billions of Android devices and is one of the fastest growing languages in the world. Today we cover how Andrey designed Kotlin by deliberately borrowing ideas from Scala, C Sharp, and Groovy, and why he considers leaving out the ternary operator one of his biggest regrets.
We also discuss why making Kotlin interoperate seamlessly with Java was a gigantic undertaking, and what it took to get it done. Kotlin adoption went through the roof after Google announced it as the official language for Android, in a move that even took Andrey and the Kotlin team by surprise.
Andrey’s new project, CodeSpeak, is a new programming language built on English, designed for an era where AI writes most of the code. If you’re interested in the future of programming languages from someone who built one of the most loved languages of today, then this episode is for you.
This episode is presented by Statsig, the unified platform for flags, analytics, experiments, and more. Check out the show notes to learn more about them and our other season sponsors, Sonar and WorkOS.
Andrey, welcome to the podcast. Hello. Thank you for having me.
It is not often that I meet someone who designed such an influential language across mobile and backend. So let’s start with: how did it all start?
Okay, so that was a little messy because I went to school back in St. Petersburg, studied computer science, and I didn’t really know exactly what kind of programmer I wanted to become. I knew I wanted to be a programmer. At some point, while I was still at the university, I started teaching programming in school. It was a big, passionate hobby of mine.
At some point, I got a job with Borland and worked in some developer tools. That was awesome. Borland was a very big name, though they went under pretty soon after I joined. I hope it wasn’t because of me.
I worked at the tail end of the UML era, doing developer tools in the UML space. That was very interesting. I learned a lot. But then Borland went under, and I went back to teaching full-time. Then I started PhD school. All that was kind of not really planned out.
In my PhD, I was working on domain-specific languages (DSLs), and generally, I was interested in languages. I was curious about typed languages specifically. I was always curious about how these things worked, but never really serious. When I started looking into DSLs, it was slightly more serious. Although my PhD was a mess and I never defended because of that.
At some point, someone reached out — he was actually a person who was in charge of Borland’s office in St. Petersburg. By that time, he was already at JetBrains. He reached out to me while I was in Tartu, Estonia, where I was a visiting PhD student for a year. It was a lovely time.
He invited me, during my next visit to St. Petersburg, to visit the JetBrains office and talk about something related to languages.
What I thought was that it was about this project called MPS (Metaprogramming System) that JetBrains had. I knew about it. It’s about DSLs. I worked on DSLs; it was plausible they wanted to talk about something like that.
But I was completely wrong.
What they wanted was to start a new programming language.
I was completely unprepared for that. I had never thought about doing something like this. My first reaction was:
“You don’t do new language. You don’t need it.”
The basic pitch was that the Java ecosystem needs a new language. Java is outdated, so on and so forth. We can talk more about this.
It was 2010, I think. I said, “but there are other languages. Everybody’s doing fine. Why do you need to do that?”
Then this conversation was actually very insightful because the guys at JetBrains explained how things actually were. It was a big problem by that time.
So Java didn’t really evolve and hadn’t been for a long time.
What was the reason behind this? Can you take us back for those of us who are not in the ins and outs?
Yeah. So the last major version of Java by 2010 was Java 5, released in 2004 — a six-year-old language. Since then, there were updates. Java 6 made no changes to the language at all. Java 7 made minor changes. In parallel, other languages — especially C Sharp — were progressing very well. And by 2010, C# had all the nice things. There already were lambdas, like header functions and all that nice stuff. There were getters and setters and many other things that made the language much nicer. And Java was felt like it was standing still. There was a project to work on lambdas for Java, but that was in the works and had been in the works for a long time and only came out in 2014. So that was the situation.
And, you know, the ecosystem didn’t stand still in the sense that other people were building languages. And there was Scala, there was Groovy. And, of course, people at JetBrains knew both Scala and Groovy. They built tools for them.
It’s traditional to build your tools in the language you’re building the tools for. So the Scala plugin was built in Scala. And there was a lot of Groovy used in JetBrains as well. So they knew what the issues were with the language. And both languages are very interesting and very good in their own ways.
But they saw an opportunity in the market because basically Groovy was too dynamic and too far from, you know, hardcore, mainstream, large-scale production. Because dynamic languages are not for that, basically.
What are dynamic languages for? What are their strengths and best use cases? The trade-off, I guess, if you look at a statically-typed language like Java, Kotlin, and Scala, for example, versus dynamic languages like Python, Ruby, JavaScript, and Groovy:
And this may be changing nowadays a little bit. And this is in part what I’m working on now. But back in the day, it was completely true. The whole art of making a good language was to restrict the user in a good way.
Yeah, but in any case, the situation with dynamic languages is that they are much more user-friendly in the beginning. But then when the project scales, you’ll have trouble making large refactorings. You have trouble making sure that everything works together. You need to do a lot more testing and rely on other things like that.
As opposed to static languages where you have precise refactoring tools and other things that can make sure that at least a certain class of problems just doesn’t happen. And, you know, this is why, at least in our mind back then, it was absolutely clear that if we’re building a language for large projects, big teams, so on and so forth, it has to be a static one.
So with Groovy, that was a big issue of performance as well, because Groovy was building a dynamic language on top of a very static runtime. So there was quite a bit of tension there.
That wasn’t the Groovy side and the Scala side. Scala is a wonderful static language and incredibly powerful and with tons and tons of good ideas. But it had its own problems. It relied very heavily on implicits, for example. And I have a history of debugging one line of Scala for an hour to try and figure out what it does. Just because it was pretty complicated.
Also, the compiler was very slow and there were issues of stability, and many, many things were just not accessible enough for a lot of engineers. So from the experience of using Scala, JetBrains, my colleagues basically understood that it’s not what’s going to change the industry. Although Scala got a lot of adoption.
And again, like Martin Odersky, he is a great language designer. And I think one of the biggest use cases was old Twitter. A lot of it was built on Scala and they scaled to massive scale, etc. And I think LinkedIn as well.
So in any case, these were, you know, it’s always very nice when other languages kind of pioneer things. And then you can build on top of their successes and failures. And we were in that position, basically.
So the argument that people at JetBrains were making was basically that there is a window of opportunity. People need this language. We, JetBrains, are the company who can actually put out a language and make it successful because:
- We have access to the users.
- We have their trust.
- We can make good tools.
And it was another issue with Scala, for example. It was very difficult to build tools for Scala back then. Now Scala 3 is more tooling-friendly, but back then it was a nightmare.
Like, I said that, you know, if you have a static language, you can’t have precise refactorings if the language is too complex. And some languages are particularly challenging. So Scala back then and C++ were incredibly challenging to make precise tools for.
So, and that was the basic pitch. And I quickly understood that, yeah, they were right. And this was something that was worth a shot in the sense that it was not completely hopeless, not completely dead in the water. I had no idea if we could pull it off.
It’s, it was then when we actually sketched some initial features on the whiteboard.
Just because JetBrains is genuinely run by engineers? Hold that thought from Android on how JetBrains is genuinely run by engineers. This is because I happen to know another company also run by engineers: Sonar, our seasoned sponsor.
If there’s a time when we need true engineers, it’s now. As AI coding assistants change how we build software, code is generated faster than before. But engineering basics remain important. We still need to verify all this new AI-generated code for quality, security, reliability, and maintainability.
A question that is tricky to answer: How do we get the speed of AI without inheriting a mountain of risk?
Sonar, the makers of SonarQube, has a really clear way of framing this:
Vibe, then verify.
The vibe part is about giving your teams the freedom to use these AI tools to innovate and build quickly. The verify part is the essential automated guardrail. It’s the independent verification that checks all code, human- and AI-generated, against your quality and security standards.
Helping developers and organizational leaders get the most out of AI, while still keeping quality, security, and maintainability high, is one of the main themes of the upcoming Sonar Summit.
It’s not just a user conference. It’s where devs, platform engineers, and engineering leaders are coming together to share practical strategies for this new era. I’m excited to share that I’ll be speaking there as well.
If you’re trying to figure out how to adopt AI without sacrificing code quality, join us at the Sonar Summit. To see the agenda and register for the event on March the 3rd, head to:
sonarsource.com/pragmatic/sonarsummit
So everybody I talked with was deeply in the weeds with IDEs and everything in new programming languages very well. We had a very technical discussion.
I don’t remember exactly all of the features we were talking about, but the current syntax for extensions in Kotlin was already there. I don’t remember why exactly we focused on extensions, but it was there.
So, from day one, we’re basically building on top of ideas from other languages, like extensions obviously came from C#.
Yeah, so it was a very exciting conversation, but I didn’t make a decision then because I was in Tartu and I needed to finish there. It took me a few months to finish.
Then I came to St. Petersburg for one month because after that I had an internship scheduled with Microsoft Research in Redmond. I was going to Seattle to stay there for about three and a half months.
I said, “Okay, guys, I have this month. I can work in the office and we can try to sketch things, but then I’ll go into Microsoft and then I will decide whether I commit or not.” Which in hindsight, I made the right decision in the end.
I had a great time for this month or so. I worked with the guys in the office — it was mostly Max Shafirov we were working with and it was incredible. We had such great discussions and I actually saw Max this morning and it was like, it was great time.
So then I went to Seattle, did something completely different. There are Microsoft researchers, some really great researchers working there, actually was exposed to the top notch level of academia for the first time — was very insightful.
But after that, I kind of realized what the question was: whether I want to try to pursue an academic career, which I didn’t feel like I was really built for and was not sure whether I can be a good researcher on my own or I’ll have to follow in somebody else’s footsteps.
So for those of us engineers, which will be the majority who have not built a language from scratch, how do you start with it? Like, speaking for myself, I know how to:
How does a language start?
In our case, we basically talked a lot for a few months. I think not everyone is like that, but I think the best when I’m talking to people.
This was the ideal environment because we were basically discussing things with the Macs constantly for many months. There were a few internal presentations that I made at JetBrains and some of the slides survived.
I can see, including my spelling mistakes in the slides — my English wasn’t as good then — and you can see some of the evolution through those slides. I think there’s a recording of one of those presentations.
So we were basically doing whiteboard design for some time. And the great thing about doing this at JetBrains was that there were a lot of people with opinions about not so much how to make a language, but what problems do programmers face and what they like and don’t like in other languages. So I had tons and tons of input from other people and very good people. So that helped. And I really, I don’t think I realized how special that environment was back then. Like I was 26, to be clear. And I had no idea how things were done in general. But somehow these people just trusted me. I’m not sure it was very rational on their part. It worked out. But I’m not sure I would recommend anyone to do this.
And so in the first few months, I understand that you kind of whiteboarded and wrote down how you want this language to evolve. You kind of, you know, like wrote out like,
“We’re going to have these features. Or how can we imagine?”
So I guess the easiest way to explain this would be like this. It basically went off what the pains were with Java. And there were quite a few. And there was a lot of experience of using Java across the community and inside JetBrains. And we kept making lists of things we wanted to fix.
I came up with some ideas and some other people suggested other ideas about how things can be fixed, what is an actual problem, and what we don’t care about, and so on and so forth. For some time, I was just, you know, pieces of the puzzle basically laid out on a table without fitting together. And then at some point, we started fitting them together. I was just doing a lot of that in my head, which is not the best way. But this is how I knew how to do it.
There were also some crazy ideas that we thought were important back then. For example, I wanted to implement multiple inheritance, fully-fledged multiple inheritance, which was a dumb idea. And multiple inheritance meaning that a class can inherit from like several classes, and you have to take care of like conflict resolution and all sorts of edge cases. Right? Yeah.
The actual challenge is not so much conflict resolution in terms of methods, but initialization of state. Constructors are really hard. And it was actually someone outside of Gibbons who explained to me that was a very bad idea. And I’m very grateful to them. Yeah. So, you know, there were crazy ideas as well. And some of them just fall off over time as we were discussing or prototyping.
I think I started writing code maybe six months in or something like that. Maybe a little earlier than that. I started with a parser. And it was actually a very unique way to start a language because the idea was to start not with a compiler, but with an IDE plugin. I have it in the editor first, which is, you know, an IDE plugin shares a lot with the front end of the compiler, so it’s not absolutely crazy. But I was just relying a lot on the infrastructure that was available in IntelliJ IDEA.
All the parsing infrastructure, and it was awesome. Like, the parsing infrastructure in IntelliJ IDEA is better than anything else in the world because it’s the heart of the IDE. It has to be incredibly fast and very robust and so on and so forth. But then later, someone who knew the infrastructure a lot better than I do had to factor that bit out to make the Kotlin compiler autonomous. And it was Dmitry Zemirov who did that. And he’s an awesome engineer. Like, he’s probably one of the best people to refactor a large code base and, like, take this one bit out of something that was already 10 plus years old back then.
So we started with this IDE plugin. I think Max wrote the scaffolds and I actually plugged in the parser and everything. And that was an interesting start because it was very interactive. So I could show off the language as if it existed because it had some tooling. But I couldn’t compile anything in the very beginning. And that was actually a very good way to experiment with the syntax.
But then soon after, I started working on a full-fledged front-end and on some translation. And Dmitry and Alex Kachman were working on the back-end. Everybody was part-time.
When you say you work on front-end, and they work on back-end, in a language context, what does that mean?
It’s slightly different in different languages.
Basically, the front-end is what deals with the:
And the back-end is what translates to the executable code.
In our case:
Front-end:
- reading the text
- parsing
- doing types
- all that
Back-end:
- generates Java bytecode
And Kotlin has multiple back-ends for different target languages:
At that time, nobody was full-time working on this project. Even I was part-time, a PhD student, part-time Kotlin developer. And it was the very early days.
Then, at some point, I gave up my PhD and focused 100%. Which was also, like, isn’t it a weird decision to start a new language part-time? Yeah. Looking back, I was young and stupid.
There’s a saying that we didn’t do it because it was easy. We did it because we thought it was easy. Absolutely that. I didn’t realize how hard the problem was. I also had an unreasonable amount of hubris. I just thought I knew how to do everything. I didn’t. But it worked out in the end.
So, when the language started, what did you call it internally? There’s always internal code names, right? Right, yeah.
So, I don’t think there was a discussion of this first name at all. It was generally understood that the language will be named Jet. And it was logical. We had all the code base using the name Jet. We had:
Then someone realized that the name was trademarked by someone else. It was actually people we know there in Novosibirsk in Russia doing something. It’s not a language, but it was a compiler, and we couldn’t use it.
This is when we started looking for another name. It was very painful — looking for names. Guys, this is so bad. It’s one of the worst things because you never know what name will work unless you want to do an extensive study.
And then all the good names are taken, of course. Then some of the names that are not taken are not taken because they’re not really Google-able.
Some people are just very brave. People who named their language Go. This is why people now call it Golang because otherwise you can’t identify it. It’s a verb in English, a very common word.
Yeah, so we had weird options. In one of my old presentations, I found a list of early names:
And those weren’t great.
By that time, other languages were popping up. One of the alternative languages was called Ceylon. The logic was: Java was the island of coffee. And Ceylon was an island of tea.
Dmitry Jemerov basically looked out of the window and said,
“OK, we have an island here in St. Petersburg. In the Gulf of Finland, there’s a big island called Kotlin.”
And it’s a good name in the sense that it’s very Google-able. Nobody uses it for anything. It’s very recognizable. It’s not super smooth for many languages, but it’s kind of OK.
Nobody was in love with that name and we were kind of hesitant.
You know, “Kot” means a bad thing in German. Also, there is like some negative connotation in Mandarin, I was told, or something like that. You know, it’s always some language has some nasty association with any word.
We basically were super hesitant. So when we announced, and we had this deadline, that we were basically putting this off, when we announced, we were still not sure.
So we called it, we decided it would be a code name. We called it Project Kotlin to have wiggle room to later replace the name — but it stuck.
The first thing we did was put out basically a Confluence page with a description of the language. It was just a bunch of wiki pages and there was no compiler available then, I think.
There, the word Kotlin appeared many, many times. I was like,
“My God, this thing doesn’t, like, I can’t do search and replace and then change the name everywhere.”
So the workaround that I came up with was to create an empty page called Kotlin. And so it had a name. And then everywhere else, you mention it as a page. When you rename a page, it gets renamed everywhere.
This is why there was an empty page called Kotlin in that documentation. But yeah, the name stuck and it turns out to be not a bad name.
So, when it started, what were the main differences with Kotlin compared to Java? Because Java was, what was the big one? How did you explain to developers who initially started onboard or wanted to give it a go?
Yeah, I guess there were a few major selling points. Then there were other things on top of that. When we started, like in the very beginning, we didn’t have null safety in mind. Null safety came a little later.
After one of the internal presentations, it was Max Shafirov who invited Roman Elizarov, who later was the project lead for Kotlin. Roman came and listened to the presentation, gave some feedback, and said something like,
“Guys, if you want to do something really big for enterprise developers, figure out null safety.”
And we did. It took a while.
So in the very beginning, it was the general idea of what makes Java feel so outdated. There were a bunch of things. Lambdas were very big. The general, like, the general feeling from Java back then was it was very verbose. It was called the ceremony language. A lot of people were grumpy about too many keywords, like public static void main is something everybody was really grumpy about.
But also, there were getters and setters for every property. There were constructors and overloads and all that stuff that looks like boilerplate because it is. Yeah. It’s super annoying to type out.
The problem with boilerplate is, on the one hand, it’s annoying to type out. But tools can generate it for you and fold it and so on and so forth. But the bigger problem is always readability. So reading is more important. Reading code is more important than writing code. We do a lot more of that.
And with boilerplate, it’s terrible because if some tiny thing is different in the middle of completely standard boilerplate code, you’ll miss it. You’ll become blind to it and you can debug for days not seeing that. So, you know, that was the point of sort of modernizing Java, making Java programs be more about what they do and less about the ceremony of making the compiler happy, basically.
And, you know, type inference was also a big thing because Java was repeating types a lot and many other things like that were, like, semicolons. The modern languages of the time already got rid of semicolons. And so in Kotlin you also got rid of it?
Yeah. So we got rid, basically, in terms of syntax, we got rid of semicolons and duplicated types. And that was a lot of noise across the code.
What does it mean that Java had duplicated types?
So in that version of Java, when you declare, say, a local variable, you say it’s a list of string called strings equals new array list of string.
Oh, yes. I remember this one.
Yes, yes. You need to type it out twice. And if you get one of them wrong, compiler, et cetera.
Right. So, and at best, you could omit the second mention of string by using a diamond operator, but that only came later, you know. Basically, it was very verbose, especially if your types are long.
So, and a bunch of things like that were really annoying to a lot of people, especially compared to C# or Scala.
So, we did all of that. And then, on top of that, there were other value-add features and null safety was a big thing that we spent multiple years actually on implementing. And I think it’s one of the main differentiating factors now for Kotlin alongside of with extensions and other things. But null safety is one of the core features.
And can we just spell out why null safety is so big?
I mean, I just today I came across a bug on the, I couldn’t send a package because in JavaScript on the Dutch post website, there’s a null issue happening in production.
But, you know, before Kotlin and a lot of languages, why is it such a big problem?
It is.
Yeah. So, dealing with null references is a big hassle in most languages. And I think it was Tony Hoare who called it the “billion-dollar mistake” at some point because, like, introducing, I think it was about introducing null pointers to C or something.
So, basically, when we look at all the runtime errors that we have in Java code, I think null pointer exceptions will be at the top. So, you know, the type system of the language is supposed to protect you from those unexpected errors.
So, there are errors you’re designed for and maybe errors that are not even your fault, like a file system error or something like that. But there are also errors that should be prevented by the compiler. So, for example, class cast exception or missing method error are things that the compiler is trying to protect you for. It’s trying to make sure that this never happens in your program unless you switch off the check by making an enforced cast or something.
And with nulls, it’s not a thing in Java. Like, anything can be null, and if it’s null, it will just fail. Yeah. It throws an exception and the program dies. So, it’s a very common thing.
So, a lot of people are kind of used to it, and there are different ways of being disciplined about it and so on and so forth. But, basically, this is a plague across any code. You know, there are different approaches to this.
And in Kotlin, we took the approach of:
- A: enforcing it in the type system,
- but also making it free at runtime.
What does that mean, that you made it free?
So, one very common way of dealing with nulls is to use something like an option type, where you have a box, which might be empty, or might have an object in it.
No. And that box is not free. Like, you have to allocate it, you have to carry it around everywhere. And, this easily creates a lot of objects in the old generation for the garbage collector, so it can be challenging. What we did was just have a direct reference at runtime; our nullable or not null reference is the same as Java’s reference.
All we do is compile-time checking and some runtime checking when we cross the boundary. But that’s a lot cheaper than allocating objects. Although the runtime is getting better, and they can optimize some of those objects away, it’s still an overhead.
What are features that you took in from Kotlin that were inspired by other languages that you admired?
A lot of them. I have an entire talk about this. It’s called Shoulders of Giants. We really learned from lots and lots of languages. And it was always the point. Andre just mentioned how Kotlin was built on top of the shoulders of giants, taking good ideas that existed, not reinventing them. This was one of the reasons Kotlin succeeded as much as it did.
But jumping forward from 2010 to 2026, one thing that is totally different today is the speed of things. AI is allowing nimble teams to build faster than ever before. Companies that used to take years to move into the enterprise are doing it in months.
This speed creates a new problem:
These show up almost immediately. This is where WorkOS, our seasoned sponsor, comes in.
WorkOS is the infrastructure layer that helps AI companies handle that complexity without slowing down.
Features include:
- SSO for enterprise buyers
- MCP offer agenda workflows
- Protection against free trial abuse with Radar
Teams like OpenAI, Cursor, Perplexity, and Vercel rely on WorkOS to power identity and security as they scale. If you’re building AI software and want to move fast and meet enterprise expectations, check out WorkOS.com.
With this, let’s get back to Andre and how Kotlin was standing on the shoulders of giants.
So the slogan for Kotlin was “pragmatic language for industry.” The pragmatic bit, which is a nice rhyme with your podcast, was kind of coming from the experience with Scala being called an academic language. A lot of people had trouble getting their heads around many of the very smart tricks in the design.
And so our idea was:
“We’re not doing academic research here. We’re not trying to invent anything. If we don’t get to invent anything, it’s a good thing, not a bad thing.”
From the engineering perspective, it’s generally a good idea to do this. Usually, you end up making something new, but most of what you’re doing shouldn’t be very new because you want familiarity. You want people to easily grasp what you’re doing. This has to be familiar from other languages.
Also, if you’re building on top of the ideas of other languages, you benefit from them having tried it already. You can look at their designs, their community’s reactions, and the implications all over the place. That gives you a huge benefit.
So we did a lot of that.
I think the language that influenced Kotlin the most is, of course, Java. Because the entire runtime of Kotlin is the JVM, and we depend on that.
Apart from that, Scala had a huge influence. We used many ideas from Scala, including:
vals and varsIt’s a huge pity that this didn’t make it into Java design. It was flipped at the very end of the design process to what Java has now. The Martin Odersky idea was much better.
We had to fix this problem on the Java boundary and figure that out.
There were many ideas we took from Scala, and that was very helpful. We usually transformed those ideas a little bit to adapt to our setting and to build on the knowledge of how it actually works in practice. We left some things out. We simplified some things.
For example, Scala had traits. Traits are a very powerful construct, like an interface where:
What you couldn’t have were constructor arguments. You always have a default constructor and can initialize all your fields.
It’s not as bad as multiple inheritance in C++, but it’s still a little complicated when it comes to the order of calling constructors. We decided we don’t want to deal with that. It’s a complex algorithm and hard to explain. Let’s just get rid of the state in interfaces and only have method bodies. And I think it was a good compromise. Especially given that Java ended up in the same place. It was easier to integrate.
Yeah, so Scala was a big influence. C Sharp was a very big influence. Extensions, of course. And we learned quite a lot from how C Sharp compilers do things.
There, there was also one particular trick that makes Kotlin syntax a lot nicer, nicer than Java’s and nicer than Scala’s, that we’ll learn from C Sharp. And it was actually my colleague who worked on the C Sharp IDE who told me about this, which is basically a super pragmatic thing they do in C Sharp.
There is like, when you call generic functions, you use angle brackets inside an expression. But the thing is that there is no such thing as angle brackets. There is less and greater. Right? And the parser can easily get confused and think that this expression, since we’re not in a type context, it’s an expression context. This expression is a comparison. It’s not an inequality, right? It’s not a call. And this is mathematically unresolvable. It’s an ambiguous grammar.
Yeah, look, you can do anything about it. And the way other languages handle this is:
collections.<Type>functionName().
Really awkward. Which is kind of weird.And we did the same or something very similar, and it just works. And the syntax is very familiar and very intuitive, and we’re very happy about that.
Yeah, because when you read it, as a person, I never get confused. Like, this is not a smaller sign. Like, I know it’s a generic. Yeah. Yeah.
Okay. Wow. Most of the time, it’s not a practical problem. And there is a way to disambiguate, if you like. So C Sharp was a big influence.
Groovy was a big influence as well. JetBrains used Groovy for build scripts. And there were incredibly useful patterns in the Groovy syntax that they call builders, which is not about building programs, but, you know, building objects.
And this is what inspired something fairly novel that we did in Kotlin, which was typed builders, where we had the same syntactic flexibility, or almost the same syntactic flexibility, as Groovy, but it was all typed. And we could make sure that all the arguments matched and so on and so forth.
So all that side basically was inspired by how Groovy people did this and reworked into a typed setting. And this is why we have, for example, extension function types. And this is why we have dangling lambdas and other things that are actually very nice syntactic constructs.
So, yeah, many, many things came from different languages.
A less known language called Gosu, I think it was what inspired us to do smart casts.
What are smart casts? Oh, yeah. So, I think smart casts are one of the nicest things a compiler can do to a developer. Because it’s a very common situation when you say:
If x is a string (so you do an instanceof check), then do something with x.
The annoying thing is that in a lot of languages, you have to cast x to string again. Like, you’ve done the check. After you’ve done the if, you know it’s a string, but then you need to write it out again.
Yeah, so you’ve just done the check, but you have to say string again to make the compiler happy.
So, smart casts basically get rid of that. So, that cast gets figured out automatically. So, if that’s a string and then inside the bracket, you can now use it because it’s a string. Yeah, you can use it as a string.
And isn’t it an easy thing, right? So nice. Yeah, it’s a very nice thing.
Yeah, it’s a pretty complicated algorithm. Because, you know, variables can change values and the check that you’ve just made can go stale. And, you know, there’s a bunch of algorithmic trickery around this.
And you can’t do a smart cast on any expression. It has to be a certain type of expression that can be stable enough and so on and so forth. But, you know, it’s a very nice thing. And you can get rid of so much noise in the code because, like, all the code in the world is riddled with this instanceof cast. instanceof cast.
So, we wanted to get rid of that. And it worked. And it was fun to implement.
What were things that you looked at other languages, you considered, maybe we should bring it in. But you, after debate, you’re like:
“No, let’s just leave this out.”
Like, not all of them, obviously, but some of the big ones that kind of came close. We had a design for pattern matching in Kotlin that was inspired by functional languages like Scala and Haskell and others. But at some point, early on when I was still working on the parser, I just realized that this is a huge feature.
So, when I was sketching it out on a piece of paper, it looked like a very useful thing, just another feature in the language. But then when I started working on the parser, I realized it’s an entire language in size. Like, you have to create a parallel universe in syntax for pattern matching. And I was like, okay, this will be a lot of work. Let’s postpone it.
Later on, when we were doing review for 1.0 or maybe a little earlier than that, I just realized that smart casts plus we have something called destructuring together give us like 80% of all the good things pattern matching can do to normal developers. Then there is another group of developers that can be very vocal, mostly compiler developers and people super into functional programming. They have a point, but that point is only relevant to them, and there are not very many, so we decided to not have pattern matching back then.
And, you know, maybe there comes a day that pattern matching gets added to Kotlin. And pattern matching is, is it in the case? Yeah, it’s the… So you can have, like, a lot nicer case statements, a lot more expressive ones, right? Yeah.
Generally, Kotlin has this compromise where you have our version of switch case, which is called when, and you can have smart casts there. So you can say:
That kind of gives you a lot of the niceties of pattern matching, but some things you can’t express like that. And that was, I think, a good compromise because it’s a really big feature. It’s hard to design well. There would be a lot of work on the tooling side. But maybe it gets in the roadmap one day. I’m not sure.
Java is trying to get towards pattern matching, so we’ll see. Maybe they kind of make it more mainstream.
Why did you omit the infamous ternary operator, which is when you write out something with the question mark and the colon, and it confuses new developers every single time if you’ve not seen it before? Yeah. Was it for readable reasons?
This is the saddest story I think in the design of Kotlin. I didn’t realize how much people liked it. The reason was, Kotlin used this principle from functional languages that everything we can make an expression is an expression. So if is not a statement, and the ternary operator is sort of a patch on the design of C and other C-like languages that makes an if expression, basically.
The logic was:
okay, we have if as an expression already,
can we just get rid of this extra syntax construct,
especially given that it's using very precious characters?
Like, there is a question mark and a colon, and we might find some other use for that. So we decided to not have it. We used question marks for nullable things and the colons for types and so on.
But it turned out that if as an expression is pretty verbose; people don’t like it. I resisted for some time, and then by the time I agreed, it was too late because you can’t retrofit the ternary operator into the current syntax in Kotlin—it just doesn’t agree with how other operators have been designed.
So you’re actually sad about it not being there a little bit? Yeah, I think in retrospect, it was a mistake because pragmatically, it’s more use than harm to have it. But we just can’t retrofit it.
What are some other interesting features that you like about the language that you added that we could explain for those who are not familiar?
Okay, so the good ones, there’s quite a lot of them. One feature that is not a traditional kind of language feature is Java interoperability. That’s probably the single thing we spent the most time on. And I always say that 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.
Interoperability means that from Kotlin, you can invoke Java, and from Java, you can invoke Kotlin. You do a bunch of work there, but it just works in the end as a developer. You don’t need to think about it.
The idea is whenever you have a Java library somewhere in the world, you can always use it from Kotlin. It was a big selling point because if you start as just a language in a vacuum and you don’t have any libraries, that’s not a good start.
In this direction, definitely, it was an absolute requirement for Kotlin. But also, we had the requirement to go the other direction. In an existing project, you could just rewrite parts of your code from Java to Kotlin, and everything keeps working. And some libraries actually did that. Many projects started using Kotlin bit by bit.
A lot of people started with just writing tests. But then, you start adding things in Kotlin, new things, for example. And all the Java code around that has to transparently use the Kotlin code. So we put a lot of effort into that. And that was fun.
Can you explain to us as engineers, like, it sounds like it was a friggin’ big project. What is the work, right? Because from the outside, again, I’m just being your average developer, where I’m invoking a Java class.
And things I can think of are:
What is hard? Tell me, tell me. I’m dying to know.
So one thing to note here is that we don’t control the Java compiler. We somehow need to make it work so that in your Java code, you make a call into something that only exists in the Kotlin source. And the Java compiler somehow agrees to call it to begin with. It’s not a Java file. It doesn’t know it exists.
So the way it actually works is: when we build a mixed project, what we do is we first compile all the Kotlin code. That can depend on the Java sources in the project. So we have a Java frontend baked into the Kotlin compiler so we can resolve everything in the Java code. Then we produce class files, binaries for the JVM that the Java compiler can read. So when Java compiles, it takes Kotlin sources as binaries. And this is how it works.
We would have to implement a Java compiler otherwise. Fortunately, Java has separate compilation, so this works.
This trick means that whenever you have tooling, like in your IDE, for example, when you navigate from Java sources to Kotlin sources, it has to be a special trick. Someone needs to go and teach the Java world to know about the Kotlin world.
Of course, the IDE doesn’t do the compilation to navigate. But at compilation time, we don’t control the compiler. So we did our own IDE. This way, we could do something about the Java tooling, but we couldn’t do anything about the Java compiler. So that’s trick number one.
Then, when it comes to incremental compilation, it becomes even funnier because Java incremental compilation is a complex algorithm on its own. Now we are incrementally compiling two languages at once. And that’s fun.
Incremental compilation algorithms are generally a very messy, very complicated heuristic with tons of corner cases. So, that’s like one example.
But then you start making interesting new things in Kotlin. You need to expose them to Java. You need to make sure that whatever fancy thing you have, Java can actually interoperate with that.
One example would be Kotlin’s approach to making Java collections nicer in Kotlin without rewriting the collections using the same library. Java collections are what’s called invariant because they’re all read-write. So if you have a list, it always has a set method.
That’s a little bit of a problem because whenever you have a list of objects, you cannot assign a list of strings to that. That’s annoying because you want to be able to represent a list of anything, and for that, you need to play with question marks, wildcards, and stuff like that.
It would be very nice if we had a read-only list interface that doesn’t have a set method. Then there is no problem in assigning a list of subclasses to a list of superclasses. But this interface doesn’t exist at runtime, right? We can’t just invent it. Or can we?
So we actually can. No.
In the Kotlin compiler, we have this layer of trickery specifically for Java collections where Kotlin always sees Java collections. If they come from the Java world, they are read-write, mutable collections, we call them. But mutable, right? Yeah.
So the Java collections are always mutable or platform mutable. I’ll talk about that later. But when you do it in Kotlin, you can actually distinguish between read-only and mutable collections, and it’s all very nice on the Kotlin side.
But then when Java sees the Kotlin collections, they are normal again. When we expose them through binaries, the Java world always sees them as normal collections; they’re mutable for Java, and it’s all right.
Okay, I’m starting to see why you said you need a lot of money for this because this is just one of many things. But this itself sounds like, I don’t know how you solve that.
Yeah, so just to add a little bit of detail to this. So the nice thing about those read-only collections is that you can pass a list of string for a list of object, right?
Wouldn’t it be nice if a Kotlin method that takes a list of any could accept a list of string in Java? But aren’t we erasing all the Kotlin nice stuff? We are, but we know that this list is actually what’s called covariant. So we can expose it to Java as a list of question mark extends and not just list of objects. So, you know, it becomes covariant for the Java world as well. And that’s like one hack that makes it a little more transparent.
And there’s a bunch of that. So, you know, so that’s another thing that we had to play with. But the biggest thing is, of course, nullable types. And actually, we handle nullable types and these things with collections kind of similarly, which makes the whole typing layer of the interop quite interesting.
But basically, so Java doesn’t know anything about nulls, right? Well, it knows about nulls, but not about nullable types. It does not exist. Yeah, Java doesn’t know about nulls at compile time. So in terms of types, it’s just not represented. So technically, every Java type is a nullable type.
And this is where we started. We said, okay, so Kotlin types can be not null and it’s very convenient. And when you have a not null type, you can just call a method on it normally, right? But if something is nullable, you can’t just dereference it. You have to first check for null and then use it, right? Or if there is a safe call operator, well, just propagate null is on the left-hand side.
So we started with saying,
“Okay, all Java types are nullable, which is a conservative, like very mathematical way of treating it.”
This is correct, right? Yeah, you’re not going to be wrong with that. Yeah. And we implemented that and we started using it inside JetBrains. And the feedback was horrible. Like your code is plagued with those null checks and you know that they shouldn’t be there because you can’t express anything on the Java side the right way.
And there were like, we had some annotations for the Java side. It was also brittle and not always worked because, you know, there can be long chains and stuff. And some libraries just don’t have the annotations. And we struggled with that for a long time.
And basically we realized that this assumption that everything in Java has to be treated as nullable just doesn’t work. This was a turning point where we sat down and reimagined the whole thing.
And we worked with a great type theory type practice, I would say, guy from, I think it was back then he was in Cornell, Ross Tate. So Ross helped me figure out the sort of mathematical side of how you can represent those types that come from Java and should be, like we should be aware of that they are from Java and can possibly be nullable.
But we shouldn’t treat them as nullable because it was very inconvenient. And Ross put together a very nice sort of calculus about those.
And when we started implementing it, all the nice things are gone. The mathematical beauty is completely gone from all that. And I think we took the general idea of sort of splitting a type in two and everything else is just very messy industrial kind of thing. That’s not sound, but it works well.
Okay. And interoperatively sounds like it was a journey, but a necessary one.
How long did it take? Can you give me just a sense of like how many people working on it? How much, because I think in traditional projects we can get a sense, but I have no idea with the language. How does this work? And how long did you think it would take versus how much it took?
Yeah. So let’s start with that.
Yeah. So, so I had no idea. And I always said like, okay, a year from now feels far enough. We’ll probably be done by then.
In practice, we started in 2010, yeah, autumn of 2010, basically. And we released in February 2016. So, you know, it was a long time, five-ish years. And that, you know, in part was just because I didn’t know how to manage projects.
And my initial team, the people who worked full-time on the project, I looked up on GitHub to verify that. Everybody who, almost everybody, who joined JetBrains to work on Kotlin was a fresh graduate. Because I used to teach and I had some good students and I knew how to work with students. And so basically everybody on the team was a student, apart from a few veterans from JetBrains who were helping, not all of them even full-time.
So we started getting experienced engineers on the team a bit later. And, you know, to be fair, a lot of those people, people who are following Kotlin know those names. People who are core contributors, who built out, like, absolutely foundational parts of Kotlin, joined as fresh graduates. And they became great engineers.
But I think I overdid it a little bit. So it’s great to have, you know, younger people have no fear. And that’s wonderful. But, you know, the balance was not right.
And how big was the team initially and then towards the release?
So we started out basically with four people part-time. And, yeah, we went like that for maybe a year or something. So the initial prototype was built like that. And then people started joining in. By the time we released, I think it was around 25 people or something.
And the team grew quite a bit. So by the time I left in 2020, it was about 100 people on the team, 70 of them engineers. So it became a pretty big undertaking.
Can you tell us about the development process inside language?
I think a lot of us are used to building, you know, like services, backend services or products or mobile apps, etc. They typically have a release process. How does this work inside a language? Like, what is your release process and what is the, I guess, best practices?
Like, do you even do code reviews or, you know, like how can we imagine? Because, again, it feels such a rare project. There are people building languages, but not many of them.
Yeah, so one peculiar thing about building languages is what’s called bootstrapping when you write your compiler in your language.
Oh, nice.
Which means that, you know, to compile your code, you need a previous version of your compiler. And you better agree with your colleagues which version it is. It can be really tricky, especially when you do things about the binary format. And there is, like, quite a lot of bootstrapping magic going on.
And I don’t think you can reproduce the Kotlin builds from scratch. Because, you know, if you just take a snapshot of the Kotlin repo, you can only build that with a Kotlin compiler. And I don’t think we kept all the bootstrapped versions. So it might not be really possible without a lot of manual intervention to rebuild all the sources from the very beginning and reproduce all the versions.
Because sometimes, you know, we had to, like, commit a hack into a branch and use that branch as a bootstrap compiler for the next build and then throw the branch away. So that was, like, a one-off compiler used to facilitate some change in the binary format or syntax or something. So that’s a separate kind of fun.
But generally, I mean, many practices are very similar. Like, we had code reviews pretty early on. It’s my personal quirk, again, that I like to talk to people. So in code reviews, I often just sat together with someone and either they reviewed my code or I reviewed theirs. But this is, you know, I can’t argue that it’s much better or worse. It’s just how I prefer it because I like talking to people.
So code reviews, yes. And, of course, we had an issue tracker like everybody else. Ours was always open. So everybody can submit bugs to the Kotlin bug tracker, which was very helpful. It’s hard to manage because there will be, like, with usage, there will be a lot of bugs and a lot of feature requests and all kinds of stuff. But it’s worth it. You have a communication channel.
Release cadence is a very difficult thing to figure out for such projects. Because one big consideration you have for languages is backwards compatibility.
In part, this is what delayed 1.0 because we wanted to be reasonably sure we can maintain compatibility as soon as we call it 1.0. In part, because it was the expectation, especially Java is incredibly stable and very good with that until Java 9 came about. And also, Scala had a lot of trouble because they were breaking compatibility a lot. And the community was struggling, really. So we really didn’t want to repeat that.
But, you know, it turns out you can even break compatibility Python 2 to Python 3 and survive.
Barely. Barely survive.
They’re doing very well. Now they’re doing well, yes.
Yeah.
So we were really serious about that. But basically what it means is you start doing interesting things like deprecation cycles. So we actually invented an entire tool set for compatibility management.
So before 1.0, we tried to help people migrate. So we had those milestone builds. Embarrassingly, we had 13 of those.
And, you know, when we broke the language in major ways, we tried to provide tools for automatic migration.
That’s nice of you.
Which was, I don’t think, a standard practice in the industry back then. Now people are doing it more. So I’m very happy to have sort of popularized this idea. And then when we were preparing for 1.0, we did a major review of everything and took a year to sort of review all the design.
What we’re doing is basically trying to anticipate what changes we might want to make or what new features will require. And to basically prohibit things that might block that. So we tried to make sure that the changes we were planning were guarded well by compiler errors to make sure that users don’t accidentally write anything that looks like a new feature. And that was fine.
We had design meetings, I think, every day at some point—basically working on that, like, “okay, let’s outlaw this. Let’s prohibit that.” And we prohibited a lot of stuff correctly and some stuff incorrectly. But, you know, generally worked out. So this compatibility thing was a big deal.
But there’s also a lot of stuff that we didn’t anticipate. So we had to figure out ways to manage this. And there is something in Kotlin compiler called “message from the future,” which is basically when in a newer version of a compiler, you introduce something that the old compiler doesn’t understand.
We have different options. And one option a lot of languages go for is:
But it’s a little hard for people then to manage their versions because new libraries, new versions of libraries come with new compiler expectations and you have to migrate your entire project to do that. It’s a little annoying. And if what you’re adding is like one method that basically invalidates the whole library for an old compiler, that’s not great.
So what we’re doing is a newer compiler can write something into the binary that tells the old compiler, “okay, this method is what you can’t understand, but everything else is fine.”
Wow, that’s smart. Yeah.
So we call this a message from the future and like it can provide some details. So there’s that.
And there’s also the discipline of experimental features, which is incredibly helpful. And I am very happy to see other languages doing it now. And even Java does experimental features now, which is wonderful.
Andrei just talked about experimental features in programming languages and how that used to be rare back in the 2010s. What this reminded me is that running experiments in production used to also be rare. Not because teams did not want to do it, but because doing it meant building a lot of internal tooling around it:
Assignment, rollouts, measurements, dashboard, debugging, the whole thing.
For a long time, only a handful of companies really pulled this off at scale. Companies like Meta and Uber.
Which brings me to Statsig.
Statsig is our presenting partner for the season. Statsig gives engineering teams the tooling for experimentation and feature flagging that used to require years of internal work to build.
Here’s what it looks like in practice:
And the key is that the measurement is part of the workflow. You’re not switching between three different tools and trying to match up segments and dashboards after the fact. Feature flags, experiments, and analytics are in one place, using the same underlying user assignments and data.
This is why teams and companies like Notion, Brex, and Atlassian use Statsig. Statsig has a generous free tier to get started, and pro pricing for teams starts at $150 per month.
To learn more and get a 30-day enterprise trial, go to Statsig.com/pragmatic.
And with this, let’s get back to Andre and experimental features in Kotlin.
So we did quite a lot of work when you’re doing something experimental. This is something that’s supposed to break, and you want to emphasize this to make sure that the user is aware that:
“this is something we are not promising to keep compatible. This is something we’re going to break.”
We used to put the word experimental in package names for people to understand that this is going to be renamed. And warnings when you use language features, and we require compiler keys to enable language features and stuff like that. It kind of helps. So we did quite a lot of that.
All this is an extra layer. And unlike a SaaS system, for example, a compiler leaves behind, but not behind, creates a lot of artifacts that pin down its history in the world. There is source out there and there are binaries out there, and you’re guaranteed to encounter them every time anyone hopes that
“this is an obscure case. Nobody will ever hit that.”
With enough users, you hit every freaking case. And this is so surprising.
I discovered this fairly early on. I think before 1.0, when we had a few thousand users, I realized that
“if something’s possible, some person out there will actually do it.”
So you got 1.0 out. Can you tell me how Kotlin grew in popularity? When you released it, what was your target audience? And then how did Android happen?
Okay, so that’s a complicated story. Let’s try to not get off track, because this has a lot of sidetracks to it.
When we started Kotlin, we were not really very aware of Android. And I mean, we knew that that was a thing called Android.
Kind of ironic.
Yeah.
From now, message from the future.
Right.
Yeah.
So basically in 2010, we were focused on the majority of Java developers that was all about the server side.
Clear.
Yeah.
So the most money IntelliJ was making was on Spring users. And, you know, everybody knew that this was what the Java platform was about by then. So we were targeting server side developers, basically.
And also desktop developers, because JetBrains had the, probably the last desktop application written in Java, or at least in Swing.
So that was the target. It was initially not even a plan to do Android.
Kotlin got some usage for the server side. And, you know, it’s still there and it’s growing there, not as fast as on Android, but still has quite some representation on the server side.
But then a few years in, some person on the Internet asked us whether Kotlin works on Android. And I was like, I heard Android uses Java, so Kotlin should work. We’ll never try. Go and try.
I think it was either the same user or a different user who came back and said
“the toolchain crashes.”
And it wasn’t even Kotlin toolchain. It was the Android toolchain that crashed. And, you know, we looked into it and it turns out that some tool in the Android toolchain that’s written in C just fails with a core dump. And it’s not very clear what’s going on.
We later figured it out. It turned out that the Android developers and the people who built the Android platform actually read the spec of the JVM, unlike the people who implemented the Hotspot VM. Because the Hotspot VM, I suspect, came before the spec. So it was the reference implementation, but it was actually specified after it was built.
The Hotspot VM was super lenient to weird things. Like, there would be, if we put a flag on a class file that was not allowed for classes, Hotspot wouldn’t care. And we ran everything on Hotspot. So we thought everything was fine.
But then on the Android side, those were the people who actually read the spec and implemented it. Yeah, they would complain about everything.
This is why we used the Android toolchain as a testing environment basically, because
“this is how we could get rid of stupid things in our bytecode.”
They helped us a lot with validating everything. But, you know, there were some gotchas there. Some legacy stuff nobody cares about in mainstream Java just were faithfully implemented on the Android platform.
That was fun.
So, you know, at some point, pretty early on, I had this realization that Android was a growing platform. Which, to me then, I didn’t have much understanding of the dynamics of markets, but it meant that there would be a lot of new applications.
And it’s much easier to start completely anew with a new language.
So, I made sure, at some point, that we worked well on Android. It was already after the lawsuit.
So, the big context to all this was that when Oracle acquired Sun Microsystems, they sued Google for billions of dollars for using Java.
And I think that is settled.
It was settled in some way, yeah.
And then everyone could go on their own way.
Right.
But yeah, it took years and years to settle.
Back then, it was very much a thing. And, you know, that dispute was somewhere in the background.
But yeah, so basically, we saw that a lot of people on Android really liked Kotlin. They loved it.
Yeah.
As soon as it was stable, pretty much. I mean, I think for all the things that you mentioned: it was just so much nicer than Java. Easier to write, easier to read, lots of nice features.
So, you know, you use Android as a way to actually make sure that Kotlin compiled correctly.
And then, why did it take off on Android?
Yeah, so the situation in Android was pretty interesting because unlike Java server side that is kind of under control of the teams that develop on it. In the case of Android, there are devices in the pockets of people, right? And when you have billions of those devices, and those devices don’t always update the virtual machine.
So, people on Android were basically stuck with old Java. And even when Java started progressing, and, for example, Java 8 came out in 2014, it was very difficult to roll out this new version of Java across the entire Android ecosystem because it required updates to the virtual machine.
There were workarounds, and Retro Lambda really helped, and so on and so forth. But there was still a lot of people stuck with really old Java. So, Java wasn’t on par with Kotlin or C Sharp in 2014. But it still was much better, and solved the major problem. But it was not available to the Android people.
So, there was a lot more frustration with Java in the Android community.
And also, there was Swift on iOS. Where it was a real example of a big ecosystem transitioning from a really dated language to something really nice.
I think compounding these two things were the major factors. Also, we made sure that Kotlin worked well on Android.
Very fortunately, at some point, Google switched the developer tooling from the Eclipse platform to the IntelliJ platform when IntelliJ was open-sourced back in, I don’t remember, 2013, I think.
So, we had a nice plug-in because everything worked on the IntelliJ platform, and the same plug-in worked for Android. Many other things were just very smooth. Well, very smooth—there were a lot of bugs, but reasonably smooth.
So, it felt like a very good match, and a lot of people appreciated that.
We really wanted to somehow draw the attention of the team at Google to maybe talk about it or something, but it just didn’t happen.
We released in 2016, and there was some communication with Google in general, but there was no interest on that side. They were like, okay, we, I guess we’ll just keep going as we do.
Some people were already building Android applications, and some people were building production applications in Kotlin before we released 1.0.
Kudos to the brave people because they gave us indelible feedback. But you guys are too brave.
So, it just grew organically.
When we started, in the very beginning, I set this internal goal to myself, that if we get to 100,000 users, it’s a success.
I’ve done well enough if it gets to 100,000. Of course, it’s hard to tell how many users the language has, but you can kind of estimate that.
I think we were on track to get to 100,000 users during 2016 because it was growing, it was in the tens of thousands, it looked good.
Then, some people from Google reached out and said they wanted to chat.
It turned out they wanted to chat about announcing official support for Kotlin at Google I/O 2017, that would be in like three months from the time of that conversation.
They said, “yeah, sure, let’s do it. What do we need to do?”
It turned out we had to figure out quite a few things, but we managed.
I think it was a heroic effort on the side of the Google team. They did amazing, impossible things.
I have good friends among them now.
It was really, really close. Like, we could have missed the deadline, but we figured it out.
On our side, we had to make many things work and figure out how we interoperate with Android Studio better, and how to set up processes and everything.
But there was a big legal thing around it. This is when the Kotlin Foundation was invented. We had to design the protocols for decision-making in the Kotlin Foundation.
Google owned the trademark for Kotlin for one year because of legal things. It was basically a guarantee from the JetBrains side until the foundation was set up.
You can look up the public record:
Google was in possession of the Kotlin trademark for a year.
But then the foundation was set up and the trademark was transferred to the foundation.
It was fun. It was a pretty crazy time.
But it was amazing to see how happy people were at Google I/O when the announcement happened.
Then usage must have skyrocketed. You probably blew past 100,000 pretty quickly.
Yes, I think we went into millions that year.
So this was basically the moment happening.
I knew many years before that the easiest way for a language to succeed is to be part of a platform.
For example:
And I knew that Kotlin had no platform. So it was supposed to be a much tougher time for Kotlin than for some other languages. But, yeah, the platform came along somehow.
Jumping forward to a lot more closer today, you left Kotlin in 2020. Later, you left JetBrains. What are you doing right now?
Yeah, so I’m also working on a language right now. But it’s sort of a different kind of language because the times have changed. And, you know, you can look at it from a similar perspective. Like, in Kotlin, we wanted to get rid of boilerplate. We wanted to make programs more to the point. And less of a ceremony.
And I think this is where we, today, we have a great opportunity to do the same thing at a different level. Because of AI, right? Because of AI. It’s all because of AI.
Yes. AI is great because many things that are obvious to humans are obvious to LLMs as well, which closes this gap between what the machine can understand and what a human can understand quite a lot. Which means we might not need to write dumb code anymore. That would be very nice.
So, on the one hand, you know, the entire history of programming languages is going from lower to higher levels of abstraction. We started with machine code. And then assembly was a step up, actually.
Teams could grow and you didn’t have to be a super competent programmer to build working software. And then, you know, things like Kotlin built on top of that success. And we raised level instructions some more, but now we can do even better in the same domain.
So, you can imagine a normal program, some application code. A lot of the things in this code are obvious to you and to me. So, if you ask me to write this code, you don’t spell everything out. You explain what the program needs to do and I can implement it. And it will work the way you want.
There are, you know, it depends on how detailed the specification is. But you can tell me a lot less than you would have to tell a compiler.
And so, this is the point with Codespeak. We want to basically shrink the amount of information a programmer needs to tell the computer to make the program work. From my current anecdotal experience, you can shrink a lot of the code about 10x.
Which means that a lot of projects out there can be a lot smaller. And it will be a lot easier for humans to deal with that and a lot easier to read — and reading is the most important bit — and a lot easier to navigate.
It becomes, you know, the essence of software engineering. When you are not dealing with a stupid compiler, you’re not restricted by that anymore. What you’re expressing is what only you know about what needs to happen because everything else, the machine knows as well.
So, can you tell me a bit more on what Codespeak is or what this language is? Is it designing an actual, like, in a formal language, just simpler? Is it using, of course, we know that AI and LLMs and agents can do all the funky stuff. Where is this? What is this?
Okay, yeah, so I’ll try to explain this.
So, I think the best way of thinking about Codespeak is it’s a programming language that’s based on English. It’s not a formal language or not an entirely formal language. But it’s a programming language. It’s a language that’s supposed to be used by engineers. But it uses LLMs heavily.
And this is like the way new languages will be. Because, you know, you can think about the ultimate language of today as a normal programming language that uses an LLM as a library.
You know, there was a time where NPM was wonderful because, you know, it’s a huge repository of all kinds of JavaScript libraries. It’s the node packet manager, one of the biggest package managers in the world, right?
Right, yeah.
So, you have:
- a huge library out there that you can call,
- but now you have an even better NPM,
- The LLM that has seen all the code in the world,
- and if you're inventive enough, you can fish this code out of the LLM.
Yeah. You need to know how to prompt.
Right.
And the trick is, like, it would be really nice to have a programming language that has the entire LLM as a library or as a bag of libraries, right?
The trick is to take anything out of an LLM, you have to use natural language. So, the query language to this incredible database of all the knowledge is informal. And there is no way, at least known today, that you can make it formal.
So, inherently, this ultimate language of today has to be, at least in part, informal. And this is what we’re working on.
So, it’s still in the air, like, how formal can we make it? And, you know, it’s not the goal to make it super restricted. But the goal is to leverage all the power and support the user. You know, we need to rule out stupid mistakes and things like that. And we’re still working on that. But the basic idea is, if you, instead of spelling out every line of code and every bit of your algorithm, you can basically communicate intent the same way I can communicate it to you, you will just get there much faster.
So, one question that I asked Chris Lattner, which I’m going to ask you as well, you’re talking about designing a language for software engineers to build software more efficiently, maybe more concise, in a new way, and it sounds super exciting. But going to the other side, we have LLMs. Do you think there is a need to design a new type of programming language for LLMs to use more efficiently?
That’s a very interesting question. And I had a few discussions about this. My position is it’s probably misguided because of a number of things.
So, one, to get an LLM to understand some language well, you need a huge training set. And with the new language, that training set is not there. You can try to synthesize it and so on and so forth, but it’s not going to be as good as other languages. Like, for example, right now, the newer languages are just harder for LLMs than the more established ones.
And, you know, there are ways around it. I think the later models added some more Kotlin into the RL sets and it’s getting better. But still, it’s pretty hard. And so that’s challenge number one.
Also, challenge number two, I don’t think there necessarily has to exist a language that makes it better because LLMs are trained on human language. Their knowledge of programming languages is part of that. Their power is in having been exposed to all the code in the world and its existing code. And inventing a new language for that, I don’t know how promising that can be.
You can do another thing, which is an interesting research project. You can sort of extract a language from an LLM because, internally, it has some intermediate representations of what’s going on during inference. And maybe you can sort of extract the optimal prompting language.
It’s not guaranteed to be intelligible to humans. And there are some experiments that show that you can create completely unintelligible prompts that give the same results as normal human prompts, but they will be shorter.
You maybe can do something like this. I don’t know if it will help a lot. But what we’re doing in code speak as part of working in this language, we need to really nail down this query language capacity.
What we’re doing now is we are looking at existing code, and we’re trying to find the shortest English descriptions for this code that can generate equivalent implementations—not necessarily character to character, but they have to work the same way.
That’s an interesting exercise because you need to figure out how to represent the ideas in the code in a way that:
But also, this code you represent evolves over time, right? So you have a commit history on top of this version. Going forward in time, you need to be able to represent all the changes in your code speak version.
You need to make sure that when it’s a small change in the original code, the change in the spec is smaller. That’s an interesting challenge. So in this way, we’re sort of discovering code speak as a language, or at least parts of it, and not really designing that bit of it.
You know, it’s a very new world in the sense that, nowadays, if you work with AI, everything is a machine learning problem. That means, back in the day, if you had a very smart algorithm on paper, you could just implement it and make sure it works. Nowadays, whatever algorithms you have in mind, you need the dataset.
First of all, like if you don’t know how to collect a dataset, don’t even start. And, yeah, this is what we’re doing.
So just taking a look at, you are using these tools day in, day out. I mean, you’re building with them. How do you think programming as a whole, or I’ll say software engineering, is being changed by AI? And how do you think the future is starting to look? Especially thinking about software engineers. You’re a software engineer yourself. You’ve written so much code in your life. And are you still writing code?
Yeah, I’m writing some code, yeah.
Sorry, typing or prompting?
I’m doing both. Sometimes I’m just typing. More often, I’m typing with cursor tab completion. I’m doing quite a lot of prompting as well. And that’s a combination of all this. But cursor’s completion is really a step up from traditional IDEs. And I think the IntelliJ side has something similar now. So it’s like a lot of coding, but in a very different kind of mindset and a different tool set.
Yeah, so in terms of what’s happening to programming, I think we are in the early days of the new era. So, you know, it’s only last year that we figured out that coding agents are good. No. Cloud code and cursor agent and so on and so forth. And I think this is a very early step.
Right now we are in this phase where a lot of people are in love with agents and it can be very useful and I use them every day. But I think there are inherent problems with the model, with how you interact with a coding agent because it’s a one-on-one chat. And as a human, I talk to the agent in human language. So I’m communicating my intent on a high level.
And that intent gets translated into code and it’s the code that I commit to the repo and it’s the code that my teammates will see. So my chat history is lost. Big problem.
Yeah, so it turns out I’m talking to a machine in human language. But the way I communicate with my team is the machine language. That’s kind of backwards.
So, yeah, so what we’re trying to do in the Codespeak is to elevate everything to the human language level. So this is where we start. We say, okay, we have this incredible tool. We can prompt agents to implement code for us. And we are just picking it up. So I think a lot of teams haven’t yet realized how difficult it is to review the code.
And I’ve talked to people who are like,
“Maybe we can just not review this code.”
I’m like, yeah, I mean, you can for a couple of days and then it just collapses. And I think another big theme of today is that we’ll be doing a lot of testing.
And like, you may not need to review the code if your tests are really good. You need to verify it, right? Yeah. That’s what you’re saying is verifying might not mean reviewing. Right. Or it could not mean. Yeah, depending on the domain. Of course, of course.
You might get by without reviewing the code as much, but being sure somehow either reviewing the tests or somehow else, making sure that your tests are good. That’s a trend. And we are putting a lot of effort at Codespeak into automated testing and making sure the tests actually check the right things and that they check all the code and all that stuff.
It’s very interesting computer science. And also, it’s now a question of, especially in the case of Codespeak, and I think for other agents as well, like, yeah, reviewing code can be too much, but can we present the tests we generated to the user in a way that actually verifies that we did what was to be done?
It’s tricky. Some tests will be just very long and tedious to read and, you know, but we’re working on that. And that’s where we are.
And I think we’ll see a lot of development in terms of power of the models and we’ll get some quote unquote obvious things implemented in agents. For example, the agents are just starting to use like language servers and basically all the stuff that we’ve always had for code is not very utilized.
And, you know, if you compare like IDE-integrated agents like Cursor or Juni at JetBrains, you have a lot of like code navigation capability and, you know, databases of code is indexed and you can navigate it very quickly. You can find things very quickly.
When you run cloud code, for example, it might not have that and use grep and it will be as successful, but take a lot longer and burn a lot more tokens.
So, you know, I’m sure this year all these tools come to most agents and we’ll have a lot more sophisticated scaffolding around the models.
So that’s one thing. But then, you know, my question is always what’s going to happen in the endgame or in further future. And there it’s very hard to predict. And we can assume that models will become much smarter. But an important thing is that humans will not.
So one thing I know about the future and it’s hard to know the future, but this thing I do know about the future, humans will be as smart or as dumb as they are today. And if we have incredibly smart models, what we will be doing is constrained by how humans are and this is one of the reasons why I’m working on Codespeak because Codespeak is a tool for humans, not for models.
Yeah. And humans, I know I can build a tool for them.
I guess an important footnote is that many people will say things like,
“If we have smart enough models, they can review the code themselves and they can test the code themselves.”
But then my question would be like, who’s making the decisions here?
You know, if all the software engineering work is done by models, it means humans don’t have any say in that. And this has a name. It’s called technological singularity.
Yeah. When humans are not making decisions, it means we’re not in charge.
Yep. So this is not the future I’m building Codespeak for. Nobody should build any projects for that future. In that future, we’re gone. Your projects don’t matter.
But so my assumption when I’m talking about the future is that the technological singularity is not happening. And so the basic assumption is humans are in charge.
And if humans are in charge, it’s their job to communicate intent. So we have to say what kind of software we need to build. And when we’re talking about serious software, it’s always complex. There’s no way there’s some very simple thing that will make a difference.
And when we talk about this complexity, this is what our jobs will be, like dealing, managing this complexity, figuring out what we actually need to do. And this is absolutely engineering. There is no way someone can tackle huge amounts of complexity without an engineering mindset. It can be called software engineering, can be called something else, but you will have to do it. You will have to navigate this complexity, organize this complexity, figure it out.
And I’m not talking about the complexity of many, many layers of implementation. Maybe not. Maybe that is what’s called accidental complexity, something that happens or arises from how we implement systems. But there is also essential complexity. How we want it to behave is complex enough that we need to figure it out.
And this is why I believe there will be teams of engineers working on systems like today. Maybe they will be a lot more powerful teams. Maybe fewer people can deliver a lot more software. Yes, but still teams of people working on organizing complexity.
And this is what Codespeak is for.
Going back to where we are today with what the models can do today, what do you see with developer tools? It feels a little bit of a wild, wild west right now, very much so. I mean, there’s a lot of, obviously with Cloud Code, with Curse or with others.
But what are areas that you think we will see, we will have to see new, different, better tools to actually just catch up with how we can generate? And what parts feel the most messy and the most interesting? Especially because at Kotlin, you have, and the team has built so many tools for developers.
Right. So I think, as I already mentioned, this year will be the year of making developer tools available to agents.
There are some technical challenges, but you can’t figure it out. The people will be doing that.
There’s also a surprising advantage to using a good UI for your agent. It’s very nice to have everything in your terminal, in one sense. But then you can have a lot better user experience if it’s a dedicated environment.
The terminal tools, especially Cloud Code, are amazing. And it’s a complete breakthrough of what you can do in a terminal. But generally, you can do better in a specialized environment.
So I think we’ll see more of this integration into development environments or just new development environments built from the ground up to work with agents primarily. So that is an important thing.
Since we are putting a lot more emphasis on review, there should be new tools for review. And I think we can do better than what we’re doing now in many respects.
I don’t expect many breakthroughs in testing this year because it’s hard. I’m doing it right now. It’s hard. It’s not going to happen this year. But maybe some advances will arrive this year.
But generally, I think the big lesson of the last couple of years is that all the things that were, quote unquote, obviously needed and, you know, the idea of connecting agents to developer tools was absolutely the trivial thing to think of two years ago. But they take a long time to happen because it’s hard.
And, you know, nobody in this industry is lazy. Like everybody’s working their asses off. But it just takes time. You need to figure out the basics before you can do advanced things. So, you know, all the straightforward ideas will get implemented at some point.
I think there’s been this massive jump with AI, especially over the winter break, where the coding agents, the CLIs, have become a lot more capable.
And I know so many developers who are actually just prompting most of their code, if not all of it. It’s just a massive, massive jump. I don’t think we’ve seen anything this fast.
I see a lot of engineers scared because it can shake you to the bone. You know, it took 10 years to get really good at coding. And the writing the code part feels that it’s kind of going out, you know, the trash can.
You yourself have coded for a longer time. What would your advice be for developers who are feeling like this, that they’re feeling, you know, it is scary.
I think we, and I talk with some folks, a lot of people message me as well. How are you thinking about this specifically these last few months? It’s really hard to give advice.
There are a few ideas I can share. So one thing is there’s a lot of hype and a lot of it gets to the management and a lot of people make suboptimal decisions. But that will go away.
So, you know, there’s more and more news about people not hiring junior developers, for example.
And a lot of other things can be really stressful in the moment, but some of them will be rolled back. So that’s one thing.
Another thing, it’s absolutely worth it to invest your time into learning these tools and getting good at it. There’s a lot of skepticism around in the developer community about how useful it actually is. And, you know, I tried it on my project and it’s no good.
There is quite a bit of skill to using these tools. Unfortunately, it’s not super formalizable. At least so far, nobody figured out a really good, clear way of communicating how to do it well. But there are people who can do it much better than others. They not always can’t articulate why their prompts work better. But, you know, you can learn it. You can get a lot better at it.
And, you know, not necessarily believing everyone on Twitter. Some people claim crazy things, but you can be very productive with these things when you use them well. And it’s absolutely worth investing into that.
And yeah, so as I mentioned before, in the future, it will still be engineers building complex systems. So keep that in mind. It’s not like we all go to nothing.
And for new grads, people coming out of university, what would your advice be for them who are like determined, like, “all right, I actually want to be a standout engineer. Maybe with these tools, I can do it faster.” What would you advise them to focus on either skills or experiences to get?
I guess it’s a matter of what your inclinations are.
So, you know, generally, if you have any inclination in looking under the hood and figuring out how things work, go as deep as you can. As a younger person, you have a lot of mental capacity for that. And this helps a lot. You become a very good expert in very wide fields, just through drilling down on many things.
That’s closing. I just wanted to do some rapid questions. I just ask and you shoot what comes next.
What is a favorite tool that you have? It can be digital. It doesn’t have to be digital.
Well, I love my AirPods. They’re incredibly convenient. They fit under my earmuffs.
Well, another tool would be earmuffs.
Earmuffs. Incredibly good.
Yeah, I saw you wearing it. I’ll take that one, Earmuff.
And what’s a book recommendation that you recommend and why?
There is this classic that’s been recommended across the tech community for many years. It’s called Zen and the Art of Motorcycle Maintenance.
I heard that recommended.
Yeah, it’s a very good book. I mean, there is a part of it that’s about technology and how to deal with the real systems and others, but it’s also a very good novel. I really like it.
Well, Andrew, thank you so much. This was very interesting and I think inspiring as well.
Thank you very much. It was great to chat.
It was great. Thank you.
The thing that struck me most from this conversation with Andrey was his observation about how we work with AI coding agents today. You talk to an agent and play in English. It generates code. You commit the code. But that conversation, your actual intent, it disappears. You communicate with the machine in human language, but with your teammates in code, in machine language.
Whether or not CodeSpeak becomes the answer, what is sure is that we’re missing an intent layer. And someone is going to figure out how to preserve it.
If you enjoyed this episode, please do share it with a colleague who’s been thinking about where programming is headed. And if you’re not subscribed yet, now’s a good time. We have more conversations like this one coming.
Thank you and see you in the next one.
2026-02-04 08:00:01
Uneasy Calm: Ryan Hass on Three Pathways for U.S.-China Relations Under Trump
Welcome to the Sinica Podcast, the weekly discussion of current affairs in China. In this program, we look at books, ideas, new research, intellectual currents, and cultural trends that can help us better understand what’s happening in China’s politics, foreign relations, economics, and society.
Join me each week for in-depth conversations that shed more light and bring less heat to how we think and talk about China. I’m Kaiser Guo, coming to you this week from my home in Chapel Hill, North Carolina.
Sinica is supported this year by the Center for East Asian Studies at the University of Wisconsin-Madison, a national resource center for the study of East Asia. The Sinica Podcast is and will remain free.
But if you work for an organization that believes in what I’m doing with the show and with the newsletter, please consider lending your support. I know you think of this as boilerplate by now, but seriously, I am looking for new institutional support.
The lines are open and you can reach me at:
or just my first.last name at gmail.
Listeners, please support my work by becoming a paying subscriber at cynicapodcast.com. Seriously, help me out.
I know there are a lot of Substacks out there and they start to add up. Yes, but I think this one delivers some serious value. You get my stuff, the China Global South podcast, the fantastic content from Trivium, including not only their excellent podcast but also their super useful weekly recap. You get James Carter’s “This Week in China’s History” column. You get Andrew Methvin’s Chinese Phrase of the Week.
I am really trying to deliver value for your hard-earned dollars, so please do sign up. Things are tough, I get it, but consider help now. Tough for me too.
As we move into the second year of Donald Trump’s seemingly interminable second presidency, U.S.-China relations have once again defied easy characterization.
What began as a return to tariff escalation and hardball trade tactics has somewhat unexpectedly given way to a period of relative strategic calm marked by:
Even in the national security strategy and the national defense strategy that was just released.
The once dominant language of great power competition has definitely receded, and many of the most vocal China hawks who shaped Washington’s approach for the past decade appear to have been sidelined.
In their place, we’ve seen a policy posture that reflects Trump’s highly personalistic approach to foreign affairs and emphasis on leader-to-leader rapport.
“Xi Jinping’s my friend,” deal-making over doctrine, and a willingness to bracket or at least downplay ideological disputes in favor of transactional progress on trade, technology, and risk reduction.
Trump’s repeated praise for Xi Jinping, his apparent sensitivity to certain of Beijing’s red lines, including on Taiwan, and his apparent comfort at treating China as a peer rather than a civilizational rival mark a sharp departure from recent bipartisan orthodoxy in Washington, if you indeed believe that it was a bipartisan consensus.
Supporters argue that… This shift has lowered the risk of conflict and delivered tangible gains. Critics, though, counter that the United States is conceding leverage without securing durable returns. Either way, the result is a relationship that feels less confrontational for now.
In my private communications with certain among my more panda-hugging friends, there’s this sort of bewilderment. It’s like, we kind of agree that Trump is awful for this country but not so bad for U.S.-China relations, right? But beneath the surface calm lie unresolved structural tensions, deep mutual dependencies, of course, that can be weaponized, and parallel efforts in both capitals to reduce those vulnerabilities.
So, what comes next? Are we headed toward a genuine lasting stabilization or a familiar snapback to the acrimony that once dominated, once our expectations collide with reality? Or a more ambiguous middle path, one in which both sides buy time, avoid escalation, and quietly work to insulate themselves against future shocks?
Well, to help us think through all these questions, I am joined by Ryan Haas, director of the John L. Thornton China Center at Brookings, and one of the most clear-eyed analysts of the U.S.-China relationship working today. Ryan has just published an essay on the Brookings website laying out three plausible pathways for the relationship under Trump scenarios ranging from:
He joins me from D.C. And Ryan, welcome back to Sinica, man. Thank you, Kaiser. It’s wonderful to be back with you.
So Ryan, like I said, you’re joining us from Washington. Let me start there. One of the strengths of your piece is that it treats leaders as not free agents but constrained actors. From where you sit in D.C., what are the most powerful domestic forces that are shaping the U.S.-China policy right now? And which of them do you think actually matter to President Trump?
Well, it’s a really interesting question. I have to say, sitting in Washington, D.C., one thing that is very palpable is a hope, a wish among many inside the beltway that we will soon snap back to the way things were before—that this one to two-year window is just sort of a brief pause from the long-term trajectory of intensifying competition and confrontation.
I’m a little less confident of that. In fact, I’m fairly skeptical that’s where things are headed, but that’s certainly a palpable sense of mood within the beltway.
To your question, I actually think that President Trump is fairly unconstrained in terms of his approach to China. I believe he is pursuing the approach that he thinks will yield the best benefit for him personally and politically, but also for the country. The basic contours of it, to the extent that you can assign strategy to what President Trump is doing, are:
- Trying to lower the temperature of the U.S.-China relationship through direct engagement with President Xi.
- Showing tremendous respect to President Xi and, by extension, China in service of that effort.
- Building deterrence in Asia militarily.
- Reducing dependence upon China for critical inputs to the U.S. economy.
- In his own way, trying to rebalance the U.S.-China economy.
That’s the direction he is trying to take things. I don’t think he surveys the landscape of the U.S. political class and finds too many threats to his vision and approach to the relationship. But he’s thinking about midterms, he is thinking about 2028, and he’s thinking about affordability and things like that.
I mean, is that part of the logic that’s driving him to soften things with China right now—to hit pause?
Yeah. I think that there are a few things causing him to do that. First, he believes that China has us over a barrel in terms of their control over earth and other critical inputs. Until we get out from under the sword of Damocles that the Chinese have above our head, I don’t think he sees much value in taking the U.S.-China relationship toward head-on collision.
He also recognizes that he’s managing a lot of other problems around the world simultaneously. Adding to that list with intensifying confrontation with China may not be wise or prudent.
But I think he also recognizes that there isn’t a ton of appetite in the United States among the body politic for head-on confrontation.
This is something, Kaiser, you have written about and talked about—the vibe shift in the United States. President Trump, one of his unique strengths is… His reptilian feel for the mood of the American people. And in this regard, I think that the president reflects what he can sense from the American people in terms of what their expectations are for the U.S.-China relationship today.
Well, that’s comforting. The other questions, industrial policy coalitions used to be, at various times, a ballast for stability or even an active force for improved relations with China. Are they acting on him today? Is there business pressure somewhere? Is Jensen Huang a major force in his thought these days?
Well, I think that President Trump operates much differently than traditional U.S. presidents, in the sense that he is not sitting in the Oval Office waiting for his staff to bring him options for him to decide upon as it relates to China. As we’ve talked about before in Berkeley and elsewhere, he is his own China desk officer. He takes his own responsibility for calling the shots and setting the direction of U.S. policy towards China.
And in doing so, he is not informed by stale, turgid intelligence briefings that stone-faced people deliver to him early in the morning. He is talking to a range of people in and outside of government. He’s talking to people he treats as peers and considers as peers, including Jensen Huang, but not just Jensen Huang. He is basing judgments upon the body of inputs he’s receiving, which are far broader than a traditional U.S. president would.
So if he is so unconstrained and if his policy toward China, as with all things, is such a function of his just idiosyncratic whims and his character, is this current pivot away from ideology credit where it’s due? It’s something that I’m really happy to see. Is this something that could survive Trump or is it inseparable from his personal instincts and his incentives?
Well, I’ll try to take this in two parts. The first is that I think Trump is in a category of one amongst the U.S. political class in his willingness and tolerance to affect the change in America’s overall orientation towards China. And you noted this very articulately in your introduction, that he has moved the United States away from sort of an emphasis and a framing of great power competition as the sole lens through which to view the U.S.-China relationship to something that’s much broader.
I think of it as sort of non-conflictual coexistence, a more pragmatic, realistic appraisal of the nature of the U.S.-China relationship than preceded President Trump. But it does raise the question, I think a very legitimate question that you’re asking, which is, is this just something that will perish when President Trump departs office?
I can’t tell you. I honestly don’t know. But my instinct would be that no, this has the potential to outlast President Trump. However, for it to do so, a few things will need to happen:
First, President Trump will need to demonstrate return on investment. Over the next couple of years, he will need to demonstrate that this less harsh approach to the U.S.-China relationship yields tangible benefits for the American people and American workers.
Secondly, whoever succeeds him, whether Democrat or Republican in 2029, will need to be able to make a case for what America’s national goals are and how China relates to them.
It’s impossible to know how those two variables will play out, but it is certainly a possibility that we could see an elongation of this period beyond just Donald Trump.
The ball then is sort of in Beijing’s court. They need to pay a return on that investment, and I think if they want it to endure beyond Trump.
But speaking of Beijing, let’s flip the lens to Beijing. Is Xi similarly unconstrained? Is he a sort of singular determinant of Chinese policy toward the U.S., or does he have domestic determinants of China’s policy toward the United States at this point?
I mean, and if they are, is it like economic stabilization in the post-COVID period? There’s plenty of things that bedevil the Chinese economy right now.
Is it:
What are Xi’s considerations as far as you can tell?
Well, one of the unique aspects of this moment is that we are in a situation where the two countries are driven by very personalistic leadership styles. There are some, for me, uncomfortable similarities now in the way that the two countries are sort of operating.
I don’t think that Xi is perfectly unconstrained. I’ve never subscribed to the view that he has a monopoly on power in China and that he alone can determine the outcomes for 1.4 billion people. But I do think that there are certain things that… He is very invested in and that his brand is associated with, his political brand. One of them is making progress towards greater self-reliance and less dependence upon the United States and the West for China’s future growth, innovation and technological breakthroughs. And this period of relative calm in the relationship, I think serves that purpose. It gives breathing room and space for China to make progress down the path of greater self-reliance.
The second is being able to give proof to the narrative that time is on China’s side, that China has “winded its back” and that it’s the United States that on a relative basis is declining. And I think there are plenty of proof points that President Xi and those around him can point to, to build that case persuasively inside China today, which I think also gives some momentum to the current direction that we’re in.
I mean, I know it’s hard to say with any certainty, but is it your sense that there’s debate within the Chinese system about how hard or soft to lean into this current period of calm? Is this something that, you know, is he facing opposition? In other words, are there people who are saying,
“Hey, America’s showing weakness, time to press our strength,”
or does it seem to be, you know, Xi’s calling the shot in that case?
Ryan Hass: You know, it’s a good question. My latest sort of touch for that is a bit dated. I was last in Beijing and Shanghai in December. So I’m a month plus out from my last contact with people who are in policy circles in China.
But based upon that last round of conversations, my view is that many people recognize that this moment is serving China’s interest well, that China’s goal is to try to relieve pressure and sort of unblock the path to China’s continued rise.
To the extent that President Trump is willing to play a role in that by relaxing pressure upon China, whether it be through:
I think those are all sort of indicators that this is working to China’s long-term benefit.
Kaiser Guo: So Ryan, a central claim or assumption in your essay is that both sides, Beijing and Washington, are behaving less out of mutual trust than out of mutual sense of vulnerability. That, I think, isn’t a claim that many people would challenge, actually, and I wouldn’t.
To what extent do you think that policymakers in both capitals genuinely understand this as kind of a negative sum dynamic? And to what extent are they simply discovering through painful trial and error that they are mutually vulnerable and that they need to chill out?
Ryan Hass: Well, I have a pretty high degree of conviction around this point, but I don’t have some smoking gun evidence that I can point to to prove it.
My sense is that both leaders and those around them have come over the past year to recognize that the other side is capable of doing immense harm to itself.
And I think that this has been a revelation, more so on the US side than the Chinese side. The Chinese side has been well aware for a long time that the United States is capable of being a dangerous superpower that can do immense harm to China.
But when President Trump and Secretary of Treasury Besant and others entered office last year, they entered office with a certain degree of bravado and hubris. Secretary Besant famously said that
“China is holding a pair of twos in terms of, you know, the cards it has in its hand and the lack of leverage it has over the United States.”
No one is talking like that anymore.
Through painful trial and error, both sides have come to realize that they are each capable of doing harm to the other. And that if one side initiates action against the other, it should expect painful retaliation response.
And so I don’t think that President Trump and President Xi over the past year have developed some like brotherly friendship where they decided not to do harm to each other.
I think they both come to recognize that if they take actions that are harmful to the other, that they will get hit back in response. And that it will hurt.
And that was the whole lesson in 2025 leading up to Busan, right?
Kaiser Guo: And you know, your trip may have been a couple of months ago, but that was still in the post-Busan era. So I think you have a probably quite accurate read of how they’re feeling right now. Not much has changed since then, so.
Ryan Hass: Right.
Right.
Yeah. There haven’t been many major ruptures or fluctuations from then till now. Except the rupture that, you know, Mark Carney spoke of.
But so Ryan, let’s jump in with your first scenario, the soft landing. In this pathway, both leaders:
I mean, you know, they’re really talking about investment right now. We’ve got Ford talking about working with Xiaomi possibly, according to the FT, at least on a battery plant, right?
Yeah, you’re absolutely right. I think for this scenario, the soft landing scenario to take root, a couple of things would need to happen.
So that’s the first prerequisite.
I think one of the things that some people point to who are advocates of this approach would be some type of grand bargain.
So we know that President Trump is planning to travel to China in April. If that visit were to yield a sort of significant breakthrough on a contentious issue, most people would identify Taiwan as the candidate, Taiwan combined with some type of transactional benefit for the United States and its workers. Then that would give momentum or solidity to the idea that we could travel down this path.
But short of that, I think it’s hard to imagine both sides really sort of believing and acting in ways that both leaders believe they can sustainably improve over the long term of the nature of the relationship.
What makes that costly from the American side?
So you say that it would require both sides to send costly signals. What sorts of signals are we talking about from Beijing, and what would be costly about those? How hard would they be to deliver domestically in Beijing?
It’s a great question. I think in the case of China, there is a certain degree of skepticism about whether the Chinese leadership would be comfortable seeing some of its companies and crown jewels invest or produce outside of China. We see this in particular with Meta’s efforts to acquire a Chinese-origin AI company that relocated to Singapore.
Meta’s, yeah.
Another area, in the Taiwan context, would be if President Trump were to alter longstanding declaratory policy toward Taiwan, would China reciprocate by:
These are the types of questions that sort of point to costly signals that each side would expect the other to give if they were to give it themselves.
I have trouble seeing that is costly to China compared to the electoral costliness of signals from America. So it feels like China can ram this through; Trump faces electoral pressure.
Yeah, he might. But let’s keep in mind, he’s never going to be on a ballot again for the rest of his life.
That’s true.
And so, President Trump has never shown a lot of conviction about election outcomes that don’t involve his name on the ballot.
Ryan, looking back over recent U.S.-China history, is there a precedent that you can point to for restraint for restraint actually holding for any decent length of time?
I can’t think of anything off the top of my head right now that would give a lot of confidence to the notion that restraint for restraint is a time-tested and well-established trend. This is the critique that I think people of the soft landing approach would make, is that the soft landing would The discussion involves the United States making concessions to China without receiving reciprocal benefits in return. There’s a pretty calloused skepticism that has built up over years, including within the Trump administration, as a consequence of the underperformance of China in the phase one trade deal.
Obviously, you floated this possibility that something like a fourth joint communique on Taiwan could anchor the sort of soft landing you’re talking about, the grand bargain.
What problem would such a document actually be trying to solve? What would be the content of a fourth communique? And is Taiwan ultimately the issue that makes this scenario maybe politically untenable, even if both leaders are inclined toward restraint? I mean, is Taiwan going to flummox this?
I think it will be very difficult. The idea would be that the last time that the United States and China had a communique was in 1982. A lot has happened in the last 40 plus years. A new framework that sets out a baseline of understanding for how both sides will approach cross regulations may be a useful stabilizing mechanism.
I’m on the more skeptical end of the spectrum on this question. I don’t think that the challenge is a lack of understanding about the nature of cross-strait issues. I think that there are just competing interests involved that need to be managed.
In Washington, it’s treated as sort of a foregone conclusion that Beijing is desperately seeking a fourth communique or some type of new understanding related to Taiwan with President Trump. There are a few factors that may mitigate against that as a foregone conclusion:
Yeah, yeah, yeah. Just to remind everyone, this is your most optimistic scenario. And in this most optimistic version, there is still a sense that the soft landing would be kind of inherently provisional, something closer still to a pause than to a full reset.
I am ineradicably optimistic but still have trouble seeing either polity really arriving at some kind of durable modus vivendi right now. There’s just no trust. There are many deeply entrenched habits of mind on both sides.
But there are other scenarios that you posit here. The second scenario is the one I sincerely hope to avoid: a hard split.
You frame this as a familiar arc: Trump starts conciliatory, grows very frustrated, and then swings really hard. We’ve seen this many times. What are the most plausible triggers that could push the relationship down this kind of path toward a hard split?
Well, there are a few ways we could get here:
1. There could just be a misunderstanding on what each side agrees to. President Trump comes to the conclusion that the Chinese are under-delivering on their promises. He grows frustrated, angry, and we find ourselves back following the same cycle as we did during the first term, where:
- The first three years focused on negotiating a phase one trade deal.
- The fourth year focused on letting it rip because the president was so angry and frustrated that COVID had spread and undercut his reelection prospects.
2. China takes actions against American allies that involve **use of force** and puts the United States in a very difficult position of deciding whether or not to employ force against China to come to the defense of their allies and uphold **Article 5 commitments** or traditional understandings of security commitments.
Examples of such allies include The Philippines or Japan. Right. Right. Right. And then what some people in Washington would say is that as the midterms get closer, the political incentive for President Trump to become harder and harder towards China will grow, and that the political imperatives of President Trump wanting to hold off Democrats gaining control of the House and relaunching impeachment probes against him will compel him to grow tough.
This is the hope, I think, of a lot of people in Washington who want us to get back into the business of great power competition. And I’ll just offer just a quick caution, Kaiser, as to why I’m not yet convinced that this is the natural course of events that we’re going to find ourselves in.
First, you know, the president has demonstrated that he is very sensitive about America’s dependence on rare earths. That dependence is not going to change in the next 12 months, 18 months, even two years.
Yes. The second is that President Trump just genuinely is not activated by the military threat or the ideological nature of competition between the United States and China. But he’s much more focused on economic and tech issues. He wants to make deals that he can point to and tout his as successes and breakthroughs.
And having a hostile relationship with China would sort of move against that objective.
I also think that President Trump is pretty comfortable with the status quo right now. He doesn’t face immense political pressure at home for where the US-China relationship stands. He also likes to brag privately with his colleagues and counterparts about how much tariff money he believes that the United States is generating from tariffs on China, never mind the fact that it’s US importers that pay the tariffs.
And then lastly, I think that President Trump is very focused on legacy and blowing up relations, burning down the house with China is not a legacy enhancing exercise. Putting the relationship on a new plane potentially could be.
So, I mean, the fear of a blue wave in 2026 in the midterms, I mean, I get that. But part of him also has somebody’s got to be showing him these polls that say,
“there’s just not a lot of appetite right now among voters for tough on China. It’s not a winning campaign strategy right now.”
I mean, poll after poll after poll is showing that that is fundamentally weakened vibe shift once again.
Right.
So, I mean, hopefully that’s a mitigating force.
Yeah.
And traditionally, midterm elections are not animated by China or by foreign affairs. I mean, there really isn’t any empirical evidence that going tough on China improves the odds of House and Senate candidates getting elected.
So, from Beijing’s perspective, I mean, it’s pretty easy for us to think of what kinds of U.S. actions would collapse strategic calm and force Beijing to take a harder line that would be reciprocated by Washington. I mean, all sorts of triggers, right?
But where do you think miscalculation is especially dangerous? What are the areas where you think that crossed wires and signals misinterpreted are particularly dangerous?
I would suggest, just as a hypothetical scenario, if the United States became more aggressive with other countries about urging them, insisting that they adopt America’s AI tech stack—
Right.
—and conditioning security support for them doing so. That could be an example of how things could go off track.
And if there were further actions like we saw last fall where the Department of Commerce rolls out something in an uncoordinated fashion, the 50% rule, the affiliates rule.
Right.
Something along those lines that the Chinese perceive as violating the truce, the understanding that was reached between both leaders—that could compel the Chinese to reciprocate and retaliate.
Well, that problem may be solved. Trump has apparently neutered BIS, right? So we’ll see.
One thing that struck me is how much this scenario depends on momentum, on anger compounding on anger. Once the relationship starts moving in this direction, how easy is it to reverse?
I ask because this isn’t the first time either Beijing or Washington has seen things go sideways. And you’d think that both sides might have learned something about how to manage that sort of crisis. And at least sometimes they’ve managed to get the relationship back on track.
And we saw that with the taco meal that resulted in Busan.
Has there been any learning? I mean, do you think that there’s enough sort of wisdom on either side to avoid that kind of scenario?
Well, I think that the key to avoiding that scenario is the two leaders. When things begin to veer off track, it’s the two leaders that usually put things back on track. And the challenge, the structural challenge, is that the Chinese traditionally, historically, are pretty reticent about requesting calls from President Xi to President Trump.
So if there is an incident that is an unplanned encounter between naval vessels or whatever it may be, and things begin to sort of go off the rails, pressure builds. We have a spy balloon-like dynamic emerge inside the United States where there is just boiling angst and anger about something that China has done that violates American airspace or hurts American sailors or whatever it may be.
When the Chinese do not appear to be reaching out to President Trump personally, we could find ourselves in a tough spot. And if the Chinese are perceived to be the instigator of this downward spiral and they don’t communicate directly with President Trump but try to operate through intermediaries, I think that President Trump could find himself both humiliated and offended in ways that could sort of compound the initial problem.
So that’s scenario two: one where there’s a hard split, not an optimal outcome at all, obviously.
You, fortunately, ultimately judged scenario three, which is about buying time and building insulation, as the most likely path. I would certainly concur. But what, in your mind, makes this outcome more resilient than the other two? I mean, because it seems sort of inherently unstable, right? It’s provisional. It’s about sort of just playing for time. And so it feels very impermanent.
But why do you think this is maybe more durable than the other two possible outcomes?
To me, Kaiser, and this is unscientific, this is just sort of a feel, it feels like the most realistic scenario. I don’t think that either of the two leaders is prepared to sort of make significant lasting concessions to the other. I don’t think that either country is prepared to accept a subordinate status to the other.
I think that both countries, in their own way, are able to tell themselves a story that time is on their side. And if they just regenerate or strengthen themselves, that they will be able to outlast and outpace the other.
And so this third scenario of sort of buying time and building insulation, it’s most appealing to me because it works for both leaders and how they describe their intentions and their goals.
This scenario allows him to make directional progress on all those goals.
Similarly, for President Xi, I think that there’s a fairly mirrored set of objectives.
President Xi is very committed to strengthening China’s self-reliance and moving down that path. He certainly, in my mind at least, does not seek a confrontation or conflict with the United States. But he also isn’t interested in making any significant gestures or major concessions to the United States either.
I think that the Chinese believe that they have momentum behind them. And the wave of leaders that have come to Beijing over recent weeks to visit President Xi, I think, have reinforced that perception.
So a core insight of your piece, Ryan, is that both sides are constrained by deep mutual dependencies. I think most people who are listening are aware of some of these and can rattle them off:
But what do you see as underappreciated vulnerabilities on each side that might reinforce this uneasy equilibrium? Are there things that we’re not talking about enough where there is mutual dependence?
Well, I’ll offer a few.
When I was in China last December, I was discomforted to be reminded in almost every meeting about America’s dependence upon active pharmaceutical ingredients from China, APIs. And I don’t think that that was just sort of a stream of consciousness idea that bubbled into the minds of everyone we were sitting down with. It was a reminder that rare earths aren’t the only source of American dependence upon China.
Similarly, I think for China, they are painfully aware of their dependence upon the United States and the West for:
But also at a more intangible level, access to America’s higher educational system. This is something both from the students themselves and their future contributions to Chinese society, but also Chinese leaders’ ability to keep that door open for students, the children of their peers, is critically important. And if the relationship were to deteriorate, we’ve already seen that this is something that the Trump administration has considered using as a retaliatory tool.
Now he’s talking about 600,000 Chinese students in America. I guess maybe he thinks about them as a service export rather than as human beings who contribute to the flourishing of our academic community.
But whatever the case, I think that having Chinese students in the United States enhancing the education of classrooms that they’re a part of is a net benefit for the American people.
So, Ryan, in this scenario, you kind of suggest that the way we score this is by measuring who reduces dependence faster. I mean, if we look out five, ten years from now, which side do you think is better positioned to actually succeed in reducing those dependencies? I mean, who’s working hard at this?
But what’s your assessment of this?
Well, we have a tendency to swing from one extreme to the other in the way that we talk about this in Washington. A few years ago, Kaiser, you and I were talking about peak China, whether it’s a serious thing, how should we think about it? Everyone was focused on all of China’s weaknesses, vulnerabilities, and soft spots.
In recent months, it feels like the pendulum has swung to the other extreme where China can make everything. China can do anything. Ten foot tall again, right?
The world is sort of gravitating towards China. The United States is in dire straits. I’m uncomfortable with either of those extremes.
I think that China does have profound challenges, but it also has immense strengths. Neither of those are going to go away anytime soon. We have to get comfortable to be able to look at both of those side by side.
And the same can be said of the United States.
I will just make one observation that I hope is in service of answering your question, which is that I am deeply uncomfortable with the direction that our country is headed in certain respects. I think that right now the social fabric of the country is tearing, and national unity is the foundation of national strength.
No country can be stronger on the world stage than it is at home.
What we are watching in Minnesota and elsewhere is deeply troubling, both for me from a spiritual standpoint, but also just from a civic standpoint, and also in a measure of national power.
Secondly, I worry very much about America’s alliance network fraying and unraveling. Alliances traditionally have been a force multiplier of American influence on the world stage. Now, I think that our alliance network exists more in name than function.
This is going to be a long-term cost that the United States is going to pay for the moment that we find ourselves in.
But more fundamentally, and this I think, speaks most directly to the question that you’re asking, I worry that America’s economic competitiveness is eroding somewhat.
I just feel like at a certain level, President Trump is pursuing a 19th century strategy of assuming the control of natural resources will be the source of national power. We find ourselves in a different world today.
I think that his resource obsession is a strategic distraction.
For me, the goal needs to be to stimulate growth.
Growth comes from productivity. Innovation and diffusion come from:
- Talent
- Ideas
- Efficient allocation of capital
- A transparent and predictable legal system
This is how America gains strength.
The further we turn from that, the more that I fear we will lose our ability to achieve the sort of escape from dependence that your question was anchored in. Yeah, I mean, it’s so frustrating to be, this is a man whose favorite metaphor is cards, but, you know, he’s talking about who’s got the stronger hand, you know, who holds more cards.
It feels like somebody’s got to be able to convince him that what he’s been doing by, like you say, turning away talent at the border, by destroying those things like predictability, rule of law, alliances, all these things, you know, that act as force multipliers for us.
He’s plucking valuable cards out of his hand and, you know, lighting them on fire to light his cigars. It’s just bizarre.
I mean, I feel like at this point, Beijing must look at, you know, the hands that each side holds and conclude that there’s some very pronounced asymmetry here.
I feel also like that could really make this equilibrium that you described in scenario three more fragile. I mean, if one side succeeds faster than the other in reducing vulnerability, and right now it looks like China’s succeeding faster in reducing vulnerability, that actually seems like it would destabilize this equilibrium.
I agree with you if the equilibrium is measured in bilateral terms only.
And I thought that Adam Tooze made a very important point in the interview that you flagged to his with Ezra Klein after Davos, which is that if we are thinking about the world as undergoing a power transition from the United States to China, it is going to trigger all the anxieties, insecurities, and antibodies in the United States about China’s rise and compel us to try to suppress it.
And if we rather think about what’s going on in the world, not as a power transition, but as a power diffusion, where the United States is not significantly declining, but power is growing much more diffuse in the international system. The international system is splintering. It’s growing more disordered.
Then the nature of the challenge shifts, and the way that we think about and address and respond to it also evolves.
I am much more inclined to the latter view, that we’re seeing a splintering and a diffusion of power rather than a transition in power. But this is going to be, I think, sort of a core aspect of the debate that will be underway about the way that America relates to the world for the next couple of years.
Yeah, it’s interesting. I seized on that metaphor that Tooze used, too.
And I started thinking about that kind of moral panic securitization that we’ve seen in this country as an autoimmune response.
“You’ve got to take some goddamn antihistamines and chill.”
I agree with you that this scenario, this third scenario that you describe, is probably the most likely.
Does this framework, just stepping back, suggest that we’ve entered a phase right now where U.S.-China relations are less about, you know, trying to build trust or establish shared norms and more just about engineering resilience under assumed conditions of enduring mistrust?
I mean, where each side, you know, we’ve got a hand on the other’s choke points,
It’s, you know, I guess it’s structurally analogous to, obviously not identical to, kind of, you know, mutual assured destruction during the Cold War.
If that’s right, how should it change the way policymakers even think about stability?
Well, it’s a great question. I am inclined to your second scenario that you just described. I do think that we’re both sort of holding each other’s oxygen tubes to a certain extent.
I don’t think that there’s any outbreak of goodwill or warm, fuzzy feelings towards each other right now. And I also think that we’re in a pretty fraught moment. Both countries believe that they are gaining a certain degree of advantage over the other or that they can do immense harm to the other.
But on top of that, if you look at, you know, social science work and some public polling data,
And so this isn’t the time. We are not at a moment where there’s going to be some grand breakthrough in the relationship.
I think that if we manage it well through this coming period, we will have done a service as stewards of a long-term relationship rather than as authors of some concluding chapter to it.
Well put. Beautiful.
A final question to you. I mean, if listeners wanted to just cut through the rhetoric and only watch for just a handful of real concrete indicators over the next, say, 12 to 18 months, what would you tell them to focus on to assess which scenario we’re actually in or which we’re careening toward?
I would encourage people to watch the frequency of interaction between the two leaders,
- how often they talk on the phone,
- how often they acknowledge exchanging views through each other as ambassadors or intermediaries.
I would pay attention to the degree to which both sides are preparing for engagements, direct face-to-face summits between the two leaders, whether this is a professional process or just sort of a slapdash trip across the ocean. I would watch to see how well the United States is doing in terms of building or stockpiles, reducing its sort of vulnerability to shocks in the industrial supply chain system from China.
And similarly, I would watch to see the degree to which China is sort of making progress and innovating around some of the export controls and other obstacles that the United States has put in its development path.
So how important are atmospherics going to be around the April Trump visit to Beijing? Well, I think it’ll be significant.
You know, it’s somewhat ironic, Kaiser, because traditionally, the United States trades form for substance. You know, we decide to negotiate away different sort of bells and whistles of a Chinese leader’s visit to the United States in exchange for substance. Because we know that the Chinese leader cares deeply about the imagery that comes out of such engagements because
it bestows respect and gives people inside China pride that their leader is being treated with dignity on the world stage.
Now, I think we’re in a moment where sort of the roles are reversing, where it’s President Trump will be committed to the trappings of dignity and respect, and we’ll want something grander and more dramatic than what he experienced with the state visit plus in 2017 or 18. 17 it was, yeah. I expect that he will probably go to a second city this time as part of his trip.
And so how he is received by the public, but also, you know, the imagery that comes out of that will be important to him. But ultimately, I think that the measure will be to what extent has his travel to China benefited the American worker and the American people. And, you know, we’ll have to see.
Well, I will be there on the ground in Beijing in April. I’m leaving very soon. In fact, just two weeks from now. And I will report faithfully. I’ll do a couple of shows about, you know, preparations for the Trump visit and see how that plays out. Because I think that is a very, very telling indicator.
And I think you’re absolutely right. We are in this world right now where the Trump presidency cares very much about all the symbolism, the pageantry, all the sort of etiquette and the formalism of it. And I think Beijing knows that. Beijing knew that before November 2017 when he went. They sort of turned up the flatterometer to very, very high. They know how to do this.
Well, I will be listening carefully to your reporting from on the ground, Kaiser.
Well, thank you, Ryan. Make sure to read the piece. It’s on the Brookings website and everything else that Ryan writes because it’s all super, super good.
Ryan, thank you so much for taking the time to chat with me. Let’s move on to paying it forward. Do you have a younger colleague or somebody who you’ve been working with who deserves a shout out here on the show?
I do this selfishly because, you know, I’m looking to cultivate, you know, new guests to bring on. I would point to Audrey Wong, who is an incredibly thoughtful, talented researcher, writer, public intellectual, who is doing tremendous work explaining China’s economic orientation to the world.
Fantastic.
And we can find her stuff on Brookings?
Audrey, I believe she’s at USC right now.
Oh, okay. Cool. Excellent. Audrey Wong. I will look out for her.
And what about recommendations? As you know, we do a recommendation every week. What do you have for us? You got a book or a film or some music, a travel destination, something that you want to recommend?
You know, Kaiser, I wish that I had something super cool to share. I’m going to just default to a book recommendation from Robert Sutton. He wrote The Conscience of the Party, the biography of Hu Yaobang.
And it’s as much just a gripping human story about Hu Yaobang, the last reformer in China, as it is a sort of an x-ray of the Chinese Communist Party system and the way that it operates and how it operates. So it’s for anyone who’s sort of interested in the functions of the party. I think that Robert’s book is a tremendous starting point.
That’s been on my list for a while. I really need to finally get around to reading it.
That’s an excellent recommendation. Thanks, Ryan.
So I’ve got a book as well, as well as a couple of China-related things. But my book is just for fun. I’ve been reading the long-lost final book that Alexander Dumas wrote. The English translation that I have is called The Last Cavalier, but it’s also known as The Knight of Saint-Hermain. The French title is Le Chevalier de Saint-Hermain.
But either way, it is a really fun bit of Napoleonic-era historical fiction in which actually Napoleon himself is a major character. And Dumas gives him a really kind of believable personality. I mean, much better than Ridley Scott gave him in that lamentable film, which I hope none of you had to suffer through.
But there are loads of fascinating characters. Many of them are historical. It sent me skirting to Wikipedia many a time just to sort of look these people up. But it’s also just got a ton of historical material mixed in. It’s got letters and decrees and courtroom proceedings, all kind of jumbled into the fictional stuff.
I mean, the story, the plot is a bit of a shaggy dog. It’s maybe, you know, 40% fewer total tangential plot lines might have made this book a little more sort of readable. But it’s still worthwhile if you’re interested.
Dumas actually writes himself or his father. I mean, he does this sort of breaking the fourth wall thing where he suddenly starts talking to the first person and then talks about his father, who was this Napoleonic general, who’s also Alexander Dumas.
It’s anyway, great stuff to take your mind off the world as it is. But still, you kind of get to scratch this itch for, you know, political turmoil and intrigue. If you’re listening to this show, you probably have such a niche.
For a couple of quick China-related recommendations, some really good sense-making of the Chinese economy has dropped just in the last couple of days for the day we’re taping. Check out the Asia Society conversation led by Lizzie Lee, who listeners will know, of course, from her many appearances on the show.
She’s joined by two of my faves:
It’s about the challenges of rebalancing the Chinese economy, but it goes way beyond that. It goes, you know, into the – obviously, you know, the problems of the property market and much else. It’s as good as you would expect with these three all taking part.
Related to that is the latest outstanding Trivium China podcast, of course, which you can find on the Sinica Network. It’s hosted by Andrew Polk, and it is just a banger of an episode.
Joe Peisal, who heads macro research at Trivium, is the guest for the first half, and they do this thing that they’re going to be doing every month or so, just looking at the macro numbers. But this one sort of looks at just – not just macro numbers for Q4, but for the year. And it’s a great survey.
The second half, though, features Danny McMahon and Corey Combs, who are both absolutely brilliant.
They are both really brilliant. It’s on, you know, why China is facing headwinds on boosting capital expenditure, which, if you follow the Chinese economy, you’ve probably heard, dropped really, really precipitously in the last quarter. So check out those shows.
I’m a neophyte soul when it comes to the Chinese economy, but I’m always interested in learning. So these guys have taught me just enormous amounts.
Anyway, Ryan, great to have you on again, man. And this is going to be a very Brookings-heavy month because I’m going to be talking to your colleagues, Kyle Chan and Patty Kim about the work of theirs recently.
“Delighted to hear it, and thanks for having me on, Kaiser.”
Thank you. You’ve been listening to the Sinica Podcast. The show is produced, recorded, engineered, edited, and mastered by me, Kaiser Guo. Support the show through Substack at SinicaPodcast.com, where you will find a growing offering of terrific original China-related writing and audio.
Email me at [email protected] if you’ve got ideas on how you can help out with the show. Do not forget to leave a review on Apple Podcasts.
Enormous gratitude to the University of Wisconsin-Madison Center for East Asian Studies for supporting the show this year. And, of course, huge thanks to my fabulous guest, Ryan Haas, who is always a favorite, fan favorite, my favorite.
I’m really – thank you, Ryan, once again. Thank you, guys. Thanks for listening. We’ll see you next week. Take care.
