Tools like Claude Code represent a new generation of development aids: they do not just suggest individual lines of code, they work agentically — that is, they carry out multi-step tasks in a project largely independently, reading existing files, changing multiple places and checking intermediate results. The fact that dedicated hands-on workshops for developers are now being offered on this field of application is a good indication of how quickly the topic has developed from a gimmick into an everyday question.

For companies commissioning web or TYPO3 projects, the interesting question is not whether a team uses such tools. What is interesting is how it uses them — and what that means for deadlines, quality and maintainability.

The difference between autocomplete and agent

This shifts the role of the developer. The effort moves from input to formulating the task and reviewing the result. Anyone who describes a requirement imprecisely quickly gets a lot of code that looks plausible and still misses the goal. That is precisely why the structured approach — task breakdown, context, acceptance — is the actual learning content and not the operation of the tool.

Where speed arises — and where it does not

Experience shows that the main beneficiaries are tasks that are clearly defined and easy to verify: boilerplate, i.e. uniform scaffolding code, test cases for existing logic, migration steps, renaming across many files, opening up unfamiliar codebases. Even the initial orientation in an inherited legacy system is significantly faster when a tool summarises structure and dependencies.

Little is gained where the difficulty does not lie in writing: in domain decisions, in architectural questions with long-term impact, in security and data protection considerations, in everything that requires deep knowledge of the client and their processes. Naming this boundary openly protects against exaggerated expectations on both sides of the project table.

Review becomes the bottleneck

When code is produced faster, more code is also produced that has to be read. Teams that underestimate this merely shift the problem: implementation takes less time, acceptance takes longer, and you pay for it in maintenance.

In practice, it has proven effective to plan review effort deliberately instead of treating it as a leftover item. This includes manageable change packages, a traceable commit history and the rule that no one approves changes they do not understand. Automated checks in the pipeline — static analysis, coding standards, tests — catch some of the routine errors and keep human attention free for what really requires judgement.

Rules that should live in the project

To keep the use reproducible, it helps to anchor guidelines in the repository rather than in people's heads:

  • Responsibility: The person who submits a change remains responsible for it — regardless of who or what wrote the code.
  • Conventions: Store coding standards, directory structure and naming documented in the project so that an agent can orient itself by them.
  • Boundaries: Define which areas are not to be processed automatically — such as authentication, payment processing or migration scripts on production data.
  • Data protection: Clarify which content may be sent to an external service at all, and consistently keep credentials and customer data out of the context.
  • Tests: The same testing obligation applies to generated logic as to hand-written code.

Special features in TYPO3 projects

In CMS projects the framework is narrower than in a free greenfield project. TYPO3 comes with its own conventions — extension structure, configuration files, database definitions, upgrade paths between versions. Agentic tools deliver good results here when they know the relevant project context, and otherwise produce code that appears generically correct but does not fit the framework.

The use is therefore particularly useful for recurring routine work: adapting templates, consistently updating configuration, detecting deprecations before a version change, creating documentation for existing extensions. The substantive modelling — which content types, which editorial processes, which permissions — remains manual work in dialogue with the editorial teams.

Qualification as part of the introduction

The fact that workshops on this topic are emerging points to a second aspect: handling agentic tools is a learnable skill and not a matter of course. Cutting tasks sensibly, providing context, critically reviewing results, recognising abort criteria — a team learns this faster together than each person on their own. Whoever accompanies the introduction also prevents five different, undocumented ways of working from becoming established in a team.

What this means for projects

For clients, the benchmark shifts: it is not the question of whether AI is involved that decides quality, but whether a team has demonstrable processes for review, tests and responsibility.

A speed gain is realistic for clearly defined implementation work, while conception, architecture and acceptance retain their effort. Anyone who specifically asks about these processes when selecting a service provider will recognise more quickly where speed also becomes substance.

Sources