Skip to content
Training course
Beginner to Intermediate Tailored to your team

Codex Training

A course about delegating engineering work rather than pairing on it: scoping tasks Codex can finish alone, preparing the environments they run in, and reviewing what comes back.

Level
Beginner to Intermediate
Length
1 or 2 days
Delivery
On site, Remote, Hybrid
Group size
5 to 20 participants
See all courses

Booked privately for your team. Dates and length are agreed when you book.

What your team will be able to do

Every module ends with something participants can repeat on Monday morning, in your codebase and against your conventions.

Hand over whole tasks

Write a brief complete enough that a task comes back finished rather than half-done and confused.

Run several at once

Keep several independent tasks in flight without losing track of which branch is holding what.

Prepare the environment

Define the container a task runs in so it has every dependency it needs and none of your credentials.

Review what comes back

Read a change that was written without you watching, and know which parts of it to check first.

Work from the terminal

Drive Codex locally for the work that is quicker to supervise than it is to specify.

Know what to hand over

Separate the tasks worth delegating from the ones where writing the brief costs more than the work.

Curriculum

Built around hands-on work rather than slides. The running order and the depth of each module are adjusted to the group before delivery.

70% hands-on
1

How Codex works

From 1 day
  • The model, the harness around it, and which of the two is at fault when a run misbehaves
  • Cloud tasks, the local command line and the editor extension, and what each one is for
  • The sandbox a task runs inside, and what it can reach from in there
  • Approval modes, and picking one that matches how much you trust the task
2

Delegating a task

From 1 day
  • Writing a brief that is complete without turning into a specification document
  • Several tasks in flight at once, and keeping their branches apart
  • Setup scripts, dependencies, and the state a task needs before it can start
  • Reading the log of a run you were not present for
3

Codex on your own machine

From 2 days
  • The command line for work that is quicker supervised than specified
  • AGENTS.md: the instructions every task inherits without being told
  • Configuration, profiles and settings that differ per repository
  • Connecting it to the systems a task genuinely needs, and stopping there
4

Fitting it into how the team works

From 2 days
  • Delegated changes arriving in a review process that was built for humans
  • What your pipeline ought to catch before a reviewer ever sees it
  • Credentials, environment variables, and what never belongs in a task at all
  • The categories of work to keep in human hands, decided deliberately rather than by accident

How long you book it for

Every length is drawn from the same modules. A longer booking is more of the course, not a different one.

Essentials

Beginner

1 day

The delegation model and how to scope a task so it comes back finished. One day, and for most teams that is the whole of it.

Modules covered

  • How Codex works
  • Delegating a task

Core

Intermediate

2 days

Adds the local command line and the work of fitting delegated changes into a review process that was designed for humans.

Modules covered

  • How Codex works
  • Delegating a task
  • Codex on your own machine
  • Fitting it into how the team works

Not sure which one fits? The intake call settles it, and the length can still change afterwards.

Built around your team

No two runs of this course are the same

The curriculum above is a starting point, not a syllabus. Before anything is booked I find out where your team actually stands, then rebuild the course around that. A team already running agents daily spends its two days somewhere completely different from one that installed the tool last week.

  1. Step 1

    Intake call

    A call before anything is agreed: what your team already uses, what has gone wrong so far, and what you need them doing differently afterwards.

  2. Step 2

    Stack review

    Language, framework, review process, CI. Exercises are rebuilt against your repository so nothing in the room is hypothetical.

  3. Step 3

    Curriculum reshaped

    Modules get dropped, deepened or added. You see the adjusted outline and sign it off before the date is fixed.

  4. Step 4

    Delivery and follow-up

    We run the course, then check in once the team has applied it to real work and the awkward questions have surfaced.

What gets adjusted

  • Depth of each module
  • Your stack and repository
  • Group size and seniority mix
  • Length and how days are split
  • English or German
  • On site, remote or hybrid

Is this course right for your team?

Who it is for

Developers with a backlog of well-defined work that does not need them present while it is done.
Leads deciding which categories of work are safe to hand over and which are not.
Platform engineers who will end up owning the environment definitions everything else depends on.

What participants need beforehand

  • Branches, diffs and pull requests as a daily habit rather than an occasional one.
  • A codebase in a mainstream language, with a test suite that runs.
  • A laptop with a working checkout and permission to open pull requests against it.

How the training is delivered

Same material either way. The format changes how much of it lands in the first week.

On site

I come to your office and work with the team in the room. Usually the most effective option for a first rollout, because the sideways questions get answered as they come up.

Remote

Delivered live over video in focused blocks rather than one long day, with shared screens and hands-on exercises on your own work.

Hybrid

A day on site to get everyone moving, followed by shorter remote sessions once the team is applying it to real work and hitting real friction.

Optional add-ons Certificate of participation

There is no public schedule. Every course is booked privately for a single team, and we agree the dates together.

Luka Breitig, software engineer and AI coding trainer
Your trainer

Luka Breitig

Software engineer and AI coding trainer

I train engineering teams to work with AI coding tools, and I use the same tools to ship production software every week. The material comes out of building things, not out of a slide deck.

Before going freelance I spent six years as technical co-founder of a marketing agency, responsible for everything technical from automation infrastructure to coordinating a freelancer network. That is why the courses spend as much time on review, guardrails and rollout as they do on prompting.

  • Ships production software every week
  • Delivers in English and German
  • On site across Europe, or remote
  • Speaker at Nomad Summit, Chiang Mai

Trusted by teams & training providers

I deliver AI training for some of Europe's leading organisations and L&D platforms.

Cegos Integrata

Cegos Integrata

Commissioned trainer via leading European L&D provider

NobleProg

NobleProg

AI coding workshops via one of the world's largest IT training marketplaces

Innomotics

Innomotics

In-house AI training for engineering teams

Bots & People

Bots & People

Commissioned trainer for developer workshops

Code First Girls

Code First Girls

Course creator — 3-month AI & agentic tools curriculum

Nomad Summit

Nomad Summit

Conference speaker on AI tools, agentic development, and developer workflows (2025)

Vertiv

Vertiv

In-house AI-assisted coding training for engineering teams

Questions about this course

The things teams ask before booking. If yours is not here, ask me directly.

No. The delegation model is easier to pick up than pairing with an agent, because there is far less to steer in real time. Working knowledge of pull request review matters much more, since that is the skill the entire day rests on.

A Codex-enabled account each, plus a repository they are allowed to open pull requests against. Both are worth arranging a week ahead. I send the exact requirements once a date is agreed, including which plan covers the parallel task work.

Yes, and the environment setup module only pays off if they do. Half of what makes delegation work is a container that can install your dependencies and run your tests, and getting that right for your stack is time very well spent in a workshop.

Yes, because the working model is different: one is a conversation you steer, the other is a brief you hand over and come back to. Teams using both tend to split their work between them. If you only want one course, the Claude Code one is broader; this one goes deeper on delegation.

Five to twenty. Delegated tasks take real minutes to run, so the day is paced around those gaps, and a smaller group is what makes the discussion in each gap worth having.

Yes, in German or English. The tool's output, its configuration files and its documentation are all English, so the materials follow that by default, and a German version is available if you would rather have one.

Still not sure whether this is the right fit for your team?

Book this training for your team

Tell me the size of the group, the codebase they work in, and roughly when you want to run it. I will come back with a proposal.

Download trainer profile

Delivered in English or German, on site across Europe or remotely.