Boundary avoids code reviews by putting stable invariants, architecture rules, and CLI checks around work that engineers and agents produce.
2
Agents inspect other agents' transcripts to find hallucinations, tool-call errors, inefficient approaches, and language features that perform worse in testing.
3
Vaibhav argues that agent-first systems need stronger foundations, including inferred error types, type-safe cross-language calls, execution traces, and new programming languages.
Summary
Vaibhav Gupta describes how Boundary builds software without code reviews, fixed AI tooling standards, or a single required workflow. The team writes small architecture rules that stay unchanged for months, uses design documents with Slack notifications, and adds CLI checks that catch broken dependency boundaries. Agents then inspect the transcripts of other agents, compare tool use and errors, and help identify fixes. Gupta says this approach can make a programming language practical to build with a small team, but he thinks the deeper problem is that languages such as JavaScript and TypeScript contain assumptions that create slop. He presents BAML as a foundation designed for agents, with visual code navigation, execution traces, type-safe CLI tools, inferred error types, and calls across languages such as Python, TypeScript, Rust, and Go. His argument is that teams should build detection tools while also replacing weak foundations underneath them.
Stable invariants let engineers choose their own AI tools
Boundary does not try to force every engineer to use the same model or coding workflow. Gupta says some people use Claude, some use Codex, and others adopt tools they find elsewhere. The team instead keeps an architecture.md file that is very small and contains only rules expected to remain unchanged for months or years. For Boundary, those rules describe the compiler's layers. When an agent goes deeper into the compiler, it must speak with at least one other person. This gives the codebase a stable boundary without dictating how each engineer works.
Design documents need systems that make people read them
Boundary's rule is that code can be sloppy, but writing cannot. The team built a design-document tool with versioning and comments, backed by Markdown files and CLI scripts. Adoption improved after they added a Slack integration that notified a channel whenever a document changed. Gupta says the channel quickly became one of the company's most popular, with people reading new documents even at 2:00 a.m. The team then added a stricter rule: shipping a design document requires people to read it. Gupta learned this after he started producing ten design documents a day and made the team deal with his own output.
Dependency checks show exactly where architecture breaks
Boundary built a tool that visualizes its dependency graph, including selected external dependencies, and shows how the codebase changes. The graph has semantic boundaries around individual packages. CLI tools enforce invariants so that a new package or a leaky dependency cannot quietly damage the architecture. When Claude makes a change, CI/CD or the Git commit history can identify where the break occurred. Gupta says this let the team change its architecture deliberately, and that the architecture had stayed unchanged for the previous three or four months.
Agents can review other agents' work through transcripts
Boundary runs agents continuously to create BAML programs and start projects from scratch. The team records the full Claude transcript, including the tools used and what happened during execution. Humans can inspect these records, but agents inspect them too. They look for incorrect language behavior, unnecessary tool calls, and places where an agent took three calls when one should have been enough. Humans then help decide which reported issues are real, which are hallucinations, and which are matters of taste. Other agents can create fixes for the accepted problems.
A/B tests can compare agent approaches instead of guessing
Gupta wants teams to compare language features and agent strategies with data. Rather than guessing which skill or feature worked better, Boundary can test alternatives and measure tool-call counts, errors, and whether the outcome was correct. He describes this as a way to build data-driven systems without writing every piece of analysis by hand. The method also changes the economics of building a programming language. Gupta says a project that once seemed to require hundreds or thousands of people-hours can be pushed forward by spending millions of tokens on agent-generated work and evaluation.
Agent-first code navigation focuses attention on behavior
Gupta demonstrates a view where engineers see a visual representation of a codebase instead of starting with every source file. They can expand parts of the system, choose which areas deserve attention, and jump to the exact linked lines when needed. Execution traces then show how the program runs and how much time each part consumes. He argues that tracing in Python or TypeScript would be too expensive if implemented directly, while a system designed from first principles could make the cost effectively zero. Agents could use the traces to find bugs, errors, and inefficiencies.
Type-safe tools turn many agent operations into one command
Gupta proposes agent-first replacements for familiar search and execution workflows. Instead of searching for every use of a function with ripgrep, a tool could return its description, docstrings, source code, and usages in one response. The same approach could expose external libraries without a separate web search. Functions could also become standalone CLI commands with typed parameters, and a collection of functions could be bundled into a portable CLI binary. Gupta says this would give agents deterministic, type-safe, guessable operations across Windows, Mac, Linux, and WebAssembly targets.
Inferred error types make unhandled failures a compile-time problem
BAML tracks errors through function calls without requiring developers to write the error types manually. Gupta's divide example knows that division by zero can occur. A higher-level calculate function also inherits that error because it calls divide. The compiler can then prove whether every error has been handled. If code catches an exception and returns a sentinel value, the compiler can know that the function no longer throws that error. Gupta contrasts this with nested try-catch blocks that eventually degrade into logging that an error happened. His goal is to remove unknown failure cases from the system.
BAML crosses existing language boundaries instead of demanding a rewrite
Gupta says a new language will fail if adopting it requires rewriting the world's existing code. BAML functions can be called from languages such as Python, TypeScript, Rust, Go, Ruby, and Java. A Python program can call a typed BAML function, including its async version. The bridge can also pass lambdas, generics, and closures across language boundaries. Gupta says this lets engineers keep their current languages while giving agents stronger boundaries underneath. He reports that one Boundary engineer had built a partial C compiler purely in BAML the day before the talk.
"I think we do need a new Git. I think we do need a new database, and yes, I think we need a new programming language."21:09
Who should watch
Your team relies on code review to catch work that nobody has time to read, and you want concrete ideas for automated checks and transcript analysis.
You are building agent-powered developer tools and need ways to compare tool calls, errors, and outcomes instead of trusting generated code.
You are considering a new language or execution layer but cannot rewrite an existing Python, TypeScript, Rust, or other codebase.
