Not a Single Line of Code by Hand
What development at Peuka looks like now that AI agents write most of the code.
My day starts with a look at Slack. Before I do anything else, I check what happened overnight: Which pull requests went through, and where is there feedback? I don't have to dig for that myself. Every morning, our agents send me a summary of what kept them busy during the night, how many pull requests got finished, and what was reviewed.
In Suddenly Employed, I wrote that I no longer write a single line of code by hand at Peuka. Besides me, the team consists of four to five developers and at least as many agents. So here's what that looks like day to day.
Bob, Marvin, and the Rest
We're constantly trying out new tools, but the foundation has been the same since day one: Our main agent is called Bob, runs on OpenClaw, and uses GPT by OpenAI as its model. Simply because that's how we set him up first, and he's been surprisingly reliable ever since. Bob knows the entire platform inside out, and thanks to Slack, pretty much the whole company too: He's part of it like any other team member and reads along a lot. Bob orchestrates the other agents. Some of them run on OpenClaw as well, some as shell scripts, and some as hosted solutions. We also use Amp so that the developers themselves can kick off tasks that then keep running on their own.
By the way, the group photo at the top shows our core agent team, from left: Bao, Bob, Jean, and Eve. Of course, nobody actually took it. I created the image with ChatGPT. Bao, Jean, and Eve mainly handle technical reviews, but they can take on other tasks too. Each of them uses a different model: Bao is based on DeepSeek, Jean on Claude, and Eve on Grok. Jean also writes code, just like Bob. Bao and Eve could do that as well, but they're meant to focus on reviews. Bob, in turn, can review too: If Marvin writes the code, for example, Bob steps in as a reviewer. That way, we make sure there are always at least three agents available for a review.
And then there's Marvin. If you've read my ClockLab story, the name might ring a bell: I brought Marvin along from back then. That's why he isn't part of the core team. He works more like an external freelancer. At the same time, he's our most advanced agent and the only one running on Mission Control, a huge Kanban board that shows what he's currently working on. On his own, he turns an issue into to-dos, a plan, and QA, builds the feature, and responds to the other agents' feedback until the pull request is done. If you think about it, it's process automation all over again, basically ClockLab 2.0: no time tracking or invoicing this time, but GitHub is integrated just like back then.
From Issue to Pull Request
A typical workflow at Peuka looks like this: A feature gets built and ends up as a pull request on GitHub. There, Codex reviews it automatically first. Then more agents with different specialties take over, deliberately using different models so the reviews don't all turn out the same. Depending on the scope and code ownership, a human takes a look afterwards. Smaller, non-critical changes now go live fully automatically.
What I Still Do Myself
My main job is deciding which features go into development in the first place, and how. I set the product details and the direction, review the concepts, and check the result at the end. If an agent gets stuck, I'm the human in the loop: I clear the blocker, and things keep moving.
Learning the Hard Way
Of course, not everything went smoothly. A classic: Whenever one of the models gets an update, the agents suddenly behave differently. What worked reliably yesterday suddenly does something completely different today.
The bigger problem was homemade, though. Bob was supposed to be used by the whole company. That was the whole point, after all. But most colleagues had little experience with AI: Sessions were never closed, and pretty much everything got uploaded and passed on. At some point, the server capacity wasn't enough anymore, and the tokens ran out faster than expected.
So we moved more and more guardrails into shell scripts that reflect our rules. Reviews, for example, now run in a fixed order instead of all starting at once. If human requirements are missing, there's a blocker. And these days, not everything gets parallelized anymore.
What About Data Protection?
With Bob, every request first goes through a local model running on our own machines in the office. It classifies the data, and only then is it decided what gets passed on to external models at all. Anything privacy-related stays on the local models.
A Task Is Never Done
Which leaves the question of slop. Lots of specialized agents check the code we write. That happens in the pull request, but also afterwards: At night, more agents go over the existing code, validate it again, and clean it up.
Strictly speaking, it has turned into an agent graph by now: a network of agents handing tasks to each other. A task is never really finished, because it can be reviewed and reworked again at any time, and that also turns up bugs that would otherwise have been noticed much later. You can think of it a bit like having several teams working around the clock.
The Results Speak for Themselves
I expected the system to become more stable over time. The other developers were skeptical at first, though. Rewriting the existing platform from scratch unfortunately isn't an option, as it's too complex in some places. So the old software is still at its core. Around it, however, we've reworked payment processes and interfaces, above all security, and integrated a whole bunch of new microservices. After a few intense weeks, the system was running so stably that it can stay in place until it's eventually replaced.
In parallel, we're building a new platform that accesses the old one. New partner integrations already run through it, and step by step, it's meant to take over more and more of the old platform's tasks. Along the way, we've also introduced Apple Pay and launched new apps, among other things. Guest bookings are gone in return: Anyone booking through Peuka now needs a user account.
In the beginning, we still deployed by hand. Today, everything runs automatically via GitHub CI/CD, with test coverage I'm pretty proud of.
The Culture Shock
For the team, this was a culture shock. Until then, everyone wrote every line of code by hand and asked AI for help at most, then partly copied the result over. The first step was to use Claude Code and Codex in the IDE at all. The next shock followed shortly after: With Amp, you don't even need an IDE anymore.
Going from a classic developer who writes every line and wants to understand it, to someone for whom orchestration is what counts: All of that within six months is a massive shift. Because the results spoke for themselves, though, the shock turned out smaller than expected, and even the switch to Amp was possible: Everyone understood the potential. The team handled the change really well.
