fighting slop with slop — Vaibhav Gupta, Boundary

Fighting "slop" Fighting "slop" with "slop". with "slop". My name is Wibb, and I'm My name is Wibb, and I'm going to talk about something that going to talk about something that going to talk about something that might might might seem a little seem a little seem a little silly at first glance. I'll silly at first glance. I'll silly at first glance. I'll show you show you our team's engineering practices very quickly. We do not our team's engineering practices very quickly. We do not perform perform perform code review. We require code review. We require code review. We require every engineer to every engineer to every engineer to work on work on work on tasks in tasks in tasks in parallel, we have parallel, we have parallel, we have no standardization no standardization no standardization in how people in how people in how people use AI, and use AI, and use AI, and I immediately know what I immediately know what I immediately know what you're all thinking. you're all thinking. you're all thinking. We may be some kind of We may be some kind of We may be some kind of YC startup for YC startup for YC startup for buzzers, but I can buzzers, but I can buzzers, but I can guarantee you that I'm a guarantee you that I'm a millennial. So what are we millennial. So what are we millennial. So what are we actually doing in actually doing in actually doing in our company without our company without our company without code review? Well, code review? Well, code review? Well, about three years about three years about three years ago we decided to ago we decided to ago we decided to create a create a create a programming language. This is where there is programming language. This is where there is programming language. This is where there is absolutely no absolutely no absolutely no room for "slop" ( room for "slop" ( poor quality code). This is poor quality code). This is poor quality code). This is something that should work something that should work something that should work exactly the exactly the exactly the same every time. This is something that same every time. This is something that same every time. This is something that cannot be changed in a cannot be changed in a cannot be changed in a year or a month just year or a month just year or a month just because you made a because you made a because you made a bad design bad design bad design decision. You must decision. You must decision. You must be infallible. be infallible. be infallible. And for the last three years we have And for the last three years we have And for the last three years we have been waging a fierce war been waging a fierce war been waging a fierce war against this "slope." against this "slope." When I first encountered When I first encountered this enemy, I went this enemy, I went this enemy, I went to my great to my great to my great mentor, Slop Sue, mentor, Slop Sue, mentor, Slop Sue, and he taught me a and he taught me a and he taught me a thing or two. To defeat the thing or two. To defeat the thing or two. To defeat the "slop", we must "slop", we must "slop", we must become the "slop". So become the "slop". So become the "slop". So we started, we prepared we started, we prepared , and then we started , and then we started , and then we started winning. So if you winning. So if you winning. So if you think about it, what is " think about it, what is " slop"? "Slop" is slop"? "Slop" is any code that you don't any code that you don't any code that you don't read. And whether read. And whether read. And whether you admit you admit you admit it or not, this is the least it or not, this is the least it or not, this is the least amount of "slop" amount of "slop" amount of "slop" that will ever be that will ever be that will ever be in your codebase.

in your codebase. in your codebase. Appreciate it. So we Appreciate it. So we Appreciate it. So we started to fight back with the started to fight back with the started to fight back with the "slope", and we started to "slope", and we started to "slope", and we started to fight back with the fight back with the fight back with the "slope". How do "slope". How do "slope". How do we release a we release a we release a stable stable stable programming language with programming language with programming language with such engineering such engineering such engineering practices? Well, the first practices? Well, the first practices? Well, the first clash we had clash we had clash we had was a clash of was a clash of was a clash of standards. standards. standards. The difficulty with hiring The difficulty with hiring The difficulty with hiring great engineers is that, great engineers is that, great engineers is that, unfortunately, you unfortunately, you unfortunately, you can't tell can't tell can't tell them what to do. Some of them what to do. Some of them what to do. Some of them want them want them want to use the Cloud. to use the Cloud. to use the Cloud. Some of them want Some of them want Some of them want to use Codec. to use Codec. to use Codec. Some of them want to Some of them want to Some of them want to use use use the latest thing the latest thing the latest thing they just found on they just found on they just found on Hacker News. So instead of Hacker News. So instead of Hacker News. So instead of trying to trying to trying to adhere to adhere to adhere to standards in our standards in our standards in our codebase, we codebase, we codebase, we did something that is did something that is did something that is immutable. We immutable. We immutable. We created an created an created an architecture.md file. Instead of architecture.md file. Instead of architecture.md file. Instead of using Cloud MD, using Cloud MD, using Cloud MD, just choose something that just choose something that just choose something that each model can understand each model can understand each model can understand . This file should . This file should . This file should be incredibly be incredibly be incredibly small and contain only what small and contain only what small and contain only what won't change won't change won't change for months or for months or for months or years. In our years. In our years. In our case, these are case, these are case, these are compiler levels. You compiler levels. You compiler levels. You delve into delve into delve into the compiler, tell the the compiler, tell the the compiler, tell the agent to just agent to just agent to just talk to at least talk to at least talk to at least one other one other one other person. This person. This person. This slows down the process a bit. slows down the process a bit. slows down the process a bit. So now we have So now we have So now we have standards. So, standards. So, standards. So, everyone can everyone can everyone can use whatever use whatever use whatever they want. But the they want. But the they want. But the real enemy real enemy real enemy we faced we faced we faced was actually the battle was actually the battle was actually the battle over design. Everyone here over design. Everyone here over design. Everyone here knows that you should knows that you should knows that you should write perfect write perfect write perfect design documents.

