Teaching Juniors in the Age of LLMs

Coding agents are inevitable. It would be highly unusual, and maybe even a red flag, if a technical role did not have AI available at this stage.

What does this mean for juniors? How do we bring up juniors in the age of AI?

These are questions I’ve had to tackle in the last 2 weeks, and here are my broad thoughts.

Focus on prototyping first

The important thing is to let them get familiar with coding agents and prototype changes. They should be comfortable screwing around with a project in a development environment, breaking it, testing it, and debugging UX changes.

AI vibe ‘slop’ is everywhere. Teaching juniors how to ‘make it real’ is one of the best ways to get them involved and familiar with the codebase.

After prototyping, it’s about the ’next most obvious thing’

Going from a 4k+ LoC change to production is a journey. No company or software development process should let arbitrary vibe-coded output go straight into production. You can have strong gates that prevent issues and let changes be made safely, but this step should be about teaching hygiene.

How might we make changes so they’re appropriate? Maybe it’s setting up feature flags for the feature you’re building. That’s a small unit of change which lets you turn ‘slop’ on and off safely. Maybe it’s preparing a design document with a list of phases and checks for how the change gets introduced and safely turned off (AI assistance with these is fine).

In my opinion, if you belong to a company with a focus on vibe coding and LLMs in production, the focus should be on how we introduce and manage changes, and how we design software that can be safely switched on and off (theories on managing legacy software, and so on).

The details of programming matter less than the mechanics of good design. Not necessarily theoretical design, but practical design. Choices that make decisions reversible, knowing how to communicate the change you want and convince others it’s appropriate (whether the feature is a good feature, or a well designed feature that can be processed), or some other setup.

Through these experiences, hopefully people pick up on what good design and good decision making look like.

LLMs and decision making

On a meta level, the software development lifecycle isn’t about the code. It’s about the decisions you make in the process of creating the code. Decisions which reflect human relationships or domain elements to drive a business outcome. LLMs can compress the time needed to make decisions, but there’s still a level of gumption needed to work out what is appropriate, and which decisions are the critical ones that we can fall back on. That’s the human part worth installing: when a decision is critical and when it doesn’t matter, and when to raise and discuss it with the wider team.

Snowballing changes

As juniors work on the ’next most obvious thing’, hopefully their judgement improves and that next most obvious thing gets better communicated and discussed with others. In an environment like this, the knowledge becomes a kind of tacit knowledge, where the growth and the nuances reflect a person’s decision making process.

Vibe coding and agentic engineering

Ultimately the key focus of agentic engineering is human decision making, not the code itself. So focusing on and teaching people how to make decisions and design is perhaps the best thing we can strive for.