Coding agents are AI tools that not only provide code suggestions but independently perform actions on the computer: creating, modifying and deleting files, launching commands, installing dependencies.This very independence is what makes them useful in everyday development – and at the same time turns them into a security issue that goes beyond classic autocomplete.

A recent guide on Golem.de describes the core problems soberly: local coding agents can independently delete files, expose credentials and be manipulated.For agencies and IT departments that work with third-party source code and third-party data, these are not theoretical edge cases but questions of due diligence.

Three risk areas that should be kept apart

Unintentional changes. An agent tasked with performing a refactoring interprets the task independently.If it deletes files or overwrites configurations in the process, this does not necessarily become apparent immediately – especially not when many changes arise in a single run and nobody reviews them individually.

Exposure of credentials. Development environments typically contain more secrets than one is aware of in everyday work: environment variables, database credentials, API keys, SSH configurations, tokens in local configuration files.An agent that reads files to build context can process such content and, in the worst case, pass it on to an external service.

Manipulation from outside. Agents process text – from repositories, issues, documentation, dependencies.If this text contains instructions, the model may interpret them as a command.The technical term is prompt injection: injected instructions in seemingly harmless data redirect the agent's behaviour.

Why this weighs more heavily in client projects

In a private side project, an accidentally deleted directory is annoying.In a client project, the same incident touches several levels at once: contractual confidentiality obligations, data processing under data protection law, traceability of changes and, not least, trust in delivery quality.

There is also a practical problem: if it remains unclear which lines of code came from a human and which from an agent, this complicates troubleshooting and the allocation of responsibility.Code quality is not a matter of style here but a question of maintainability over years.

Guardrails that prove themselves in practice

The most effective measures are unspectacular and organisational in nature.They start less with the model than with the environment in which it operates.

  • Limit permissions: An agent needs access to a project directory, not to the entire user account.Separate working directories, dedicated users or containers reduce the potential damage.
  • Separate secrets: Credentials do not belong in files that an agent routinely reads.Secret management and short-lived tokens limit the value of a leak.
  • Use version control consistently: Every agent change in its own branch, traceable in small commits.What cannot be reviewed as a diff should not reach the main branch.
  • Review remains human: Generated code is treated like third-party code – including checks for introduced dependencies.
  • Lock out production access: No connection to live databases, production systems or customer data from within the agent environment.
  • Confirmation for critical actions: Deleting, installing, network access and publishing should require explicit approval instead of running automatically.

The question of data flow

Before deployment, a simple inventory is worthwhile: which data leaves the computer, where does it go, how long is it stored, and who may use it for which purposes?Even an agent started locally is not automatically an agent computing locally – many tools send context to models in the cloud.

For projects involving personal data or confidential business information, this distinction is central.It determines whether a tool may be used at all, whether a data processing agreement is required and whether customers must be informed about it.

Rules beat bans

A blanket ban is rarely sustainable: developers then continue using the tools privately, just without consultation.More productive is a written, concise policy that clarifies three things: which tools are approved, in which projects they may be used, and which actions fundamentally require human approval.

This also includes a response path for the case that something does go wrong – for example, if there is suspicion that an access key has leaked.Rotate keys, review access, document the incident: this should be practised before it is needed.

Assessment for web and software projects

Coding agents shift the boundary between suggestion and execution – and with it the boundary of responsibility.Anyone who uses them in client projects should design the technical environment so that misbehaviour remains limited, instead of trusting in the model's good behaviour.

Sandboxing, secret separation, version control and human review are not brakes here, but the prerequisite for the productivity gain to be robust in the first place.

Sources