The first generation of AI support in the editor was essentially better autocomplete: it suggested the next line, completed a function signature, filled in a loop.The human remained at the controls throughout, line by line.That phase is now coming to an end.

Currently, a different way of working is moving into the foreground, for which the term agentic has become established.This refers to a tool that not only delivers a suggestion, but works through a task itself in several steps: reading files in the project, grasping connections, making changes in several places, executing commands, checking results.Claude Code is one of the tools that translate precisely this approach into concrete development workflows.The fact that the Golem Karrierewelt now offers a workshop on the basics and advanced agentic workflows is a good indication that the topic is leaving the experimentation phase and arriving in project practice.

What actually changes in the way we work

The difference is less a technical one than an organisational one.With autocomplete, the unit of work was the line.With agentic workflows, it is the task – that is, more like what otherwise appears in a ticket.

This shifts the role of the developer in three directions:

  • From writing to describing. Anyone who delegates a task must formulate it precisely: what should be achieved, which boundary conditions apply, which places in the project are off-limits.Vague requirements become expensive because they produce vague results – only faster.
  • From typing to checking. The proportion of reading code rises compared with writing.A changeset that touches ten files demands a different kind of review than a hand-written method.
  • From individual step to workflow. This way of working makes sense where tasks have recurring patterns: migrations, refactorings, catching up on test coverage, adapting interfaces.

Shorter cycles create new need for checking

For client projects, the effect is initially pleasant: tasks that used to mean half a day of tedious work are completed faster.That shortens development cycles and makes it more realistic to reduce technical debt along the way instead of pushing it onto a big refactoring.

But the effort does not disappear, it shifts.If more code changes are produced per day, quality assurance becomes the bottleneck.Specifically, this affects three areas:

Review. A pull request – that is, a changeset submitted for review – with thirty changed files is practically no longer possible to read seriously.Agentic work therefore needs small, thematically scoped changesets, even if the tool could technically accomplish more in one pass.The discipline of keeping tasks small becomes more important than before.

Tests. Automated tests were always sensible, but here they become a prerequisite.They are the net that checks whether a quickly generated change leaves existing functionality untouched.Projects without robust test coverage benefit significantly less from agentic workflows, because every change has to be checked manually.

Traceability. Anyone who wants to understand in six months why a particular place looks the way it does needs commit messages and documentation that record the intent – not just the result.This applies more strongly to delegated work, because nobody on the team typed the change line by line themselves.

Responsibility stays where it was

One point that is often lost in the discussion: liability for delivered code does not change.Whether a function was created by hand or generated by an agent is irrelevant to the client and to auditing bodies.Whoever approves, is responsible.

In practice, this means that teams need rules before they deploy such tools widely.Sensible questions are: In which repositories may an agent work?Which areas – payment processing, authentication, personal data – remain excluded or require a four-eyes principle?How do we handle dependencies that an agent suggests?And which data from the project may be transmitted to an external service at all?The last point in particular is the real hurdle in many mid-sized projects and belongs before the technical evaluation.

What a realistic entry looks like

The leap from occasional autocomplete to delegated tasks cannot be accomplished by installing a tool.It requires practised workflows – which is why training offerings on precisely this transition now exist.

A pragmatic path begins with well-defined, low-risk tasks: adding tests for existing code, replacing outdated calls project-wide, updating documentation from the code.That builds experience without a mistake landing directly in productive business logic.Only when review and test routines can keep pace with the higher throughput does it become worthwhile to delegate more complex tasks.

An honest measurement is just as important.Anyone who wants to demonstrate the benefit should not look at the amount of code generated, but at the lead time from requirement to approval – and the error rate afterwards.

More code is not a result, but a cost factor.

What this means for web and software projects

Agentic workflows shift the bottleneck in projects from implementation to quality assurance. Those who invest in test coverage, small change sets and clear approval rules can actually turn the shorter cycles into faster releases; those who do not primarily produce a faster need for rework. For project planning, this means: review capacity and test infrastructure must now be factored into the calculation just as much as development time itself.

Sources