Onlook overlays a visual canvas on a live codebase, allowing coding Agents to modify interfaces directly. Designers avoid one handoff, while engineers gain another source of code responsibility.
Onlook Opens a New Version: AI Agents Edit Live Interfaces
For years, a layer of manual work separated design tools from code generators.
Designers created screens in Figma, then engineers rebuilt the layouts, styles, and components from scratch. AI could shorten coding time, but it usually remained confined to the development environment and could not see the live page.
Onlook aims to remove that separation. Rather than building another standalone visual editor, it overlays the canvas directly on a real codebase. Users can bring their own Agent and have it modify the interface in production code.
Onlook is a YC W25 project. This update reaches the developer community as an open-source desktop application. The code is available in the GitHub repository, and the team has also published a website and demo video.
What Actually Changed in Onlook
The key change is not that the canvas has more buttons. Onlook has changed what it operates on.
The team says it has fully rebuilt Onlook, repositioning it from a conventional design tool as an agentic design tool, and has open-sourced the project.
“Agentic” has two meanings here.
First, visual actions can map to real code. Dragging an element, resizing it, or changing its style no longer produces only a static mockup. The corresponding component in the codebase is modified.
Second, the executor does not have to be Onlook's built-in model. Users can work with the Agent they already use. The Agent interprets the intent, finds the relevant files, and performs the changes; Onlook displays the page and the results of those interactions.
This differs from uploading a screenshot and asking a model to generate a set of pages. The former starts with an existing codebase, and interface changes land directly in the project structure. The latter is more likely to produce a working page, but much less likely to preserve consistency with an existing design system, business state, and routing logic.
Of course, “modifies code directly” does not mean every action automatically becomes a mergeable pull request. Who can make changes, which directories are accessible, and how changes are reviewed still depend on the project's own permissions and processes.
The Canvas Must Live Inside the Codebase
A conventional Figma-to-code workflow usually has four stages:
- Designers finish the static designs.
- Engineers read the design files.
- Engineers locate the components and implement the styles.
- Both sides repeatedly discuss differences in pixels, spacing, and interactions.
Onlook compresses the first and third stages into one.
The canvas shows the real interface rendered from the codebase. When a designer moves an element, the Agent can locate its implementation through the component tree and write the change back to the source code. Engineers no longer need to receive a separate design specification; they can review the result in the same Git diff.
The most practical effect is a shorter feedback cycle.
In the past, moving a button required a designer to update the file, an engineer to implement the change, and both sides to review another preview. The goal of agentic UI is to make visual adjustments against the current code and page state. Feedback shifts from “communication across tools” to “code review across roles.”
But code responsibility does not disappear. It simply moves.
Designers can see results faster and more easily request small adjustments. Engineers face more changes that land directly in source code. If an Agent breaks a responsive rule, overrides a local style, or bypasses an existing component, the review burden does not decrease automatically.
This is Onlook's most important distinction from conventional design tools: it reduces duplicate implementation, not engineering judgment.
25,000 Supporters Do Not Guarantee a Mature Workflow
The Onlook team says the project has gained support from more than 25,000 designers and developers, with more than 100 contributors.
These figures demonstrate that the project has a real community behind it. More than 100 contributors also means it is no longer just a demo project. People are willing to keep submitting code, fixing issues, and writing documentation.
Support, however, cannot be converted directly into production readiness.
The fact that the desktop app opens and an Agent can modify files only proves that the technical path exists. Large projects face a different set of questions:
- Does the team use React, Vue, or another framework?
- Does the page depend on complex state management?
- Do the components have clear design tokens and boundaries?
- Who runs tests and checks visual regressions after an Agent makes changes?
- How are file conflicts handled when multiple people and Agents work at the same time?
These questions rarely appear on a product launch page, but they determine whether a team can use the tool every day.
The 25,000 supporters are better understood as the scale of interest and early adoption. Whether Onlook becomes part of the daily development workflow depends on whether teams can integrate it with existing CI, component standards, and code review practices.
After Two Stints at the Top of GitHub Trending
Onlook has twice ranked first on GitHub's global Trending list.
That achievement can attract attention and contributors, but a trending position only shows that a repository received unusually high traffic for a period of time. It does not prove that the new version is stable.
The more significant move in this release is the full rebuild and open-sourcing of the project.
Onlook did not simply add another AI feature. It redefined the product's boundary: visual design becomes an interface for operating the codebase, rather than something designers do in a separate window. Open-sourcing the project also lets the community inspect how Agents map actions to source code instead of evaluating a recorded demo alone.
Open source provides two benefits here.
First, it makes the system auditable. Teams can see how an Agent identifies page elements and organizes changes, then extend the capabilities for their own codebase.
Second, it enables experimentation. Teams vary widely in their tech stacks, component standards, and Agent toolchains, so a fixed product is unlikely to cover every use case at once.
But open source does not mean adaptation is free. A general implementation in the repository does not eliminate the need to handle permissions, sandboxes, logs, and reviews.
Who Should Try Onlook Now
Onlook is currently best suited to several kinds of teams:
Teams with an existing frontend codebase.
If a project already exists, Onlook's value lies in making later UI changes faster, not generating the first version of the page. For an empty repository, a conventional design tool paired with a coding Agent is often the more direct option.
Teams that frequently fine-tune interfaces.
Campaign pages, marketing sites, dashboards, and internal tools often require small changes to copy, spacing, and layout. Keeping visual actions and code changes in the same pipeline can reduce communication overhead.
Teams willing to let Agents modify real source code.
Teams need to accept code review, testing, and rollback procedures. Agents should initially run on separate branches, with access limited to specific directories.
Small teams with stable component standards.
When a design system already defines buttons, forms, and layout constraints, Agents are more likely to follow existing patterns. If components have no clear boundaries, greater freedom on the canvas may cause technical debt to accumulate even faster.
Rolling it out across a core project from the start is not advisable. Teams should first test it on a low-risk page and track the number of Agent changes, the time spent on manual corrections, and the number of rollbacks. These three metrics are more useful than the speed shown in a demo.
The source code is available at github.com/onlook-dev/onlook. The team also provides a website and demo video, allowing teams to review the complete workflow before deciding whether to install it.
Editorial Take
Onlook is worth watching because its canvas is not merely more convenient. It replaces the handoff between design and coding with a Git diff. In earlier AI-generated component workflows, engineers typically still had to filter, rewrite, and integrate the output. Here, visual changes enter the existing codebase directly, and reviewers evaluate executable changes rather than static designs. That is the meaningful difference.
My assessment is that Onlook will create value first in smaller frontend projects. With fewer components, fast previews, and easy-to-inspect diffs, the cost of experimentation is low. The obstacles to larger projects are more likely to involve component boundaries, permissions, visual regressions, and concurrent collaboration rather than model capability alone. The team's reported 25,000 supporters, more than 100 contributors, and two first-place finishes on GitHub Trending demonstrate attention, not stability. Public data on rework rates, failure categories, and review records would provide a better basis for deciding whether Onlook is a complete workflow or an attractive entry point.