Fourteen engineers, their own repositories, one day.I talk for two hours. They build for six.
A guided build day for an in-house engineering team that wants to work with coding agents on its own code and has nobody to ask. The morning is orientation: your stack, three ways of delivering software with an agent, and the toolbelt that wraps each one. From eleven o'clock everyone builds and I go round the room. Four remote sessions afterwards carry the syllabus, a briefing on what has changed since the last one, and a retrospective on what the team shipped.
Run once so far, for fourteen engineers. The curriculum, the review panel and the handoff tooling are open source, so nobody has to take my word for any of it.
Your engineers are right to be suspicious.
The leadership is usually already convinced. The engineers are not, and they have good reasons: the technology mostly arrives as marketing, the demos are on toy repositories, and nobody has shown them what it does to their code, with their tests, through their review process.
A training course does not fix that. Eight hours of somebody talking produces a room that can describe agentic delivery and still has not done it. What changes an engineer's mind is merging something of their own before lunch, then doing it again in the afternoon with a backlog and a definition of done, and finding out for themselves where the agent quietly produces something that looks right and is not.
So this is not a course. It is a supervised first shipment. I deliver the orientation, everyone runs the same one-shot exercise on their own repository, and then I sit with each person as their day diverges from everyone else's. The room, not the slides, is where the work happens.
The day starts two weeks before the day.
Three things happen before I arrive, and they are in the price. The first time out, one of them happened on the morning instead, and it cost the room the best part of an hour while people decided what to build. That does not happen again.
-
Two weeks out
The stack picture
Before the day I build a picture of what your organisation runs, from what it shows the internet: DNS and mail records, certificate history, what your public hosts announce about themselves, and what your job adverts and public repositories say about the stack. Read-only, from public records, with your written permission first. Nothing is probed and nothing is logged into.
It exists so that the "your stack" segment on the day is you correcting my picture rather than me presenting yours, and so the project shortlist fits what you actually run. It is also, reliably, a list of things the CTO did not know were visible. It is not a penetration test and does not pretend to be one; anything it turns up that needs a proper look goes to the code and security review, or to a CREST firm if that is what it needs.
-
One week out
The project shortlist, chosen
From the stack picture and a call with whoever runs engineering, I write a shortlist of real work in your estate, sized for an agent: an untested module, a dependency upgrade nobody wants to do, feature flags that should have been deleted, a runbook that does not exist. Sized S for the one-shot block and S or M for the agile block.
Every engineer picks one for each block, or brings their own of the same size, the week before. I see the picks before I travel. The board is written before anyone arrives, and the fifteen minutes on the day are for confirming it, not for deciding.
-
The week before
Thirty minutes of setup, each
Claude Code signed in, the GitHub CLI signed in, the toolbelt installed, the review panel's keys in place, the nominated repositories cloned with the tests run once and the build, test and lint commands written down. Those commands are the first thing that goes in the agent's instructions on the day.
A checklist does the walking. The first fifteen minutes of the one-shot block are budgeted for whatever the checklist missed, and the tutor run sheet says what usually goes wrong.
Two hours of orientation. Then three delivery lifecycles, for real.
Times assume a nine o'clock start. If the venue starts later, everything shifts by the same amount; the proportions are the plan. A break every hour and forty minutes, an hour for lunch.
| Time | Segment | Min |
|---|---|---|
| 09:00 | What we wantWhat the room wants out of the day, on a whiteboard, where it stays. | 10 |
| 09:10 | Your stackMy picture of what you run, corrected by the people who run it. | 15 |
| 09:25 | Where my work overlaps yoursWhat I have shipped that looks like your estate, and the gaps, said out loud before anyone asks. | 15 |
| 09:40 | Three ways of deliveryOne-shot, agile and waterfall with an agent, and what each is not good for. The "not good for" column is the content. | 25 |
| 10:05 | The toolbeltThe skills that wrap each lifecycle. Everyone runs three commands, which surfaces key problems before the break. | 20 |
| 10:25 | Projects, confirmedThe picks were made last week. This is right size, right block, nobody on the same module. | 15 |
| 10:40 | Break | 20 |
| 11:00 | One-shotOne prompt, one pull request, the review panel, merge before lunch. Everyone runs the same exercise on their own repository; this is where the day stops being a lecture. | 100 |
| 12:40 | Lunch | 60 |
| 13:40 | AgileA backlog, a definition of done, two or three slices built and merged, and a handoff to the neighbour mid-slice to find out whether the context survives a change of hands. | 100 |
| 15:20 | Break | 20 |
| 15:40 | Planning for waterfallOne project for the whole room. Business case, specification, stage gates and a baseline, planned fully today. | 50 |
| 16:30 | Waterfall: the fenced build beginsThe build runs through the remote sessions. Today it starts. | 30 |
| 17:00 | Close |
One rule for the whole engagement: you own what you merge. The agent writes; the engineer whose name is on the pull request has read it, has run it, and would defend it in review.
That rule is why the review panel is in the toolbelt from the first hour. Four models from four vendors argue about the diff and only what survives the argument reaches the engineer. One model agreeing with itself is not evidence, and neither is one engineer who has stopped reading.
Four remote sessions, two hours each, over three months.
The day changes what people believe. The remote sessions change what they do on a Tuesday when I am not in the room. They are taught sessions, not remote build days: fourteen people typing on a video call is not a session anyone can shape, and the building happens between the sessions, on real work, where it should. Each one has the same three parts.
- The retrospective. Each engineer, a few minutes, screen shared: what merged since last time, what the panel caught, what the definition of done caught, and what neither caught that a human did. One line each goes into the team's own emerging-practice document, so the learning is shared rather than repeated fourteen times.
- The syllabus. One module a session, taught: tests as the safety net, security through the panel, the stage gate and what fast does not cover, and the definition of done rewritten from three months of the room's own work.
- The briefing. What has changed in agentic coding since the last session. The ground moves every few weeks, and half of what was true on the day will have moved by the fourth session. I say which half, and what to do about it.
One engagement, one price.
Fixed fee, staged payments, deliverables agreed in writing before the start. The prep and the four remote sessions are in the price, not lines on top of it. There is no remote-only version: going round the room is the mechanism, and it does not survive a video call.
Guided build day
£10,800
Up to fifteen engineers, on their own repositories. Before the day: the stack picture, the shortlist, the setup checklist and a call with whoever runs engineering. On the day: two hours of orientation and six of building. Afterwards: four two-hour remote sessions, each a retrospective, a syllabus module and a briefing on what has changed, dates agreed by email. Every engineer ends the day with a change of their own merged or in review. Travel quoted separately, and outside the UK it is quoted before anything is agreed.
Fixed fee · staged payments · deliverables agreed in writing before the start · VAT not included
An IT department, not a software company.
The team this is built for has ten to thirty engineers inside a business that sells something other than software: distribution, healthcare, insurance, logistics, a back office. They have real systems, real revenue depending on them, a leadership that wants the AI question answered, and no one inside the building whose job it is to answer it.
A software company whose engineers already have their own opinions about which agent to use probably wants the talk instead, and I will say so on the first call. The day is for the room that has not started, and needs to start on its own code rather than on a demo.
Everything taught on the day is published.
The toolchain is the one I use on my own work, and it is open source, so your engineers can read it before they decide whether to believe me.
- panel-review, the four-model review panel, and how it works.
- session-handoff, the skill that makes the mid-slice handoff on the day survivable.
- The eight-session curriculum the day is cut from, for the founders and product owners who specify software rather than write it.
- Flying Start, the production system all of this was learned on: 155,298 lines in nine languages, built solo in 86 commit days.