Whiteboard (YC W26) – An open-source IDE for thoughtful software design

Hello! We’re Sid, Alex, Ketan, and Milan. We’re building Whiteboard (https://whiteboard.dev.fast/), an open-source desktop app where humans and agents can architect software together in a common workspace. Here’s our repo: https://github.com/devdotfast/whiteboard.We were missing the feeling of a “whiteboard session” with another dev where you leave with a deep understanding of a system, so we built this app for ourselves. Whiteboard plugs into the tools you already use - e.g. Claude Code, Codex, etc. – and gives your agent an SDK to draw on an in-app canvas to describe its work. We began with an MVP based on HTML artifacts and started rethinking the app as we ran into limitations:1. Built on top of CodeOSS: We found that in pure HTML tools it was hard to connect a spec or diagram to code. In Whiteboard, when you click on visualizations like a sequence diagram, an entity relationship diagram, or a quote from the agent’s trace, you can jump to the underlying code directly. When navigating code, you get keybindings and LSP support from VSCode out of the box. We’ve found this is especially valuable because tradeoffs are often only discovered after a first pass at implementation (re: slop)2. Semantic diff viewer: we wrote a semantic, AST-aware diff viewer in Rust so you can only view the code changes which are relevant to you [1]. We’ve set up some sane defaults: large added functions are summarized as pseudocode, and things like unit tests and large documentation changes are collapsed / hidden. This is all customizable with a WASM-based plugin system.3. Decision Log: We found it difficult to reason about what set of decisions our agents made autonomously. So we built tools for agents to query and link their own traces to the Whiteboard, so you can understand how the requirements that you set were implemented, and understand what decisions your agent made autonomously.Here’s a quick demo video explaining more: https://www

Hacker NewsToolAISource
0Sign in to voteCopy link

FL score

72

out of 100

Verdict

VALIDATE

high confidence

Competition

No competitor data yet

Trend

No signal yet

An IDE that bridges human architects and AI agents by making agent decisions visible and code changes understandable through semantic diffs and decision logs.

The pain

When AI agents generate code, developers lose the understanding of why decisions were made and what tradeoffs were accepted. Existing tools like Claude Code or Codex produce artifacts disconnected from the codebase, making it hard to reason about implementation details or connect diagrams back to actual code.

The gap

No existing tool combines a code editor with semantic diff viewing, decision logging, and agent SDK integration in a way that makes AI-assisted architecture feel like a collaborative whiteboard session rather than a black box output.

Build angle

Start with developers who already use Claude Code or similar agents for architecture work. Charge for hosted decision logs, semantic diff customization, or team collaboration features. Build the open-source core to establish trust and adoption, then monetize the workflow layer.

Strengths

  • Team is shipping fast with a working MVP and clear technical decisions (CodeOSS foundation, Rust semantic diff, WASM plugins).
  • Addresses a real gap in the AI-assisted development workflow that will only grow as agents become more autonomous.
  • Built-in extensibility through SDK and plugin system creates a platform for future integrations.
  • YC backing and open-source strategy reduce friction for initial adoption.
  • Semantic diff viewer is a genuine technical innovation that solves a specific problem other tools ignore.

Risks

  • Market timing risk: AI agents may not become the default development workflow for years, limiting addressable market size.
  • Monetization unclear: open-source positioning makes it hard to charge early adopters, and enterprise deals move slowly.
  • Competitive pressure from well-funded IDE vendors (JetBrains, Microsoft) who could add agent collaboration features.
  • Buildability concern: maintaining CodeOSS fork, Rust semantic diff engine, and WASM plugin system requires sustained engineering effort beyond four founders.
  • Adoption friction: developers already invested in Claude Code or Cursor may not switch workflows for better decision visibility.
  • Narrow TAM: only useful for developers who (1) use AI agents for architecture and (2) care about understanding agent reasoning, which is a small slice today.

Questions about this idea?

FlyBot reads the scoring and gives you a second opinion on “Whiteboard (YC W26) – An open-source IDE for thoughtful software design”.

Open FlyBot