Skip to content
Winter Sale from $619, until 31st December 2026 Book now
Agentic coding workshops iOS + Android

Secure Agentic Coding Workshop: Adopting Coding Agents Without Opening New Holes

A secure agentic coding workshop teaches a team to treat a coding agent like a fast new colleague with shell access: give it the least privilege that still gets the job done, keep secrets out of its reach, isolate what it runs and review what it changes. The best format combines a short threat model with labs in which participants first attack and then lock down their own agent setup.

7 min read

Key takeaways

  • The main risks are not exotic: prompt injection through files and issues, secrets in reach of the agent, destructive commands, invented dependencies and unreviewed changes.
  • Every major tool already ships controls – permission modes, allow and deny rules, sandboxes, approval settings. Most teams simply never configure them.
  • Labs beat slides: watching your own agent follow a planted instruction convinces a team faster than any policy document.
  • Mobile teams have extra crown jewels – signing certificates, upload keys and store API keys – that an agent should never be able to read or print.

The threat model in one table

A coding agent reads untrusted text, decides what to do and executes commands with the developer's rights. That combination is what makes it useful and what makes it risky. The workshop starts by mapping the risks to concrete controls:

RiskHow it happensControl
Prompt injectionInstructions hidden in a README, an issue, a web page or a tool resultLimited tools and network access, approval for sensitive actions, review
Secret exposureAgent reads .env, keystores or CI config and echoes values into logs or codeDeny rules, secrets outside the repository, secret scanning
Destructive commandsA wrong rm, a force push, a database resetCommand allowlists, sandbox, protected branches
Supply chainAgent adds a package that doesn't exist yet – or a look-alike someone registeredDependency review, lockfiles, allowed registries
Over-privileged integrationsMCP servers or tokens with write access to everythingRead-only scopes, per-project configuration, server allowlist
Insecure code mergedPlausible code without an authorisation check or input validationMandatory human review, security-focused checks in CI

Our overview of security risks of agentic coding explains each risk in more depth; the workshop focuses on what your team configures and practises.

Workshop modules

  1. How agents act. The loop of reading, planning and executing, and where untrusted input enters it.
  2. Threat model for your setup. Which tools, which repositories, which cloud agents, which integrations – and what each can reach.
  3. Permissions and sandboxes. Configuring what the agent may run, read and reach on the network, on developer machines and in CI.
  4. Secrets. Where they live today, where they should live, and how to keep them out of prompts, logs and commits.
  5. Dependencies and MCP. Vetting packages and servers the agent wants to add or use.
  6. Review gates. What a human must look at before agent-written code is merged, and what CI checks automatically.
  7. Policy. Turning the day's settings into a short written policy the team can follow.

A full day covers all seven; a half day focuses on modules three to five for teams that already have a threat model.

Talk to an AI Code Engineer about your agentic coding workshop.

In a free call we look at your team, your codebase and your goals and suggest a workshop format that fits – remote or on-site, in English or German.

Three labs that change behaviour

Lab 1: Attack your own agent

Participants plant a harmless instruction in a file the agent will read – for example a comment in a README that tells it to print the contents of a dummy secrets file or to add an unexpected dependency. Then they give the agent an unrelated task and watch. Whether or not the agent falls for it, the discussion about why is the most valuable half hour of the day.

Lab 2: Lock it down

The same setup, hardened: deny rules for sensitive paths, an allowlist of commands that run without asking, a sandbox for shell commands, approval for network access. Participants repeat the attack and see which layer stops it. They also notice where the lock-down is too tight to work with, which is equally important – controls that annoy developers get switched off.

Lab 3: The secret that slipped

A dummy API key ends up in a commit. Participants set up a pre-commit secret scanner and a CI check, then rehearse the response: revoke, rotate, rewrite history only if needed, document. Agents are fast at producing commits; the safety net must be just as fast.

Controls the tools already give you

