Whiteboard: The Open-Source IDE Built for Software Design in the AI Era

When "Understanding" Becomes the New Bottleneck in Software Development

As intelligent coding agents like Claude Code and Codex become industry standard, a paradox is emerging: developers are shipping code faster than ever, yet finding it increasingly difficult to understand the actual structure of their own codebases. A growing backlog of PRs merged without sufficient comprehension is accumulating a hidden cost known as "cognitive debt."

Whiteboard was built to address exactly this pain point. It's a desktop application — MIT-licensed and open source — backed by YC W26, created by four former technical leads: Sid, Alex, Ketan, and Milan. While iterating on an MVP for their previous startup, they experienced firsthand what happens when more and more code changes get merged without genuine understanding: the team gradually loses the ability to make intentional contributions to their own system.

The project's core philosophy draws from an idea articulated by Geoffrey Litt — that in the age of AI-assisted development, "understanding" has replaced writing as the true bottleneck in software development.

Geoffrey Litt is a researcher at MIT CSAIL, known for his work on "malleable software" and end-user programming. His insight has a deeper technical logic: when AI code generation outpaces humans' ability to read and review, a structural mismatch emerges between the rate at which a codebase grows and the cognitive capacity of its developers. "Cognitive debt" is analogous to technical debt, but where the latter describes compromises in code quality, the former describes a decline in a team's depth of understanding of the system — even when the code itself passes tests and reviews, the team may progressively lose the ability to make intentional changes. This phenomenon is especially pronounced in teams using autonomous agents like Claude Code or Devin, whose generated code often lacks the idiomatic patterns humans are familiar with, raising the cognitive barrier to future maintenance.

Letting Humans and AI Agents Co-Design on a Shared Canvas

Whiteboard aims to recreate a disappearing experience: the whiteboard session with another developer, after which both parties leave with a deep understanding of the system. It plugs into your existing toolchain and provides a SDK for AI agents, enabling them to "draw" on an in-app canvas to illustrate what they're doing.

The team initially built their MVP on top of HTML artifacts, but quickly hit a ceiling — pure HTML tooling struggled to connect specs or diagrams to actual code. This led to several key architectural decisions that grounded the product on a more solid foundation.

Three Core Capabilities

Code–Diagram Linking Built on CodeOSS

Whiteboard is built on top of CodeOSS (the open-source core of VSCode). When you click on a reference in a sequence diagram, an entity-relationship diagram, or an agent execution trace, you can jump directly to the underlying code. During code navigation, you get VSCode keybindings and LSP support right out of the box.

The team notes this is particularly valuable because many design tradeoffs only surface after the first implementation is complete — making it a practical defense against AI-generated "slop" (low-quality, bloated code).

CodeOSS is the open-source core of Microsoft's Visual Studio Code, published on GitHub with Microsoft's proprietary extension marketplace and telemetry components removed. VSCode itself is built on CodeOSS, so Whiteboard users inherit years of accumulated keybindings and extension compatibility from the VSCode ecosystem. LSP (Language Server Protocol) is a standardization protocol proposed by Microsoft in 2016 that decouples language intelligence (code completion, go-to-definition, reference lookup, error highlighting) from the editor into a separate process — editors only need to implement a client to connect to any language's server. Thanks to LSP, Whiteboard doesn't need to reimplement language intelligence from scratch; users get the same code navigation experience as a mainstream IDE when jumping between diagrams and code.

Semantic, AST-Aware Diff Viewer

Whiteboard includes a semantic, AST-aware diff viewer written in Rust, letting you focus only on code changes that are actually relevant to you. It ships with sensible defaults: large newly added functions are summarized as pseudocode, while unit tests and large documentation changes are collapsed or hidden. The entire logic is fully customizable via a WASM-based plugin system. This diff library (diffr) has also been open-sourced separately.

Traditional text-level diff tools (like git diff) compare two file versions line by line, meaning formatting adjustments, comment changes, or parameter line breaks generate a lot of noise that obscures real semantic differences. AST (Abstract Syntax Tree)-aware diff tools first parse code into a syntax tree, then compare at the tree-structure level — capable of identifying semantic operations like "function was renamed" or "parameter order was swapped," not just string-level changes. This is especially critical when AI agents routinely generate hundreds of lines of code: developers don't need to read through auto-generated boilerplate and test files line by line, but can focus directly on the changes that affect business logic. Whiteboard chose to implement this library in Rust and expose the plugin interface via WASM, allowing it to be embedded in browser or cross-platform desktop environments without native dependencies.

Decision Log

When faced with a chain of decisions made autonomously by an AI agent, developers often struggle to reconstruct the reasoning behind them. Whiteboard gives agents tools to query and link their execution traces to the canvas, so you can clearly see: how your stated requirements were implemented, and exactly what decisions the agent made while running autonomously.

Real-World Use Cases

According to the team, engineers at companies like Salesforce and Modal are already using Whiteboard as an architecture review or spec-level change review tool — essentially for any change they want deep visibility into.

Two typical workflows stand out:

Reviewing your own AI agent's output: Because Whiteboard makes large-scale code review more manageable, developers typically have an AI agent generate a prototype, create a corresponding Whiteboard session alongside it, and then iterate on the design from there.

Reviewing others' changes in a tiered approach: Whiteboard can be combined with tools like Greptile — for example, running automated code reviewers for small changes while escalating changes requiring human judgment into a Whiteboard session. This "automate the simple, focus humans on the complex" tiered approach is a real-world need as AI-assisted development scales up.

Open-Source Strategy and Commercialization Path

The Whiteboard desktop app is MIT-licensed and open source, currently supporting macOS and Linux. The team's commercialization plan is clear: they'll charge enterprises for a hosted web service that includes session creation and management, trace storage, and multi-person collaborative review — while committing to keep the product self-hostable.

The Show HN launch received 255 upvotes and 95 comments, reflecting strong community interest in the question of how to maintain code comprehensibility in the AI era. When coding speed is no longer the bottleneck, tooling for understanding and design may well be the next frontier in the developer tools arms race.