In CodeRabbit's latest episode of The Merge, I sat down with Simon Farshid, founder and CTO of Assistant UI, an open-source library for building AI chat and agent interfaces. We talked about the hidden work behind those interfaces, the growing importance of product judgment, and the coding-agent loop Simon runs with CodeRabbit.
Assistant UI gives React developers customizable components for AI chat and handles the underlying work, including streaming responses, conversation state, attachments, message editing, voice, and connections to agent backends.
That library began as Simon's hackathon project. He kept needing the same chat interface for his own experiments and startup ideas, so he built it for himself. “I didn't plan to make it into a startup,” he said. “It was something that I needed myself.”
Turns out, plenty of other developers had the same problem. Assistant UI now shows up in well over 2,000 open-source GitHub repositories and gets 1.4 million npm downloads a month, including package updates.
The hard part is the state
“Building chat interfaces seems very easy,” Simon said. “The hard part is state management.”
Then he started listing what that means. Responses stream token by token. Markdown renders while the stream is still arriving. Users attach files, queue messages, switch to voice, edit what they said, or stop a response halfway through.
People arrive with habits formed by ChatGPT, Claude, and other polished AI products. That familiarity sets the bar. They expect the same smooth streaming, recoverable history, and control from every AI agent built into another product.
Assistant UI handles this standard chat infrastructure so teams can focus on the interactions their users need.
Taste moves closer to the code
Our conversation soon moved from interface mechanics to the engineer's changing role. If a coding agent can implement a clear specification, where does the difficult work go?
“You get 80% of the work done with 10% of the effort,” Simon said. “All the alpha is in the remaining 20%.”
For Simon, taste is practical. It's the judgment behind a clean API, a useful interaction, or a feature that solves a recurring problem without forcing every team into the same design. He described trying new patterns in customer codebases first, then bringing the ones that hold up into the main library.
As agents speed up implementation, engineers focus on defining outcomes, catching awkward edge cases, and deciding what is ready to ship.
The loop running on Simon's machine
Near the end of the episode, Simon described one way he is changing his own workflow.
“One really cool loop is having an agent look at the CodeRabbit errors and then fixing them and pushing updates,” he said.
Simon was using “errors” to mean the review findings CodeRabbit surfaces. His coding agent handles straightforward findings and pushes an update. It summarizes anything less certain for Simon, who decides what the agent should fix before the next review.
He is testing similar loops elsewhere. One runs overnight, checking Assistant UI's documentation file by file and updating anything that has fallen behind.
Simon closed with an idea he calls “lean forward.” AI can get a project most of the way there with little effort. He argues that engineers should stay involved in the remaining work, where product judgment, careful review, and attention to detail set the result apart.
Watch the full episode of The Merge for our conversation about Assistant UI's open-source beginnings, the future of generative interfaces, and the development loops Simon is already putting to work.
— Hendrik