How one company used AI to revive a training model the software industry abandoned
The apprenticeship model survived for centuries. Masters invested years in novices, transferring technique and judgment in exchange for cheap labour and eventual succession. The economics were simple: teaching costs time, but trained apprentices create value that exceeds the investment.
Then came software engineering, and the economics broke.
A senior developer in a major market commands $200,000 or more, fully loaded. Dedicating ten hours weekly to teaching a junior—520 hours annually at a fully-loaded rate of $96 per hour—implies a mentorship cost exceeding $50,000 per year. Per apprentice. Most companies looked at this arithmetic and made a rational decision: stop hiring juniors. Job postings demanding three years of experience for entry-level roles became standard. The pipeline feeding senior talent began to crack. Companies complained about the shortage of experienced engineers while refusing to create any.
One company decided to test whether AI could change the calculation.
The Setup
The experiment was modest in scope: one junior engineer, one senior mentor, and a deliberate integration of AI tools from day one. The junior had some programming background in PHP and MySQL, the kind of experience that demonstrates capability without conferring fluency in modern stacks. The plan was conservative: start with frontend development in TypeScript, build competence gradually, and expand scope when the foundation was solid.
The structure was a single daily check-in before lunch. Not pair programming, not constant oversight, but a consistent touchpoint where the senior could provide direction, review progress, and shape the junior's thinking. The rest of the day, the junior worked with AI as a constant companion: asking questions, debugging errors, learning patterns.
The company expected a standard onboarding trajectory and got something much better.
The Four-Week Pivot
By week four, the junior's progress had outpaced expectations. An opportunity arose requiring backend work in Go—a compiled, statically-typed language with a concurrency model entirely unlike anything in the junior's PHP background. Conventional wisdom counselled patience. The junior was still learning TypeScript. Adding a second language, a second domain, a second set of concepts would surely overwhelm them.
They tried it anyway.
The expected constraint did not materialise. The junior began working in Go and TypeScript simultaneously, switching between frontend and backend as projects required. The tight feedback loop with AI absorbed the cognitive load that would traditionally fall on the senior or accumulate as frustration. Syntax questions were answered in seconds. Error messages were explained instantly. The pattern-translation work—"I know how to do this in PHP, how do I do it in Go?"—happened continuously, without scheduling a meeting or waiting for the senior's availability.
The daily check-in shifted in character. With AI handling the immediate technical questions, the senior spent their time on higher-order concerns: how to structure a solution, when to push back on requirements, what trade-offs matter in production systems, how to navigate a professional codebase. They were teaching software development, not Go syntax. The languages became incidental.
The Mechanism
What emerged was a division of labour that neither traditional apprenticeship nor self-directed learning could achieve.
AI handled the information bottleneck. Documentation exists for every language and framework, but finding and applying the right information takes time. That time compounds when a junior is context-switching between languages or encountering unfamiliar error messages. AI collapses this latency to near zero. The junior could ask "why is this Go code throwing a nil pointer error" and receive an explanation calibrated to their current understanding, immediately, without consuming any senior engineering time.
The senior handled judgment formation. Architecture decisions, code review that teaches rather than merely approves, institutional context, professional development. These cannot be automated because they depend on experience, taste, and knowledge of the specific system. A senior reviewing a pull request isn't just checking correctness. They're modelling how to think about code in production, how to anticipate failure modes, how to balance speed against maintainability. This is the mentorship that matters, and AI freed the senior to focus on it exclusively.
The daily touchpoint provided rhythm without overhead. One meeting, every day, before lunch. Enough structure to ensure the junior never drifted far off course. Light enough that the senior's own work remained uninterrupted. The consistency mattered more than the duration.
The Progression
Over the following months, the junior's reliance on AI evolved. Early on, it was constant—every unfamiliar function, every cryptic compiler message, every "how do I" question. As competence grew, AI became less a teacher and more a reference, consulted for specific problems rather than general guidance. The senior's role evolved in parallel, from daily instructor to periodic adviser.
Twelve months after starting, the junior was productive in both Go and TypeScript—a progression that traditional onboarding would spread across two or three years. The timeline compressed by roughly 50%, at perhaps 5% of the traditional mentorship cost.
Then they added DevOps.
Fifteen months in, the junior is now working across three domains: frontend, backend, and infrastructure. The pattern repeats: AI provides domain knowledge on demand, the senior provides strategic direction, the junior learns whatever the work requires. The approach that enabled TypeScript learning enabled Go learning enabled DevOps learning. It is not language-specific or domain-specific. It is a method for accelerated professional development.
The Outcome
The company is now piloting a formal apprenticeship programme.
What began as an experiment with a single junior engineer has become a template. The economics that made apprenticeship unviable—$50,000+ in senior time per junior per year—have shifted. AI absorbs the repetitive explanation work that consumed senior bandwidth. The senior's investment becomes higher-leverage: shaping judgment rather than answering syntax questions. Daily check-ins replace all-day pairing. The AI tools cost approximately $2,000 per developer annually—a rounding error against the $50,000 saved in senior time. The model scales.
This does not mean any company can simply hire juniors and hand them an AI subscription. The structure matters. The senior must be willing to mentor and capable of teaching judgment rather than just reviewing code. The daily touchpoint must actually happen, consistently, without being crowded out by "more urgent" work. The junior must be oriented towards learning, not just task completion. AI is the enabler, not the solution.
But for companies willing to build the structure, the implications are significant.
The Implications
For companies struggling to hire: The talent pool for experienced engineers is constrained and expensive. The talent pool for promising juniors is vast and underutilised. AI-assisted apprenticeship offers a path to building engineering capacity rather than simply competing for it.
For senior engineers asked to mentor: The burden shifts from answering questions to shaping thinking. This is harder in some ways—it requires genuine teaching skill, not just technical knowledge—but it is also more sustainable. The senior is not interrupted constantly. Their own work continues. The mentorship becomes a focused investment rather than a continuous tax.
For juniors trying to break in: The "three years of experience required for entry-level" barrier exists because companies cannot afford the traditional onboarding cost. If AI changes that calculation, the barrier may fall. Juniors who can demonstrate the ability to learn with AI assistance become viable hires even without extensive prior experience.
For the industry's talent pipeline: Software engineering has been consuming senior engineers without producing them. Companies hire experienced developers from each other while collectively underinvesting in training. This is a tragedy of the commons that AI might help resolve—not by replacing junior developers, but by making it economical to train them.
The Caveat
Fifteen months is not a generation. One company is not an industry. One junior is not statistical significance. The junior in this case may have been unusually capable; the senior unusually skilled at teaching; the company unusually willing to experiment. The apprenticeship programme now being piloted may succeed or it may surface failure modes not visible in the initial experiment.
What can be said is this: a model the software industry abandoned as uneconomical has been revived in at least one company, with results that prompted institutionalisation. The combination of AI for immediate feedback and senior mentorship for judgment formation produced a junior engineer capable of working across three technical domains in fifteen months—a trajectory that traditional approaches would not have attempted.
The economics of apprenticeship may have changed. Companies that recognise this early will access a talent pool their competitors are ignoring. Those that wait for proof will find themselves competing for the same limited pool of experienced engineers, at ever-increasing prices, while wondering why the pipeline remains empty.
The apprentice is returning. The question is which masters will welcome them.
Lloyd Moore advises technology companies on engineering economics and organisational design.