Coding agents have arrived in software development. A survey by JetBrains concludes that nine out of ten developers regularly work with such a tool. This refers to assistants that not only suggest individual lines of code but independently execute several steps: reading files, writing changes, starting tests, evaluating results.

At the top of the popularity list, according to the survey, is Claude Code, by a clear margin. GitHub Copilot follows as the second widely used tool. Within a short time, a field has thus formed in which two names shape everyday work — while the question of how to work reliably with these tools has only begun to be answered.

From autocomplete to agent

The difference from classic code completion is practically relevant. A suggestion in the editor can be accepted or discarded in a second. An agent, by contrast, works over several minutes and in the end leaves behind a series of changes that must be reviewed together. Responsibility thus shifts from writing to judging.

This explains why adoption is so high and yet the discussion shows no sign of abating. A tool that nine out of ten people on a team use is no longer an experiment but part of the development process — with all the consequences for code review, test coverage and traceability of changes.

The repository becomes the agent's working environment

This is precisely where a second observation comes in. Under the term Agentic Engineering — the deliberate design of projects for collaboration with AI agents — a webinar by the native web GmbH on 26 August 2026 is dedicated to the question of how a repository must be structured so that an agent can work in it reliably.

The question is remarkable because it reverses the perspective. The bottleneck is not the model but the project in which it works. An agent reads the code, the configuration, the documentation and the test results — and derives from them what it should do. If this foundation is unclear, it produces unclear results.

From the practice of web and TYPO3 projects, several points can be named where this difference becomes visible:

  • Traceable structure: A project with recognisable conventions for directories, names and responsibilities is easier for an agent to grasp than a custom solution that has grown over years.
  • Automated tests: They are the feedback against which an agent can check its changes. Without them, the controlling instance is missing that turns a suggestion into a robust result.
  • Reproducible setups: If the project can be started with a few defined steps, an agent can actually try out changes instead of merely guessing.
  • Documented decisions: Why a module is built the way it is built is rarely found in the code. This very information prevents an agent from accidentally undoing grown decisions.

Shorter cycles, but not automatically less effort

For client projects, the high adoption initially means: routine work becomes faster. Refactorings, migrations, creating recurring structures, writing tests — here agents show their practical benefit most clearly.

But the effort does not disappear; it shifts. When more changes arise in less time, the need for quality assurance increases. Reviews must become more thorough, not more superficial, because a plausibly looking change is not necessarily a correct one. Teams that skip this step merely move errors into a later project phase, where correcting them is more expensive.

What the two reports show together

The survey describes a state of affairs: coding agents are standard, and two tools dominate. The webinar topic describes an open construction site: How must a project be structured so that these tools work reliably? Together, the two give a realistic picture of a technology that is widely used but whose methodological embedding is still emerging.

Context also includes what the sources do not say. No figures are available here on productivity gains, error rates or the quality of the changes produced. Anyone making a tool decision should therefore not base it on popularity ratings alone but test it against their own codebase.

A pragmatic start

For companies that want to structure their use of coding agents, a delimited start is advisable rather than a company-wide rollout:

  1. Select a project that is well tested and manageable — there the risk is calculable and the feedback is quick.
  2. Before using the agent, check the foundations: Does the test suite run, is the setup reproducible, are the conventions documented?
  3. Clarify which types of tasks are delegated and which are not — security-relevant matters and architecture decisions are sensibly left with the team.
  4. Adjust review rules: Who reviews agent-generated changes, and what is the basis for approval?
  5. Record experiences so that individual cases become a robust way of working.

For web and software projects, this means: The question is no longer whether coding agents are used, but how well a project is prepared for them.

Investments in test coverage, clean structure and documented decisions pay off twice over — they help the team and are what make the agent usable in the first place.Anyone who develops existing codebases in this direction shortens development cycles more sustainably than by choosing a particular tool.

Sources