design documents. design documents. And our team has a And our team has a And our team has a very simple rule. very simple rule. very simple rule. Code can be Code can be Code can be sloppy, but text can't. sloppy, but text can't. sloppy, but text can't. And of course, if I And of course, if I And of course, if I tell every tell every tell every engineer this, they write engineer this, they write engineer this, they write great copy and great copy and great copy and do everything by hand. They do everything by hand. They do everything by hand. They don't use AI. Well don't use AI. Well don't use AI. Well , unfortunately, no. So , unfortunately, no. So , unfortunately, no. So we created a we created a design tool, a tool design tool, a tool for design for design documents. This documents. This design document tool design document tool effectively replaces both effectively replaces both effectively replaces both Notion and GitHub for such Notion and GitHub for such Notion and GitHub for such documents. It has documents. It has documents. It has versioning, versioning, versioning, comments, everything you comments, everything you comments, everything you need. And, of course, need. And, of course, need. And, of course, we do it. People we do it. People we do it. People are taking advantage of this. Well are taking advantage of this. Well are taking advantage of this. Well , unfortunately, no. We , unfortunately, no. We , unfortunately, no. We built another built another built another tool on top of tool on top of tool on top of this. And this this. And this this. And this tool was a tool was a tool was a Slack integration for Slack integration for Slack integration for that previous that previous that previous tool. tool. tool. Whenever a design document Whenever a design document Whenever a design document was updated, this was updated, this was updated, this channel received a channel received a channel received a notification. And what ended up notification. And what ended up notification. And what ended up happening was that this happening was that this happening was that this channel very quickly channel very quickly channel very quickly became the most popular became the most popular became the most popular in our company. At 2 in our company. At 2 in our company. At 2 a.m., someone a.m., someone a.m., someone published a new published a new published a new design document. Three design document. Three design document. Three people immediately started people immediately started people immediately started reading it because it was reading it because it was reading it because it was just interesting. just interesting. just interesting. The most interesting thing is that these are The most interesting thing is that these are The most interesting thing is that these are design documents that are design documents that are design documents that are not going to not going to not going to change. But change. But change. But that wasn't that wasn't that wasn't enough. All of this is enough. All of this is enough. All of this is actually based actually based actually based on Markdown files and on Markdown files and on Markdown files and simple CLI scripts simple CLI scripts simple CLI scripts that make the system that make the system that make the system work like GitHub without work like GitHub without work like GitHub without being it. So now being it. So now being it. So now agents can agents can agents can do that. But the real do that. But the real do that. But the real problem with all of problem with all of problem with all of this is this is this is that I built it, and that I built it, and that I built it, and then I had a then I had a then I had a mild AI psychosis, I mild AI psychosis, I mild AI psychosis, I started churning out 10 started churning out 10 started churning out 10 design documents a design documents a design documents a day, and soon the team day, and soon the team day, and soon the team started struggling with started struggling with started struggling with my "garbage." So my "garbage." So my "garbage." So we had to add the we had to add the we had to add the last rule. This last rule. This last rule. This last rule last rule last rule was that was that was that if you're going to if you're going to if you're going to publish a design publish a design document, you should document, you should document, you should require people to require people to require people to actually actually actually read it. And with this read it. And with this read it. And with this latest standard, latest standard, latest standard, we suddenly had we suddenly had we suddenly had design documents of design documents of design documents of extremely high extremely high extremely high quality. But what about the quality. But what about the quality. But what about the battle for architecture?

battle for architecture? battle for architecture? How do you make your How do you make your How do you make your codebase codebase codebase match? We match? We match? We built another built another built another tool. This tool. This tool. This tool tool tool visualizes our visualizes our visualizes our dependency graph, both dependency graph, both dependency graph, both internal and internal and internal and some external, and some external, and some external, and allows us to allows us to allows us to observe observe observe changes in the changes in the changes in the codebase. It has codebase. It has codebase. It has semantic boundaries of semantic boundaries of semantic boundaries of individual packages. But even individual packages. But even individual packages. But even more interesting is that we more interesting is that we more interesting is that we can create CLI can create CLI tools that tools that tools that guarantee that certain guarantee that certain guarantee that certain invariants cannot invariants cannot invariants cannot be violated. And it be violated. And it be violated. And it works like this: when Claude works like this: when Claude works like this: when Claude creates a new package creates a new package creates a new package or adds an unreliable or adds an unreliable or adds an unreliable dependency, we see dependency, we see dependency, we see it through CI/CD or a it through CI/CD or a it through CI/CD or a simple git simple git commit history that commit history that commit history that shows exactly where what shows exactly where what shows exactly where what breaks. Thanks to this, breaks. Thanks to this, breaks. Thanks to this, we we we can really change can really change can really change our architecture. We have our architecture. We have our architecture. We have n't changed our n't changed our n't changed our architecture in the last architecture in the last architecture in the last three or four months. three or four months. three or four months. But, no matter how much we But, no matter how much we But, no matter how much we work on design work on design documents and how much we documents and how much we documents and how much we try to have try to have try to have stable code, would stable code, would stable code, would you really release you really release you really release code without reading code without reading code without reading it? Would you trust it? Would you trust it? Would you trust your team to your team to your team to do this? Now do this? Now do this? Now think about a think about a think about a programming language. A programming language. A programming language. A programming language has programming language has programming language has so many so many so many invariants. There are invariants. There are invariants. There are generics, closures, generics, closures, generics, closures, memory management, memory management, memory management, FFI boundaries. Could you FFI boundaries. Could you FFI boundaries. Could you trust such a trust such a trust such a system? Python still has system? Python still has system? Python still has bugs after 25 years bugs after 25 years . Well, here's where we . Well, here's where we . Well, here's where we did something different.

