Why the standard curriculum bounces off
An agentic coding workshop for senior developers fails in the first thirty minutes if it opens with a demo of scaffolding a todo app. The room has fifteen years of experience in it. They have all seen a generator produce plausible code. What they have not seen, or have seen and been burned by, is what happens when an agent operates inside a large system with real coupling.
Start there. Show a change that goes wrong in a way that looks right. A senior engineer who watches an agent confidently edit a file it never fully read, and then watches the test suite stay green because the coverage gap was already there, is now paying attention for the rest of the day.
What seniors are actually stuck on
From the sessions we run, the recurring blockers are not about tool mechanics:
- Review load. Their own throughput went up and now they are the bottleneck for everyone else's agent output. Nobody warned them.
- Where to draw the line. Migrations, auth code, anything touching money. Most teams have no written policy and every senior has a different private one.
- Losing the codebase. If you stop writing the code, you stop holding the model of it in your head. That cost is real and it arrives quietly, usually during an incident.
- Mentoring juniors who now produce more code than they understand. This is the one that comes up in every single engagement.
The exercises worth doing
Run the workshop in the team's own repository. Take a real ticket that has been sitting in the backlog because it touches three services. Have pairs specify it properly, run an agent on it, and then swap and review each other's diffs without knowing what was specified. The gap between what was asked for and what a reviewer can reconstruct from the diff is the lesson.
A second drill: give the agent a task and deliberately withhold the test command. Then give it. Same task, same agent. Watching the difference between run the tests yourself before you report done and no such instruction converts sceptics faster than any slide.
Being honest about what agents do badly
We say this in every session because seniors will otherwise assume we are hiding it. Agents are weak at changes requiring system-wide invariants that are not written down anywhere. They are weak at knowing when to stop. They will patch a symptom for as long as you let them. And they are worst exactly where your codebase is most idiosyncratic, which is usually the part that matters most to your business.
None of that means do not use them. It means the senior engineer's job shifts toward writing down the invariants and holding the line on review, which is a genuinely different job description than the one they signed up for.
Do this next
Before booking anything, ask your seniors one question in writing: what have you refused to delegate to an agent, and why. Collect the answers. The disagreements in that list are your workshop agenda, and they are more useful than any vendor's syllabus.