AI Wrap-Up #1

Given the progress around AI and agentic coding, I think it makes sense to start a journal about how I feel about these advances and their impact on working in software development. With everything moving so fast, it’s extremely difficult to have a firm opinion. Everything is being reinvented every day, but I thought it would be interesting to keep a journal to track my conclusions and see how they evolve over time.

Looking back at 2025/2026

As a huge tech enthusiast, I dove headfirst into anything remotely related to AI back in 2024. By late 2025, my conclusion was that AI was an excellent “copilot” for software development. It helped me with coding, but especially with thinking through architecture and prototyping. Unfortunately, it just couldn’t handle working in large codebases like the one we had at SKEAT. I had tried different approaches, including Devin, with very underwhelming results. AI did, however, seem pretty comfortable creating prototypes from scratch.

In late 2025 / early 2026, I had the chance to chat with some American peers who showed me their workflows with Claude Code, and it was honestly incredible. It felt like a giant leap had happened in less than six months. AI now seemed perfectly capable of working in large codebases, and even performed better in them: quickly analyzing a repo, the business logic, linters, tests, etc. I immediately realized a pretty massive shift was happening. I think the work on agent harnesses had just as much impact as the models themselves.

Building Claudio at SKEAT

I very quickly started working on bringing this to SKEAT. The idea was to let agents work independently and in parallel on certain tickets from our backlog, just like a developer would, before going through human code review and acceptance. SKEAT’s big advantage was the whole testing stack we had built over several years, with multiple layers: unit tests, integration tests, e2e, SAST analysis, etc. The perfect feedback loop for agents.

The first problem I ran into was the environment: we needed to be able to spin up complete environments for agents very quickly. But SKEAT isn’t a simple monolith. It’s fairly heavy infrastructure, with multiple services, a CQRS architecture, several databases, Kafka… This made autonomous AI work more complicated, especially when running agents in parallel. I explored several solutions before finding one robust enough, which is still in place today.

I built on Coder, an open-source platform for creating and managing remote development environments on your own infrastructure. In practice, instead of manually configuring a machine for each agent, you define an environment template that Coder can reproduce on demand. In our case, each ticket gets its own environment on a dedicated Kubernetes cluster. But creating these environments on demand wasn’t enough: downloading Docker images, building services, and installing all the dependencies took too long, so every night, we prewarm a base environment using Kubernetes CronJobs: images are downloaded or built, build caches are prepared, and volumes containing dependencies are prepopulated. We then take a snapshot of the disk containing that state.

When a ticket is assigned to an agent, Coder creates its environment using a copy of this prewarmed disk. The repository is checked out on the ticket’s branch, then the SKEAT stack starts through Docker Compose, inside its Kubernetes pod. Each agent therefore has its own services, databases, and Kafka. It can modify the code, run the application, and execute its tests without interfering with the other agents.

The expensive preparation work happens upfront, which lets us quickly spin up multiple independent environments and handle several tickets in parallel.

And above all, Kubernetes lets us control each environment’s network communications through NetworkPolicies. We block incoming and outgoing traffic by default, then explicitly allow certain traffic: communication with Coder, DNS resolution, and outbound Internet access on a few ports, especially for HTTPS and Git.

We called this project “Claudio” internally, and right from launch, we managed to clear 80% of our backlog in record time (2 weeks), while still going through human code review and product QA. To understand these incredible results, you mainly need to understand that we were giving Claudio fairly simple tickets: adding logic, fixing display bugs, etc. Tickets that would be very quick even for a human, but still took time because of all the mental overhead for the developer: switching to the ticket, reading the specs, creating a branch, etc. AI gets around the “fixed costs” of a ticket.

However, more complex tickets that required discovery work weren’t handed over to the agent to handle independently. For those, the agent acted as an assistant.

September 2026

AI has made huge leaps in capability again. Our “Claudio” is still alive, and I was pretty happy to see that the “one sandbox per agent” model has become so standard, with plenty of cloud services offering it.

We haven’t switched to those services because, even today, I think our Kubernetes / prewarming / network policies setup is so good at combining security, speed, and efficiency that it’ll stick around for many more years (I hope…)

Over the past few months, with the arrival of Fable, Astra… agents have become even stronger. During code reviews, we now look for architecture mistakes, naming issues, overengineering, and especially a problem all AIs seem to have: ignoring invariants and constantly adding unnecessary validation/serialization at multiple levels.

But it’s still really promising: Just a few months ago, we were hunting down some pretty ugly bugs. Today, I barely see any. I’m mostly worried about code quality and maintainability, although I think I might be part of a dying breed because a lot of developers (even at big companies) seem completely OK with no longer reviewing AI-generated code.

Autonomy and code review

I think that’s a mistake that will cost them dearly, but that’s my opinion, it’s subjective, and I’m curious to see what I’ll think in a few months. Their main argument is that, in large repos / organizations, the concept of ownership doesn’t mean anything. Nobody owns the code or understands it entirely, so why not treat an agent’s work the same way?

My opinion (very subjective) is that it’s not just about code. A human developer’s job was never just to churn out lines of code. It was also to discover blind spots / tradeoffs during implementation that directly affect the product, software costs, architecture, and maintainability, and bring them up with colleagues and the product team, whether during development or QA, to avoid introducing a monstrosity.

An AI, given the sheer volume of code it can pump out and its growing tendency to want to one-shot implementations without human validation, will make default choices without discussing them, with potentially very negative consequences. And with the sheer volume of PRs, the people doing QA and code review can’t even understand them all anymore and end up approving them.

I get the feeling that Anthropic / OpenAI have been giving frontier models this instruction: “work autonomously, make decisions” since mid-2026, and they no longer give a shit about the catastrophic consequences this behavior could cause. At this point, they’re just fighting to the death for market share.

I’m not saying we shouldn’t give AI more autonomy, I have a lot of confidence in agents’ ability to write code, but very little in their judgment. To be honest, I’ve written very, very few LOC over the past few months, sometimes none for several weeks. But I spend 6–8 hours a day doing code reviews, asking the agent for changes (yes, constantly), testing things, and exploring with the models.

I can understand why developers with fairly strong “tunnel vision,” who weren’t particularly interested in the product, might start slowly slipping into a kind of depression, because code review really is the most horrible thing to do, especially when it’s AI-generated code with no person behind it.

Personally, I also feel a bit down about that side of things. I miss coding myself, having the satisfaction of seeing my tests turn green after a long day of intense coding. But I’ve always leaned toward product / business, so that feeling is quickly replaced by the satisfaction of seeing my company and my product move forward and create more value for my customers.

A quick thought on Europe

I think Europe (which I’m part of as a Frenchman) is in a catastrophic position given the recent developments in AI. We’re paying the price for decades of deindustrialization, anti-innovation laws, and internal political crises that drive capital (even European capital) abroad.

Mistral, which we had such high hopes for, seems to have accepted its fate and is increasingly shifting toward being a cloud provider rather than building models.

In 2026, the United States even went a step further by asking Anthropic to restrict/censor its AI to ensure it couldn’t serve interests other than those of the United States.

Behind the scenes, AI is becoming a weapon, and Europe is, of course, going to lose this innovation war too. Except this one seems far more consequential than the others.