did something different. We created a system We created a system in which agents in which agents in which agents constantly work and constantly work and constantly work and create applications create applications create applications in BAML. We take these in BAML. We take these in BAML. We take these programs to BAML. One programs to BAML. One programs to BAML. One second. And we second. And we second. And we task agents with task agents with task agents with trying to create trying to create trying to create something from scratch. Then we something from scratch. Then we something from scratch. Then we review the entire review the entire review the entire transcript of the work, transcript of the work, transcript of the work, see what see what see what tools tools tools were used and were used and were used and what happened. And of course, what happened. And of course, what happened. And of course, we as humans can we as humans can we as humans can test them. But more test them. But more test them. But more importantly, we can importantly, we can importantly, we can instruct agents instruct agents instruct agents to check them. Agents to check them. Agents to check them. Agents find what was find what was find what was good and what was bad, and good and what was bad, and good and what was bad, and not just what was not just what was not just what was incorrect in the language, but incorrect in the language, but incorrect in the language, but also what required also what required also what required three three three tool calls when tool calls when one should have been enough. And then we one should have been enough. And then we can move on to can move on to can move on to identifying problems. And identifying problems. And identifying problems. And we can bring we can bring we can bring people in to work on people in to work on people in to work on these issues to these issues to these issues to understand which ones are understand which ones are understand which ones are real, which ones are real, which ones are real, which ones are hallucinations, and which ones are hallucinations, and which ones are hallucinations, and which ones are tasteless, as much as tasteless, as much as tasteless, as much as I hate that I hate that I hate that word. And then we word. And then we word. And then we can instruct can instruct can instruct agents to create agents to create agents to create fixes for those fixes for those fixes for those issues and fix them. issues and fix them. issues and fix them. And most importantly: And most importantly: And most importantly: instead of instead of instead of just trying to just trying to just trying to identify these problems, identify these problems, identify these problems, we can go further. we can go further. we can go further. What if you could What if you could What if you could find language find language find language features and instead of features and instead of features and instead of guessing guessing guessing what's good and what's not, what's good and what's not, what's good and what's not, you could do A/B you could do A/B you could do A/B testing? You could testing? You could testing? You could figure out what figure out what figure out what required fewer required fewer tool calls, what tool calls, what allowed for fewer allowed for fewer allowed for fewer errors, what errors, what errors, what gave the correct gave the correct gave the correct result, and result, and result, and deterministically deterministically deterministically understand what was understand what was understand what was happening. The bottom line is that happening. The bottom line is that happening. The bottom line is that you can you can you can start building start building data-driven systems without writing data-driven systems without writing a single line of code. And a single line of code. And a single line of code. And the thing that the thing that the thing that really really really worries me the most here is not worries me the most here is not worries me the most here is not that any of these that any of these that any of these tools are exactly what tools are exactly what tools are exactly what you should you should you should build, but that it would build, but that it would n't n't take eight take eight take eight people to build a programming language. This would take

people to build a programming language. This would take people to build a programming language. This would take at least two years. at least two years. at least two years. It would take hundreds, It would take hundreds, It would take hundreds, thousands, and tens of thousands, and tens of thousands, and tens of thousands of man-hours, and thousands of man-hours, and thousands of man-hours, and you would still end up with a you would still end up with a you would still end up with a broken system. And broken system. And broken system. And today we can today we can today we can just spend just spend just spend billions of tokens, billions of tokens, billions of tokens, make it work make it work make it work and make the system and make the system and make the system stable. And you too stable. And you too stable. And you too can go home and can go home and can go home and create these create these create these internal internal internal tools, even tools, even tools, even if they're not perfect, if they're not perfect, if they're not perfect, to make sure to make sure to make sure your code is ready for your code is ready for your code is ready for release without release without release without having to read having to read having to read every line, because your every line, because your every line, because your engineers engineers engineers won't do that anyway. And won't do that anyway. And won't do that anyway. And I think we can I think we can I think we can start winning start winning start winning this battle against SLO. And this battle against SLO. And this battle against SLO. And as long as we win this as long as we win this as long as we win this battle, SLO can be battle, SLO can be battle, SLO can be defeated. But, defeated. But, defeated. But, unfortunately, I have to say unfortunately, I have to say unfortunately, I have to say something sad. I think something sad. I think something sad. I think we'll we'll we'll lose the war anyway. I lose the war anyway. I lose the war anyway. I believe we are believe we are believe we are losing this war losing this war losing this war because some of the because some of the because some of the fundamental things fundamental things fundamental things we are trying we are trying we are trying to use to use to use are themselves are themselves are themselves broken. How many of broken. How many of broken. How many of you have used you have used you have used TypeScript? Probably TypeScript? Probably TypeScript? Probably most of you, most of you, most of you, I hope, or I hope, or I hope, or at least your at least your at least your agents. Well, somewhere like that. agents. Well, somewhere like that. agents. Well, somewhere like that. Um, did you know that the Um, did you know that the Um, did you know that the main design goal of main design goal of main design goal of TypeScript is to find a balance TypeScript is to find a balance TypeScript is to find a balance between correctness and between correctness and between correctness and performance? And there performance? And there performance? And there 's an asterisk here, because 's an asterisk here, because 's an asterisk here, because they actually mean they actually mean human productivity. And if human productivity. And if you think about it, there are things you think about it, there are things you think about it, there are things you would never do you would never do you would never do in a programming language in a programming language in a programming language at the most basic at the most basic at the most basic level if you were level if you were level if you were designing it in a designing it in a designing it in a world where people had never world where people had never world where people had never written a single written a single written a single line of code. Let me line of code. Let me line of code. Let me show you what this show you what this show you what this really means. I'm really means. I'm really means. I'm going to going to going to write something, and you write something, and you write something, and you try to guess what try to guess what try to guess what this code does.

