Harness Engineering · A Talk for Leaders

Who's going to be senior in 2031?

The people you hire this year. There is no other supply. The agent writes junior-tier code, so cutting junior intake looks free for six years. That is also how long it takes before a quick fix stops being possible.

intake · who you hire bench · who can judge the cliff · and the debt
Who's talking

Ian Johnson

  • Staff software engineer at Parento, running agents against a real production codebase, daily.
  • Founder of Fulcorum · fulcorum.com, on-demand video courses on shipping AI-generated code that's production-grade.
  • Author of Harness Engineering and the open-source tool Keystone.
I am not here to tell you the agent is overrated. I use it all day. But the second-order effect on your org chart is what I am here to talk about.
The decision on the table

The case for cutting junior hiring is not stupid.

  • The agent produces junior-tier output in minutes, at near-zero marginal cost.
  • A junior costs six figures, needs onboarding, and takes senior time you are already short of.
  • The saving is visible this quarter. It shows up in a headcount line that somebody is measured on.
  • Every peer company appears to be reaching the same conclusion, which makes it feel safe.
Every part of that is true. Cutting junior hiring is still one of the worst trades available to you.
Concede it fully

The agent really has replaced junior output.

  • CRUD endpoints, form validation, test scaffolding, migrations, glue code.
  • Faster than a junior, at any hour, without asking a follow-up question.
  • Often better than a first-year engineer's first draft.

If your argument for hiring juniors is that you need the code they produce, you have already lost that argument. Do not make it.

Their output was a byproduct. You were paying for the judgment the work would build.
The part the business case misses

A junior is a senior under construction.

WHAT YOU BUY Junior-tier output now replaceable, and honestly it was never the point the agent took this WHAT YOU WERE ACTUALLY BUYING A senior, in six years judgment, context, the ability to tell plausible from correct nothing takes this

You cancelled a subscription to the left-hand box. The invoice for the right-hand box arrives separately.

The Arithmetic

You manufacture a senior on a six-year lead time.

The model, stated so you can attack it
  • You hire 100 juniors a year.
  • About 40% reach senior at your bar.
  • It takes about 6 years.
  • You lose about 10% of the senior bench a year.

Steady state: a bench of 400. Argue with any number you like. The shape below does not change for any lead time over four years, which is every version of this anyone has proposed.

Nothing in your control shortens the six years. Not budget, not tooling, not a model release.

You can make the six years better, but not shorter, because a junior builds calibrated instinct out of reps.

The Cliff

Stop hiring juniors in 2025. Nothing happens until 2031.

100% 75% 50% 25% 2025 · intake cut 2031 · the bench starts falling keep hiring resume in 2031 never resume 2025 2027 2029 2031 2033 2035 2037 2039 2041
senior bench, as a share of steady state
Why this one gets made

The first six years look free. That window is the trap.

  • 2025 to 2031: the bench is flat. Cohorts hired before the cut are still arriving. The savings are real and the cost is invisible.
  • 2031: the first year nothing arrives. The decline starts, and it will not stop on its own.
  • 2037: down to 53% even if you reversed course the moment the decline appeared. The fix takes six years too.
  • 2041: 35% if you never reverse it.
By the time the metric moves, the correction is already six years late. You cannot fix this decision in the year you notice it.
The Risk Profile

This breaks cheaply, fixes slowly, and gives no feedback in between.

Breaking it

It takes one headcount decision and one quarter. On paper you can reverse it at any time, for free.

Fixing it

Six years of salary before the first return. You start it in a year when the bench is already thin and everyone is busy.

And the part that makes it genuinely dangerous

There is no signal in between. Six years of flat metrics is exactly what a correct decision and a catastrophic one both look like. You will not get evidence in time to act on it, so you have to decide this on structure rather than on data.

The Obvious Objection

"We'll just hire seniors instead."

  • That is not a hedge, because everyone else is placing the same bet at the same time.
  • If the industry stops manufacturing seniors, the shortage arrives everywhere at once. Then your plan and your competitor's plan fail in the same quarter.
  • Companies making this same decision are training, or failing to train, the people you plan to hire in 2031 right now.
  • Poaching moves a senior between orgs. It does not create one. In aggregate the industry is buying from a pool nobody is refilling.
You are not diversified. You are correlated. Every firm's fallback plan is to buy from a market that every firm stopped supplying.
Demand Side

The agent multiplies the need for judgment rather than reducing it.

  • Volume of change goes up. Ten times the diffs, same number of people who can evaluate one.
  • Every generated change still needs somebody to decide whether it is correct here. That is a question about your business, and no model has the answer.
  • The agent has no accountability: nobody pages it, it skips the postmortem, and it does not answer for the outage.
  • Review capacity, not typing capacity, is now the binding constraint on how fast you can ship.
You automated the abundant half of the job and left the scarce half untouched. Then you cut the supply of the scarce half.
Name the failure mode

Comprehension debt.

Shipped, working, revenue-generating code that nobody currently on staff can explain.
Technical debt

Visible. Has a name, a backlog, an owner, and a budget line. Everyone agrees it exists.

Comprehension debt

Invisible. Every dashboard is green: tests pass, velocity is up, the code is clean. Nothing measures whether a human still understands it.

The symptoms, in order

You will see this as a quality problem, not a hiring problem.

  • Incident time-to-diagnosis climbs while time-to-fix stays flat. Nobody knows where to look anymore.
  • "I don't know why that's there" starts appearing in postmortems, about code written last year.
  • You revert changes more often, because the change was plausible and the reviewer had no basis to say otherwise.
  • Agent output quality degrades on its own, because the agent imitates the codebase, and the codebase is now full of things nobody vetted.
  • Your remaining seniors spend all day reviewing and none of it deciding, then leave.
