Senior Engineers Are the Next DRAM Shortage

There’s a shortage coming that nobody’s put on a slide yet: senior engineers. Every company on earth is about to want one who can drive a fleet of agents with judgment — and almost nobody is making new ones anymore, because AI ate the entry-level work juniors used to learn on. You cannot conjure a senior in a quarter. We just watched this exact movie with memory: DRAM prices went vertical because demand exploded and you can’t build a fab overnight. Senior engineers are next, and the only hedge is to build your own, starting now. The best thing you can build in the agentic era isn’t your product — it’s another Engineer. I have juniors on my team. This is my problem, right now. Here’s how I’m thinking about it. Stop hiring and mentoring junior engineers and you’ve quietly unplugged the machine that makes senior ones. A few years out, you run dry — right when everyone else is dry too, and the price of the few left goes through the roof. I’ve written about the org chart flattening from the middle, and about how the bosses are coding again. This post is the piece those two were circling around: what happens to the bottom of the chart, and whose job it is to fix it. Spoiler — it’s yours, senior engineer. It’s mine. And most of us are about to get it wrong in a very specific, very tempting way. Yes, the Naysayers Are Right (Sort Of) The doom take goes like this: AI eats entry-level engineering work, entry-level jobs dry up, the ladder loses its bottom rung, and a few years from now there’s a hole in the workforce shaped exactly like the seniors we forgot to grow. And… they’re right. That failure mode is completely real. If you take the work juniors learned on and route 100% of it to agents, and you do nothing else, that is precisely what happens. And this isn’t just me predicting it. Martin Fowler and Thoughtworks pulled a room full of CTOs, architects, and senior practitioners together in Engelberg this past June, and one of the five headline findings from that retreat was — I’m quoting the report — “an apprenticeship and skills-transmission crisis.” Not a maybe. A crisis, named as such, that came up independently in at least six different sessions. Their words for the failure mode: If juniors never get to struggle with real code, real production incidents and real design trade-offs because agents (or senior engineers pairing exclusively with agents) absorb that work, the industry will lose a vital mechanism for growing the next generation of engineers with judgment and taste. If juniors never get to struggle with real code, real production incidents and real design trade-offs because agents (or senior engineers pairing exclusively with agents) absorb that work, the industry will lose a vital mechanism for growing the next generation of engineers with judgment and taste. Read that clause again — “senior engineers pairing exclusively with agents.” Hold onto it; it’s the accelerant, and I’ll come back to it. First, the machine it’s breaking — because to see why this is a genuine shortage and not just hand-wringing, you have to see what a junior engineer was actually for. Why We’re About to Stop Making Seniors Step back and look at what hiring a junior engineer actually bought you, for the entire history of this industry. It bought you two things, not one — bundled so tightly that nobody bothered to pull them apart: The work they did. Real tickets, real fixes, real features. Not glamorous, but it shipped, and it roughly paid for their salary. The senior they were becoming. Every one of those tickets was also a rep. The hard stuff — good software taste, judgment about what breaks and why, the gut feel for when something is off — none of it comes from a book or a bootcamp. It’s learned on the job, slowly, doing real work under someone who has already been there. That second thing was the actual product. Hiring juniors was always a supply chain for seniors — we just never had to call it that, because the first thing quietly paid for the second. The on-the-job training rode along, essentially for free, on top of labor you were buying anyway. It looked like “hiring cheap hands.” It was really “manufacturing seniors, subsidized by the hands.” Now watch what AI does to that bundle: it splits it clean in half. The work — thing one — is increasingly done by agents, faster and cheaper than any junior. So the spreadsheet says the obvious thing: stop hiring juniors, the work is handled. And it’s dead right about the work. But it silently cancels thing two right along with it — the OJT pipeline that was the only mechanism we ever had for growing seniors. AI made the junior’s labor redundant, and companies are about to throw out the junior’s training value along with it, because the two always came in one package and nobody ever put a line item on the half that mattered more. That’s the whole thing in one sentence: we’re about to stop making seniors because the thing that used to pay for making them just got automated. You Can’t Just Buy Them I can hear the objection, because it’s the obvious one and I’ve made it myself: just hire seniors when you need them. Let the other guy train them. Poach the finished product. It’s cheaper, it’s faster, and it has worked for the entire history of this industry. Right? WRONG. Here’s why that breaks: everyone is about to have that exact same idea at the exact same time. Every company that quietly decides juniors are too expensive is also quietly deciding to buy its seniors on the open market later. There’s signal it’s already starting: hiring at top tech firms is up roughly 20% year-over-year.1 So in a few years you have the whole industry bidding for a pool of senior engineers that nobody bothered to replenish. Demand goes vertical. Supply is flat — worse than flat, because we all stopped feeding the pipeline at once. You already know what that does to a price. You don’t even have to imagine it. Look at what AI just did to memory. Data centers got hungry, demand went vertical, and DRAM prices rose more than 400% from the start of 2024 through the end of 2026 — nearly doubling in a single quarter at the peak, with the shortage forecast to run past 2028 and maybe, per SK Hynix, past 2030. Why so brutal? Because you cannot conjure a fab in a quarter. The capacity takes years to build, nobody built enough of it ahead of the demand, and so now everyone pays through the nose for the scarce thing. Senior engineers are the DRAM of the next few years. Same shape, exactly: demand exploding — every shop on earth wants a senior who can drive a fleet of agents with judgment — supply badly constrained, and a lead time you cannot compress by throwing money at it in the moment. It takes years to make one, and no purchase order speeds that up. When the scarcity hits — and it will — the companies that kept training through the lean years will have their own supply, grown at cost. Everyone else will be bidding against each other for whoever’s left, at whatever the market demands. And a cornered market demands a lot. So flip the framing entirely. Growing your own engineers isn’t charity and it isn’t a feel-good morale program. It’s a hedge. You are buying senior-engineer futures at today’s price, insuring yourself against a scarcity spike you can already see coming on the tape. I made almost this exact argument about buying your own inference hardware — spend a little capital now so you’re not at the mercy of a supply you don’t control later. Talent is the same bet, and it’s a bigger one. Luck favors the ready. The Trap That Pours Gas on It So we agree there’s a shortage coming. Here’s the cruel part: the way most shops are using AI right now is accelerating it. Meet the accelerant I told you to hold onto. There’s a terrific writeup from the folks at FlintAI — their team is now 5 devs and 45 agents, all living in Slack. Nine agents per developer. The agents take roles — triage, deploy, review — the human steps in for the two decisions that actually matter (code review, release approval), and they report something like a 3x productivity bump. It’s a genuinely impressive piece of engineering and you should read it. That’s the model everybody’s racing toward right now: take your best seniors, strap nine agents to them, and harvest the multiple. And it works! I’m not knocking it (and I’m doing it too)! But look at the shape of it. One senior, nine agents, 3x. If you have five seniors, you have five of those. That’s linear. You add leverage exactly as fast as you add seniors — and we just established you can’t make seniors fast, and they’re about to get scarce and expensive. You’ve built your entire leverage story on the one input that’s turning into DRAM. Worse: every hour that senior spends conducting their private agent orchestra is an hour they’re not spending minting the next senior. The nine-agent senior isn’t just linear. Left alone, it’s decreasing — a fab quietly running its own supply down. But Your Business May NEED to Focus Only on Seniors! What you should do about this depends on your business. If you’re a three-person startup clawing for product-market fit before the money runs out — go fast, go alone, strap on the nine agents and run. You don’t have a next generation to grow yet; you have a runway to beat, and that’s fine. But if you’re a growing company that plans to still be here in five years and to need senior engineers you don’t yet have, the calculus flips hard. You are, whether you’ve named it or not, in the business of manufacturing seniors — and you just watched the subsidy that funded it disappear. The Only Hedge: Fan Out Through People There’s a line you’ve probably heard: “If you want to go fast, go alone. If you want to go far, go together.” It’s usually served up as an African proverb but it’s the whole argument in nine words. The nine-agent solo senior is going fast, alone. Mentoring is going far, together. Speed and distance are not the same race. Now run the other play. Take that same senior and, instead of having them personally drive nine agents, have them ALSO mentor three juniors — and teach each of those juniors to drive their own set of agents. And what should the juniors build? Real, valuable work the business needs — but contained, isolable, testable, the kind of thing you can hold in your head all at once. (I’ll get specific about the what and the how further down.) Do the arithmetic on the shape, not the exact numbers. One senior directly produces some output. But a senior who also levels up three juniors, each of whom is now driving their own cluster of agents, has produced three more nodes that each fan out on their own — and those juniors become seniors who mentor their own juniors. That’s not one senior times nine agents. That’s a branching tree. It compounds. It’s the difference between a line and a curve, and over a couple of years the curve isn’t close. You can’t conjure a senior in a quarter — but this is how you break ground on the fab now, so you have your own supply when everyone else is bidding for scraps. The senior’s most valuable output was never the code. In the agentic era it definitely isn’t the code — the agents write the code. The senior’s most valuable output is more people who can produce output with judgment. That’s the highest-leverage thing a senior human can do now, and it’s the thing the nine-agent-conductor model quietly skips. To Be Clear: Seniors Still Build Don’t read any of this as “stop coding and go be a full-time mentor.” Ugh, no. I wrote a whole post about how the bosses are coding again and I meant every word — the seniors absolutely still need to be building. You cannot mentor judgment you’re not actively practicing. The day you stop shipping is the day your feedback goes stale, your instincts drift, and the juniors can smell it. You can’t learn to swim from a book or by watching from the deck for two years — that goes for the coach too. Get in the water. Stay in it. The shift isn’t whether seniors build. It’s what fraction of their time building gets. The trap isn’t a senior who codes — it’s a senior who codes with 100% of their time, running their private nine-agent orchestra and calling it leverage while the bench behind them stays empty. Carve out real time — not the scraps, not “if I get to it” — to grow people. Build with most of your time; mentor with a real slice of it, deliberately protected. Both, on purpose. A leader who owns the entire critical path and mentors no one isn’t scaling; they’re a single point of failure with great throughput. But You Can’t Just Hand Them the Keys Here’s where it gets hard, and where most “just let the juniors use AI” takes fall apart. You cannot fan out through juniors who don’t have judgment, because a junior driving nine agents with no judgment isn’t a force multiplier — it’s a slop cannon pointed at your production systems. The FlintAI folks are right about that. Judgment is the whole ballgame. So the real question isn’t “should juniors use agents?” (obviously yes) or even “should seniors let them?” (yes, and it’s going to feel bad — more on that in a second). The real question is: how do you build judgment in a person when the tool will happily do the thing before they’ve understood it? I’ve been chewing on this hard enough that I sat down and wrote an actual development plan for it. The core insight is this: agentic tools remove the friction of producing code and infra changes, but they do not remove — they increase — the need to verify them. The failure mode of the next few years isn’t juniors who can’t type the commands. It’s juniors who can’t tell when a tool’s confident output is locally correct and globally wrong. The manifest that applies cleanly but misconfigures resource limits. The fix that resolves one node’s symptom but ignores the partition. The script that runs successfully and deletes the wrong thing. So What Am I Planning? Concretely, here’s the shape of it. First, give the juniors real work with a real blast radius, kept deliberately small: canary tests, smaller services, SDKs, example clients that double as test harnesses. Stuff the business genuinely needs — but contained, isolable, testable, the kind of thing you can hold in your head all at once. They ship something that matters and they get the reps. Nobody learns judgment on a toy. Then drill them. Not metaphorically — literally. Chaos drills, not just tickets. This is the part I’m most excited about. Take the Chaos Monkey idea and turn it into training: deliberately break things — kill a node mid-rollout, partition the network, and so on — on a cluster that’s safe to wreck, and put a junior in front of it with a clock running. It’s a casualty drill straight out of the Rickover playbook, for software. And predict-then-observe is the whole point: before they touch anything, they say out loud what they expect to see and why. The gap between the prediction and what actually happens is the lesson — far more than whether they eventually fix it. Certs as a forcing function, not a finish line. I don’t care about the badge on the wall. I care that a performance-based exam puts a human alone at a live terminal with a broken system and a clock, which is exactly the confrontation with failure that agents paper over. Where a credible cert exists, use it as scaffolding to guarantee the confrontation happens. I’m planning on LFCS, CKA, and AWS SAA, since my juniors live in a Linux/cloud world. No-AI-assist checkpoints. At least one exercise per skill area with the agents turned off, under time pressure. Not because agents are bad — because the only way to know the mental model exists independent of the tool is to take the tool away and watch. And here’s the part people get exactly backwards, so let me say it loud: use AI to learn all of this 10x faster. The same tool that threatens to skip the apprenticeship is the best tutor a junior has ever had. Stuck on how Raft handles a split vote? Ask. Can’t see why the NetworkPolicy is silently dropping traffic? Have the model walk you through it, then go verify it on the cluster. Grinding toward the CKA? An agent will quiz you, explain every wrong answer, and generate fresh broken-cluster scenarios all night long. My juniors will learn faster than I ever did — I learned this stuff from thick O’Reilly books and Usenet threads, and they’ve got a patient expert on tap. That’s a gift. Use it hard. The one rule: you can’t lean on it 100%. Learn with it constantly, then prove — at the no-AI checkpoint, under the clock — that the knowledge is in your head and not just in the context window. Lean on AI to learn; don’t lean on it to know. Both can be true, and the space between them is the whole ballgame. This Is Just Rickover, Again If this sounds familiar to longtime readers, it’s because it’s the same well I always draw from. The US Navy figured out how to put a 22-year-old in front of a live nuclear reactor and trust them not to melt it, and they did it decades before anyone said “agentic.” The Rickover program didn’t work because the kids memorized procedures. It worked because it was built, top to bottom, around rising standards, constant training, predict-then-observe, and escalating bad news fast. You qualified by proving judgment under failure, not by reciting the manual. And every qualified operator’s job included training the next one. The knowledge fanned out, by design, or the fleet didn’t have enough operators. Sound familiar? I care about this one more than the tech, honestly. I was homeless as a teenager. I grew up on welfare. I did not claw my way into this career on raw merit alone — mentors reached back and pulled, over and over, and I would not be writing this from a house in the Bay Area if they hadn’t. So when I say mentoring the next generation is an obligation, I don’t mean it as a nice LinkedIn sentiment. I mean I owe a debt I can only pay forward, and so do you, and the agents don’t get us off the hook. If anything they raise the stakes, because the easy path — hoard the leverage, skip the humans — has never been more tempting or more available. Why Your Seniors Will Hate It Letting a junior build the thing — agentically, their way, at their pace — is slower than doing it yourself, and it’s WAY slower than strapping nine agents to your own senior brain and cranking. You will watch them go down a road you’d have skipped. You will want to grab the keyboard. Every instinct sharpened over your career screams just do it yourself, it’ll take ten minutes. And you’ll be right — it would take you ten minutes, and it’ll take them a day, and at the end of that day you have something more valuable than the feature: you have a person who’s a notch closer to not needing you. You just added a unit of the thing that’s about to be scarcest. That’s the trade. Short-term velocity for long-term capacity. The mentor pays a tax now and compounds later. You can’t learn to swim from a book, and your juniors can’t learn judgment from watching you swim, either — you have to let them get in the water and thrash a little while you stand close enough to pull them out. Conclusion The naysayers are right that the old apprenticeship is dying. They’re wrong that nothing replaces it. The apprenticeship changes shape: juniors who drive agents with taste can learn faster than we ever did — if someone bothers to build the taste. That “if” is the entire post. So do the math the rest of the market is about to do the expensive way. Senior engineers are the next DRAM: demand going vertical, supply nobody replenished, a lead time no purchase order can compress. The price is going to spike, and the shops that kept training through the lean years will have their own supply while everyone else pays ransom for scraps. Growing your own is the hedge — you’re buying senior futures at today’s price. The mechanism is mentorship: fan out through people instead of hoarding agents on the seniors you already have. One senior who makes three who each make three more is a curve, and curves win. Go alone and you’ll go fast; go together and you’ll go far. Have strong opinions, loosely held — but hold this one tight: the highest-leverage thing you can do in the agentic era is still, stubbornly, to build another Engineer, not just build it yourself faster. What’s next for me: I’ve got that development plan — four pillars, certs as forcing functions, a distributed-systems practicum with no exam because none exists yet — and I’m actually running it, not just writing about it. I’ll report back on what survives contact with reality, honestly, including the parts I get wrong. That’s the deal. If you’re wrestling with the same thing — or if you think I’m romanticizing mentorship and the real answer is just more agents — drop me a note on LinkedIn. I especially want to hear from anyone actually growing juniors in an agent-heavy shop right now; that’s the experiment that matters. And yes — if this helped, pay it forward. Somebody did it for me. Gergely Orosz, “State of the software engineering job market in 2026”, The Pragmatic Engineer — “‘Top’ tech companies are hiring 20% more vs a year ago,” based on TrueUp data tracking open positions at top-paying tech firms. ↩︎ Gergely Orosz, “State of the software engineering job market in 2026”, The Pragmatic Engineer — “‘Top’ tech companies are hiring 20% more vs a year ago,” based on TrueUp data tracking open positions at top-paying tech firms. ↩︎ Share! Share on Facebook Tweet Share on Google+ Post to Tumblr Pin it Submit to Reddit