No one at Buzzinga writes code by hand anymore

Somewhere in 2026, we crossed a line at Buzzinga: no one on the team writes code by hand anymore. All our development happens through coding agents. Right now that mostly means Claude Code and Codex.

We used Cursor heavily before this, and in 2026 we moved completely to these two tools. But the exact tools matter less than people think. Everyone has access to the same tools now. What makes the difference is how you use them.

The team steers

Our engineers do not type the implementation. They steer the agents: where to go, and where not to go. They take the design and architecture level decisions, and the agents do the building.

It changes what a work day looks like. One engineer on our team spends the day on planning and research: architecture decisions, migrations, the things that need real thought. Once everything is ready, he hands the implementation to Claude Code before leaving the office and lets it run overnight. The thinking happens during the day. The typing happens at night.

I have started doing the same with the goal command in Claude Code, where you hand it a bigger objective instead of a single task. I have separate learnings about where that works and where it does not. That is a post of its own.

One thing we have not automated: code generation straight into PR creation. We may try that soon. The coding is handled by agents, but it is still each engineer's responsibility to verify that the code quality is the best it can be. That responsibility never goes to the agent.

Agents need rules, not vibes

Agents are only as good as the context you give them. This is where most of our setup effort goes.

We keep documentation of the whole app in markdown files inside the codebase.

For a backend repo, that typically means the architecture, how the app works, an openapi.yml that is shared with the frontend, and then feature level docs: roles and permissions, the diagram editor, document management, and so on.

For a frontend repo: design principles, the domain model, the how-it-works and architecture docs taken from the backend, user personas and their jobs, and again the feature level docs.

The agents read these. But so does the team. Everyone learns the project from these docs first and the codebase second, because understanding the product decides whether the right thing gets built.

Roles stopped mapping to job titles

Once the context and rules were in place, something happened that we did not fully plan.

Our UI/UX designers now build frontends themselves. For some apps we do not have Figma designs at all. We build the UI directly with agents. Frontend engineers started doing backend work. Core backend engineers now do almost everything.

The hardest problem in all of this was consistent UI. Agent-built frontends drift fast if you let them. We ended up writing hard rules into the codebase: design principles, CSS variables and tokens, and component rules that every agent-built screen has to follow. The same files our designers maintain are the files the agents obey.

A recent build

Right now we are building an internal app for an embedded software security company. There is no Figma for it. From the brainstorming session where we defined the scope and the architecture, we went directly into development.

We presented the demo in late June, and it went great. The app is in staging now, and the production release is planned for early July. From a brainstorming session to production, on a timeline we would never have imagined before.

What clients actually care about

Our clients mostly care about two things: the timeline and the reliability of the app. This setup gives them both, on timelines shorter than we used to plan for ourselves. Nobody has ever asked us to type the code by hand.

Still early

I feel this can still improve a lot. We have integrated Jira for quick bug fixes and reporting, and there is more we are wiring up. We will keep sharing what we learn here.

If you are curious what this way of building would look like for your product, happy to compare notes.