this code does. Safe enough. How Safe enough. How about this? or, about this? or, about this? or, better yet, this one. Why do we better yet, this one. Why do we better yet, this one. Why do we turn things into turn things into turn things into strings when we sort strings when we sort strings when we sort them? It's just a mess them? It's just a mess them? It's just a mess built into language, whether built into language, whether built into language, whether you like it or you like it or you like it or not. How about this? I not. How about this? I not. How about this? I love this part of love this part of love this part of TypeScript. And you know what? TypeScript. And you know what? TypeScript. And you know what? My agent loves this My agent loves this My agent loves this part of TypeScript. It's part of TypeScript. It's part of TypeScript. It's a mess built into a mess built into a mess built into language. And whether language. And whether language. And whether you like it or not, you like it or not, you like it or not, systems are going to be systems are going to be systems are going to be messy if you messy if you messy if you build them build them build them with these with these with these tools. Oh, tools. Oh, tools. Oh, sorry, wrong sorry, wrong sorry, wrong presentation. But if presentation. But if presentation. But if you think about what you think about what you think about what JavaScript does: JavaScript does: JavaScript does: first there's JavaScript, first there's JavaScript, first there's JavaScript, and then once it and then once it and then once it was there, we started was there, we started was there, we started building systems building systems building systems on top of it. We on top of it. We on top of it. We created CoffeeScript, created CoffeeScript, created CoffeeScript, then TypeScript, and now then TypeScript, and now then TypeScript, and now we're trying to create an we're trying to create an we're trying to create an effect. But the thing is, the effect. But the thing is, the effect. But the thing is, the foundation is already broken. And what foundation is already broken. And what foundation is already broken. And what 's more, the way 's more, the way 's more, the way we write code is we write code is we write code is also different now. So also different now. So also different now. So why are we trying to why are we trying to why are we trying to patch something like this?

patch something like this? patch something like this? Why don't we just Why don't we just Why don't we just try doing try doing try doing something a little different? And I something a little different? And I something a little different? And I think if we think if we think if we try to do that, try to do that, try to do that, we're going to need, we're going to need, we're going to need, essentially, a made-up language. essentially, a made-up language. essentially, a made-up language. So let me So let me So let me show you what show you what show you what BAML can really do, and BAML can really do, and BAML can really do, and how, by starting to think from how, by starting to think from how, by starting to think from first principles, first principles, first principles, you can tackle you can tackle you can tackle clutter at the most clutter at the most clutter at the most fundamental fundamental fundamental level. I keep level. I keep level. I keep saying that you don't saying that you don't saying that you don't need to read code. Does need to read code. Does need to read code. Does it matter at all it matter at all it matter at all ? Well, ? Well, ? Well, let me show let me show let me show you a new way of you a new way of you a new way of thinking about code, and that thinking about code, and that thinking about code, and that doesn't mean we all have to doesn't mean we all have to doesn't mean we all have to do it do it do it right now. But what right now. But what right now. But what if every time if every time if every time I looked at the code I looked at the code ...Oops. What if every ...Oops. What if every ...Oops. What if every time I looked time I looked time I looked at code, I saw not the at code, I saw not the at code, I saw not the code itself, but a quick code itself, but a quick code itself, but a quick tool that could tool that could tool that could visually visually visually visualize it visualize it visualize it for me? When I for me? When I for me? When I clicked on elements, clicked on elements, clicked on elements, it took me it took me it took me to the exact lines of to the exact lines of to the exact lines of code they were code they were code they were associated with. If I associated with. If I associated with. If I wanted to capture the bigger wanted to capture the bigger wanted to capture the bigger picture, I could picture, I could picture, I could zoom, zoom, zoom, click, expand, and click, expand, and click, expand, and navigate my navigate my navigate my codebases in a codebases in a codebases in a much more interesting way.

