Contents
Working safely with coding agents is a discipline of its own: an agent that reads files, runs commands and installs packages has access to resources that used to be reserved for humans. A security workshop shows your team the resulting risks – from prompt injection and leaked secrets to compromised dependencies – and how to control them with clear rules and technical safeguards.
Why Coding Agents Are a New Security Topic
Classic AI autocomplete suggests code that a human accepts or rejects. Coding agents go further: they open files, run tests, start builds, call tools through interfaces such as the Model Context Protocol and create commits. The question shifts from "Is this code secure?" to "What is this tool allowed to do in my environment?"
The risk is not theoretical: an agent processes content from issues, web pages, documentation and dependencies. Any of these can contain instructions that did not come from the user. Teams using agents in production work therefore need a shared security understanding – and that is exactly what a security workshop provides.
The Key Risks When Working with Coding Agents
| Risk | Example | Countermeasure |
|---|---|---|
| Prompt injection | A comment in a dependency or an issue text tells the agent to modify files or send data | Restricted permissions, approvals for risky actions, network limits |
| Leaked secrets | API keys from a .env file end up in the context, in logs or in a commit | Secrets outside the working directory, exclusion rules, secret scanning |
| Unsafe dependencies | The agent installs a look-alike package or a non-existent one that an attacker has registered | Package approval, lockfiles, dependency scanning |
| Overly broad commands | Deleting directories, force pushes, changes to production databases | Sandbox, allow-lists, no production access |
| Insecure generated code | SQL injection, missing authorisation, weak cryptography | Review checklists, static analysis, security tests |
| Untrusted tool integrations | An MCP server of unclear origin gains access to internal systems | Approval process for integrations, minimal rights |
For a detailed look at code-level risks, see our article on the security risks of AI-generated code.
Safeguards: A Security Model for Coding Agents
Least privilege and sandboxing
An agent should only be allowed to do what the current task requires. In practice this means working in a container or isolated development environment, write access only within the project directory and network access limited to required hosts. Many tools offer permission modes in which certain actions require confirmation. Our article on sandboxing, permissions and approvals covers the details.
Keep secrets strictly separate
Credentials do not belong in files the agent can read. Use secret stores, short-lived tokens and separate development credentials without production rights. Secret scanning in pre-commit hooks and CI additionally prevents anything from slipping into the repository. More in agentic coding and data security.
Approve integrations deliberately
Through MCP and similar interfaces, agents can access ticket systems, databases or cloud consoles. Every integration widens the attack surface. Define who approves new integrations, which rights they run with and how they are monitored. Background in our article on the Model Context Protocol.
Humans stay in the review loop
Agent-generated code is reviewed like any other code – with particular attention to authentication, authorisation, input validation and new dependencies. Automated checks complement the review but do not replace it.
Possible Content of a Security Workshop
- Threat model: which data, systems and rights does an agent actually have in your environment? Joint analysis of your own toolchain.
- Prompt injection live: in a controlled environment, the team sees how injected instructions work and which protective layers stop them.
- Configuring permissions: allow-lists, approval modes, sandbox setup – hands-on for the tools used in your company.
- Secrets hygiene: cleaning up configuration files, setting up secret scanning, handling tokens.
- Supply chain: rules for new dependencies, checking suggested packages, lockfile discipline.
- Review checklist: the team creates its own security checklist for pull requests containing agent-generated code.
- Policy: wrap-up with a draft internal policy for safe agent use.
Checklist: Safe Agent Use in Your Team
- Agents run in an isolated environment without production access.
- Risky actions (deletion, push, package installation, network access) require approval or are governed by allow-lists.
- Secrets are not stored in the working directory; secret scanning is active.
- New dependencies are reviewed before merging.
- Integrations (e.g. MCP servers) are documented and approved.
- Agent-generated pull requests go through the same review as human code.
- A written policy exists and the whole team knows it.
Who the Workshop Is For and How It Works
A security workshop on coding agents is aimed at developer teams, tech leads, security officers and platform teams who are introducing or already using agents. It is particularly valuable before a broad rollout or in regulated industries. We place AI developers from real-world practice as trainers who work with these tools every day. Format (in-house or remote) and scope are agreed individually – for example a compact security module within a larger training or a dedicated session. Workshops start from €799 net; send requests to team@app-entwickeln-lassen.de.
Planning an app? Request a free fixed-price quote in 2 minutesConclusion
Coding agents deliver real productivity but also new attack surfaces. With least privilege, clean separation of secrets, controlled integrations and consistent review, the risks are manageable. What matters is that the whole team understands the rules and applies them day to day – a hands-on security workshop lays that foundation.
Frequently Asked Questions
What is prompt injection in coding agents?
Prompt injection means that content from files, web pages or tickets contains instructions the agent executes even though they did not come from the user. Restricted permissions and approvals limit the potential damage.
Should coding agents have access to production systems?
We advise against it. Agents should work in isolated development environments; changes to production go through regular, reviewed deployments.
Is static code analysis enough protection?
No. Static analysis catches certain classes of bugs but not risks from overly broad permissions or prompt injection. It is one building block alongside sandboxing, secret separation and review.
How long does a security workshop on coding agents take?
That depends on your starting point and the depth required. We agree scope and format individually, for example as a compact module or a dedicated training day.