Agentic Coding Workshop for Teams: What a Hands-On Day Looks Like

Most teams have already tried a coding agent by now. A few developers are enthusiastic, a few are skeptical, and nobody agrees on what good looks like. A team workshop closes that gap in one shared, practical session instead of leaving everyone to learn alone at different speeds.

Why train the whole team together

Individual experiments produce individual habits. One developer lets the agent change twenty files at once, another never lets it touch more than a function. When the team trains together, you agree on shared vocabulary, shared guardrails and a shared definition of a reviewable change. That agreement is worth more than any single prompt trick.

What the day looks like

The structure below is typical for a one-day format. Exact timing depends on team size and experience.

1. Calibration (60 minutes). We look at what the team already does, which tools are in use (for example Claude Code, OpenAI Codex or Cursor) and where agents have helped or hurt so far.
2. Guided agent session (90 minutes). Everyone works through a small feature from plan to diff. We practice writing a short plan first, letting the agent implement in small steps and stopping it when it drifts.
3. Review lab (90 minutes). Participants review agent-written changes, some of them deliberately flawed. The goal is to build the instinct for what to question: missing edge cases, invented APIs, silent behavior changes.
4. Your codebase (120 minutes). Teams pick a real ticket from their backlog and work it with the agent, supported by an instructor. This is where the learning sticks.
5. Wrap-up (30 minutes). We write down the team's rules, such as how large a change may be, who reviews it and what must be tested before merging.

Skills participants practice

• Writing task descriptions an agent can act on, including constraints and acceptance criteria
• Keeping context small and relevant, and maintaining project instruction files (see our guide on AGENTS.md and CLAUDE.md)
• Splitting work into steps that can be verified one at a time
• Running tests and reading the results instead of trusting the agent's summary
• Recognizing when to stop prompting and write the code by hand

Typical exercises in more detail

The review lab deserves a closer look because it is where most teams change their minds. We hand out several agent-written changes. One has a subtle off-by-one error, one quietly renames a public function, one adds a dependency nobody asked for and one is simply good. Participants review in pairs, write down what they would ask the author and then compare notes. The point is not to trick anyone. It is to show that a plausible diff and a correct diff are different things, and that a fast reading habit has to be replaced by a deliberate one.

In the backlog session, we encourage teams to start with tasks where success is easy to check: a bug with a clear reproduction, a missing validation, an additional test file or a small screen. Once the first merge feels safe, the group tries something larger and experiences first-hand why splitting work into steps matters.

Roles inside the team

We also discuss who does what after the workshop. Some teams nominate an agent champion who curates the shared instruction file and collects lessons learned. Others rotate the role monthly. Either way, somebody should own the working agreement, otherwise it drifts and the old habits return within weeks.

How apprat.io approaches it

Our motto is AI speed, human responsibility. The agent does much of the typing, but a senior AI Code Engineer plans the work, reviews every change, tests on real devices and owns the result. Workshop instructors work exactly this way in their own projects, so the exercises reflect daily practice rather than demos. Our processes are ISO 9001 and ISO 27001 certified, which shapes how we treat secrets and access in the exercises.

Preparing your team

A little preparation makes the day far more productive:

• Choose two or three real tickets of small to medium size that are safe to work on.
• Make sure everyone can run the project locally and has access to the chosen agent tool.
• Decide who will own the resulting rules afterwards, for example a tech lead.
• Check your company's policy on sending source code to third-party services before the day.

What you take away

Teams leave with a written working agreement, a starter instruction file for their repository, a list of tasks that suit agents and tasks that do not, and a first set of merged changes. For a broader view on running these sessions, see our workshop agenda template and our guide to measuring workshop ROI. If you want to discuss format and dates, you can book a call for free.