Every major coding agent has security settings; the workshop works with the ones your team actually uses:

  • Claude Code has permission modes, allow and deny rules in its settings files, hooks that can block tool calls, and a sandbox for shell commands that restricts file system and network access at the operating-system level. Anthropic's sandboxing documentation describes how it works.
  • OpenAI Codex runs locally with sandbox modes and approval settings that decide when it must ask before writing files or using the network; its cloud tasks run in isolated containers.
  • Cursor and GitHub Copilot let you control which commands run automatically in agent mode; their cloud and coding agents work in separate environments whose network access and secrets you configure.

The point of this module is not to memorise settings but to agree on a team baseline – committed to the repository where the tool supports it – so that a new developer gets the safe configuration by default.

Mobile teams: protect the crown jewels

App projects carry credentials that are far more damaging to lose than a typical API key:

  • Apple distribution certificates and their private keys, provisioning profiles and the App Store Connect API key (.p8),
  • the Android upload keystore and its passwords, plus Play Console service account credentials,
  • backend keys that end up compiled into the app binary, where anyone can extract them.

None of these belongs in the repository or in reach of an agent session. They live in CI secrets or a dedicated certificate store, and the agent works with the pipeline that uses them, never with the files themselves. Our playbook on secrets and API keys in AI-built apps shows the setup, and the security audit for AI-generated code covers what to check in code that is already written.

From workshop to policy

The last block produces a one- or two-page agent policy. It names the approved tools and plans, the classes of code and data agents may access, the approved MCP servers, the review rule for agent-written changes and the path for reporting an incident. Teams with ISO 27001 will recognise the structure: asset management, access control, supplier relationships and secure development, applied to a new kind of tool.

jocapps GmbH, the company behind appsubmitter.io, is ISO 27001 certified, and our AI Code Engineers work in customers' own developer accounts every day – the same least-privilege habits are what we teach. Workshops run remotely or on-site, in English or German. If your security team wants to go through the threat model before committing to a format, book a free call; the MCP workshop and the AI code review workshop go deeper on two of the modules.

Security baseline to leave the workshop with

  • Approved tools and plans are listed, with their data and training terms understood.
  • A shared permission configuration is committed to the repository where the tool supports it.
  • Deny rules cover .env files, keystores, certificates and folders with real data.
  • Shell commands run sandboxed or from an allowlist; network access needs approval.
  • Signing keys, store API keys and service account files live only in CI secrets.
  • A secret scanner runs before commit and in CI.
  • New dependencies and MCP servers need human approval.
  • Every agent-written change is reviewed by a person before merge.

Frequently asked questions

Is it safe to let a coding agent run shell commands?

It can be, with the right setup: a sandbox or allowlist for commands, no access to secrets, approval for network access and protected branches. Running agents with all checks disabled on a machine that holds production credentials is the setup to avoid.

Should we forbid modes that skip permission prompts?

Not necessarily. They are useful inside an isolated container or VM without secrets. The rule should be about the environment: no unattended mode on machines or in pipelines that can reach production systems or signing keys.

Who should attend a secure agentic coding workshop?

Developers who use the agents, at least one person from security or IT who owns the policy, and the tech lead who decides on the configuration. Mixed groups produce settings that are both safe and usable.

Can you help us review our current agent setup first?

Yes. In a short conversation we go through your tools, repositories and integrations and suggest whether a workshop, a shorter review session or coaching for the people who own the configuration fits best.

Free, 15 minutes, no obligation

Plan your agentic coding workshop with us.

Our AI Code Engineers run hands-on workshops on Claude Code, OpenAI Codex, Cursor and AI app builders – and ship apps to the App Store and Google Play every week. Tell us about your team.

AI tools, store policies and requirements change quickly – always check the current documentation of the tools and stores you use. This article is independent advice and not affiliated with or endorsed by Apple, Google, Anthropic, OpenAI or any other company or product mentioned; all trademarks belong to their owners.

Workshop for your team?

Talk to an AI Code Engineer – free, 15 minutes, in English or German.

Book a call for free

Chat and hotline are open 24/7. Answers from our senior AI Code Engineers (real humans) usually take closer to 72 hours than 1 hour.