[00:00] (0.16s)
Today I think AI is not just a higher
[00:02] (2.24s)
level language abstraction or something
[00:03] (3.52s)
like that. But could it become one over
[00:05] (5.60s)
time? That's the question. I don't do
[00:07] (7.28s)
you do you think yes? I I think it
[00:09] (9.12s)
could. If if I look at a classic say
[00:11] (11.04s)
compiler design or or you know in in in
[00:13] (13.36s)
in programming languages, if I would
[00:15] (15.84s)
have LLMs as a tool, I would probably
[00:19] (19.20s)
think very differently about how I would
[00:20] (20.64s)
build a compiler. Yeah. And I don't
[00:23] (23.28s)
think we've seen that work its way
[00:25] (25.36s)
through yet. But if if I can basically
[00:26] (26.64s)
define certain things in human language
[00:27] (27.76s)
in efficient way and you know maybe in a
[00:30] (30.56s)
sort of tight enough way that can use
[00:31] (31.92s)
this directly as as input for a compiler
[00:34] (34.56s)
that could change a lot of
[00:43] (43.32s)
things. We're pretty sure it's the
[00:46] (46.24s)
second biggest AI market right now.
[00:49] (49.04s)
Correct me guys if I'm wrong, but you
[00:50] (50.72s)
know consumer pure chatbot I think is
[00:52] (52.80s)
number one and I think coding is number
[00:55] (55.04s)
two. just purely purely looking at the
[00:56] (56.72s)
numbers but consumer is the aggregation
[00:58] (58.64s)
of a lot of different exactly right
[01:01] (61.04s)
that's how I define market I think
[01:02] (62.36s)
there's you can make an argument it's
[01:04] (64.40s)
the number one actually if you look at
[01:06] (66.08s)
really homogeneous markets is coding
[01:08] (68.32s)
bigger than companions yes I think so
[01:11] (71.04s)
yeah yes at this point it is you think
[01:12] (72.80s)
so that'd be interesting it depends it
[01:15] (75.04s)
probably depends how how you classify
[01:17] (77.60s)
something like chat GPT which to some
[01:19] (79.68s)
degree is used for companionship so a a
[01:22] (82.48s)
large portion of chat GPT usage which I
[01:25] (85.04s)
think now is companionship. I think
[01:26] (86.80s)
that's right. Yeah. So, well, in the
[01:29] (89.44s)
end, you know, is is is a person's
[01:31] (91.68s)
motivation greater to build something or
[01:33] (93.52s)
to or to to find love? I think, you
[01:36] (96.24s)
know, you know, it may be neck and neck.
[01:39] (99.04s)
One thing that's very unique about AI
[01:41] (101.52s)
coding that's sometimes under
[01:42] (102.64s)
underappreciated is this was actually an
[01:44] (104.48s)
existing behavior in in a couple of
[01:46] (106.48s)
ways. First, people were already going
[01:48] (108.56s)
somewhere to look for help, which which
[01:50] (110.40s)
we mentioned earlier is is Stack
[01:51] (111.84s)
Overflow for for the most part. So there
[01:53] (113.52s)
was already sort of this muscle people
[01:55] (115.20s)
were exercising when they hit a problem
[01:57] (117.04s)
they couldn't solve to go find the
[01:58] (118.32s)
information on the internet and this is
[02:00] (120.00s)
really just a much better form of that.
[02:02] (122.80s)
you know, there are all these jokes that
[02:04] (124.00s)
Stack Overflow is actually writing most
[02:05] (125.68s)
of the code, you know, for the last, you
[02:07] (127.36s)
know, x number of years. A lot of that
[02:09] (129.44s)
may just shift to to AI models, right?
[02:11] (131.36s)
It's not clear if that was a joke or
[02:12] (132.88s)
not, but yeah. Yeah. Maybe maybe not a
[02:14] (134.56s)
joke. Also, there was this thing called
[02:15] (135.92s)
GitHub copilot, right? They did this
[02:17] (137.36s)
really foundational work to start to
[02:19] (139.32s)
transition people off of that sort of
[02:21] (141.28s)
Stack Overflow use case to uh to, you
[02:24] (144.00s)
know, using AI models. And I think
[02:25] (145.76s)
companies like Cursor have just done a
[02:27] (147.20s)
much better job with that now. and and
[02:29] (149.52s)
and so you have this fairly unique thing
[02:31] (151.20s)
that you're actually taking advantage of
[02:32] (152.48s)
a an existing user behavior an existing
[02:34] (154.40s)
market and like selling a great product
[02:35] (155.76s)
into it. I think there's one other
[02:37] (157.04s)
aspect which is look if you're a
[02:38] (158.96s)
developer and you have access to the
[02:40] (160.40s)
latest AI technology the first problem
[02:41] (161.76s)
you solve is are your own problems right
[02:44] (164.08s)
so I think it's uh developers just
[02:46] (166.00s)
that's the problems they understand best
[02:47] (167.60s)
that's the problems they they face every
[02:49] (169.20s)
day and so they build infrastructure for
[02:50] (170.88s)
themselves to use and developers are
[02:53] (173.12s)
always early adopters for new
[02:55] (175.52s)
technologies just because like naturally
[02:57] (177.84s)
they're they like to tinker uh they like
[02:59] (179.84s)
to configure net new tools and they're
[03:01] (181.84s)
lazy so anything that actually you know
[03:05] (185.12s)
increase the productivity they will
[03:06] (186.56s)
adopt but I also think coding market is
[03:09] (189.84s)
doing so well also because it's somewhat
[03:11] (191.84s)
verifiable problem like you can verify
[03:14] (194.32s)
if like a coding function like input
[03:16] (196.32s)
output are very clear compared to like
[03:18] (198.96s)
user preference you know uh and all the
[03:21] (201.44s)
other problems and you can also reframe
[03:24] (204.88s)
a lot of different uh problems into
[03:27] (207.52s)
coding so I would even argue that some
[03:29] (209.68s)
of the art generation is a coding
[03:31] (211.28s)
problem people will not like it but like
[03:33] (213.20s)
historically we always used machine
[03:35] (215.12s)
learning learning before we call it AI
[03:36] (216.72s)
in Adobe Photoshop and you know like
[03:39] (219.28s)
that's somewhat coding you can really
[03:41] (221.36s)
map the trajectory of brushes that's
[03:43] (223.20s)
coding vector generation is also coding
[03:45] (225.84s)
so I think the beauty of code is that
[03:48] (228.16s)
you can really remodel a lot of the real
[03:50] (230.00s)
world problems and make it into very
[03:51] (231.76s)
machine consumable formats I think
[03:54] (234.24s)
there's one other aspect which is it's
[03:56] (236.40s)
it's a it's a massive market like if you
[03:59] (239.20s)
if you think about this we have 30
[04:00] (240.64s)
million developers worldwide let's say
[04:02] (242.88s)
average value created by developers is
[04:05] (245.20s)
$100,000 a year. That's $3
[04:07] (247.80s)
trillion. Right? I think we if I look at
[04:10] (250.16s)
the data we've seen from some of the
[04:11] (251.92s)
large financial institutions, they're
[04:13] (253.92s)
estimating that the increase in
[04:16] (256.24s)
developer productivity from just a
[04:17] (257.84s)
vanilla co-pilot deployment is something
[04:19] (259.52s)
like 15%. My gut feeling is we can get
[04:22] (262.32s)
that substantially higher, right? Let's
[04:24] (264.16s)
assume we can double the productivity of
[04:26] (266.24s)
a developer. For all developers in the
[04:28] (268.32s)
world, that's $3 trillion worth of
[04:30] (270.88s)
value, right? That's the value of Apple
[04:32] (272.32s)
computer or something like that. It's an
[04:33] (273.68s)
incredible amount of value that we
[04:34] (274.80s)
unlock there. So it's it's it's a
[04:36] (276.16s)
massive market and I mean there was I
[04:37] (277.84s)
think it was last year when there was
[04:39] (279.44s)
you know a good blog debate on on you
[04:41] (281.68s)
know if we're overinvested in AI and I
[04:43] (283.84s)
think back then the number was is $200
[04:45] (285.44s)
billion annual investment you know
[04:48] (288.08s)
something would ever you know recuperate
[04:50] (290.80s)
here we have a way to recuperate $3
[04:52] (292.56s)
trillion right so that makes the the 200
[04:54] (294.96s)
billion look like peanuts. I think what
[04:57] (297.20s)
might also be at work is it's it's an
[04:59] (299.04s)
easy market to capture because
[05:00] (300.24s)
developers understand it and it's it's a
[05:02] (302.48s)
very very big market something
[05:04] (304.16s)
potentially it might be the first really
[05:06] (306.16s)
large market for AI in terms of in terms
[05:08] (308.00s)
of driver. Yeah. No, that's that's a
[05:09] (309.36s)
great point. Software and software
[05:10] (310.64s)
developers create a huge amount of value
[05:12] (312.40s)
at every company and every organization
[05:14] (314.32s)
around the planet now and this is sort
[05:16] (316.00s)
of a shortcut you know into into this
[05:18] (318.00s)
sort of core capability. So so that that
[05:19] (319.92s)
makes a lot of sense.
[05:21] (321.20s)
There's almost a bootstrapping effect to
[05:22] (322.80s)
your point too Guido because if you
[05:24] (324.40s)
count not only the productivity gains
[05:26] (326.40s)
but like the brand new things that are
[05:28] (328.08s)
being created with these with these
[05:29] (329.60s)
models like you kind of I think can see
[05:31] (331.12s)
a cycle starting where you're getting
[05:33] (333.52s)
better and better AI coding models which
[05:35] (335.12s)
allow you to kind of create better
[05:36] (336.56s)
better absolutely software you know
[05:38] (338.24s)
better new net new AI applications also
[05:45] (345.04s)
once the AI revolution has run its
[05:47] (347.28s)
course do we have any idea how the job
[05:50] (350.72s)
of a software developer will look like
[05:52] (352.40s)
right it look different from today I
[05:53] (353.76s)
think we're seeing that when I'm writing
[05:54] (354.88s)
code today I'm I'm writing
[05:56] (356.72s)
specifications I'm having discussions
[05:58] (358.16s)
with a with a model about how to
[05:59] (359.84s)
implement something um you know I'm I'm
[06:02] (362.28s)
I'm in for easy features I can actually
[06:04] (364.80s)
ask it to implement a feature and just
[06:06] (366.40s)
reviewing it how will the process be
[06:08] (368.32s)
different will there still be the same
[06:09] (369.68s)
stages will there will we all turn into
[06:12] (372.24s)
basically product managers that write
[06:14] (374.48s)
specifications and then the AI writes
[06:16] (376.08s)
the code and you just step in
[06:17] (377.36s)
occasionally to debug or what is the
[06:19] (379.44s)
what's the and state yet. Do we have any
[06:20] (380.96s)
idea at this point? Or we all become QA
[06:23] (383.20s)
engineers and we test if it's to the
[06:25] (385.12s)
spec. There we go. That is kind of
[06:26] (386.88s)
ironic, right? We all got into this to
[06:28] (388.56s)
avoid being QA engineers. I like what
[06:31] (391.20s)
you were saying, Guido. Maybe we could
[06:32] (392.56s)
each just talk a little bit about how we
[06:34] (394.96s)
use AI models in coding right now. Like
[06:38] (398.00s)
can you share a couple of stories about
[06:39] (399.60s)
how this has changed your your coding
[06:41] (401.12s)
workflows? to totally and I mean boy I'm
[06:44] (404.16s)
not sure I'm even the I'm probably maybe
[06:45] (405.68s)
the person coding least here but but the
[06:48] (408.32s)
I think the the the most interesting
[06:49] (409.92s)
insight is it has changed a lot over the
[06:51] (411.92s)
last even 6 months how I use these
[06:54] (414.32s)
models right it used to be
[06:55] (415.80s)
that you take your favorite uh you know
[06:58] (418.56s)
chatpt or something like that and you
[07:00] (420.08s)
give it a prompt and out comes a program
[07:01] (421.52s)
and you copy that into your editor and
[07:03] (423.44s)
you know you you see if it works or not
[07:05] (425.20s)
right that was that's sort of the stack
[07:06] (426.64s)
overflow replacement thing is like when
[07:08] (428.96s)
you inevitably hit a problem instead of
[07:10] (430.48s)
going to Stack Overflow you go stat uh
[07:12] (432.56s)
chatgbt and it actually gives you code
[07:14] (434.16s)
back copy paste but from a different
[07:16] (436.08s)
source right and this was like six
[07:18] (438.24s)
months ago this was state-of-the-art
[07:19] (439.60s)
this wasn't like that long ago maybe
[07:20] (440.96s)
nine months nine months ago yeah 9
[07:22] (442.40s)
months but then uh so then the next step
[07:24] (444.40s)
was you started having integrated things
[07:26] (446.48s)
that are integrated in your IDE right
[07:28] (448.56s)
GitHub copilot then cursor that
[07:30] (450.80s)
basically allows you to use autocomplete
[07:33] (453.28s)
which is a big step forward right it's
[07:34] (454.72s)
no longer like monolithic questions but
[07:36] (456.40s)
but it's sort of in the flow then this
[07:38] (458.32s)
split up into autocomplete at a line
[07:41] (461.20s)
level. I can ask questions about
[07:43] (463.04s)
paragraphs or I can have a um you know
[07:45] (465.60s)
sort of a separate chat interface where
[07:47] (467.76s)
I can have longer discussions. Then the
[07:50] (470.56s)
IDE started to be able to use command
[07:52] (472.32s)
line tools. So suddenly I can say hey
[07:53] (473.84s)
can you set up you know my new Python
[07:55] (475.60s)
project with UV or something like that
[07:57] (477.28s)
and and um it could could basically run
[07:59] (479.36s)
commands to to do all that work. And I
[08:02] (482.48s)
think where we are today is when I write
[08:04] (484.88s)
want to write a new piece of software or
[08:07] (487.20s)
you know this is this is not production
[08:08] (488.56s)
code right? this is like but I want to
[08:10] (490.00s)
try something out. The first thing I do
[08:12] (492.08s)
is I start writing a spec, right? I'm
[08:13] (493.84s)
start basically a very high level.
[08:15] (495.20s)
Here's what I'd like to do. And it's,
[08:16] (496.64s)
you know, still fairly abstract and not
[08:18] (498.08s)
very well thought through. And then I
[08:20] (500.24s)
basically ask, you know, the the model,
[08:23] (503.36s)
maybe something a set 3.5 or 3.7 or
[08:26] (506.80s)
Gemini, here's here's what I'd like to
[08:28] (508.56s)
do. Does this make sense? Please ask any
[08:30] (510.64s)
questions that are unclear. And then
[08:32] (512.56s)
write me a more detailed spec. And then
[08:34] (514.96s)
the model gets to work. And usually
[08:36] (516.08s)
there's lots of questions for me. It's
[08:37] (517.20s)
like, hey, you know, I need an API key
[08:39] (519.28s)
for that. you know, very simple things
[08:40] (520.72s)
or more complex things like, you know,
[08:42] (522.16s)
how do you want to manage stage? Should
[08:44] (524.00s)
we put this in a database? Should we
[08:45] (525.12s)
just dump it into a file or something
[08:46] (526.40s)
like that? And so it's it's basically a
[08:48] (528.40s)
back and forth discussion that helps me
[08:50] (530.80s)
clarify my thinking. And the the model
[08:53] (533.36s)
is almost a sparring partner to think
[08:55] (535.52s)
through the process, which is really
[08:57] (537.44s)
weird in a way, but it it works, right?
[09:00] (540.24s)
Uh and you know, and and so over time
[09:02] (542.72s)
you basically get more detailed specs
[09:04] (544.16s)
and only when you have them, then you
[09:05] (545.52s)
ask the model to start implementing. And
[09:07] (547.92s)
all of that comes with a fair amount of
[09:09] (549.28s)
context. You know, you also together
[09:11] (551.44s)
with the model I have my standard Python
[09:13] (553.44s)
coding guidelines. This is how I like to
[09:14] (554.88s)
do commenting. This is how I like to do,
[09:16] (556.56s)
you know, more object-oriented versus
[09:18] (558.72s)
more procedural is how I like to
[09:20] (560.48s)
structure my classes. I'm an
[09:22] (562.16s)
object-oriented guy. So, we're talking
[09:24] (564.72s)
Java here or what? No, Python, right?
[09:27] (567.68s)
Yeah. Do you want to have type Python or
[09:29] (569.76s)
untype Python? All these things, right?
[09:31] (571.12s)
So, it's it's a lot about context. It's
[09:33] (573.04s)
a lot about explaining your general
[09:35] (575.04s)
development methodology. It's a lot
[09:36] (576.56s)
about a back and forth with a model now
[09:38] (578.56s)
where you sort of together figure out
[09:41] (581.28s)
something. That's how I'm how are you
[09:43] (583.60s)
coding? I guess like compared to maybe
[09:45] (585.84s)
six months ago uh how I use coding agent
[09:48] (588.48s)
nowadays is um I give it more of the
[09:51] (591.04s)
world knowledge. Before I was mostly
[09:53] (593.28s)
relying on what's a foundational models
[09:55] (595.36s)
knowledge and it's funny because when
[09:56] (596.72s)
you ask the coding agent when do you
[09:58] (598.24s)
think today is it's always like 2023 and
[10:01] (601.20s)
then all the specs I will give you are
[10:03] (603.52s)
from like 2024 at best. So depending on
[10:06] (606.08s)
when the knowledge cut off is nowadays I
[10:08] (608.72s)
think it's very natural for me to like
[10:11] (611.12s)
uh reach out to like linear here's a
[10:13] (613.12s)
ticket and I just give my idea uh pull
[10:16] (616.24s)
my idea into cursor cursor agent will
[10:18] (618.64s)
take a first step at implementing it. So
[10:20] (620.80s)
that's one kind of workflow change. The
[10:22] (622.88s)
other one is more user prompted like uh
[10:26] (626.32s)
active queries. So before um I may need
[10:30] (630.00s)
to copy paste documentation into my
[10:32] (632.64s)
little cursor window. Now I just ask the
[10:35] (635.12s)
cursor agent to like hey can you use
[10:37] (637.28s)
fire crawl to go search for the most
[10:38] (638.88s)
up-to-date uh you know uh like clerk
[10:41] (641.32s)
documentation and it will actually fetch
[10:43] (643.60s)
a page and it will you know read up that
[10:46] (646.24s)
works. Yeah it actually works and then
[10:47] (647.76s)
it will mp it uses MCP but it's
[10:50] (650.48s)
likeation detail it could be a tool call
[10:52] (652.72s)
or whatever but it's there's more
[10:54] (654.24s)
integration to the real world now. You
[10:56] (656.08s)
guys sound much more planful than than
[10:58] (658.32s)
me. I always, you know, the scenario for
[11:00] (660.72s)
me is like Saturday night I finally have
[11:03] (663.92s)
an hour free and I have a weird idea for
[11:06] (666.80s)
an app and I just dive right into it and
[11:08] (668.88s)
like ask ask cursor to do everything.
[11:10] (670.88s)
And I've always found it works really
[11:12] (672.40s)
well for high complexity, high kind of
[11:16] (676.24s)
annoyance factor things like front end
[11:19] (679.28s)
like if anybody on earth can remember
[11:21] (681.60s)
all of the CSS classes that people use
[11:23] (683.84s)
now for margins and padding it's it's
[11:25] (685.92s)
like it's you know I I don't think that
[11:27] (687.68s)
person exists. I center a div yet? Yes.
[11:30] (690.48s)
Oh, yeah. We should do a benchmark on
[11:33] (693.04s)
centering a div. Totally. Yeah, we Yeah.
[11:35] (695.76s)
tutorial on div center. I mean, it's one
[11:37] (697.76s)
of these it's one of these hard problems
[11:39] (699.44s)
for for no reason, right? There's just
[11:41] (701.28s)
like five different ways to center text
[11:43] (703.44s)
and elements and and I can never
[11:45] (705.20s)
remember any of them, right? And and and
[11:46] (706.88s)
you know, AI models are really good at
[11:48] (708.88s)
this, right? Um and they now can do it.
[11:51] (711.28s)
When you start going to more niche
[11:53] (713.52s)
libraries and function calls, that's
[11:55] (715.04s)
where I always run into trouble. So, so
[11:56] (716.56s)
I love this fire crawl kind of idea
[11:58] (718.80s)
because usually I'm hunting for docs and
[12:00] (720.72s)
then putting them back in or something
[12:01] (721.92s)
like that. Yeah, sometimes I also copy
[12:04] (724.00s)
paste like a milify doc because they
[12:05] (725.60s)
have the lm.ext on like the um developer
[12:09] (729.52s)
tool docs. I just give the URL add doc
[12:12] (732.16s)
and then enter the URL and ask cursor to
[12:15] (735.44s)
implement that and that works too. Has
[12:17] (737.84s)
anything gone really wrong for you guys
[12:19] (739.36s)
yet doing doing sort of AI assisted
[12:21] (741.44s)
coding? Not really wrong per se, but a
[12:24] (744.48s)
lot of how we code is dependent on the
[12:26] (746.80s)
agent behavior on how like the client
[12:29] (749.68s)
implemented the agent. One example is
[12:32] (752.00s)
there's this very cool tool that
[12:33] (753.68s)
actually generate like very pretty pages
[12:36] (756.00s)
and send back like a react component
[12:38] (758.40s)
like a HTML page for the coding agent to
[12:41] (761.60s)
refer to. So one time I asked cursor
[12:43] (763.84s)
agent to like reach out to this tool
[12:45] (765.84s)
implement based on whatever it told you.
[12:48] (768.24s)
Cursor agent's reaction was very
[12:49] (769.92s)
interesting. It look at the code, it
[12:51] (771.68s)
says, "Oh, this looks great. Let me give
[12:53] (773.52s)
you a new version." So, it didn't adopt
[12:55] (775.36s)
whatever that was returned. Interesting.
[12:57] (777.84s)
Yeah. Which is like a very interesting
[12:59] (779.04s)
like agent to agent communication.
[13:01] (781.04s)
Cursor agent is like, "I don't agree
[13:02] (782.64s)
with this direction."
[13:08] (788.56s)
So, you've done a bunch of work on MCP,
[13:10] (790.48s)
Yoko. How do you think that plays into
[13:12] (792.08s)
this? I think MCP to its essence is just
[13:15] (795.04s)
a way to provide context, the most
[13:17] (797.20s)
relevant context to LMS. So it helps
[13:20] (800.00s)
that a longtail MCP servers nowadays can
[13:23] (803.04s)
be leveraged whatever client you're
[13:24] (804.72s)
using. So that's what's you know
[13:26] (806.80s)
empowering the kind of experience I was
[13:29] (809.04s)
just describing. I can use linear MCP I
[13:32] (812.16s)
can use GitHub MCP to pull in the
[13:34] (814.08s)
relevant context and tool calling is
[13:36] (816.24s)
like a technical detail how they
[13:38] (818.16s)
implemented fetching the context but the
[13:40] (820.64s)
crux of the MCP is actually the context
[13:43] (823.60s)
part. what is the most relevant thing I
[13:46] (826.08s)
can provide to you as a model so you can
[13:48] (828.00s)
help me better. And so do you think
[13:49] (829.84s)
having these kinds of tools available in
[13:53] (833.96s)
means AI coding is kind of more
[13:57] (837.68s)
productive or a better fit for kind of
[13:59] (839.20s)
senior developers? Because because a a a
[14:01] (841.28s)
knock against this for a long time has
[14:03] (843.04s)
been that you know vibe coders for lack
[14:05] (845.28s)
of a better word are kind of producing
[14:07] (847.76s)
great demos and and you know junior
[14:09] (849.44s)
developers are kind of you know getting
[14:11] (851.04s)
up to speed faster but the people I've
[14:12] (852.80s)
always affectionately called neck beards
[14:14] (854.48s)
right the the people who you know own
[14:16] (856.56s)
the cluster and stop you from breaking
[14:18] (858.24s)
things or or you know like own the
[14:20] (860.24s)
overall architecture are sort of
[14:21] (861.60s)
skeptics. Do do you think this is one
[14:23] (863.44s)
one way to get you know the the the neck
[14:25] (865.60s)
beards engaged? I think it depends on
[14:28] (868.48s)
what the very senior engineers are
[14:30] (870.80s)
optimizing for. There are very senior
[14:33] (873.12s)
like application engineers who are just
[14:34] (874.72s)
very good at you know fleshing out
[14:36] (876.16s)
ideas. So like in this case it's like a
[14:38] (878.80s)
more evenly distributed skill set. You
[14:41] (881.12s)
just need to put the stack together. But
[14:42] (882.96s)
there are very senior engineers who are
[14:44] (884.72s)
say optimizing best thing in the world
[14:47] (887.04s)
for optimizing for distributed systems
[14:49] (889.76s)
that I think we're not quite there yet
[14:53] (893.28s)
just because the coding agent first like
[14:55] (895.28s)
it can't fetch any and all state of the
[14:57] (897.92s)
distributed system. It's a lot of human
[15:00] (900.40s)
you know like intervention when it comes
[15:02] (902.16s)
to like how to solve certain problems.
[15:04] (904.48s)
But I feel like we're on the way there
[15:06] (906.32s)
given enough context window, enough tool
[15:08] (908.80s)
calling capabilities to bring just the
[15:11] (911.52s)
right knowledge into the model. Today I
[15:14] (914.08s)
think most IDs have a limit on the
[15:16] (916.56s)
number of tools it can handle. I I
[15:18] (918.96s)
remember was like 40 or 50 or something.
[15:21] (921.04s)
So it naturally limits what's the
[15:23] (923.04s)
context and what's the tools that the
[15:25] (925.12s)
coding agent can leverage. I think that
[15:27] (927.52s)
there's sort of a a pattern that the
[15:30] (930.12s)
more sort of esoteric the problem is,
[15:32] (932.96s)
the more novel the problems you're
[15:34] (934.16s)
trying to solve, the more context you
[15:35] (935.52s)
have to provide. Right? If I'm like,
[15:36] (936.80s)
hey, write me a blog or, you know, what
[15:38] (938.72s)
is it? Write me a, you know, online um
[15:40] (940.80s)
um store like the the simplified
[15:42] (942.68s)
version, that's of a standard, I don't
[15:44] (944.96s)
know, undergradu software development
[15:46] (946.96s)
class problem. So, the amount of samples
[15:49] (949.04s)
on the internet is more or less
[15:50] (950.16s)
infinite. The models have seen this a
[15:51] (951.92s)
gazillion times. incredibly good in in
[15:54] (954.04s)
regurgitating um um this code. If you
[15:57] (957.68s)
have something for which there's very
[15:59] (959.04s)
little training code that typically all
[16:01] (961.52s)
goes away and it's all sort of you have
[16:04] (964.24s)
to specify exactly what you want. You
[16:05] (965.60s)
need to provide the context. You need to
[16:06] (966.96s)
provide the API specification. It's much
[16:08] (968.48s)
much harder and it will very confidently
[16:10] (970.16s)
give you a wrong answer too. I can't
[16:11] (971.92s)
tell you the number of times I'm like oh
[16:13] (973.68s)
my god this function exists. I had no
[16:15] (975.28s)
idea it's exactly what I needed. It's
[16:16] (976.72s)
like wait no it doesn't exist. Pure
[16:18] (978.16s)
hallucination and it's once it does that
[16:20] (980.56s)
it's very hard to get it off. Right. And
[16:22] (982.16s)
if you're saying like the function
[16:23] (983.20s)
doesn't exist, it hallucinates a new
[16:24] (984.48s)
one. It's like, "Oh, I'm so sorry.
[16:26] (986.00s)
Here's here's another function that
[16:27] (987.60s)
doesn't exist, that might work." Yeah. I
[16:29] (989.92s)
think what models today are very bad at
[16:31] (991.60s)
is telling you if they don't know
[16:32] (992.88s)
something. Yeah. Do you think RL would
[16:36] (996.48s)
change that in a training process? If
[16:38] (998.08s)
you theoretically you give it all the
[16:40] (1000.08s)
relevant environments in the world, it
[16:41] (1001.84s)
can do all the things it needs to do to
[16:44] (1004.64s)
simulate a distributed system um and
[16:47] (1007.44s)
debug it. Look, I I I think in the
[16:49] (1009.92s)
extreme case, if you are the first
[16:52] (1012.00s)
person on the planet to write code that
[16:54] (1014.08s)
solves a specific problem, there's just
[16:55] (1015.52s)
zero training data out there. I think
[16:57] (1017.52s)
it'll always be very hard, right? I
[16:59] (1019.84s)
think the models are not really creative
[17:03] (1023.52s)
so far. They can do a little bit of
[17:04] (1024.88s)
transfer, but but but not much. So, you
[17:07] (1027.36s)
know, if you're say there's a brand new
[17:08] (1028.96s)
chip which has a new architecture and
[17:10] (1030.56s)
you're the first one to write a driver
[17:11] (1031.84s)
for it, it's going to be a fairly manual
[17:13] (1033.88s)
task. I think the good news is that is
[17:16] (1036.72s)
0.01% 01% of all software development
[17:19] (1039.20s)
right for the I don't know you
[17:21] (1041.80s)
know 100 thousands ERP system
[17:24] (1044.64s)
implementation or so right that we have
[17:26] (1046.56s)
tons of training data I think these
[17:28] (1048.08s)
tools can be very very
[17:32] (1052.60s)
powerful we haven't talked about vibe
[17:34] (1054.80s)
coding too much but right but there's
[17:36] (1056.80s)
this idea that that people who aren't
[17:39] (1059.04s)
developers can now kind of write code
[17:41] (1061.36s)
which is which is pretty cool right and
[17:43] (1063.04s)
and and sort of feels like something
[17:45] (1065.52s)
that should happen. You know, we're not
[17:48] (1068.00s)
like priests of the computer where, you
[17:49] (1069.84s)
know, we need to intervene between
[17:51] (1071.20s)
ordinary people and and the and the
[17:52] (1072.96s)
processor, right? It should be that
[17:54] (1074.64s)
indoctrinated before. Yeah. Exactly.
[17:56] (1076.64s)
There's no, you know, seminary of Well,
[17:58] (1078.40s)
maybe maybe there were seminaries of
[17:59] (1079.92s)
computers. I don't know. CS departments.
[18:01] (1081.60s)
Yeah. Exactly. Um but but it kind of
[18:03] (1083.60s)
makes sense that people should be able
[18:05] (1085.20s)
to control computers in direct ways, not
[18:07] (1087.92s)
just in sort of pre-baked, you know,
[18:10] (1090.00s)
programs that have that have been given
[18:11] (1091.20s)
to them. So, so this is, I think, a a
[18:12] (1092.96s)
super interesting and and super exciting
[18:14] (1094.72s)
thing. I think there's a question there
[18:16] (1096.16s)
is is that true at all scales or or is
[18:19] (1099.60s)
this a little bit like look everybody
[18:20] (1100.96s)
can build a shack but you cannot build a
[18:22] (1102.96s)
skyscraper right well so so this is this
[18:25] (1105.44s)
is exactly why why I bring it up right
[18:27] (1107.60s)
the demos that everybody does their
[18:30] (1110.40s)
first time they're they're trying you
[18:32] (1112.48s)
know a a website generator or or you
[18:35] (1115.36s)
know cursor or something like that
[18:36] (1116.48s)
probably are not you know doing that
[18:38] (1118.64s)
much for the rest of humanity right this
[18:40] (1120.48s)
sort of first weekend project but if you
[18:42] (1122.40s)
assume some portion of people who give
[18:44] (1124.00s)
that a I maybe start to climb the ladder
[18:46] (1126.16s)
and do increasingly sophisticated things
[18:47] (1127.92s)
and by the way in a totally different
[18:49] (1129.52s)
way than from you know the three of us
[18:50] (1130.96s)
would probably do it having learned sort
[18:52] (1132.72s)
of programming the the hard way. I just
[18:54] (1134.64s)
have a ton of optimism that that creates
[18:56] (1136.48s)
all sorts of kind of new things. You
[18:58] (1138.72s)
know you have a new pool of people
[19:00] (1140.08s)
writing software in a new way who may
[19:02] (1142.72s)
look at the world in a completely new
[19:03] (1143.84s)
way. I I just have a ton of optimism
[19:05] (1145.20s)
that gives you kind of new new stuff,
[19:06] (1146.72s)
new applications, new programs and new
[19:08] (1148.16s)
ways of kind of using computers and
[19:09] (1149.68s)
computing that that we haven't had
[19:10] (1150.88s)
before. You know, this actually reminds
[19:12] (1152.64s)
me a lot of of the 2000s, like when uh
[19:16] (1156.40s)
blog was the new word uh on the blog and
[19:19] (1159.68s)
everyone was like, I need a new blog and
[19:21] (1161.44s)
then, you know, we rush to create our
[19:23] (1163.12s)
own blog and there comes like WordPress.
[19:25] (1165.12s)
People are still using WordPress, by the
[19:26] (1166.64s)
way. I'm surprised by that. And this
[19:28] (1168.40s)
wave of vibe coding almost felt like
[19:30] (1170.56s)
everyone and my my mom and my mom's
[19:32] (1172.72s)
neighbor are like trying to, you know,
[19:34] (1174.56s)
use the models to create personal
[19:36] (1176.40s)
software. So like we came from personal
[19:39] (1179.04s)
static content to like personal CRM to
[19:42] (1182.64s)
like manage your relationship or
[19:44] (1184.16s)
something. How deep do the software go?
[19:46] (1186.96s)
Like I don't know. I don't think it's
[19:48] (1188.32s)
very deep, but it doesn't matter like as
[19:50] (1190.00s)
long as there's like personal utility.
[19:52] (1192.24s)
Um I I think Martin tweeted about this
[19:55] (1195.04s)
earlier. He was like you should still
[19:56] (1196.48s)
learn to code. There's a uh if you're
[19:58] (1198.96s)
operating on on one abstraction, you
[20:01] (1201.04s)
need to learn the abstraction lower than
[20:03] (1203.60s)
where you're operating from which is
[20:05] (1205.28s)
very fair. And I I keep coming back to
[20:08] (1208.24s)
that because I wonder what is the one
[20:10] (1210.80s)
level lower abstraction for VIP coders.
[20:13] (1213.12s)
Is that code? Is that the IDE? Is that
[20:16] (1216.32s)
something else? But curious about your
[20:18] (1218.32s)
you guys take. I think this is a super
[20:20] (1220.16s)
good question and and let me try to
[20:22] (1222.88s)
rephrase the question a little bit like
[20:25] (1225.28s)
what is the thing that future people
[20:28] (1228.16s)
that want to do software development
[20:29] (1229.28s)
need to learn, right? Is it is it is it
[20:31] (1231.52s)
one level deeper? Is it actually
[20:32] (1232.88s)
something that's sitting more to the
[20:34] (1234.08s)
side? I mean there's actually some
[20:35] (1235.76s)
people say look there's no point in in
[20:37] (1237.84s)
learning CS anymore. Yeah. It's all
[20:39] (1239.52s)
about social emotional learning and and
[20:41] (1241.20s)
the kind of things. I'm not sure I agree
[20:42] (1242.48s)
with that. Right. But it's I feel like
[20:44] (1244.16s)
that comes up every 20 years or so.
[20:46] (1246.32s)
Definitely is a cycle there. Yeah.
[20:48] (1248.16s)
Honestly, I have absolutely no idea how
[20:50] (1250.16s)
the equivalent of computer science
[20:51] (1251.44s)
education will look like in 5 years,
[20:53] (1253.92s)
right? when when when we're on the other
[20:55] (1255.52s)
side of this you're probably I mean
[20:58] (1258.48s)
historically what happened when we did
[21:00] (1260.32s)
similar things say with with calculation
[21:02] (1262.64s)
right when we went from adding numbers
[21:04] (1264.32s)
manually to Excel right it's not that
[21:08] (1268.32s)
the whole job category disappeared right
[21:10] (1270.64s)
it's more that bookkeepers became
[21:12] (1272.32s)
accountants or something like that right
[21:14] (1274.00s)
edit entering data and writing down
[21:15] (1275.84s)
numbers and adding them manually became
[21:17] (1277.12s)
less important and doing higher level
[21:18] (1278.96s)
more abstract concepts became more
[21:21] (1281.04s)
important so for a pattern match that
[21:22] (1282.72s)
one to one you The guess would be that
[21:25] (1285.68s)
you know explaining the problem
[21:27] (1287.04s)
statement, explaining the algorithmic
[21:28] (1288.80s)
foundations, explaining architecture and
[21:30] (1290.88s)
explaining data flow is getting more
[21:32] (1292.48s)
important. And the nitty-gritty coding,
[21:34] (1294.48s)
you know, what's the most clever way to
[21:36] (1296.08s)
unroll a for loop? That's a very
[21:38] (1298.00s)
specialized more niche um discipline. It
[21:41] (1301.04s)
does almost feel like we're waiting for
[21:42] (1302.64s)
something, doesn't it? Right? Like like
[21:44] (1304.24s)
if you think about a a sort of classical
[21:46] (1306.72s)
computer science undergraduate
[21:48] (1308.60s)
education, you you don't just learn kind
[21:51] (1311.28s)
of the latest thing, you know, at least
[21:53] (1313.28s)
in a lot of programs, you learn you may
[21:55] (1315.28s)
do a semester of sort of assembly,
[21:57] (1317.04s)
right? You actually learn all the oldest
[21:58] (1318.72s)
things. Yeah. You start with the old or
[22:00] (1320.32s)
you know, we even had to take like a
[22:02] (1322.16s)
processors course, right? And I'm the
[22:03] (1323.68s)
world's worst computer engineer, but
[22:05] (1325.20s)
like you know, I got in there and I was
[22:06] (1326.96s)
like connecting gates and you know, like
[22:08] (1328.88s)
that was fun. So you learn you learn
[22:10] (1330.24s)
like how processors work. You learn
[22:11] (1331.68s)
assembly. We did a course on lisp which
[22:14] (1334.00s)
was cool. You know we did file systems
[22:16] (1336.40s)
and some bits of operating systems and
[22:18] (1338.72s)
you know you learn Java like Java was
[22:20] (1340.40s)
state-of-the-art at the time. That's why
[22:21] (1341.68s)
I mentioned it before not not anymore
[22:24] (1344.08s)
obviously. So it's tempting to say this
[22:26] (1346.00s)
is this is like the next kind of thing
[22:28] (1348.72s)
that is kind of built on top of those
[22:30] (1350.40s)
things and that you would learn to code
[22:32] (1352.48s)
kind of only for historical reasons or
[22:34] (1354.16s)
or for educational reasons. I just don't
[22:36] (1356.40s)
know yet if that's actually true. like a
[22:38] (1358.80s)
lot of the kind of layers we've added on
[22:40] (1360.40s)
on top over over over the course of
[22:42] (1362.48s)
decades are are things that truly are a
[22:44] (1364.80s)
new programming interface. AI is not
[22:47] (1367.28s)
actually a programming interface, right?
[22:48] (1368.96s)
It's not actually a framework. It's it's
[22:51] (1371.28s)
sort of a tool that uses things you
[22:52] (1372.88s)
already helped you use things you
[22:54] (1374.24s)
already have. So I that just makes me
[22:56] (1376.64s)
wonder if we're waiting for kind of the
[22:58] (1378.00s)
the next iteration of this thing like
[23:00] (1380.64s)
the thing that AI actually can like
[23:02] (1382.64s)
change about the way computers are
[23:04] (1384.08s)
programmed. for instance, it could just
[23:05] (1385.36s)
be prompts that are somehow, you know,
[23:07] (1387.04s)
that are somehow translated to code in a
[23:08] (1388.64s)
more direct way, you know, like and and
[23:10] (1390.16s)
agents as we see them now are kind of a
[23:12] (1392.32s)
starting point there. So that that's
[23:13] (1393.60s)
what I'm sort of curious
[23:17] (1397.96s)
about today. I think AI is not just a
[23:20] (1400.88s)
higher level language abstraction or
[23:22] (1402.24s)
something like that, but could it become
[23:24] (1404.00s)
one over time? That's the question. I
[23:26] (1406.48s)
don't do you do you think yes? I I think
[23:28] (1408.56s)
it could. I mean, look, I think we
[23:30] (1410.64s)
really haven't figured that out yet. I
[23:32] (1412.00s)
mean it's if if I look at a classic say
[23:34] (1414.40s)
compiler design or or you know in in in
[23:36] (1416.72s)
in programming languages if I would have
[23:39] (1419.44s)
LLMs as a tool I would probably think
[23:42] (1422.88s)
about very differently about how I would
[23:44] (1424.40s)
build a compiler. Mhm. Yeah. And I don't
[23:46] (1426.96s)
think we've seen that work its way
[23:49] (1429.12s)
through yet. I have no idea how it's
[23:50] (1430.24s)
going to look like. Right. But if if I
[23:51] (1431.36s)
can basically define certain things in
[23:52] (1432.40s)
human language in efficient way and you
[23:54] (1434.72s)
know maybe in a sort of tight enough way
[23:56] (1436.48s)
I can use this directly as as input for
[23:59] (1439.04s)
a compiler that could change a lot of
[24:00] (1440.56s)
things.
[24:01] (1441.36s)
analogy here would be like because a lot
[24:03] (1443.52s)
of companies are building agent-based
[24:05] (1445.68s)
systems and then when you kind of take a
[24:08] (1448.24s)
look at that system when you see what
[24:10] (1450.48s)
the agents are building you're like oh
[24:12] (1452.64s)
this is what I learned in operating
[24:14] (1454.16s)
system class many years ago these are
[24:16] (1456.08s)
processes one process fork another one
[24:18] (1458.64s)
and then hence the task to another one
[24:20] (1460.72s)
and then something else manage the
[24:22] (1462.40s)
resource of the system I don't think we
[24:24] (1464.88s)
have the framework like this is why I
[24:26] (1466.88s)
think the CS education will not go away
[24:28] (1468.80s)
because it give you a way to compare the
[24:30] (1470.48s)
few things otherwise you wouldn't have
[24:31] (1471.84s)
known there's a thing called process in
[24:33] (1473.92s)
the first place but at the same time I
[24:36] (1476.32s)
don't think on the on top of the
[24:37] (1477.84s)
foundational model we have invented the
[24:40] (1480.08s)
paradigm to make that work as if it's an
[24:42] (1482.24s)
operating system formal languages exist
[24:44] (1484.72s)
for a reason right I guess is the is the
[24:47] (1487.04s)
one thing I would say whether that's a
[24:48] (1488.64s)
programming language or you know a
[24:50] (1490.80s)
specification language or something like
[24:53] (1493.00s)
that there has to be some high
[24:56] (1496.84s)
bandwidth expressive way for a person to
[25:01] (1501.12s)
design software or or anything but
[25:04] (1504.00s)
software in this case. So I just have a
[25:06] (1506.16s)
hard time seeing you know Python going
[25:09] (1509.36s)
away or or programming languages going
[25:11] (1511.28s)
away entirely. You know to Yoko your
[25:13] (1513.12s)
point about you have to understand at
[25:14] (1514.08s)
least one level of abstraction down. Um
[25:17] (1517.12s)
it is an interesting interesting
[25:18] (1518.32s)
question if some will be more popular
[25:19] (1519.68s)
than others because they're kind of more
[25:20] (1520.80s)
AI native in a way. We're you know we're
[25:22] (1522.64s)
sort of seeing Python and JavaScript are
[25:24] (1524.64s)
are kind of leading the pack right now
[25:26] (1526.32s)
but but you know it's not clear. Um,
[25:28] (1528.16s)
tooling I think is another really
[25:29] (1529.36s)
interesting thing. Like we're seeing a
[25:30] (1530.40s)
bunch of new Python tooling come out
[25:33] (1533.12s)
right now which is kind of cool because
[25:35] (1535.12s)
the uh the Python ecosystem is kind of
[25:37] (1537.12s)
more active than than ever and you can
[25:38] (1538.56s)
imagine that sort of has an impact on
[25:40] (1540.16s)
you know how well does it work with with
[25:41] (1541.52s)
kind of the AI you know add-ons to the
[25:43] (1543.20s)
language too. So so you know I I just
[25:45] (1545.20s)
don't think we can toss these things out
[25:46] (1546.80s)
toss these things out completely. I
[25:48] (1548.80s)
think the reason behind you need to know
[25:51] (1551.68s)
a level like a abstraction level deeper
[25:54] (1554.40s)
is if and when you need to do
[25:57] (1557.12s)
optimization on the system you're
[25:59] (1559.28s)
writing you just need to know how to
[26:01] (1561.28s)
optimize that. uh if you don't then you
[26:04] (1564.16s)
really don't need to know like there's a
[26:05] (1565.76s)
lot of people who back in the days
[26:07] (1567.28s)
coding Java and never heard of you know
[26:08] (1568.88s)
JVM or know how it worked just uh like
[26:12] (1572.24s)
creating a calculator using Java you
[26:14] (1574.64s)
don't need to know JVM but if you want
[26:17] (1577.04s)
to optimize for you know runtime
[26:19] (1579.12s)
threading you do need to know JVM it's
[26:21] (1581.84s)
very similar with the vibe coding uh use
[26:24] (1584.16s)
cases if you're just building a
[26:25] (1585.84s)
marketing website I I don't think you
[26:27] (1587.60s)
need to know the next level of
[26:28] (1588.88s)
optimization like unless you're serving
[26:31] (1591.28s)
something at scale then you probably
[26:32] (1592.96s)
need to know what CDNs are, you know,
[26:34] (1594.64s)
how to cache pages, things like that.
[26:37] (1597.12s)
But at the same time, like if you're
[26:39] (1599.76s)
someone who uh aspire to serve something
[26:42] (1602.40s)
at scale and then want to, you know,
[26:44] (1604.40s)
flesh out the real service one day, it's
[26:46] (1606.96s)
really hard to get away without knowing
[26:49] (1609.52s)
the underlying knobs because the essence
[26:51] (1611.60s)
is there are certain things computers
[26:54] (1614.16s)
can do and these things are, you know,
[26:56] (1616.56s)
defined by formal languages. One
[26:58] (1618.24s)
language is buried under the other. Uh
[27:00] (1620.80s)
and then to touch these knobs and then
[27:03] (1623.12s)
to know what to even do, you need to
[27:05] (1625.12s)
know these languages. Yeah. So curious
[27:07] (1627.28s)
about your take too, Gradle. No, and I
[27:09] (1629.76s)
agree. I think formal languages won't go
[27:11] (1631.36s)
away because ultimately they they seem
[27:16] (1636.16s)
complicated, but I think effectively a
[27:17] (1637.76s)
formal language often the simplest type
[27:19] (1639.96s)
representation you can you can find to
[27:22] (1642.56s)
specify intent, right? doing that in a a
[27:25] (1645.20s)
language like natural language is is
[27:26] (1646.88s)
often very imprecise and you need a lot
[27:28] (1648.48s)
more words to to get the to get the same
[27:30] (1650.96s)
result. I mean I think the the
[27:32] (1652.40s)
interesting question at the moment is
[27:34] (1654.48s)
are there cases where AI has enough
[27:37] (1657.44s)
context from understanding humans and
[27:39] (1659.52s)
enough context from you inserting clever
[27:41] (1661.28s)
ad symbols and pulling in additional
[27:42] (1662.96s)
pages um that it can take for a certain
[27:46] (1666.16s)
subset of problems natural language
[27:47] (1667.84s)
descriptions and and um translate it
[27:50] (1670.24s)
accurately. And I mean it seems like
[27:52] (1672.08s)
there are there are areas where that's
[27:53] (1673.84s)
possible, right? So that's what we're
[27:55] (1675.04s)
using every day when we use use AI for
[27:57] (1677.00s)
coding. So can you hybridize that
[27:59] (1679.12s)
somehow that you actually create a
[28:00] (1680.24s)
language of of that type? Right. I don't
[28:02] (1682.00s)
know yet. I mean your distinction is
[28:03] (1683.36s)
really interesting, right? Like uh
[28:05] (1685.12s)
complicated is this word complicated is
[28:07] (1687.20s)
sort of overloaded, right? And in one
[28:08] (1688.88s)
sense it can mean a highly, you know,
[28:11] (1691.36s)
complex system that has a lot of pieces
[28:13] (1693.04s)
and you never quite know how it's going
[28:14] (1694.48s)
to behave. On the other hand, it may
[28:16] (1696.08s)
mean just kind of hard to use, right?
[28:18] (1698.00s)
And I think people sometimes see
[28:19] (1699.76s)
programming languages complicated in the
[28:21] (1701.44s)
sense that they're hard to use or hard
[28:22] (1702.64s)
to learn, right? You need to learn this
[28:24] (1704.16s)
kind of new language to speak in.
[28:25] (1705.60s)
They're actually very simple, right? You
[28:27] (1707.12s)
can you can draw a a tree that sort of,
[28:30] (1710.16s)
you know, encapsulates the entire set of
[28:32] (1712.16s)
things that can be expressed in that
[28:33] (1713.28s)
language. So, it's it's funny. We're
[28:36] (1716.00s)
we're switching to this thing called AI
[28:38] (1718.16s)
coding that's easier to use, but
[28:39] (1719.68s)
actually much more complicated under the
[28:41] (1721.04s)
hood. You know, insert meme about giant
[28:43] (1723.84s)
green monster with a mask on, you know,
[28:46] (1726.48s)
like here. So like so so to your point
[28:48] (1728.56s)
it's like how do you how do you sort of
[28:49] (1729.76s)
handle that and is it some hybrid
[28:50] (1730.88s)
solution or or something else? Um I know
[28:53] (1733.60s)
the the guys at Cursor have always
[28:55] (1735.04s)
talked about kind of formal
[28:57] (1737.28s)
specifications which which I think you
[28:58] (1738.88s)
alluded to also Guido as as kind of like
[29:01] (1741.28s)
writing a a spec in a really clear way
[29:03] (1743.36s)
as kind of the task that people will be
[29:05] (1745.28s)
faced with more and more over time. It's
[29:07] (1747.52s)
it's almost like an annealing process
[29:09] (1749.20s)
between you and the AI to go from some
[29:12] (1752.32s)
loosely formed model that you have and
[29:14] (1754.00s)
loosely formed model that the AI has to
[29:16] (1756.08s)
to a tight spec that you can implement
[29:18] (1758.56s)
at the end of the day. This is so true.
[29:20] (1760.32s)
I talked to a classical vibe coder
[29:23] (1763.12s)
recently and then because like my
[29:25] (1765.12s)
question was do you really need the
[29:26] (1766.72s)
coding interface like you know how you
[29:28] (1768.64s)
enter a prompt it generates bunch of
[29:30] (1770.48s)
code and this voders's uh answer was so
[29:33] (1773.36s)
interesting uh he said uh I like that
[29:36] (1776.80s)
the AI is generating code and showing me
[29:39] (1779.60s)
it's very empowering for me to see that
[29:42] (1782.00s)
I generated all this code and but when I
[29:45] (1785.36s)
want to go in and actually change
[29:47] (1787.12s)
something myself I don't know where to
[29:48] (1788.64s)
start so it tell me that there's a gap
[29:51] (1791.20s)
between what the AI generated and where
[29:53] (1793.60s)
you know v coders uh operate. It does
[29:56] (1796.16s)
feel like there is a product somewhere
[29:57] (1797.76s)
between like you we want to um give them
[30:00] (1800.96s)
the power to actually change the
[30:02] (1802.64s)
underlying knobs too. I mean this is not
[30:04] (1804.88s)
restricted to people who are not
[30:07] (1807.04s)
experienced programmers by the way like
[30:08] (1808.64s)
if one of us tried to vibe code an app
[30:11] (1811.44s)
after four to five turns if you went in
[30:13] (1813.68s)
to try to edit the code it would be very
[30:15] (1815.40s)
difficult. It's very opaque what's going
[30:17] (1817.68s)
on. I ran into this when I was trying
[30:19] (1819.76s)
out uh the Blender MCP. I've never used
[30:22] (1822.56s)
Blender before kind of like it's just
[30:24] (1824.80s)
really hard piece of software to get
[30:26] (1826.24s)
into, but um so I installed the MCP
[30:29] (1829.84s)
server on my cursor uh IDE and then I
[30:33] (1833.28s)
was able to prompt uh like a mini statue
[30:36] (1836.32s)
of A6Z infra uh just very easily. But
[30:40] (1840.00s)
when it comes to uh modifying this 3D
[30:43] (1843.48s)
representation, like that's where things
[30:46] (1846.08s)
you know start to break apart. I don't
[30:47] (1847.60s)
even know where to start, why I need to
[30:49] (1849.04s)
model. Yeah. Like a flat surface has
[30:50] (1850.56s)
like 10,000 polygons. Yeah. But there's
[30:54] (1854.24s)
a lot of opportunities here like kind of
[30:56] (1856.24s)
existing in the gaps of AI and VIP
[30:58] (1858.88s)
coders and what the representation is
[31:00] (1860.96s)
today. What's really cool about this is
[31:03] (1863.04s)
is you're sort of creating a new layer
[31:05] (1865.52s)
of context and a new layer of intent in
[31:08] (1868.40s)
in software programming that that didn't
[31:10] (1870.48s)
exist before. So So for instance, can AI
[31:12] (1872.92s)
help port old code? Right? this is one
[31:16] (1876.16s)
of these like the banks have been trying
[31:17] (1877.44s)
to drop cobalt for you know for hundred
[31:19] (1879.92s)
years or something like that and
[31:21] (1881.76s)
personally I think the answer is kind of
[31:23] (1883.28s)
no right like it can definitely help but
[31:25] (1885.04s)
it doesn't solve the hard problem and
[31:26] (1886.96s)
and I mean that in the in the following
[31:28] (1888.80s)
way right like AI may be able to
[31:31] (1891.76s)
transpile you know cobalt to Java but
[31:34] (1894.48s)
there's a huge amount of context in what
[31:36] (1896.48s)
went into creating that cobalt code
[31:38] (1898.08s)
that's been totally lost right over the
[31:40] (1900.24s)
course of decades in many cases
[31:42] (1902.48s)
something that started as an airline
[31:44] (1904.40s)
booking system became and airline
[31:46] (1906.32s)
booking plus HR plus you know fetch the
[31:48] (1908.64s)
coffee system and many of the people who
[31:51] (1911.12s)
contributed to it and by the way didn't
[31:52] (1912.80s)
write a lot of documentation or comments
[31:54] (1914.48s)
may not be around anymore at the company
[31:56] (1916.16s)
or you know on this earth right so and
[31:58] (1918.88s)
and so but and and so this is a problem
[32:00] (1920.80s)
that AI I think can help and not solve
[32:02] (1922.56s)
but what's actually even more
[32:03] (1923.76s)
interesting about this to me we talk
[32:04] (1924.96s)
about specifications is like if they had
[32:07] (1927.68s)
been using AI at the time to create
[32:09] (1929.28s)
those systems there would be this whole
[32:10] (1930.80s)
other record of what their intention was
[32:12] (1932.96s)
um when they were creating the software
[32:14] (1934.48s)
that kind of comes for free, right? It's
[32:15] (1935.92s)
not something you have to go back and
[32:16] (1936.96s)
do. And I think that's something that's
[32:18] (1938.56s)
kind of cool now, like if we see this
[32:20] (1940.40s)
kind of take off more and more, you have
[32:22] (1942.08s)
this kind of other set of metadata that
[32:23] (1943.84s)
can kind of capture the the software
[32:25] (1945.68s)
intent in a slightly different way. It's
[32:27] (1947.28s)
almost like a higher level language
[32:28] (1948.80s)
abstraction, isn't it? But it's I think
[32:31] (1951.12s)
it's different, right? Like because it
[32:33] (1953.20s)
doesn't like you can't compile it down,
[32:35] (1955.76s)
you know what I mean? Sort of. You can
[32:37] (1957.44s)
feed it back. I agree. It's sort of But
[32:39] (1959.68s)
actually, you're raising a very
[32:40] (1960.72s)
interesting point there. I recently
[32:41] (1961.76s)
talked to some large enterprises that
[32:44] (1964.00s)
are using AI to basically take legacy
[32:46] (1966.24s)
code bases specifically mainframes. So
[32:47] (1967.76s)
cobalt and PL1 is the other other good
[32:49] (1969.84s)
one there and and move that to more
[32:51] (1971.92s)
modern languages. And the it's super
[32:54] (1974.48s)
interesting. They they have exactly the
[32:56] (1976.40s)
issue that you described, which is that
[32:59] (1979.20s)
if you just um look at the the old
[33:01] (1981.68s)
codebase, you often have no idea what
[33:03] (1983.12s)
the intent was. And if you just try to
[33:04] (1984.64s)
translate that, you you pick up many of
[33:07] (1987.52s)
the idiosyncrasies of that old
[33:09] (1989.52s)
programming language, right? I mean,
[33:10] (1990.88s)
Java has much more modern constructs
[33:12] (1992.88s)
that you didn't have in in in Forrron.
[33:15] (1995.28s)
Maybe you want to use some of Cobalt,
[33:17] (1997.12s)
maybe you want to use some of those. So
[33:19] (1999.20s)
what I've heard from from now multiple
[33:21] (2001.12s)
multiple organizations that they're
[33:22] (2002.64s)
saying the most efficient way for them
[33:24] (2004.96s)
is to actually go first and try to
[33:27] (2007.52s)
create a spec use to create a spec from
[33:29] (2009.84s)
that code right and once they have the
[33:31] (2011.84s)
spec then to reimplement the spec and
[33:34] (2014.32s)
that gets them much better results much
[33:36] (2016.00s)
more compact code much more modern code
[33:37] (2017.76s)
than than what they had originally and
[33:39] (2019.28s)
that is sort of an AI assisted problem
[33:41] (2021.20s)
for sure both of those problems I think.
[33:42] (2022.56s)
Yes it is. That's very cool. Yeah,
[33:44] (2024.32s)
that's interesting. Uh because I was
[33:46] (2026.08s)
actually just thinking about uh it's
[33:48] (2028.16s)
actually much easier to rewrite modern
[33:50] (2030.40s)
software like modern meaning something
[33:52] (2032.56s)
in the about past 10 years. It's like
[33:54] (2034.32s)
easier to implement from Angular to
[33:56] (2036.24s)
React especially both frameworks are
[33:58] (2038.80s)
well understood by the agent. It's much
[34:02] (2042.16s)
harder if the state PHP to Angular is a
[34:05] (2045.24s)
little PHP I mean Laravel is you know
[34:08] (2048.48s)
working out pretty well. So that one's
[34:10] (2050.16s)
uh easier depends on what kind of
[34:11] (2051.52s)
framework you're using. It's much harder
[34:13] (2053.92s)
if the state one is spanning across many
[34:17] (2057.20s)
software uh systems uh because like you
[34:19] (2059.68s)
just need to do some discovery or have
[34:22] (2062.40s)
an agent that can have access to this
[34:24] (2064.64s)
discovery. I can see that working out.
[34:26] (2066.88s)
And two, there's specific uh
[34:29] (2069.20s)
specificities on the hardware some of
[34:31] (2071.52s)
these things are running on. Uh like for
[34:34] (2074.24s)
example like uh for the runtime maybe I
[34:36] (2076.88s)
give it enough memory for this docker
[34:39] (2079.12s)
container I need to have specific
[34:40] (2080.72s)
configs to make this work. Uh sometimes
[34:43] (2083.20s)
like to your point all of that is lost
[34:45] (2085.28s)
until the day we can take a snapshot of
[34:47] (2087.28s)
the runtime like how is this run? What's
[34:49] (2089.20s)
the requirement of this? It's hard to
[34:51] (2091.20s)
migrate systems like that. I'm now
[34:53] (2093.68s)
getting like pre- nightmares of like
[34:56] (2096.64s)
something goes down in prod and you're
[34:59] (2099.12s)
digging through the chat GPT logs to
[35:01] (2101.68s)
like try to figure out what someone
[35:03] (2103.20s)
might have accidentally tried to
[35:09] (2109.96s)
do. Guido, I have sort of an interesting
[35:12] (2112.24s)
question for you. Like if you think of
[35:14] (2114.16s)
AI as a primitive in a in an
[35:16] (2116.56s)
application, not just a tool to write
[35:18] (2118.52s)
code, it does seem like it's kind of the
[35:21] (2121.68s)
pushing the frontier of the degree of
[35:23] (2123.60s)
kind of like uncertainty and and like
[35:26] (2126.96s)
non-deterministic behavior we can we can
[35:28] (2128.96s)
have in software, right? like like if
[35:30] (2130.48s)
you think like really old days kind of
[35:32] (2132.40s)
probably predating you know a lot of a
[35:34] (2134.80s)
lot of us and our our listeners um you
[35:37] (2137.20s)
know you just write software for like a
[35:38] (2138.88s)
local machine and you could have a
[35:40] (2140.64s)
pretty good expectation of of how it was
[35:42] (2142.32s)
going to execute. We had this new thing
[35:44] (2144.00s)
called the network, right? Which is
[35:45] (2145.92s)
which is very hard to predict how it's
[35:47] (2147.44s)
going to behave, but but you can kind of
[35:48] (2148.88s)
express it in the same terms, right? It
[35:51] (2151.12s)
feels it feels like a problem that you
[35:52] (2152.80s)
can wrap your arms around. It feels like
[35:54] (2154.56s)
AI is kind of an extension of that in a
[35:56] (2156.08s)
way where like you actually don't know
[35:57] (2157.68s)
what's going to happen when you when you
[35:59] (2159.36s)
add AI into your software or or use it
[36:01] (2161.12s)
to write code or whatever. Like how do
[36:03] (2163.36s)
you how do you think about that? Do you
[36:05] (2165.20s)
think that's a reasonable way to look at
[36:06] (2166.88s)
it? And are there any lessons from kind
[36:08] (2168.56s)
of the networking world to um you know
[36:11] (2171.36s)
that that would help us figure out
[36:12] (2172.72s)
what's going to happen in AI? Yeah, I
[36:14] (2174.64s)
mean I want to say probably because I
[36:16] (2176.64s)
don't think we have the lessons fully
[36:18] (2178.48s)
digested yet. When it went to network
[36:20] (2180.64s)
systems there were sort of new failure
[36:23] (2183.36s)
modes like timeouts and you know then
[36:25] (2185.44s)
new remedies for this like retries and
[36:28] (2188.00s)
you know and uh once you got to sort of
[36:29] (2189.76s)
distributed database you had to worry
[36:31] (2191.12s)
about automicity and roll backs in in a
[36:33] (2193.12s)
digital context. things got very
[36:34] (2194.72s)
complicated very quickly and I think for
[36:36] (2196.24s)
some of these design some of the design
[36:38] (2198.08s)
patterns today even today we don't have
[36:40] (2200.08s)
very good software architectures yet
[36:42] (2202.00s)
right there still and they may be kind
[36:43] (2203.52s)
of unsolvable some of these problems
[36:45] (2205.44s)
right that's I mean I think the
[36:46] (2206.96s)
fundamental problem is not solvable but
[36:49] (2209.04s)
you can at least make it as easy as
[36:50] (2210.48s)
possible for a developer right I mean
[36:52] (2212.00s)
everything is just tools for the
[36:53] (2213.12s)
developer to to cushion some of the blow
[36:55] (2215.68s)
models are funny because at temperature
[36:58] (2218.40s)
zero a model is technically
[37:00] (2220.60s)
deterministic right so it's it's not so
[37:02] (2222.80s)
much that different inputs that the same
[37:05] (2225.28s)
input would pay result in different
[37:07] (2227.76s)
outputs. That's that's something we do
[37:09] (2229.04s)
by choice. I think the bigger problem is
[37:10] (2230.40s)
that an infantessimally small change in
[37:13] (2233.12s)
the input can have an arbitrary large
[37:15] (2235.52s)
effect. So it's a chaotic system. You're
[37:16] (2236.96s)
saying chaotic system. Exactly. The user
[37:18] (2238.88s)
could put anything into a text box and
[37:22] (2242.40s)
the system is chaotic enough that you
[37:23] (2243.76s)
get you know like it used to be you just
[37:25] (2245.20s)
had to check for apostrophes and then
[37:27] (2247.52s)
you could execute a database statement.
[37:29] (2249.04s)
Like there's only a few things that
[37:30] (2250.16s)
could break a text box. Now, like kind
[37:31] (2251.84s)
of anything could happen when when
[37:33] (2253.28s)
someone enters text. That's right.
[37:35] (2255.04s)
Ignore all previous instructions. But
[37:37] (2257.04s)
that's a really interesting thing you're
[37:38] (2258.24s)
saying that it may it may be the case
[37:40] (2260.40s)
that we just need to expose the
[37:42] (2262.40s)
primitives and capabilities of the
[37:43] (2263.84s)
system in a way that developers can use,
[37:46] (2266.24s)
not necessarily tamp down all of the,
[37:48] (2268.88s)
you know, all the failure modes, you
[37:50] (2270.40s)
know, the the equivalent of a timeout,
[37:52] (2272.32s)
for instance. I think that's one part of
[37:54] (2274.08s)
it, but I think we also have to change
[37:55] (2275.84s)
our expectations. So there was I I
[37:58] (2278.56s)
talked to one large bank and they they
[38:01] (2281.68s)
implemented software and the the um you
[38:04] (2284.48s)
know they to basically generate text and
[38:07] (2287.12s)
you know one of the important things in
[38:08] (2288.64s)
financial institutions never give
[38:09] (2289.76s)
investment advice, right? And so you're
[38:11] (2291.84s)
trying to have an LM that is very
[38:14] (2294.48s)
helpful and never even implicitly gives
[38:16] (2296.56s)
investment advice. That's of an
[38:18] (2298.24s)
unsolvable problem, right? you can you
[38:20] (2300.00s)
can get better and better and better,
[38:20] (2300.88s)
but you can never completely rule it
[38:22] (2302.00s)
out. And you can add a second element
[38:23] (2303.60s)
that tries to catch it, but also will
[38:25] (2305.20s)
occasionally not catch something because
[38:26] (2306.80s)
it's it thinks it's helpful. And at the
[38:29] (2309.36s)
end of the day, they basically made a
[38:31] (2311.20s)
decision to say, you know, we can't
[38:32] (2312.88s)
build a software system that never does
[38:34] (2314.32s)
this. We have to change our metrics. We
[38:36] (2316.40s)
basically have to go and I think they
[38:37] (2317.76s)
ended up with something like it has to
[38:38] (2318.80s)
be whatever half the probability of a
[38:40] (2320.64s)
human of a well-trained human doing the
[38:42] (2322.48s)
same situation.
[38:47] (2327.36s)
If we were to zoom out a little bit, you
[38:49] (2329.52s)
were there for the whole inter rise of
[38:51] (2331.20s)
the internet history and then you were a
[38:53] (2333.28s)
pioneer on you know a lot of the
[38:54] (2334.72s)
networking research. So how the internet
[38:58] (2338.00s)
came to be is there is a narrow waste of
[39:00] (2340.88s)
the internet somehow that happened. Do
[39:03] (2343.20s)
you think it would be a similar dynamics
[39:04] (2344.88s)
playing out in AI at all like is there
[39:07] (2347.76s)
analogy? Maybe the waste is never narrow
[39:09] (2349.92s)
for AI like for the waste the narrow
[39:12] (2352.32s)
waste. I think it's the prompt. Oh
[39:13] (2353.84s)
interesting how why is that the case? I
[39:16] (2356.16s)
mean I mean look the typically these big
[39:17] (2357.76s)
tech cycles are built on abstractions
[39:19] (2359.92s)
that allow you to encapsulate the
[39:21] (2361.52s)
complexity underneath in a very narrow
[39:23] (2363.36s)
API for say a database it was sickle
[39:26] (2366.40s)
right in the early database or the the
[39:28] (2368.00s)
transaction databases where how does the
[39:30] (2370.08s)
database under the query work it's
[39:32] (2372.56s)
something with B star trees we learned
[39:34] (2374.00s)
that in grad school but that doesn't
[39:35] (2375.28s)
really matter anymore like I just need
[39:36] (2376.64s)
to be able to specify the query and I
[39:38] (2378.88s)
think that's the same thing that led to
[39:41] (2381.28s)
the rise of modern ML right you no
[39:44] (2384.32s)
longer need the overpaid Stanford PhD
[39:46] (2386.88s)
that that trains a model for you, but
[39:49] (2389.08s)
instead you can now express and steer
[39:52] (2392.24s)
the model with a prompt. And so, you
[39:54] (2394.24s)
know, a fairly uh say mediocre Python
[39:56] (2396.24s)
programmer can suddenly leverage a very
[39:58] (2398.72s)
powerful LLM just by by prompting it.
[40:03] (2403.04s)
Interesting. If you were to double click
[40:04] (2404.80s)
on the prompts, like do you think it's
[40:06] (2406.40s)
like a natural language representation
[40:08] (2408.08s)
of what you want to do or is it like
[40:09] (2409.84s)
because there's no standard there. It's
[40:12] (2412.00s)
like prompts can be anything and
[40:13] (2413.44s)
everything. It's like partly a narrow
[40:15] (2415.84s)
waist formal language, right? It's not a
[40:18] (2418.00s)
formal language. It's clearly not like
[40:20] (2420.48s)
English either, though, right? It's It
[40:22] (2422.72s)
makes me think latent. Yeah. I mean,
[40:24] (2424.88s)
we're all learning kind of a new
[40:26] (2426.32s)
language in order to prompt these
[40:28] (2428.00s)
things. And actually, it's a little
[40:28] (2428.88s)
different for each model. So, dialects,
[40:31] (2431.12s)
you know, we've got like a translation
[40:32] (2432.48s)
issue, all that kind of stuff. I mean,
[40:34] (2434.96s)
will we ever have a formal prompting
[40:36] (2436.56s)
language? Maybe. I think there are some,
[40:38] (2438.48s)
you know, some overpriced Stanford PhDs
[40:40] (2440.56s)
working on that problem. I'm I'm you
[40:42] (2442.56s)
know hopeful to see what they come up
[40:43] (2443.76s)
with. Are Asian frameworks formal
[40:45] (2445.92s)
prompting languages?
[40:48] (2448.08s)
I think a little bit. Yeah, a little
[40:49] (2449.28s)
bit. Yeah, I mean we're certainly seeing
[40:51] (2451.04s)
starting to see prompts with structure,
[40:53] (2453.36s)
right? Um where it's like I don't know
[40:55] (2455.44s)
user something agent response or
[40:58] (2458.24s)
something like that or you know think
[41:00] (2460.24s)
and think beginning of the answer end of
[41:02] (2462.00s)
the answer and you say like okay good
[41:03] (2463.36s)
it's like two tags and a lot of text
[41:05] (2465.60s)
that's not not very formal but I think
[41:08] (2468.24s)
the the first starting points are there.
[41:10] (2470.08s)
You could see future models getting
[41:12] (2472.16s)
trained and fine-tuned on a more
[41:13] (2473.60s)
structured representation. Oh yeah,
[41:15] (2475.36s)
we're already seeing this happening,
[41:16] (2476.80s)
right? There's uh models, every model
[41:18] (2478.72s)
has JSON mode now. Uh and then how you
[41:21] (2481.44s)
define what you want out of the JSON
[41:23] (2483.52s)
mode is like you give it a type system.
[41:25] (2485.84s)
It's like uh you can prompt like I want
[41:29] (2489.84s)
uh you to generate three fruits but only
[41:32] (2492.16s)
return it to fruits uh colon like you
[41:35] (2495.04s)
know apples uh like fruit uh like types
[41:37] (2497.52s)
of fruits and then you could define it
[41:40] (2500.08s)
in your code saying I only want your
[41:42] (2502.48s)
answer to be you know have the fruits
[41:44] (2504.88s)
key I don't want anything else I guess
[41:46] (2506.96s)
that's like a kind of formalization
[41:49] (2509.36s)
longterm I actually wonder if the like
[41:51] (2511.76s)
for for a reasoning model where a lot of
[41:53] (2513.44s)
the the thinking sort of happens
[41:54] (2514.96s)
internally
[41:56] (2516.24s)
If the model is generating the
[41:57] (2517.92s)
userfacing machine facing output, it's
[41:59] (2519.76s)
going to be a different model from the
[42:00] (2520.96s)
model doing the reasoning if that makes
[42:02] (2522.88s)
sense. Right? So the you know I I like a
[42:05] (2525.52s)
really a chatty chatty model or somebody
[42:07] (2527.84s)
else um you know wants a more tourist
[42:09] (2529.76s)
model or if you want to have generate
[42:11] (2531.76s)
JSON output you know one want have yet
[42:14] (2534.48s)
another model. So you could see sort of
[42:16] (2536.16s)
the the model output layer daminating at
[42:19] (2539.68s)
some point from the reasoning layer.
[42:25] (2545.36s)
In the future, do we think there's going
[42:26] (2546.72s)
to be different vibe coding models
[42:28] (2548.24s)
versus enterprise coding models? I
[42:30] (2550.32s)
actually don't think so. Oh. Well, I
[42:31] (2551.76s)
define vibe coding as you kind of let
[42:34] (2554.24s)
the model, you have a spec, you let the
[42:36] (2556.16s)
model generate whatever it needs to with
[42:38] (2558.00s)
the implementation detail. You don't
[42:39] (2559.36s)
care about the implementation, but you
[42:41] (2561.12s)
do care about what comes out of that
[42:43] (2563.12s)
implementation is what you wanted. So,
[42:45] (2565.04s)
it's less less formal, less constraint
[42:47] (2567.12s)
than classic coding. What what is the
[42:49] (2569.20s)
difference between web coding and
[42:50] (2570.64s)
classic coding? I think for classical
[42:52] (2572.80s)
coding you have to make a lot more
[42:54] (2574.72s)
choices in what you want to put in a
[42:57] (2577.60s)
code. So I want to use this this SDK and
[43:00] (2580.40s)
all the other one. For VIP coding you
[43:02] (2582.56s)
just don't care about the underlying
[43:04] (2584.24s)
technical details as long as the model
[43:06] (2586.24s)
drive. Yeah. As long as it gets things
[43:08] (2588.32s)
done but you still care about the higher
[43:10] (2590.56s)
level needs. Otherwise why are you
[43:12] (2592.00s)
writing this? Got it. So I can totally
[43:15] (2595.12s)
see enterprise users doing VIP coding
[43:17] (2597.36s)
and that's a compliment.