much more interesting way. much more interesting way. Now I'm going to quickly run Now I'm going to quickly run Now I'm going to quickly run this, and while it's running this, and while it's running , I'll show you another , I'll show you another , I'll show you another pipeline so none of pipeline so none of pipeline so none of you have to you have to you have to read the code. You see, I read the code. You see, I read the code. You see, I set up processes, set up processes, set up processes, I have an agent cycle, I have an agent cycle, I have an agent cycle, because there are because there are because there are semantic boundaries here. I semantic boundaries here. I semantic boundaries here. I can expand on that. I can expand on that. I can expand on that. I can keep can keep can keep unrolling and say, unrolling and say, unrolling and say, "No, there's too much "No, there's too much "No, there's too much trash here." Let's leave this trash here." Let's leave this trash here." Let's leave this as unnecessary noise and as unnecessary noise and as unnecessary noise and move on. So move on. So move on. So instead of having to instead of having to instead of having to understand all the code, I understand all the code, I understand all the code, I can select only the can select only the can select only the parts I want parts I want parts I want to read and to read and to read and go straight to the go straight to the go straight to the lines that lines that lines that really interest me. really interest me. really interest me. But if we go back But if we go back But if we go back to the previous to the previous to the previous pipeline that was working pipeline that was working : what if : what if : what if I could I could I could get a full get a full get a full execution trace while it was running execution trace while it was running ? In a world where we don't ? In a world where we don't ? In a world where we don't read all the code, read all the code, read all the code, the only way the only way the only way to understand it is to to understand it is to to understand it is to trace the execution trace the execution trace the execution and track and track and track how much time how much time how much time is spent on is spent on is spent on certain parts of the certain parts of the certain parts of the program at any given program at any given program at any given time. If you time. If you time. If you wanted to trace wanted to trace wanted to trace your program, your program, your program, think about how think about how think about how slow it would slow it would slow it would become if you had to become if you had to become if you had to trace everything in Python trace everything in Python trace everything in Python or TypeScript. This is or TypeScript. This is or TypeScript. This is unacceptable. unacceptable. unacceptable. The best part is that The best part is that The best part is that if you start from if you start from if you start from basic principles, basic principles, basic principles, it can be done with it can be done with it can be done with zero zero zero performance cost. performance cost. performance cost. Not only can we Not only can we Not only can we make it user-friendly make it user-friendly make it user-friendly for people, but for people, but for people, but because this is all because this is all because this is all built for agents, built for agents, built for agents, we can make we can make we can make each file have a each file have a each file have a tracking system tracking system tracking system that Claude can that Claude can that Claude can navigate. So, Claude navigate. So, Claude navigate. So, Claude can find bugs, can find bugs, can find bugs, errors, and errors, and errors, and inefficiencies inefficiencies inefficiencies and start and start and start optimizing your code optimizing your code optimizing your code without your involvement. I without your involvement. I without your involvement. I think if we think if we think if we start thinking about it this start thinking about it this start thinking about it this way, it's not about way, it's not about way, it's not about reading all the code, it's about making sure that reading all the code, it's about making sure that reading all the code, it's about making sure that the person the person the person understands the system they're understands the system they're understands the system they're working with; and the working with; and the working with; and the tools you tools you tools you build can build can build can provide information provide information provide information about that system. But I

about that system. But I about that system. But I think there's another think there's another think there's another level here. We level here. We level here. We spent spent spent decades decades decades building building building IDE tools, and IDE tools, and IDE tools, and just think just think just think how long it how long it how long it took for took for took for someone like me, someone like me, someone like me, who still doesn't know how to who still doesn't know how to who still doesn't know how to exit Vim, to exit Vim, to exit Vim, to finally start finally start finally start using VS Code. using VS Code. using VS Code. It was a beautiful day It was a beautiful day It was a beautiful day when it happened. I when it happened. I when it happened. I became a real became a real became a real programmer. Well, programmer. Well, programmer. Well, according to some people, I according to some people, I according to some people, I still am not one, because I can't still am not one, because I can't still am not one, because I can't write code in Vim. write code in Vim. write code in Vim. But what do But what do agent-centric tools look like? I think we are all agent-centric tools look like? I think we are all familiar with grep. So I won't familiar with grep. So I won't familiar with grep. So I won't talk about that, talk about that, talk about that, but I will talk about rip but I will talk about rip but I will talk about rip grep, because grep is grep, because grep is grep, because grep is not worth not worth not worth using at all. using at all. using at all. If I wanted to If I wanted to If I wanted to grep my grep my grep my codebase and codebase and codebase and figure out what it was, figure out what it was, figure out what it was, I would use rip grep I would use rip grep I would use rip grep for, say, "calculate," and for, say, "calculate," and for, say, "calculate," and it would produce a bunch of it would produce a bunch of it would produce a bunch of code where all that was code where all that was code where all that was used, and used, and used, and maybe that would be maybe that would be maybe that would be a little helpful. What a little helpful. What a little helpful. What if you could just if you could just if you could just start describing the code start describing the code start describing the code and say, "Can and say, "Can and say, "Can you describe calculate to me? you describe calculate to me? " What if that was with " What if that was with " What if that was with all the lines of all the lines of all the lines of documentation? What documentation? What documentation? What if it was with if it was with if it was with real source real source real source code? And what if it code? And what if it code? And what if it also showed you all the also showed you all the also showed you all the places where it's places where it's places where it's actually actually actually used " used " under the hood"? We under the hood"? We under the hood"? We can make can make can make what used to what used to what used to require multiple require multiple tool calls suddenly tool calls suddenly become a single call.

