Matt Presland

Vector 03 · 7 min read · · Engineering leadership

Your juniors aren't learning

The code reviews that made me a developer, and what happens to the next generation when AI does all the reps.

At the halfway point of the runway, we were doing half the speed we should have been.

I was training a new pilot in Tasmania. We did most of our training on freight runs, so trainees could learn without the pressure of passengers in the back. Freight flights come with their own pressure, though: weight. Our aircraft could only carry so much, so careful load planning was everything.

We had a solid procedure for it. Each of our regular contract customers sent through a manifest every morning with the total weight of their freight, and we worked closely with one contractor in particular to keep an eye on the accuracy of their manifests. As Chief Pilot, I'd get in about half an hour before everyone else to check that the day's plan made sense and eyeball the manifests, in case a heavy day needed a second flight.

That morning the numbers looked easy. The load fitted comfortably on our scheduled flight.

My trainee arrived, entered the figures into the load sheet and prepped the aircraft. This was one of his last training flights, and he was good. I glanced at his load sheet and quizzed him on it, which was my habit with every trainee. He described the load perfectly. When the freight arrived he loaded it, and I checked the back of the aircraft. Everything looked right, and there was even some spare space in the cargo area, which almost never happened. It all agreed with the plan.

We lined up and he pushed the throttle forward.

Our aircraft was built for short strips, and on that runway we'd normally be airborne within a third to half of its length. At the halfway point we were at half the speed we needed. At three quarters, we were at about 60 per cent. There wasn't enough runway left to stop.

I took over and gave it everything the engines had. We got airborne a metre or two from the end of the runway and cleared the boundary fence on what I can only describe as a hope and a dream. I nursed the aircraft around the circuit and landed straight away. The instruments said the engines were fine.

On the ground I started asking questions, and the answer turned up in the cargo pods under the aircraft. That contractor had sent a pallet of A4 paper, in 13 kg boxes, with a note that it wasn't urgent and could go "as space allows". It wasn't on the manifest. I pulled more than 400 kg of paper out of those pods.

Everyone had done everything right by the book. The manifest was checked, the trainee had been quizzed, and I'd looked in the back. We'd trusted the accuracy of the paperwork and followed the procedure without asking the one question that mattered: does this actually make sense?

Procedural autopilot nearly killed us.

Clean code that passes the review

I think about that take-off a lot when I look at how developers are learning now.

When I joined my first proper development job in 2018, I'd shipped products and projects, but only on my own. Nobody had ever reviewed my code. People had only ever looked at the thing on the screen. The lead developer there, Dan Wall, changed that.

The first thing Dan did was reassure me. He said my approach was clean and clear, which meant a lot to someone with no commercial experience and plenty of doubt. But the real gift was what came next. Dan could look at a piece of code and see the headache it would cause later on: a performance problem, something that wouldn't survive at scale, or one of those odd quirks you only meet when code runs in production. And he showed me, simply and clearly, how to plan for those things.

That became one of my superpowers. I've since broken production enough times that I can smell an edge case over the smell of coffee in the office. One of the developers on my team jokes that my brain thinks in code, because I'll spot the edge case in his pull request before he's even sent me the link.

None of that came from being clever. It came from reps: hundreds of reviews, a lot of mistakes, and someone patient enough to explain why.

What AI skips

Here's what worries me. AI is very good at writing clean code that passes the review. What it's not good at, at least not yet, is asking whether the code makes sense in the real world it's about to run in.

When I review a pull request now, I'm thinking about scale, the edge cases we already know about and the data problems we've had before. I'm especially sniffing for poor handling of empty values. Real datasets evolve over years, and they leave plenty of gaps behind. AI tends to look at the code as it is today. It doesn't know the history of the data underneath it.

The developers who lean hardest on AI tend to pick up the same blind spots:

  • Assuming the data will be there, because it's there in the pull request they're looking at
  • Ignoring the current state of the system: what's already in production and how it got there
  • Forgetting the data that's mid-flight, the records that were half-way through a process when the change lands
  • Missing breaking changes, or not measuring and planning for them
  • Not noticing shape and smell: code that works but doesn't fit, or that hints at trouble later

Some people ask whether code shape and code smell even matter any more if AI is writing and maintaining it. I think they matter more than ever, because they're the early warning that something won't make sense later.

My trainee wasn't careless, and neither are these developers. They're doing exactly what the procedure asks. The gap is that nobody has taught them, through reps, to stop and ask whether it all adds up. That's the bit AI is quietly doing for them, or more accurately, not doing for them.

What we're doing about it

I'll be honest: we haven't solved this. It's still evolving for us, like it is for everyone. But one habit has made the biggest difference.

Every time something slips through, the review process changes. Every mistake that reaches production becomes a new check: something a human reviewer looks for, and something our AI reviewer is told to look for too. Aviation works this way. Every incident makes the procedure smarter. Learn from the mistake, then make sure it can't happen the same way again.

For anyone leading juniors, here are the questions I'd teach them to ask of every pull request, especially the ones AI wrote:

  1. What happens at scale? It works on a hundred rows, but does it work on ten million?
  2. What does the history of the data look like? Where could there be gaps, old formats or values nobody expects?
  3. What's in flight? What happens to records halfway through a process when this lands?
  4. What breaks? Who else depends on this, and how will we know if we've broken them?
  5. Does it fit? Is it the right shape for the system, or is something about it off?

And one more, borrowed from a runway in Tasmania: does this actually make sense? If the cargo area has spare room on a heavy day, ask why.

Be someone's Dan

Dan probably doesn't remember most of the reviews he did on my code. I remember plenty of them, because they shaped how I've worked ever since.

AI is going to make our juniors faster than any generation before them. That's a good thing. But speed isn't the same as judgement, and judgement only comes from doing the reps with someone who'll explain the why.

If you're a senior developer or a leader, the most valuable thing you can do this year might not be shipping more. It might be sitting with a junior, going through a pull request line by line, and asking them: does this make sense?