when we started the project I was like

yeah well let's see you know where

Microsoft maybe maybe we'll get like 25%

of the community to take an interest or

or that would have been success but to

get to this point I'm floored you know

and our entire team is floored and and

and super grateful obviously you know

that our work is is that relevant to

that many people there's nothing more

satisfying than working on something

that you know is making a

TypeScript from day one was self-hosted

right uh and written in itself and that

meant that TypeScript the compiler the

tool set everything runs simply as a

JavaScript app precisely because of this

massive adoption and and like the ever

growing size of projects that that our

users build. You know scalability has

just become the number one issue. As

much as it pained us to to give up on on

self-hosting, we also knew that we just

could not bring any more performance.

And so we experimented with different

languages. We experimented with C. We

experimented with with a bunch of other

stuff. We ended up choosing Go as the

language to port to. We quickly realized

we could get 10x half of it from being

in native code and the other half of it

from being able to take advantage of

shared memory concurrency. You can't

just like ignore 10x. Do you know what I

mean? God damn. That changes everything.

That makes things that took minutes

instead take 10 seconds.

You have to go with it, right? And we

really have a compiler now in native

code that functionally is a carbon copy

of the old compiler. I mean like down to

the quirks. And that means the community

doesn't have to throw it all away.

Open source is a big experiment, right?

And then we're talking about like like

these issues of like like no one's

really figured out how to fund open

source, but yet there it is and it's

bigger than ever, right? And and and

it's not going away and it's and it just

keeps on growing and there's more and

more knowledge and ability that we're

capturing in all of this code that

that's out there. There's a lot of noise

too. uh and a lot of it isn't being

maintained and whatever but still it's

like it's like it's evolution captured

you know right there and this notion now

that we have like we've been on GitHub

for 12 years we have 12 years of history

captured in there right searchable like

if I know someone talked about we we did

there was an issue on this somewhere

let's let's just find it now the search

could be better

um and I'm I'm sure AI hopefully will

help on on that too right but but it's

air. There's so much value there, you

know, and and and I'm just I'm so

pleased that that it continues to grow

uh and survive.

I've had a lot of people ask me, "Oh,

why don't you go design the perfect

programming language for AI to target?"

AI's abilities in a particular writing

code in a particular language is

directly proportional to how much of

that code it has seen because it is a

big regurgitator if you will of stuff

that someone has done with some

extrapolation on on top of it right and

well we we know from the data right that

AI has seen a lot of JavaScript and a

lot of Python and a lot of TypeScript

and therefore it's pretty darn good at

writing code in those languages and so

the best language anguage for AI is the

language that AI has seen a lot of and

that means you don't new programming

languages are actually disadvantaged.

We want a very deterministic outcome

here. We want to port half a million

lines of code and know that they do

exactly what the old lines of code did.

If you ask AI to translate them, it

might hallucinate a little bit here and

there and whatever. And now you got to

like go carefully examine every line of

code. And so that's probably not the the

best way to do these massive ports. It

might actually be better to ask AI to

generate a program that helps you do the

port because then when you run that

program, you get a deterministic

outcome. We have a whole bunch of pull

requests that have happened in the old

codebase whilst we were building the new

codebase like hundreds of them that we

need to get moved over. Now we've

actually been using AI fairly

successfully to do that, right? where

you don't have to go in and oh god now

because now there's some there's enough

body that that AI can look at and AI's

gotten good enough that we can automate

some of that.

AI started out being the assistant but

you were still in control sitting in the

ID and it was just aiding you and typing

faster and completing stuff faster,

right? But now it's switching around.

The AI is doing the work, right? and and

you're supervising what it's doing and

and it doesn't necessarily need an IDE

in the same way that we need idees,

right? it still needs the services and

that's why like all of this MCP stuff is

becoming interesting and and and

connecting language services to MCP and

and having giving AI the ability to ask

semantic questions or or refactoring

questions or whatever and get sort of

boxed in determinism around certain

workflows, right? But still do sort of

the equivalent of what you would do in

an IDE but do it the LLM way or the

agent way. Um, that's going to change

development tools dramatically.