become a single call. What if instead of What if instead of searching the internet searching the internet searching the internet when you want when you want when you want to know about to know about to know about the libraries you the libraries you the libraries you use, you use, you use, you could just could just could just ask for any ask for any ask for any external library external library external library and it would give it to you? and it would give it to you? and it would give it to you? Because when I first Because when I first Because when I first started learning to started learning to started learning to code, one code, one code, one valuable lesson was that valuable lesson was that code is always the code is always the code is always the source of truth. Don't source of truth. Don't source of truth. Don't read anything but the read anything but the read anything but the code itself. code itself. code itself. Documentation can Documentation can Documentation can lie. A description, lie. A description, lie. A description, architecture file, architecture file, architecture file, or readme file or readme file or readme file will definitely lie, but will definitely lie, but will definitely lie, but code can't lie, code can't lie, code can't lie, except except except when you're working with when you're working with when you're working with weird weird weird architectures. And when architectures. And when architectures. And when you go down this path, you go down this path, you go down this path, you go from you go from you go from not reading code to not reading code to not reading code to understanding understanding understanding architecture. You architecture. You architecture. You go from go from go from not being able to search the not being able to search the not being able to search the code to fully code to fully code to fully understanding what you are understanding what you are understanding what you are getting in every getting in every getting in every tool call. tool call. tool call. But what do you do next? But what do you do next? But what do you do next? Well, the last thing I Well, the last thing I Well, the last thing I do to really do to really understand the code is understand the code is run it. So, what run it. So, what run it. So, what if everything you if everything you if everything you ran, every ran, every ran, every function you function you ever wrote, was ever wrote, was ever wrote, was instantly available? And instantly available? And instantly available? And I'll move this code I'll move this code I'll move this code here so it's instantly here so it's instantly here so it's instantly available as a simple available as a simple available as a simple CLI command. So if I CLI command. So if I CLI command. So if I run "add", "add" becomes a run "add", "add" becomes a run "add", "add" becomes a CLI command that has the CLI command that has the CLI command that has the A and B parameters A and B parameters A and B parameters appended to it. And I appended to it. And I appended to it. And I can just can just can just run it really run it really run it really quickly and see quickly and see quickly and see what happens. What if what happens. What if what happens. What if every CLI tool every CLI tool every CLI tool I had could be I had could be I had could be packaged into a CLI that's packaged into a CLI that's packaged into a CLI that's completely completely completely self-contained, self-contained, that I can just that I can just run without actually run without actually run without actually executing the executing the executing the code itself, and now it's a code itself, and now it's a code itself, and now it's a full-fledged CLI

full-fledged CLI binary that binary that binary that just has the just has the just has the functionality built into it. Suddenly we functionality built into it. Suddenly we functionality built into it. Suddenly we can build can build can build very fast very fast very fast tools where tools where tools where agents don't need to agents don't need to agents don't need to understand what's understand what's understand what's going on. Everything going on. Everything going on. Everything is typed and is typed and is typed and secure. Everything is secure. Everything is secure. Everything is deterministic, and everything is deterministic, and everything is deterministic, and everything is actually actually actually predictable. And predictable. And predictable. And the best part—imagine the best part—imagine that you can that you can that you can build anything, and build anything, and build anything, and your agents don't your agents don't your agents don't have to worry about have to worry about have to worry about deploying it to Windows deploying it to Windows , Mac, or Linux. You can , Mac, or Linux. You can , Mac, or Linux. You can simply choose simply choose any level, and the project will any level, and the project will any level, and the project will be built for be built for any architecture, any architecture, any architecture, including WASM systems. including WASM systems. including WASM systems. Suddenly, you, as an engineer, Suddenly, you, as an engineer, Suddenly, you, as an engineer, become significantly more become significantly more become significantly more productive. You are productive. You are productive. You are no longer limited by the no longer limited by the no longer limited by the systems systems systems below you. below you. below you. You can move You can move You can move very quickly. You very quickly. You very quickly. You can move at can move at can move at the speed of an agent. But the speed of an agent. But the speed of an agent. But most of what most of what most of what I've talked about up until I've talked about up until I've talked about up until today has today has today has been about been about been about tools. What tools. What tools. What if we tried to if we tried to if we tried to fix some of fix some of fix some of JavaScript's true sins? JavaScript's true sins? JavaScript's true sins? Some things that are Some things that are Some things that are deeply embedded in deeply embedded in deeply embedded in language are not trivial matters, but language are not trivial matters, but language are not trivial matters, but something more important, something more important, something more important, such as mistakes. Have such as mistakes. Have you ever seen you ever seen beautiful beautiful beautiful error handling? Besides Rust, I error handling? Besides Rust, I error handling? Besides Rust, I see what agents see what agents see what agents do here: you do here: you do here: you write a try-catch, then write a try-catch, then write a try-catch, then keep nesting keep nesting keep nesting try-catches one inside another, and try-catches one inside another, and try-catches one inside another, and eventually you give up eventually you give up eventually you give up and tell console.log that and tell console.log that and tell console.log that some some some error occurred and error occurred and error occurred and deal with it.

