Coding agents have long been part of everyday life in many development teams. They create files, refactor, write tests and now also work independently across longer task chains. A new study on Claude Code and Codex now points to a weakness that becomes relevant precisely with this autonomy: the agents have no reliable sense of time – and they don't know it.

Two findings: duration and self-assessment

The first finding concerns the estimation of effort. According to the study, both systems systematically misjudge how long a task takes. For Codex, a deviation of sometimes tenfold is reported. How strongly and in which direction the misjudgement falls is emphasised differently depending on the account – the core message remains the same in any case: time estimates from coding agents are not a basis for planning.

The second finding weighs more heavily in practice. Both assistants rate the quality of their own work around 20 percentage points too positively. An agent that declares a task done therefore not only delivers a result, but also a systematically over-optimistic judgement about it. Anyone who follows this judgement adopts a bias that is not visible in the code itself.

Both together produce a control problem that grows with the length of the task. For a short assignment – adding a function, validating a form – the developer checks the result directly anyway. If, on the other hand, an agent runs for an hour or longer on a chained task, it repeatedly decides along the way whether a sub-step is finished and whether it can continue. These very decisions are based on the overly positive self-assessment. Errors propagate instead of being caught at the next checkpoint.

Why this shifts the role of teams

In parallel with this finding, a second observation is being discussed in the industry that fits well with it: the more tasks AI takes on, the more important good teams become. AI can generate code, review code and take over work steps. What it lacks is the knowledge to classify results across multiple disciplines – that is, to judge whether a technically plausible solution also holds up in domain terms, in security terms and operationally. And it cannot take responsibility.

This above all changes the requirements for DevSecOps – that way of working that brings development, security and operations together in a shared process. If a considerable part of the code comes from agents, the bottleneck shifts from creation to assessment. The question is less how quickly something is produced, but who judges whether it may go into operation in this form.

What this means for project practice

A few sober consequences can be derived from the two findings that can be implemented in ongoing projects:

  • Do not adopt time estimates from agents. Effort estimates from an assistant are at most a conversation starter, not a basis for sprint planning, quotations or schedule commitments to customers.
  • Do not treat self-reports as acceptance. A "done" or "tests pass" from the agent does not replace a review. The reported deviation of around 20 percentage points in self-assessment is the actual takeaway here.
  • Break up long autonomous runs. Instead of one large task over hours, prefer several clearly delimited steps with fixed checkpoints. The shorter the chain, the lower the chance that a false self-assessment carries forward.
  • Interpose objective review instances. Automated tests, static analysis, linting and security scans judge independently of the agent. They do not replace human review, but they reduce dependence on self-reporting.
  • Name responsibilities. For every artefact that goes into operation, there needs to be a person who is accountable for it in domain terms – regardless of who or what wrote it.

Experience does not become superfluous, but is used differently

The obvious concern that coding agents would replace experienced developers falls short against this background. The finding points in a different direction: precisely because agents produce a lot and rate their results too highly, people are needed who know the domain context. Those who understand a domain recognise a solution that looks technically clean and misses the mark in domain terms. Those who know operations recognise decisions that work in the test system and become expensive under load or in maintenance.

For collaboration in projects, this also means: reviews should not be treated as a formality that is the first thing cut under time pressure. They are the place where the systematic bias of the agents is corrected. And they are the place where knowledge stays in the team – even for code that nobody on the team wrote by hand.

Assessment

Coding agents remain a useful tool, but they are not a reliable reporter on their own work. For web and software projects, this above all means expanding review steps, test coverage and clear responsibilities where agents bring speed.

Anyone who deploys agents while also investing in a review culture and experience within the team gains speed without losing control – anyone who focuses only on pace merely shifts the effort to later in maintenance and bug fixing.

Sources