Skip to content
Articles
ArticlesAI translation· 13 October 2025

Claude 4.5 Sonnet: The first AI developer that can code for 30 hours straight

Claude 4.5 Sonnet sets a new benchmark in software development: a coding AI that plans, programs and tests autonomously for hours on end. It shows how AgenticAI is making the leap from tool to digital development team, and rethinking entire processes along the way.

by 7 min read

Prelude: I've always had to smile at the ambition of techies to automate themselves out of a job. Automation is their favourite sport, and with LLMs they've found a new toy that's even better at it than they are 😉

TL;DR?

Skip straight to the Prompcast

Introduction: The code paradox*

For humans, software development is a complex, error-prone and often frustrating job. A single missing semicolon in thousands of lines of code can bring an entire system to its knees. At the same time, we're watching artificial intelligence make huge strides in exactly this discipline, completing tasks with a speed and precision that seemed unthinkable not long ago. Which raises a central question: what makes code so much easier for an AI to handle than the human language it was originally trained on?

This piece gets to the bottom of that question and looks at why the fundamental nature of code makes it an ideal playing field for language models (LLMs). Then we'll go a step further and show how so-called “agentic AIs”, meaning autonomous systems that pursue goals on their own, unfold their full potential in software development and fundamentally revolutionise the way we build technology.

The foundation: why code is an “open book” for language models

The remarkable ability of LLMs to understand and write code is no accident. It rests on the fundamental properties of programming languages themselves, which make them far easier for language models to process than human language.

Unambiguity instead of ambiguity

Human language is riddled with ambiguity. A sentence like “Kevin saw John with the telescope” can be read in several ways: did Kevin look through the telescope, or did John have the telescope with him? Programming languages, on the other hand, are deliberately designed to be completely unambiguous. Every instruction has exactly one meaning, so that a compiler (the program that translates human-written code into machine language) can process it without errors. That clarity removes the guessing and interpreting that make human language so hard for AI.

The power of patterns

At its core, artificial intelligence is a highly sophisticated pattern-recognition machine. And code is full of patterns. Studies show that source code is 8 to 16 times more predictable than ordinary English text. That's because developers, to reduce their own cognitive load, deliberately rely on a limited vocabulary (the commands of the programming language) and recurring structures (such as loops or function definitions). For an AI trained to predict the next word in a sentence, predicting the next line of code is a far easier task.

Measurable success

How do you judge whether a text written by an AI is “good”? The answer is often subjective. With code, success is objectively measurable: either the code compiles and the program runs as intended, or it doesn't. This binary feedback (success/failure) is the perfect mechanism for an AI to learn and correct itself without depending on vague human judgement.

The next level: agentic AI in the software development lifecycle

If the fundamental nature of code is the foundation, then modern development environments are the catalyst that turns AI from a mere code completer into an autonomous developer. This is where agentic AIs come in.

What is an “agentic AI”?

Think of an agentic AI as a system that can do far more than just answer a request. For decision-makers, the simplest definition is this: An agentic AI (AgenticAI) is a system that can pursue goals independently, plan actions, use tools and learn from the results in order to adapt its strategy. Instead of merely suggesting a line of code, an agentic AI can be given the task of developing a complete function, testing it and fixing the bugs.

-> More on “AgenticAI” here

Episode 10.6 - Generate or delegate?DocIsInDaHouse

The secret is in the feedback

The decisive reason agentic AIs are so successful at programming is the structured, deterministic feedback loop available to them. When a human developer makes a mistake, the compiler hands them a clear error message, often with the exact line and column.

It's precisely this kind of precise, instant feedback that is worth its weight in gold for an agentic AI. It doesn't have to guess what went wrong. It gets concrete data it can learn from and use to develop a new approach. This tight feedback loop is the fuel for automated behaviour. It allows the AI not only to spot an error but to correct its own strategy autonomously and learn from every setback, a capability that sits at the very heart of what makes an “agent”.

Three takeaways for practice

This symbiosis of AI and the structured world of code is leading to some valuable, practically relevant developments that are redefining software development.

Takeaway 1: Errors aren't failure, they're the perfect learning mechanism

In the world of agentic AI, errors aren't mishaps but valuable data points. An AI can analyse and categorise error messages precisely, for example distinguishing between a simple typo (syntax error) and a more complex problem that only shows up while the program is running (runtime error). Advanced systems go one step further: they act like an experienced engineer who can trace a fault in the finished product (the execution phase) all the way back to a flaw in the original blueprint (the planning phase). The numbers make the point impressively: LLM-based agents that use iterative feedback loops with automated tests (unit tests, i.e. small, isolated code checks that make sure individual building blocks work correctly) achieve a success rate of 81.8%, compared with just 53.8% for approaches without these learning loops. The strategic implication is clear: errors don't just leave the AI no worse off, they actively make it better and create a self-optimising digital workforce.

Takeaway 2: AI developers are already working in specialised teams

Modern AI systems no longer operate as lone wolves but as coordinated teams of specialised agents. One leading framework, known as RGD (Refinement and Guidance Debugging), for instance uses three different AI agents working together. Picture this system as a highly efficient digital team: the Guide Agent acts as project manager, analysing the requirements and setting the strategy. The Debug Agent is the hard-working developer who writes and fixes the code. And the Feedback Agent takes on the role of quality assurance, reviewing the results and pointing out room for improvement. This development proves that AI is turning from a simple tool into a scalable, organisable workforce that mirrors the structure of human project teams.

Takeaway 3: We're witnessing the leap from code completion to days of autonomous project work

Until recently, AI tools like GitHub Copilot were mainly helpers that completed code. The latest breakthrough with models like Claude Sonnet 4.5 marks a turning point. This model has demonstrated its ability to handle more than 30 hours of autonomous programming. In one test, it built an app with 11,000 lines of code, including planning, implementation and debugging, without any human intervention whatsoever. The shift in how we work with AI is captured nicely by the following quote:

In day-to-day coding, Sonnet 4.5 is the difference between asking an intern for corrections and having a more experienced teammate who ships real features.

In practice, this means: instead of asking the AI to change a single file, you can now hand it a complete bug ticket from your project management tool (e.g. a so-called “GitHub issue”) or a whole list of tasks, from bug fixes and writing tests to improving documentation, and expect a finished code proposal ready for integration at the end (a “pull request”). This revolutionary technology is already available to companies today through platforms such as GitHub Copilot and AWS Bedrock.

Conclusion: the blueprint for the future of work

Software development has become the spearhead of the agentic AI revolution. The reasons are clear: the predictable, logical nature of code, combined with the structured and instant feedback mechanisms of development environments, creates the perfect ecosystem for autonomous AI systems to learn, adapt and master complex tasks.

The lessons from software development are a blueprint for other industries. They show that autonomy and efficiency arrive fastest where processes are clearly structured, tasks are measurable and feedback loops are short.

Episode 10.9 - AI is not a product, it's a featureDocIsInDaHouseEpisode 11.0 - Building Your Own Intelligence InfrastructureDocIsInDaHouse

Which leads to one final, strategic question for every decision-maker: If AI agents are already capable of handling complex software projects autonomously today, which strategic processes in your organisation could be next to benefit from this structured autonomy?


Too Long, Don't Read? No problem: here's the Prompcast 😉


🚀 Service: Book your own AI expert for free 😉


*Apropos paradoxes, here is Moravec's one

“it is comparatively easy to make computers exhibit adult level performance on intelligence tests or playing checkers, and difficult or impossible to give them the skills of a one-year-old when it comes to perception and mobility”

Live long and prosper 😉✋

▶Listen