deal with it. deal with it. What if we could What if we could What if we could build build build error handling from first error handling from first error handling from first principles? What principles? What principles? What will happen in such a will happen in such a will happen in such a world? So, I showed world? So, I showed world? So, I showed you addition, you addition, you addition, multiplication, subtraction. multiplication, subtraction. multiplication, subtraction. I didn't show you I didn't show you I didn't show you division. Division is division. Division is division. Division is dangerous. This is scary. dangerous. This is scary. dangerous. This is scary. So let's So let's So let's look at look at look at division. You see division. You see division. You see here that the division here that the division here that the division throws a throws a throws a division by zero error. But division by zero error. But division by zero error. But what else is happening? what else is happening? what else is happening? The function actually The function actually The function actually knows that it is throwing a knows that it is throwing a knows that it is throwing a division by division by division by zero error. without you having to zero error. without you having to zero error. without you having to write any code write any code . If I go to the . If I go to the . If I go to the calculate function, which at calculate function, which at calculate function, which at some point some point some point calls for division, that calls for division, that calls for division, that function also knows function also knows function also knows that it throws a that it throws a that it throws a division by division by division by zero error. So error types zero error. So error types are now displayed without the are now displayed without the need for need for need for guessing. This means guessing. This means that if you catch that if you catch that if you catch or handle or handle or handle errors, we can errors, we can errors, we can provide exhaustive provide exhaustive provide exhaustive guarantees, and the guarantees, and the guarantees, and the compiler will prove whether compiler will prove whether compiler will prove whether you handled the error you handled the error you handled the error or not. No more or not. No more or not. No more guesswork. There are no guesswork. There are no guesswork. There are no unknowns. This is unknowns. This is unknowns. This is guaranteed to be proven guaranteed to be proven . So if you wanted to . So if you wanted to . So if you wanted to release an API that release an API that release an API that guarantees that it guarantees that it guarantees that it never throws never throws never throws errors, then that errors, then that errors, then that system is broken because it system is broken because it system is broken because it doesn't meet doesn't meet doesn't meet the constraints. There are the constraints. There are the constraints. There are two errors in it that you are not two errors in it that you are not two errors in it that you are not handling. If you handling. If you handling. If you want to want to want to intercept that, well, I can intercept that, well, I can intercept that, well, I can write the code for write the code for write the code for that in a second. But that in a second. But that in a second. But you can start you can start you can start catching certain catching certain catching certain errors. Let me errors. Let me errors. Let me just return the just return the just return the control value control value control value for now. And for now. And for now. And now this parser, now this parser, now this parser, which used to throw a which used to throw a which used to throw a division by division by

division by zero error, is guaranteed zero error, is guaranteed zero error, is guaranteed not to throw one again, not to throw one again, not to throw one again, because if I catch because if I catch because if I catch any exceptions here, any exceptions here, any exceptions here, I return a I return a I return a zero value every time. The zero value every time. The compiler and compiler and toolkit toolkit toolkit can do can do can do a lot of the work for us, a lot of the work for us, a lot of the work for us, and we are already used to and we are already used to and we are already used to it in our it in our it in our codebases. Many of codebases. Many of codebases. Many of us probably don't know us probably don't know us probably don't know how compilers how compilers how compilers work "under the hood work "under the hood ", but we trust them. ", but we trust them. ", but we trust them. Code is a matter of Code is a matter of Code is a matter of trust. The reason trust. The reason trust. The reason we don't we don't we don't blindly use LLM code blindly use LLM code blindly use LLM code is that we is that we is that we don't trust it yet don't trust it yet don't trust it yet because the systems underneath are because the systems underneath are because the systems underneath are n't n't n't reliable enough. One more thing before reliable enough. One more thing before reliable enough. One more thing before I tell you all to I tell you all to I tell you all to go write a bunch of code go write a bunch of code go write a bunch of code in BAML, because I've been in in BAML, because I've been in in BAML, because I've been in your shoes and I know your shoes and I know your shoes and I know what people would say to me what people would say to me what people would say to me if I suggested, " if I suggested, " Hey, use this Hey, use this Hey, use this new new new programming language." She programming language." She programming language." She will solve all your will solve all your will solve all your problems. It will simply problems. It will simply problems. It will simply bring with it a whole bring with it a whole bring with it a whole bunch of new problems. bunch of new problems. bunch of new problems. So we decided that So we decided that So we decided that we would lose the fight against we would lose the fight against we would lose the fight against chaos if chaos if chaos if we asked everyone we asked everyone in the world to rewrite all their code to this new in the world to rewrite all their code to this new system. So what does a system. So what does a solution like this look like without having to rewrite all rewrite all your code? Well, we your code? Well, we your code? Well, we started thinking about this started thinking about this started thinking about this about two years about two years about two years ago. And we asked: ago. And we asked: ago. And we asked: What if you could What if you could What if you could use BAML use BAML use BAML not just on its own, as I not just on its own, as I not just on its own, as I showed you today, but from showed you today, but from showed you today, but from any other language any other language any other language of your choice—from Python of your choice—from Python of your choice—from Python to TypeScript, Rust, Go, Ruby, Java, to TypeScript, Rust, Go, Ruby, Java, to TypeScript, Rust, Go, Ruby, Java, or whatever new language or whatever new language or whatever new language comes along? What comes along? What if every function in if every function in if every function in BAML was instantly BAML was instantly BAML was instantly available in the available in the available in the language of your choice? So in this language of your choice? So in this language of your choice? So in this case I'm calling the case I'm calling the BAML calculation function directly from BAML calculation function directly from Python, and it's fully Python, and it's fully Python, and it's fully typed. We

