Short answer
A good Claude Code workshop runs entirely on the team's own repository and moves from setup and CLAUDE.md to multi-file tasks, permissions, headless runs and review. Two days is enough for engineers to leave with merged changes and a shared way of working.
On this page
- What makes Claude Code different to teach
- Before the workshop: a 30-minute readiness check
- Day one: from first session to confident multi-file changes
- Day two: scaling up and making it stick
- Exercise bank for different team types
- What teams typically get wrong in the first month
- Follow-up that keeps the momentum
- FAQ
- Tools from the jocapps ecosystem
What makes Claude Code different to teach
Claude Code is a terminal-first agent. It reads files, edits them, runs your build and test commands, and can work through a long task with little hand-holding. That autonomy is the point, and it is also what makes training necessary. Engineers who treat it like a chat window get mediocre results. Engineers who learn to give it context, tight tasks and the right permissions get pull requests that pass review.
The workshop below is the format we use at neooutput for engineering teams of roughly 6 to 20 people. Everything happens on the team's own codebase, because the most valuable lessons come from the agent tripping over your real build scripts, your naming conventions and your test gaps.
Before the workshop: a 30-minute readiness check
Send this checklist to the team lead a week before:
- Claude Code installed and authenticated on every machine, including behind the corporate proxy
- The repository cloned, dependencies installed, tests running locally
- A list of five to ten backlog tickets: some small bug fixes, one refactor, one test backfill, one feature slice
- Agreement on which directories or files are off limits (secrets, generated code, vendor folders)
- A decision on the default permission mode for the session
Teams that skip this lose the first morning to installation problems.
Day one: from first session to confident multi-file changes
Block 1: Orientation on your repository (90 minutes)
Participants ask Claude Code to explain the architecture, find where a feature lives and trace a request through the code. Then they compare its explanation against what senior team members know. The gaps are instructive: they show exactly what the agent cannot infer and what needs to be written down.
Block 2: Writing the team's CLAUDE.md (90 minutes)
Together we draft a CLAUDE.md at the repository root: how to build, how to run a single test, code style rules that linters do not enforce, architectural boundaries and common traps. Sub-folders with special rules get their own file. We re-run the orientation tasks and look at how answers improve. Our CLAUDE.md and AGENTS.md workshop goes deeper if context engineering becomes a team priority.
Block 3: Small tasks, end to end (two hours)
Each pair takes a small ticket and drives it to a reviewable branch. The rule is that the agent must run the tests and show a passing result before the human reviews. Pairs learn to:
- State the goal, constraints and definition of done in the first message
- Ask for a plan before edits on anything non-trivial
- Interrupt early when the plan goes in the wrong direction
- Use slash commands and the conversation history deliberately instead of starting over
Block 4: Review clinic (60 minutes)
Pairs swap branches and review each other's agent-produced diffs. We discuss what was easy to verify, what was hidden in large diffs and which prompts led to cleaner changes.
Day two: scaling up and making it stick
Block 5: Larger changes with planning and subagents (two hours)
A refactor or a feature slice across several modules. Participants practise breaking work into steps, letting the agent keep a checklist, and delegating investigation to subagents so the main context stays focused. We also cover when to stop and split the task because the diff has become unreviewable.
Block 6: Permissions, hooks and safety (60 minutes)
Which commands the agent may run without asking, how to allow test runners while blocking deployments, and how hooks can enforce formatting or block edits to sensitive paths. We treat prompt injection practically: what happens if an issue description or a dependency's README contains instructions aimed at the agent.
Block 7: Headless and CI use (90 minutes)
Claude Code can run non-interactively, which opens up uses such as automated test backfills, dependency updates or first-pass reviews in CI. Teams build one small automation and discuss where human approval stays mandatory. For teams that want to go further, the agentic DevOps workshop focuses entirely on pipelines.
Block 8: Team agreement (45 minutes)
The session ends with a one-page working agreement: when to use the agent, maximum diff size for agent-assisted pull requests, review expectations, how CLAUDE.md is maintained and who owns it.
Exercise bank for different team types
| Team type | Exercise that lands well |
|---|---|
| Backend services | Add an endpoint with validation, tests and an updated OpenAPI spec |
| Frontend | Migrate a component to a new design system pattern across several pages |
| Mobile | Fix a crash from a stack trace, add a regression test, prepare a release note |
| Platform | Write a script that audits all services for a deprecated config key |
| Data | Add data quality checks to an existing pipeline with fixtures |
Mobile teams often ask how to get from an agent-built change to a store release. Building is one half; signing, store listings and handling review rejections is the other. That is where appsubmitter.io helps, with AI-assisted and human submission work in your own developer accounts.
What teams typically get wrong in the first month
- Overly long sessions. Context fills up, quality drops. Start fresh sessions per task and let CLAUDE.md carry the persistent knowledge.
- No tests to anchor the agent. In code without tests, the agent cannot verify itself. Test backfills are a great first use case for exactly that reason.
- Accepting large diffs. If a reviewer cannot read it in 20 minutes, it should have been split.
- Personal habits instead of team habits. Without a shared agreement, everyone develops private tricks and review quality varies.
Follow-up that keeps the momentum
We recommend a 90-minute check-in three to four weeks after the workshop. The team brings real pull requests, both good and bad, and we refine CLAUDE.md, permissions and the working agreement. neooutput offers this as part of the workshop package or as 1:1 consulting for the team lead. Teams planning a broader rollout across departments should also read our guide to agentic coding workshops for enterprises.
FAQ
Do participants need prior experience with Claude Code?
No. The agenda starts with orientation on the team's own code. Engineers who already use it benefit from the review, permissions and headless blocks, which most self-taught users skip.
Can the workshop run remotely?
Yes. Remote works well with pairs in breakout rooms and screen sharing. We keep blocks shorter and add more check-ins, as described in our article on remote AI pair programming formats.
Is two days necessary, or can it be one?
One day covers blocks 1 to 4 and gets a team productive on small tasks. The second day is where larger changes, safety and automation come in, which matters for teams that want to use Claude Code beyond simple fixes.
Which languages and frameworks work?
Claude Code is language-agnostic. We have run sessions on Java, TypeScript, Python, PHP, Swift and Kotlin codebases. Build and test commands that work reliably from the terminal matter more than the language.