Agents Who Code and Generative UI: Notes from AI Native Engineers London

I made it to the second AI Native Engineers London meetup on May 28th, hosted at the monday.com office near Rathbone Square, and I am glad I did.

The first edition was tightly focused on Claude Code power users. This one went broader: agentic coding and generative UI, but it kept the same bar for the room. Almost everyone there was building with AI agents day to day, not just reading about them. That changes the conversation completely.

This is my honest report from the night.

The energy in the room

I want to start with the atmosphere, because it was the thing I noticed first.

This was not a passive audience. People leaned in, asked sharp questions, pushed back on claims, and then carried the arguments into the social afterwards. When everyone in the room is shipping with agents in their own work, nobody is satisfied with the demo-day version of a story. They want to know what broke, what the failure modes were, and what it actually felt like to work this way.

That is the kind of crowd I came for. It was great meeting Konstantinos and the monday.com engineering folks who hosted, and reconnecting with people I had only spoken to online.

Talk: The Worktree Swarm

The opening talk was the one I have not stopped thinking about. Sam Winstanley walked through a real session where two developers and their agent teams went from a rough spec to 8 PRs, 4,500 lines of code, and a clean task board in a single day.

The clever part was not the volume. It was the coordination model.

They used git worktrees as a shared context surface between two developers' Claude Code agents. Instead of agents fighting over one working directory, each branch of work lived in its own worktree, so multiple agents could read, write, and test in parallel without stepping on each other. Worktrees became the shared memory of the swarm.

On top of that, they spawned specialist subagents for specific concerns. The detail that got an audible reaction from the room: a Redis expert subagent caught two critical production bugs during design review, before a line of the feature was merged. That is review happening at the design stage, by an agent whose entire job is to be opinionated about one thing. If you have read my piece on supervisor agent architecture, this is that idea running in anger on a real codebase.

They also ran a dedicated coordinator agent that polled for new commits and monitored Slack and CI, so the humans were not babysitting pipelines. The agents handled the mechanical coordination and surfaced only what needed a human decision.

What made the talk honest was that Sam kept the focus on the collaboration model, not the feature. The real question underneath it was: what does the human's role become when agents can read, write, test, and coordinate on their own? The answer that emerged was less "typist" and more "director and reviewer." That is exactly the shift I wrote about in from implementer to orchestrator, and it was striking to watch it play out in a concrete two-human, N-agent session rather than as a prediction.

Talk: Beyond Components, Generative UI for MCP Apps

Ruben Casas took the second slot with a genuinely disorienting question, in a good way: what does UI even mean when it is generated at runtime rather than designed up front?

For MCP apps, the interface is not a fixed set of screens a designer drew. It is assembled on demand based on what the model decides the user needs in that moment. That breaks a lot of the assumptions component libraries are built on. A component is a reusable, designed unit. Generative UI is closer to a vocabulary the model composes from, with the layout decided live.

The thread that connected this to my own thinking was the idea that the spec, not the rendered output, becomes the durable artefact. That is the same instinct behind treating specs as living, executable documents rather than static screenshots. When the UI is generated, the contract between model and interface matters far more than any single rendered frame.

Open mic: Claude Design

In the open mic, Orta Therox demoed Claude Design and set off a room-wide conversation about AI-native design workflows.

The most interesting part was not the tool itself but the debate it triggered: how do you pull a design system into the loop so generated UI stays on-brand and consistent, instead of drifting a little further from the system with every generation? That is the unglamorous, important problem under all the generative UI excitement. It connects directly to the MCP question from the previous talk, because a design system is exactly the kind of constraint a model needs in context to generate UI you would actually ship. I have argued before that context is everything for MCP, and a design system is some of the highest-value context you can give a UI-generating agent.

What I took away

Three things stayed with me on the way home.

Worktrees are an underrated primitive for multi-agent work. Most of the multi-agent failure stories I hear come down to agents trampling each other's state. Giving each unit of work its own worktree turns a coordination nightmare into something close to ordinary parallel development. It is a simple idea with outsized leverage.

The human role is consolidating around judgement. Across every talk, the agents handled the mechanical work: writing, testing, polling CI, coordinating. The humans set direction, reviewed design, and made the calls that were expensive to get wrong. The skill that compounds is not typing faster, it is reviewing and deciding well.

Generative UI needs constraints to be useful. Generating an interface is the easy part now. Keeping it consistent, on-brand, and accountable to a design system is the hard part, and it is where the real engineering will happen over the next year.

A genuine thank you

To the AI Native Engineers London organisers, the GitNation Foundation team, and the monday.com engineering crew who hosted and handled the logistics: thank you. Events like this only work when the room is full of people who are actually building, and that does not happen by accident.

And to the speakers, Sam Winstanley, Ruben Casas, and Orta Therox: thank you for sharing real work, with the rough edges left in. That is what made the night worth showing up for.

If you want to keep thinking through these topics, I write about system design and working with AI agents every week. Subscribe to Monday BY Gazar on Substack and follow along.

I also break down agent architecture and the senior-to-staff transition on Gazar Breakpoint on YouTube.

If you are figuring out how to put agents to work in your own team, or how your role changes when they can, book a free intro call and we can talk through your specific situation.