You will diagnose every one as a process problem, apply a process fix, and watch it not improve.
2031, Two Companies

Two companies run the same tools and the same model. What differs is the bench.

Company A · cut intake in 2025
  • Bench flat until this year, now falling.
  • Competing for scarce seniors at auction prices.
  • Six years of agent output, thinly reviewed.
  • Nobody in the building trained on this codebase.
Company B · kept intake, ran a program
  • Six cohorts trained on comprehension, on their own code.
  • Review capacity scaled with output volume.
  • A bench it grew at cost, not at market rate.
  • Institutional memory that is in people, not only in files.

Company B did not spend more. It spent about thirty minutes a week per junior, and it kept paying salaries that Company A stopped paying.

Where I could be wrong

This is an argument from pipeline structure, not a forecast.

What would make me wrong
  • If agents become accountable, not merely capable. If a model can be the party that answers for an outage, the need for a human bench collapses and so does this talk.
  • If seniority stops requiring reps. If judgment about a specific business can be installed rather than trained, the six-year lead time goes away.
I have no data about 2031. Nobody does. What I have is the structure of the pipeline, which has a six-year lag whether or not anyone believes in it.

Every way I could be wrong argues for waiting to cut, not for cutting now. The cut is the irreversible move.

The Mechanism

Seniority was never typing speed, and the agent made that impossible to hide.

  • Writing code was always the means. The job is deciding what correct means here, for this business.
  • A junior builds that judgment by being wrong, repeatedly, in front of someone who can say why.
  • The agent commoditized the means, which does not shrink the job. It reveals it.
  • And it offers, every single day, to skip the part where the judgment forms. It hands a junior working code faster than they can understand it.
Left alone, the tool that makes juniors productive is the same tool that stops them becoming senior. That is the thing a program has to counteract.
What you're actually hiring for now

The junior role changed. Reviewer first, author second.

THEN junior writes senior reviews code ~1 hour of the scarce person NOW agent writes junior reviews code senior reviews the review ~15 min

Grading the review instead of the code puts your scarcest person's attention on the only thing that transfers. It also costs them a quarter of the time it used to.

Move 1 of 4

Set a bar on what gets merged, not on who wrote it.

# every pull request carries this, written by a human
comprehension:
  does:      what this change does to the system, one sentence
  seam:      where it enters -> where it leaves
  policy:    the rule this obeys  | CHARTER-GAP
  falsifier: the case that would make this wrong
             covered by: a test       | NONE
  • Takes under a minute when you understand the change, and is genuinely hard when you don't. That asymmetry is the whole mechanism.
  • A CI gate can enforce that the claim was made. Only a person can check that it is true.
  • CHARTER-GAP means nothing in the repo answers "why". That is a finding your org should want.

tacoda.dev/comprehension-standard

Move 2 of 4

Thirty minutes a week, on the agent's code.

  • The junior reviews a diff the agent produced. Cold, no explanation, five minutes.
  • Fifteen minutes to fill a card: verdict, defect class, proof, durable fix. The prediction comes before the tests.
  • Ten minutes defending it to a senior, who grades the review and never the code.
  • Count progress in documented catches, not tickets closed.
Reviewing the agent is safe in a way reviewing your own work never is. Nothing is at stake, so people look harder.

tacoda.dev/reverse-review

Move 3 of 4 · the one with teeth

Change what you promote on, or the other three are decoration.

If you promote on output
  • The agent wins that contest, permanently.
  • You have told every junior that the fastest path is to merge more, faster, unread.
  • You are measuring the one part of the job you already automated.
Promote on these instead
  • Catches: a defect named, classified, and proved.
  • Charter contributions: gaps found and rules written that stopped a whole class.
  • Reviews that changed a decision.
  • Incidents that did not happen because somebody asked.

People optimize what you count. Right now most orgs count the half the machine does better.

Move 4 of 4

Before you decide this on a vibe, run it for one sprint.

  • Pre-register the hypothesis and the stopping rule before the first ticket, so nobody gets to reinterpret the result afterward.
  • Matched tickets: junior with an agent, senior alone. Score the outcomes blind.
  • Measure past throughput: defect escape rate, review rework, and a comprehension audit at 30 days. Can anyone still explain the change?
  • Tell people they are in an experiment, and never let the result touch an individual's review.
My prediction, on the record: the junior loses on week-one speed and wins by day ninety. If that is wrong at your company, you should know it, and this is how.
The Bill

The whole program, priced.

Per junior
30 min

per week, reviewing the agent

Per senior
15 min

per week, grading the review

Setup
1 day

PR template, one CI gate, a written bar

Compare against

One senior hire in a market where nobody has been making seniors for six years. That is the alternative you are choosing between, and it is not close.

Close

The bench you'll have in 2031 is the offer letters you sign this year.

The agent took the output, not the apprenticeship. Keep hiring, change what the first six years are for, and count the thing the machine cannot do. The cut is the only move here that you cannot take back.

Contact

Find me.

Fulcorum
fulcorum.com
Email
ian@fulcorum.com
Site
tacoda.dev
Book
leanpub.com/harness-engineering
LinkedIn · GitHub
linkedin.com/in/tacoda
github.com/tacoda
The four moves, in full
tacoda.dev/comprehension-standard
tacoda.dev/reverse-review
01 / 24
Harness Engineering
← → move · T theme · F full