Vaibhav Gupta: Fighting Slop with Slop

In a presentation titled "Fighting Slop with Slop," Vaibhav Gupta, from Boundary, offered a provocative take on modern software engineering practices. Gupta opened by acknowledging the counterintuitive nature of his team's approach: no code reviews, mandatory parallel work, and a free-for-all on AI tool usage. He humorously contrasted this with the perception of a typical "Zoomer YC startup," revealing his own "clearly millennial" driver's license to underscore his point.

The War Against Slop

Gupta defined "slop" as "any code you don't read," emphasizing that the presented practices represent the least amount of slop a codebase will ever have. The core of his argument centers on a philosophical shift: to defeat slop, one must "become the slop." This seemingly paradoxical approach, he explained, has allowed his team to ship a stable programming language over the past three years.

Engineering Practices: Standards and Design

Addressing the challenge of standards, Gupta noted that great engineers are difficult to direct. Instead of enforcing rigid standards, the team relies on an invariant: an architecture.md file. This file is kept intentionally small, containing only elements that are unlikely to change for months or years, such as the compiler's layers. For design processes, the team operates under the rule: "Code can be slop, writing cannot." To enforce this, they built a custom design doc tool, replacing traditional platforms like Notion and GitHub for this purpose. A Slack integration for this tool proved surprisingly popular, fostering rapid discussion and feedback on design documents, even at odd hours.

Architecture and Release Battles

To manage the codebase's architecture, Boundary developed a tool that visualizes the dependency graph, allowing them to monitor changes and enforce invariants. CLI tools are used to guarantee that certain rules are not broken, with CI/CD pipelines flagging issues when dependencies become "leaky." This system has helped maintain architectural stability for months. The speaker then posed a critical question: in a world where code is not always read line-by-line, how can we trust the systems being built? He pointed to the inherent complexities and potential for bugs in programming languages, citing Python's 25-year-old issues.

BAML: A Data-Driven Approach

Gupta introduced BAML (presumably the company's core technology) as a system where agents constantly run and create programs. These programs are then inspected by other agents to identify not just correctness errors, but also inefficiencies, such as excessive tool calls. This data-driven approach allows for the A/B testing of language features and the deterministic identification of optimal solutions. The key takeaway here is the ability to build complex systems without traditional methods like code reviews, enabling parallel work and flexible AI adoption.

The Foundation of Slop: JavaScript and TypeScript

Gupta then turned his attention to what he considers foundational issues in existing programming languages, particularly JavaScript and TypeScript. He argued that TypeScript's design goal of balancing "correctness and productivity" prioritizes "human productivity," leading to inherent "slop baked into the language." He cited examples like turning numbers into strings for sorting and the implicit type coercion in JavaScript as examples of these foundational flaws. He proposed that instead of patching these systems, a "made-up language" like BAML could offer a more direct solution to combating slop from the ground up.

Agent-First Tooling and the Future

The presentation concluded with a vision for "agent-first CLI tools" rather than "IDE-first UI tools." Gupta demonstrated how tools could provide rich, contextual information about code, going beyond simple text search to offer descriptions, source code, and usage analysis. He also showcased the ability to run compiled BAML functions as standalone CLI binaries, enabling agents to operate efficiently across different platforms. The core message was that by rethinking tooling from the ground up, engineers can move at "agent speed," freeing themselves from the limitations of older systems.

Finally, Gupta touched upon the inherent trade-offs in language design, noting that while BAML aims for rigor, foundational languages like JavaScript introduce their own complexities. He emphasized the importance of building with first principles in mind to create more stable and efficient software. He also highlighted the potential of BAML to integrate with existing languages, allowing developers to leverage its capabilities without a complete rewrite.