typed. We typed. We get not only " get not only " calculate ", but also " calculate async ", calculate ", but also " calculate async ", calculate ", but also " calculate async ", in case any of us in case any of us in case any of us want to write want to write want to write asynchronous code. So asynchronous code. So , BAML, while lacking " , BAML, while lacking " function coloring", function coloring", function coloring", gives you the advantage of gives you the advantage of gives you the advantage of doing whatever you doing whatever you doing whatever you want in your want in your want in your code. What if we went code. What if we went code. What if we went a little further? What if a little further? What if a little further? What if you started passing you started passing you started passing lambdas across programming language boundaries lambdas across programming language boundaries lambdas across programming language boundaries ? I have a ? I have a ? I have a function here function here function here called "with timeout". This called "with timeout". This called "with timeout". This function times out function times out function times out after a after a after a certain number of certain number of certain number of milliseconds if milliseconds if milliseconds if the task is not completed, the task is not completed, the task is not completed, and this is guaranteed to happen and this is guaranteed to happen and this is guaranteed to happen no matter no matter no matter how long it takes how long it takes . Well, in such a world, . Well, in such a world, . Well, in such a world, you can even you can even you can even pass pass pass Python lambdas over the bridge. You Python lambdas over the bridge. You Python lambdas over the bridge. You can pass can pass can pass generics through the bridge. generics through the bridge. generics through the bridge. You can transmit You can transmit You can transmit the closure. It should the closure. It should the closure. It should just work so that just work so that just work so that engineers don't have to engineers don't have to mess with it. And, more mess with it. And, more importantly, when the importantly, when the importantly, when the agent does something, the agent does something, the agent does something, the type system never type system never type system never lies. The lies. The lies. The type system becomes type system becomes type system becomes the absolute center of the absolute center of the absolute center of truth, preventing truth, preventing invariants from creeping into your code . And today I wanted to . And today I wanted to . And today I wanted to talk not about talk not about talk not about one thing, but about one thing, but about one thing, but about this general this general this general concept. You can concept. You can concept. You can build build build incredibly complex incredibly complex incredibly complex systems without systems without systems without traditional approaches traditional approaches like code review like code review . You can work . You can work . You can work in parallel and in parallel and in parallel and use AI use AI use AI however you want without however you want without however you want without needing any needing any needing any standardization. But standardization. But standardization. But most importantly, you most importantly, you most importantly, you need to think very carefully about need to think very carefully about need to think very carefully about how your how your how your engineering team engineering team engineering team uses the systems uses the systems uses the systems "under the hood." When we "under the hood." When we "under the hood." When we started building BAML, started building BAML, started building BAML, I didn't think we I didn't think we I didn't think we would be able to build would be able to build would be able to build some of our some of our some of our software products software products . And just yesterday, one of . And just yesterday, one of . And just yesterday, one of our engineers our engineers our engineers created a partial created a partial created a partial C compiler based solely C compiler based solely C compiler based solely on BAML. So when I

on BAML. So when I on BAML. So when I start to push the start to push the start to push the boundaries of these systems and you kind of boundaries of these systems and you kind of stop reading the stop reading the code, I think it code, I think it code, I think it opens the floodgates for opens the floodgates for opens the floodgates for your team to your team to your team to close the gaps in close the gaps in close the gaps in your old your old your old process. Have you process. Have you ever worked in a ever worked in a ever worked in a company that didn't have CI company that didn't have CI /CD? They said that /CD? They said that /CD? They said that implementing CI/CD would implementing CI/CD would implementing CI/CD would slow us down. Yes, slow us down. Yes, slow us down. Yes, they do they do they do slow down for slow down for slow down for three months while they three months while they three months while they implement it, implement it, implement it, but after that they but after that they but after that they move much move much move much faster. Our processes faster. Our processes faster. Our processes must evolve must evolve if we want to if we want to if we want to produce products produce products produce products at the speed of agents. at the speed of agents. at the speed of agents. And remember, this is the And remember, this is the And remember, this is the least amount of least amount of least amount of clutter clutter your your your code will ever have. So just code will ever have. So just code will ever have. So just accept it and start accept it and start accept it and start fighting it. I fighting it. I fighting it. I fell in love with fell in love with fell in love with programming programming programming about 15 years ago, about 15 years ago, about 15 years ago, and it was the first thing that and it was the first thing that and it was the first thing that really changed my really changed my really changed my perception of the world. And I perception of the world. And I perception of the world. And I sincerely don't want sincerely don't want sincerely don't want negligence to win negligence to win . I believe we . I believe we . I believe we can all build a can all build a can all build a world of beautiful world of beautiful software. To do software. To do this, I want this, I want this, I want each of you to each of you to each of you to go home today and go home today and go home today and improve those improve those improve those sloppy tools, sloppy tools, sloppy tools, make your systems make your systems make your systems and processes more and processes more and processes more reliable. And for reliable. And for reliable. And for the bravest of you—I the bravest of you—I the bravest of you—I want you to want you to want you to go back and go back and go back and think about these think about these think about these fundamental fundamental fundamental levels of systems.

levels of systems. levels of systems. Think about what Think about what Think about what they are imperfect about and they are imperfect about and they are imperfect about and try to find a try to find a try to find a way to fix it. way to fix it. way to fix it. I believe we I believe we I believe we need a new git. I need a new git. I need a new git. I believe we believe we believe we need a new need a new need a new database. And yes, I believe database. And yes, I believe database. And yes, I believe we need a new we need a new we need a new programming language. I'm programming language. I'm programming language. I'm Vibov, and I work at Vibov, and I work at Vibov, and I work at BAML. Thank you.