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

Claude Code Workshop: Six Modules, One Real Ticket, a Team Setup That Lasts

A Claude Code workshop should leave your repository with a reviewed CLAUDE.md, committed permission settings and a few shared commands – and leave your developers able to take a ticket from plan mode to a tested pull request. The most effective format follows one real ticket from your backlog through six modules instead of jumping between disconnected demos.

7 min read

Key takeaways

  • Following one real ticket through the whole day teaches more than a series of unrelated demos.
  • CLAUDE.md works best short and specific: commands, conventions and no-go areas, not a copy of the wiki.
  • Permission settings belong in the repository so the whole team shares the same safe defaults.
  • Slash commands, subagents and hooks are worth introducing on day one, but only one of each – depth comes later.

Who a Claude Code workshop is for

Claude Code is Anthropic's agentic coding tool. It runs in the terminal, inside VS Code and JetBrains IDEs, in a desktop app and on the web, and it works directly in your repository: it reads files, edits them and runs commands. The official documentation covers installation and every setting in detail.

This workshop suits teams that have decided on Claude Code – or are about to – and want everyone working the same way. Typical groups are backend, web and mobile developers with a few people who already use the tool on their own and many who have only tried it once. If your team is still comparing agents, start with the tool-neutral agentic coding workshop or read Claude Code vs. Codex first.

Before the session, every participant needs access through your organisation's Claude plan or API account, the tool installed and the repository cloned with dependencies in place. Sorting that out in advance saves the first morning.

Why we follow one real ticket all day

Together with the tech lead, we pick a ticket from your backlog that is real, mid-sized and testable – a new API field with validation, a settings screen, a migration with a data fix. Every module adds one capability to the way the team handles that ticket. By the afternoon, each pair has a pull request that went through plan, implementation, tests and review.

The benefit is that every concept lands on something people care about. Permission settings matter because the agent wants to run your migration command. CLAUDE.md matters because the agent just used the wrong test runner.

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.

The six modules

ModuleWhat the team practisesWhat gets committed
1. Setup and permissionsPermission modes, allow and deny rules for commands, what to never auto-approveA shared .claude/settings.json
2. Project memoryGenerating a first CLAUDE.md with /init, then cutting it down to what mattersA reviewed CLAUDE.md
3. Plan modeAsking for a plan, challenging it, approving it, sizing the workThe plan as part of the pull request description
4. The verification loopMaking tests, linters and builds fast enough for the agent to run them oftenScripts or make targets the agent can call
5. Extending Claude CodeOne custom slash command, one subagent, one hookFiles in .claude/ the whole team uses
6. Beyond the laptopHeadless runs with claude -p and the GitHub Actions integrationA first, small workflow – or a decision to wait

The timings shift with the group. A team with slow builds spends longer in module 4; a team with strict security needs spends longer in module 1.

Inside the modules that matter most

Permissions before productivity

Claude Code asks before it edits files or runs commands unless you tell it otherwise. Teams quickly get tired of approving npm test for the hundredth time and switch to accepting everything. The workshop finds the middle: allow the safe, frequent commands in the project settings, deny the dangerous ones explicitly (pushing to main, deleting directories, reading .env files) and keep a human prompt for the rest.

A CLAUDE.md that the agent actually follows

The generated file is a starting point, not the result. We go through it line by line and keep what changes the agent's behaviour: the exact build and test commands, the architecture in five sentences, naming conventions, the folders it must not touch and how to verify a change. Long prose, outdated wiki pages and generic advice like "write clean code" come out. Larger repositories get additional CLAUDE.md files in subfolders, which Claude Code picks up when it works there.

Plan mode as a team habit

In plan mode, Claude Code reads and proposes but does not change files. Participants practise rejecting plans: too broad, touches the wrong layer, misses a migration, forgets tests. That habit alone prevents most of the oversized, hard-to-review pull requests that make teams sceptical of agents.

Commands, subagents and hooks – one of each

A custom slash command for a recurring task (for example "add an endpoint following our pattern"), a subagent that reviews diffs against the team's checklist and a hook that runs the formatter after every edit. Introducing exactly one of each shows the pattern without overwhelming anyone. Teams that want more go on to the advanced Claude Code workshop, and MCP connections to tools like issue trackers get their own MCP workshop.

Five mistakes we see in teams new to Claude Code

  1. Every developer has a private setup. Personal CLAUDE.md files and settings drift apart, and results become unpredictable. Commit the team version, keep personal preferences in user-level files.
  2. Tasks are too large. "Build the onboarding flow" produces a huge diff nobody wants to review. Split it into steps the agent can finish and verify.
  3. No way to verify. Without tests the agent can run, it reports success because the code compiles. Add even a few tests before handing over bigger work.
  4. Long sessions that lose focus. After many unrelated tasks, context fills up with noise. Start fresh sessions for fresh tasks and use /clear generously.
  5. Reviews get skipped. Agent output looks finished. It still needs the same review as any colleague's pull request – our review process for agent-generated code is a good template.

Claude Code for mobile teams

Mobile projects add their own rules. iOS builds need macOS and Xcode, so the verification loop runs xcodebuild on a Mac or a macOS CI runner. Android work revolves around Gradle tasks and emulators. Signing assets, entitlements and store metadata are files the agent should not change without a human looking at the diff.

In mobile workshops we put these rules into CLAUDE.md from the start and practise the stack-specific loops: SwiftUI, Kotlin and Jetpack Compose or React Native with Expo. When the app is ready to ship, Claude Code app to the App Store shows how to split the release between agent and human.

Running the workshop with us

Our AI Code Engineers use Claude Code daily on client apps and on our own release tooling. We run this workshop remote or on-site, in English or German, on your repository where your policies allow it, and we prepare a matching sample project where they do not. Before the day, we check access, installs and the ticket with your tech lead; afterwards, a follow-up session looks at how the team's setup holds up in daily use. A free call is the easiest way to find out whether this format fits your team.

What your repository should contain after the workshop

  • A short, reviewed CLAUDE.md with build, test and lint commands and protected folders.
  • A committed .claude/settings.json with allow and deny rules the team agreed on.
  • At least one shared slash command for a task the team repeats often.
  • A review subagent or checklist that matches your pull request rules.
  • A formatter or linter hook so every agent edit follows house style.
  • A written rule for when to use plan mode and how large an agent task may be.

Frequently asked questions

Terminal, IDE extension or desktop app – which should we train on?

The concepts are the same everywhere. We usually train in the terminal or the IDE extension your developers already use and show the other surfaces briefly. Configuration files like CLAUDE.md and the project settings apply to all of them.

Do we need the advanced workshop as well?

Not right away. Most teams should use the basic setup for a few weeks first. Once people ask for automation, more subagents, custom skills or CI runs, the advanced workshop builds on what is already in the repository.

Can participants use their own Claude accounts?

Technically yes, but we recommend the organisation's plan so that data handling, admin settings and billing are consistent. Mixing personal and company accounts on company code is usually a policy question worth settling first.

How do we keep secrets away from Claude Code?

Deny read access to secret files in the project settings, keep secrets out of the repository and use environment variables or a secret manager. Our guide to secrets and API keys covers the details.

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.