For over three years, the primary interface for interacting with large language models (LLMs) has been a simple chat box. This design emerged not because it was optimal, but because it was the first viable interface available. However, as AI tools evolve, their use cases have expanded beyond simple queries to include complex, task-oriented workflows. In this context, the limitations of a chat interface become increasingly apparent.
What Happened: The Shift from Chat to Canvases
At GitHub, the team behind GitHub Copilot, has observed that developers often find themselves trapped in a chat-based interaction loop. This is especially true when working on tasks that require visual feedback, real-time execution, or direct manipulation of code and systems. In a blog post from September 2026, Burke Holland, a technologist at GitHub, argues that chat is ‘the wrong UI’ for most development scenarios.
He draws a parallel to academic commentary: Steven Pinker observed that the first large-scale AI implementation was a gimmicky chatbot. While chat is effective for expressing intent, it fails when the user needs to perform actions—such as writing code, managing databases, or automating workflows—without being prompted to describe them in natural language.
Holland introduces the concept of a canvas as a solution. A canvas is not a chat box. It is a full-stack application that runs within the GitHub Copilot app, with no browser chrome. It can execute local code, call third-party APIs, and communicate bidirectionally with the AI agent. This allows users to build interactive environments where AI doesn’t just respond—it acts.
Key Facts: How Canvases Work in Practice
- A canvas is a standalone, full-stack application embedded in the GitHub Copilot app.
- It runs locally on the user’s machine, enabling execution of code without relying on cloud-based AI responses.
- Canvases can integrate with local tools—like package managers or databases—without requiring AI to mediate every step.
- Users can build custom UIs from scratch, such as a Connect 4 game or a package manager interface, to interact directly with their environment.
- Canvases support real-time feedback, allowing users to see results immediately rather than waiting for text-based responses.
One example is a canvas built to manage Windows Package Manager (winget) packages. This interface enables users to browse, install, and uninstall software directly—without asking the AI to perform each action through a chat prompt. Similarly, a canvas can be used to write SQL queries, allowing developers to interact with databases using familiar tools like IntelliSense, rather than describing their needs in natural language.
Background: How Canvases Enable Task-Oriented AI
Traditional AI interactions rely on a user typing a question and receiving a text response. This model works well for exploratory queries, such as ‘Explain how to debug a Python error.’ But it breaks down when the user needs to perform a sequence of actions—like building a prototype, testing a function, or automating a workflow.
Canvases solve this by shifting the interaction surface from text to an interactive environment. For instance, a developer can:
- Create a prototype of a web interface in real time.
- Run code locally to test it.
- Use the canvas to visualize data or debug a system.
- Let the AI agent observe the state of the system and suggest improvements.
These workflows are not just more efficient—they are more transparent. The user can see what the AI is doing, how it’s progressing, and where it might be failing. This visibility is critical for building trust and reducing cognitive load.
GitHub Copilot’s canvas system is designed to support this shift. As Holland notes, the agent can generate prototypes and then notify the user when they’re ready for review. This reduces the need for constant human oversight and enables true automation of development tasks.
Why It Matters: Moving Beyond Chat to Action
When developers are limited to a chat interface, they are forced to describe every action in natural language. This leads to inefficiency and token waste—especially when the AI is asked to perform simple, repetitive tasks like ‘stage and commit’ or ‘run a SQL query.’
By contrast, a canvas allows developers to build tools that perform actions directly. For example, instead of asking AI to write a SQL query, a developer can build a canvas with a SQL editor and run queries themselves. This approach is not only more efficient—it also preserves the user’s control and reduces reliance on AI as a ‘tool’ rather than as a ‘co-pilot’.
Moreover, this shift aligns with broader trends in AI development. As AI moves from being a ‘question-answering’ tool to a ‘task-executing’ agent, the need for richer, more interactive interfaces grows. Canvases represent a step toward that future—one where AI is not just a chatbot, but a co-developer in real-time workflows.
Limitations and Open Questions
Despite its promise, the canvas model is not without challenges. First, it requires a learning curve. Developers must understand how to design and deploy interactive applications, even if they lack formal training in full-stack development.
Second, not all workflows are suited to canvas-based design. For simple queries or exploratory tasks, a chat interface remains efficient. The decision to use a canvas must be made based on the complexity and nature of the task.
Third, the current implementation is limited to the GitHub Copilot app. While this provides a strong foundation, broader adoption will depend on interoperability with other development environments and tools.
Finally, the long-term impact of canvas-based AI workflows on developer productivity remains unproven. More research and real-world case studies are needed to validate claims about efficiency, cost savings, and error reduction.
What to Watch Next
As AI tools mature, we will likely see more platforms adopt canvas-like interfaces. GitHub has already demonstrated this with its Copilot app, and other tools—such as IDEs and code editors—are expected to follow.
Developers should experiment with canvases in tools like GitHub Copilot. For deeper insights into how AI handles complex tasks, see How GitHub Copilot Handles Million-Line Pull Requests. For a broader discussion on AI’s role in development, explore AI Hot Takes: What’s Real, What’s Not, and Why It Matters.
Ultimately, the future of AI in development may not lie in chat boxes—but in interactive, action-oriented environments where AI becomes a co-developer, not just a responder.
Sources & further reading
Featured image: View of the UOV transport and automation lab, facing downwards from a raised platform towards the end of a hall. by Powerfox, CC BY-SA 4.0, via Wikimedia Commons. Image source · License