The Build
The building blocks for training junior entrants in a post-AI world
Last week, I laid out the rules - the principles any junior development program has to obey before you build a program that works. Make the invisible visible. Human and machine. AI as questioner, not answerer. Leadership measured in hours, not just dollars. All bounded by two honest constraints: co-location and motivation.
This week: the program you build on top of these rules.
First, a quick recap. The old junior development model wasn’t one thing - it was a developmental chain: three uneven inputs (domain knowledge, procedural experience, and network capital) that fused into discernment, matured into judgement, and culminated in a trusted, accountable practitioner. AI is severing those threads, and doing so unevenly - cutting deepest at the procedural work that had no substitutes and was, in many ways, carrying the other two. (See image below.)
An effective junior training program doesn’t need to start afresh, but it does need to rebuild each of those threads deliberately, putting special emphasis on the ones AI cuts most directly.
The building blocks of the program outlined below aren’t, therefore, a menu to pick from. Rather, each one is a repair aimed at a specific severed thread. To keep that visible - and to stop this becoming a generic list of L&D activities - I’ve divided the program into three clusters, with nine specific building blocks in total, each one tagged with what it actually rebuilds. (The four rules from last week are the test every one of them has to pass; assume they’re switched on underneath each block.)
One more note before we start. This post is the what. The order in which you assemble these - which is just as important as the parts themselves - is the next post.
For now, though, let’s get into the parts, grouped by cluster.
Cluster 1: Rebuilding the Procedural
This is the load-bearing repair - the procedural thread that AI cuts most directly and that has no real substitute.
1. Manual Work Runs
This is the deliberate reinstatement of doing the core work by hand, before AI is allowed anywhere near it.
Pick the defined core areas of the function - building an intelligent overview of the supplier landscape, running an RFP end to end, building a spend cube from raw data, drafting a contract summary, constructing a should-cost model - and have the junior do them manually. Synthesizing multiple reports, building spreadsheets, making phone calls to vendors, all of the actual grind. Then cycle them through these major areas over the course of their first year, so they build a manually-worked foundation across the breadth of the function.
This might, to some, feel like nostalgia, but it isn’t. It’s the direct answer to where the chain is maximally impacted by AI: procedural experience is the one input that can only be acquired by doing, so you have to reinstate it on purpose rather than let AI remove it. The manual run is, then, the floor everything else is built on.
Rebuilds: procedural experience (primary) - and, as a natural byproduct, domain knowledge and the first calibration of discernment alongside it.
2. Simulation
This is the safe, modeled practice of high-stakes work. The mechanism is deliberate practice - repetition with rigorous, specific feedback - in an environment where being wrong carries no real-world cost.
In Procurement, that looks like simulated sourcing events, mock negotiations against a deliberately difficult counterparty, or a library of past deals where the junior has to make the call before seeing what actually happened, and then debriefs against the actual outcome.
Two design notes matter here. First, the debrief is where the learning actually happens - the simulation is only the trigger. Second, you don’t need a purchased platform (although there are various low to high tech solutions available in the marketplace for specific areas): a well-built case and a good facilitator can capture most of the value, and AI, even the LLMs themselves, have now collapsed the cost of the rest. AI can role-play a stubborn sole-source supplier, or generate a flawed analysis for a junior to pull apart. But, as stated in last week’s rules, it should only ever do so as the counterparty or the questioner; the moment the AI hands over the “right” answer, we’ve rebuilt the discernment trap inside our own simulator. This is where “struggle first, AI second” does the most difficult work.
Rebuilds: procedural experience and judgement (primary) - as well as domain knowledge and discernment (via the debrief).
Cluster 2: Rebuilding Knowledge and Network
These repair the two inputs that do have substitutes so they lean on a series of familiar tools, but in an organized and more committed fashion.
3. Independent Learning
These are the tools we’ve already utilized to date: traditional coursework, classical training programs and certifications, as well as personal reading.
This is also the block organizations reach for first precisely because it’s the most familiar and the easiest to buy. It is also the least urgent block in the entire program (at least in terms of repairing) because domain knowledge is the input with the most substitutes. There are plenty of solid solutions in the market and AI actually adds a unique additional synthesis layer to it. As such, it still matters, and you should continue to provide it, but be careful how heavily you lean on it and, thereby, avoid the harder repairs that need to be made.
Rebuilds: domain knowledge (primary).
4. Rotation Program
Cycling the junior through different categories and targeted ‘client’ functions to build breadth.
Done well, this is designed backwards from a needs analysis - the areas of current and future demand, where the real skills gaps are, the highest-turnover roles, etc. - rather than from a generic “expose them to everything” instinct. The structure is well-established: assignments of a defined time period (weeks to months), cycling through the development timeline, each one deepening domain knowledge in context and - just as valuably - putting the junior in new rooms with new people.
Rebuilds: domain knowledge (primary); and network capital and procedural range alongside it.
5 & 6. Senior Relationships: Mentoring and Sponsorship
These two get conflated constantly, and the conflation is costly, because they do genuinely different jobs and repair different threads.
Mentoring develops the person. It is Rule 1 - making the invisible visible - turned into a relationship: a more experienced practitioner narrating their reasoning, coaching, correcting, modeling the judgement that otherwise stays locked in their head. The evidence for its impact is strong; the practical key is to formalize it - a mentorship charter with defined expectations and genuine senior accountability - rather than leaving it to whoever happens to be friendly and willing.
Sponsorship is a different thing entirely. A sponsor spends their own positional capital - their reputation, their relationships - to put the junior into the rooms and onto the work that builds a name. While a mentor develops the person, a sponsor moves the career. And this matters enormously here, because sponsorship is one of the very few real substitutes for the network capital the work used to generate for free. A sponsor trusts your performance, and stakes their own standing on it.
You need both, and for different reasons: mentoring rebuilds the discerning eye, sponsorship rebuilds access.
Mentoring rebuilds: discernment and tacit knowledge transfer (primary); domain knowledge alongside it. Sponsorship rebuilds: network capital (primary); and professional identity.
7. Structured Stakeholder Development
This is the junior’s own deliberate plan to build their network - a defined approach to meeting leaders across the function first, then counterparts across the business and, eventually, customers and suppliers, and learning from each group as they go along.
The logic is straight from the developmental chain. Network capital used to form by osmosis, simply because the work put juniors in the rooms where decisions were made. Remove the work - or scatter the team across home offices permanently - and the osmosis stops. So the network has to be built as an explicit, structured plan rather than left to chance. This is also where last week’s co-location constraint comes to the fore: some of this is far harder, and in some cases impossible, to replicate fully over video.
Rebuilds: network capital (primary).
Cluster 3: Building Judgement and the Discerning Eye
This cluster is the upper reaches of the developmental chain - the repairs aimed not at the inputs, but at what the inputs are supposed to produce.
8. Structured Project Ownership
This means giving juniors real accountability, early; not simply supporting a senior’s project from the wings - but owning one. Building it, testing it, leading it, and being answerable for how it turns out.
The sharpest version of this would be what some have called “structured entrepreneurial ownership” - internal programs where juniors can identify events or innovation opportunities, pitch and prototype them, run sprints, etc., handing them genuine ownership of a real business challenge. The underlying principle is the one that should govern this whole cluster: meaningful accountability builds judgement faster than passive exposure ever can (and yes, this entails taking some risk).
It’s also where you deliberately manufacture the thing the chain depends on and AI most cleanly removes - the felt cost of being wrong. Judgement doesn’t form without consequence, and consequence doesn’t exist when you’re only ever assisting.
Rebuilds: judgement and ownership/accountability (primary); procedural experience and network capital alongside.
9. Feedback and Evaluation
This is the block that tells you whether any of the other eight are actually working - and the one most programs get wrong, because they measure the convenient thing instead of the right one.
If discernment is the goal, you have to test discernment - not tool fluency, and not output speed. This means three things:
First, measure the process, not the outcome. A sound decision can produce a poor result through sheer bad luck, and a reckless one can get lucky - so judging people on outcomes alone teaches them nothing reliable. You have to assess the quality of the reasoning. The discipline here is to track whether someone is getting sharper, not just faster - time to competence and error reduction, not volume of output.
Second, use AI to provide graded critiques. Hand the junior a flawed AI-generated analysis and assess how well they find what’s wrong, and why. The point is to test their ability to discern and then whether they can judge - which is the exact faculty the whole program exists to build.
Third, utilize a decision journal - something regular readers will recognize from the practitioner playbook earlier in this series. The junior records the call and the reasoning at the time it’s made, and reviews it later against what actually happened. What was a personal habit for the individual practitioner becomes, in a program, the assessment instrument for judgement itself.
(It’s worth noting also that judgement-based assessments based on a single assessor or a single data point are inherently unreliable. Such assessments need multiple assessors and multiple instances, otherwise it’s just one senior’s gut feel wearing a rubric. Maintain that intent right from the start.)
Rebuilds: discernment (primary); judgement and the habit of reflection and articulation alongside.
These Are a System, Not a Menu
So those are the nine repairs and the basis for any strong junior development program.
Each block exists to rebuild a specific severed or impacted thread, reinforcing a particular aspect(s) of the developmental chain. As a result, the blocks work in concert with each other; if you choose only three because they’re cheap and the easiest to stand up, you’ll repair three threads and leave the rest cut. This is precisely how organizations end up with programs that look busy and develop no one.
But knowing the parts is not the same as knowing how to assemble them. Drop a junior into owned, accountable projects in month one and they’ll drown; never get them there at all and they stay a perpetual apprentice, lacking the confidence to take the next step up.
The parts have an order - and that order is governed by a principle we’ve already discussed: graduated stakes. What that actually looks like - the first twelve to eighteen months, phase by phase, with the stakes rising on a deliberate schedule - is the next post.
Last week’s post gave us the rules that tell us what good looks like. This one gave us what to build. The next post will give us the order to build it in.