Introducing Nuanced Canvas

Canvas is a document editor for building software. Instead of chat threads, you write documents and agents comment on them, just like teammates giving feedback. The agent implements changes when you’re ready.

Docs, not chat threads

I’ve been frustrated with how much of the AI coding experience revolves around telling agents what to do and then watching them do it. Agents have gotten increasingly good at writing code, but I don’t think our tools have gotten nearly as good at helping us understand and shape the software we’re building. Existing interfaces also seem to be getting noisier. I find myself context-switching more frequently while flooded with tool calls and agent output. I feel like I can’t think straight or organize my ideas clearly, and I believe this is because the interfaces are in constant tension with the focus required to thoughtfully engineer systems.

Writing is thinking

Canvas is my attempt to change that. When I worked at GitHub, we had an incredible writing culture in engineering. We’d write product and engineering specs (known internally as ADRs or RFCs), and teammates would leave comments and feedback. That feedback would surface a lot of hidden assumptions or considerations that helped us collectively think through decisions before we wrote the code.

I loved that process, and I wanted to bring that experience to building software with agents.

A quiet place to think

In Canvas, you write a document describing what you want to build. Agents read it in the context of your codebase and leave comments, much like teammates reviewing a spec. You work through the feedback, and when you’re ready, the agent implements your changes in an isolated Git worktree. You review the diff, commit, and ship a PR.

We built Canvas around a few ideas:

1. I need to understand my software. More code doesn’t mean more understanding. Sometimes I’m still figuring out what I want, and the agent jumps ahead and either writes software based on half-completed thoughts, or hands me a complete plan. Suddenly I’m wading through assumptions I haven’t examined and decisions I haven’t made. I’ve lost my train of thought, and I’m reviewing its conclusions before I’ve had a chance to form my own. My eyes glaze over from all the AI-generated text piling up, and it’s tempting to accept the plan just to keep moving. Writing helps me work through those decisions myself. I want an agent to ask a useful question or offer a suggestion without taking over the process. If human understanding is the bottleneck, our tools should give us room to develop it.
2. My thinking benefits from criticism and collaboration. Plan modes and agent questions help clarify requirements and explore alternatives, but chat is a terrible interface for developing ideas collaboratively. A small revision becomes another prompt, which subsequently prints another response; another version to keep track of. I’m scrolling through long conversations, copying text into the prompt, annotating agent responses, and restating context just to work through a single decision. I end up managing the conversation instead of developing the idea. In Nuanced Canvas, agents comment directly on the relevant parts of my spec, so we can work through refining it more precisely. I can write, read, and edit a document scoped to an idea or part of the system, while agents follow along and give targeted feedback that’s localized to specific areas of the doc.
3. My understanding needs structure. Documents and directories make that understanding navigable and organized instead of burying it in conversations that keep accumulating messages, leaving me to reconstruct scope and figure out which decisions still apply. I’m often working across several projects, with half an idea in one chat and the rest scattered across others. A thread starts with one question and drifts into three different problems. Its boundaries expand and don’t necessarily match the work. By contrast, documents let me give each piece of work a name, a purpose, and a scope outlining what we’re trying to accomplish, what belongs here and what doesn’t. Directories make the relationships between those pieces visible. Documents provide more stable boundaries between work, meaning I can return to a coherent description of the work instead of retracing a conversation to remember where we landed.
4. Agent activity shouldn’t be the main event. It’s strange how much of the AI coding experience involves staring at an agent working. Following a prompt, my screen is cluttered with tool calls, terminal output, and intermediate reasoning. There’s an enormous amount of agent activity on screen, and most of it doesn’t actually require your attention. I don’t want to spend my time watching an agent read files and run commands. I want to understand what it’s building, why it’s making certain decisions, and where it needs my input. This is why we moved all of that activity into a separate pane. You can still inspect everything the agent is doing when you need to, but it’s not the center of the experience; the document is.
5. The document is alive. Something that always bothered me about traditional specs is how quickly they became outdated. You’d spend all this time writing a thoughtful document, implementing the feature, and then the software would evolve while the spec stayed frozen in time. With Canvas, the document isn’t just something you write before coding. It’s an ongoing interface to your software. If you want to change how notifications work, go to the notifications section and edit it. If you want to revisit a decision you made weeks ago, it’s still there, alongside the reasoning that went into it. You’re not starting a new conversation and hoping the agent reconstructs what you meant; instead, you’re updating the existing description of your software.

Donald Knuth wrote, “let us concentrate rather on explaining to human beings what we want a computer to do”. That is more relevant now, as agents produce code faster than I can make sense of it.

I’ve spent a lot of time thinking about what software development looks like when writing code is no longer the bottleneck.

I think that the hard work shifts toward understanding what we’re building, keeping track of changes and thinking through the consequences. Writing has always helped me work through those questions, and I think it becomes even more necessary as agents take on implementation. I don’t want to become a passive observer of my own codebase.

I want to be absorbed in the work, like a painter making a mark before stepping back to take in the whole composition, and deciding what the painting needs next. I want tools that help me maintain a clear understanding of my software as it evolves, so I can keep making thoughtful decisions about it, and so I can keep creating.

That’s Nuanced Canvas.

Available for Mac today.