Vector 1
Organizations & Work

10,000 Early-Career Hires vs. 10,000 Veterans: The $11.2 Billion Experience Gap

Brian J. Curry
Brian J. Curry
October 14, 2026 · 34 min read

Knowledge and experience are the new super-optimizers in the age of AI. Hiring for context and breadth is the new corporate optimization matrix, and here are the model, the math and the code that price it.

Take two companies with 10,000 employees each. One is staffed with people early in their careers, zero to eight years in. The other is staffed with people who bring twenty years or more of experience across several domains. Pay both at market. In the model in this piece, the second workforce is worth $8.2 billion more to shareholders before AI and $11.2 billion more once AI is in the building. That’s about $1.1 million of equity value per person, after paying the veterans’ higher salaries. What drives the gap is experience and breadth of knowledge. Age is not a variable in the model.

For two decades the technology industry optimized for output: lines of code, tickets closed, sprint velocity, puzzles solved in 45 minutes. It hired young, measured throughput and treated experience as a cost to be managed down. AI has broken that model. Execution is now the cheap input. A model writes the code, drafts the analysis and closes the routine ticket. What it cannot supply is the knowledge of what to build, which answer is wrong, and how a change in one part of the business moves three others. That knowledge lives in experienced people, and it is now the scarcest input a company has.

I have been building this argument across several pieces. In The Collective Context Window, I argued that the KPI that matters is the knowledge a firm’s people bring to its AI. In Knowledge Networks in Organizations, that a company’s value sits in the expertise and connections among its people. In The End of the Vertical Data Scientist, that AI replaces narrow execution and amplifies the people who see across problems. In The Caveman Ritual, that coding interviews select for exactly the skill AI made cheap. My last piece, The Data Cap Rate, valued corporate data as an equity asset and left 60.8 percent of a firm’s enterprise value in a residual that includes the knowledge held by its people. This piece prices that residual.

An optimizer improves one metric. A super-optimizer knows which metric matters, sees how improving it moves the others, and directs the machines doing the optimizing. That is what experience buys, and AI multiplies it. Below are a model that values a person’s knowledge the way the last piece valued data, an experience-by-breadth matrix that shows what each kind of hire is worth, a simulation of two teams on the same payroll, and a scorecard a board can track. Two Python scripts reproduce every number. The model and its parameters are mine.

1. Output was the old optimization target

Walk through how a typical technology company hires and promotes, and you find one variable being maximized: visible output per head. The interview loop tests how fast a candidate can produce a known solution under observation. The performance system counts shipped features, closed tickets and commits. The org chart is a pyramid with a wide base of junior producers, because producers were what the work needed and juniors were the cheapest producers.

That system was internally consistent, and it was always measuring the wrong thing. In The Caveman Ritual I worked through the interview math. interviewing.io’s data shows strong candidates failing a single round up to 22 percent of the time, so the chance a strong candidate survives four independent rounds is (1–0.22)⁴, about 37 percent. A process that rejects most of the people it should hire is selecting for something other than ability. It selects for drilled recall, which is the skill AI now supplies for almost nothing.

The deeper problem is Goodhart’s law, in Marilyn Strathern’s phrasing: when a measure becomes a target, it ceases to be a good measure. Output metrics reward local optimization. In The End of the Vertical Data Scientist I simulated a retailer’s promotions two ways. A vertical optimizer chose the most profitable discount each week. A horizontal planner priced the whole season, accounting for how discounts train customers to expect them. The weekly optimizer won the first ten weeks and lost the season, earning 2,041.6 against 2,600.0 in that model, 27.4 percent less, because nobody owned the downstream effect.

That is the difference between an optimizer and a super-optimizer. The optimizer improves the number in front of it. The super-optimizer knows which number matters, how it interacts with the others and when the local win is a long-run loss. That judgment does not come from a bootcamp or a benchmark. It comes from having watched systems fail across many years, many problems and many domains. For two decades it was treated as overhead. AI is turning it into the main source of value, because AI is very good at the first job and has no idea how to do the second.

2. The evidence: experience is the asset AI cannot copy

The economics of firm-specific knowledge are old and settled. Robert Topel’s Specific Capital, Mobility, and Wages estimated that ten years of seniority raise a typical worker’s wage by over 25 percent, which he described as a lower bound. Jacobson, LaLonde and Sullivan followed Pennsylvania workers with six or more years of tenure who lost their jobs in the 1980s. Five years later they were still earning about 25 percent less, even when they found work in the same industry, and the authors traced the loss to knowledge and matches specific to the old employer. When a long-tenured person leaves, the knowledge does not travel with full value. Both sides lose, and the firm’s loss never shows up in its accounts.

Finance has priced the firm’s side of this. Eisfeldt and Papanikolaou model organization capital as embodied in a firm’s key talent, who can take part of it with them when they leave. Firms with more organization capital than their industry peers earned 4.7 percent a year more than those with less. Markets pay a premium for knowledge held by people precisely because it can walk out the door.

Now add AI. A landmark field study by Brynjolfsson, Li and Raymond covered 5,179 customer support agents and found a 14 percent productivity gain on average, 34 percent for novices and minimal gains for the most experienced. That result is often read as AI favoring the young. Read it again. The authors’ own explanation is that the assistant spread the practices of the most capable workers to everyone else. The AI’s value came from codifying what the veterans already knew. Novices got faster at routine work because the veterans’ knowledge was in the tool.

The Dell’Acqua et al. study of 758 BCG consultants shows where that stops. On tasks inside AI’s capability frontier, consultants with GPT-4 completed 12.2 percent more tasks, 25.1 percent faster, at more than 40 percent higher quality, with below-average performers improving 43 percent against 17 percent for above-average ones. On a task outside the frontier, consultants using AI were 19 percentage points less likely to reach the correct answer. AI compresses the gap on work it can already do and widens the cost of not knowing when it is wrong. Knowing when it is wrong is what experience is for.

The labor market is already sorting on this. Using records from the largest U.S. payroll software provider, Brynjolfsson, Chandar and Chen found a 13 percent relative decline in employment for workers aged 22 to 25 in the most AI-exposed occupations, while more experienced workers in the same occupations held steady or grew. The Great Codification working paper from Eisfeldt, Liu and Schubert reports that chatbots raised the value of knowledge stored in people. Entry-level output is being automated. Experienced judgment is being repriced upward.

3. The model: pricing the knowledge in a person

The Data Cap Rate valued data as replacement cost plus capitalized excess rent. People need one adjustment, because the market already pays for part of what they know. A wage buys portable, general skill, the part a person could sell to any employer. The firm’s equity value comes from what the wage does not pay for: its share of the firm-specific knowledge the person builds, and all of their leverage, the lift their knowledge gives everyone else’s work and every AI system they direct. Leverage is the unpaid factor of the knowledge economy, the same way human data was the unpaid factor in my Returns to Data series.

w(t) is the wage and s(t) is the firm’s surplus in year t, both in thousands of dollars a year. e_t is years of experience and τ_t is tenure at this firm. G is the market value of general skill, which wages track, rising from $110k for a new graduate to $200k. S is firm-specific knowledge, worth up to $120k a year once fully built, of which the worker captures a share β = 0.4 in pay, consistent with wages that rise with seniority. D is depth of judgment, which grows with experience at a diminishing rate and equals 1 at twenty years. b is breadth, the number of domains a person holds at working depth. λ = $150k is the leverage rent of a four-domain, twenty-year person at full tenure. A is the AI multiplier on leverage, 1 without AI. c_0 = $40k is the first-year cost of colleagues’ time spent onboarding. q is the annual quit hazard and r = 10 percent the discount rate. V is the person’s knowledge capital: the present value of the surplus they create, weighted by the chance they stay. k_h is the people cap rate. The quit hazard plays the role depreciation played for data, which is the Eisfeldt and Papanikolaou mechanism in one term.

Run two hires through it. A twenty-year veteran with four domains costs $198.4k a year. Their surplus is -$40k in the first year while they learn the firm, $49.6k in the second, and $217.4k by year ten as firm knowledge compounds with their depth and breadth. With a 7 percent quit hazard their knowledge capital is $695k. A new graduate with one domain costs $110k, their surplus reaches $63.5k by year five, and with an 18 percent quit hazard their knowledge capital is $87k. The veteran costs 1.8 times as much and is worth 8.0 times as much. The people cap rates tell the same story: 17 percent for the veteran against 28 percent for the new graduate, whose value walks out the door faster.

With AI, the model adds two effects. Leverage is multiplied by A = 1.5, my assumption for how much further an experienced person’s knowledge reaches when it directs agents rather than a team of juniors. In The End of the Vertical Data Scientist I put the relation as V ≈ A × C: AI multiplies the context a person brings. A novice gets the 34 percent routine-work gain Brynjolfsson, Li and Raymond measured, applied to the routine half of their job and fading as they gain skill. The veteran’s knowledge capital rises to $947k and the new graduate’s to $140k. AI lifts both, and the ratio stays at 6.8 to 1.

The experience premium: a proposed model (mine) that values the knowledge
in people the way The Data Cap Rate valued data. Wages pay for portable,
general skill. The firm keeps part of the firm-specific rent and all of the
leverage, the lift a person gives everyone else's work.
Money in $ thousands unless noted. Every input is illustrative.

from dataclasses import dataclass, replace
import math
import numpy as np

G0, G_MAX = 110.0, 200.0   # market wage for general skill: new grad, fully developed

def general(e: float) -> float:
    """Market value of general (portable) skill after e years; wages track it."""
    return G0 + (G_MAX - G0) * (1 - math.exp(-e / 5))

def depth(e: float) -> float:
    """Judgment from experience, with diminishing returns; equals 1 at 20 years."""
    return (1 - math.exp(-e / 10)) / (1 - math.exp(-2))

def quit_for(e: float) -> float:
    """Annual quit hazard falls with experience (illustrative)."""
    return 0.18 if e < 5 else (0.12 if e < 10 else 0.07)

@dataclass(frozen=True)
class Person:
    experience: float      # years of experience at hire
    breadth: int           # domains held at working depth
    tenure: float = 0.0    # years already at this firm
    quit: float = 0.10     # annual quit hazard
    S_max: float = 120.0   # firm-specific knowledge rent at full tenure, per year
    beta: float = 0.40     # worker's share of the firm-specific rent (paid in wages)
    lever: float = 150.0   # leverage rent, 4 domains, 20 years, full tenure, per year
    ai_lever: float = 1.0  # AI multiplier on leverage (knowledge directing agents)
    ai_novice: float = 0.0 # AI uplift on a novice's output, as a share of general skill
    onboard: float = 40.0  # first-year cost of colleagues' time spent onboarding

    def specific(self, tau: float) -> float:
        return self.S_max * (1 - math.exp(-tau / 4))

    def wage(self, t: int = 0) -> float:
        return general(self.experience + t) + self.beta * self.specific(self.tenure + t)

    def surplus(self, t: int) -> float:
        """Firm's rent from this person in year t, over and above their wage."""
        e, tau = self.experience + t, self.tenure + t
        S = self.specific(tau)
        lev = self.lever * (self.breadth / 4) * (S / self.S_max) * depth(e) * self.ai_lever
        novice_ai = self.ai_novice * general(e) * max(0.0, 1 - e / 5)  # fades as skill grows
        cost = self.onboard if (t == 0 and self.tenure == 0) else 0.0
        return (1 - self.beta) * S + lev + novice_ai - cost

    def value(self, r: float = 0.10, years: int = 25) -> float:
        """PV of the firm's surplus, weighting each year by the chance the person stays."""
        return sum(self.surplus(t) * (1 - self.quit) ** t / (1 + r) ** (t + 1) for t in range(years))

def with_ai(p: Person) -> Person:
    # 1.5x leverage is my assumption; 0.34 x 0.5 applies the 34% novice gain to the routine half of work
    return replace(p, ai_lever=1.5, ai_novice=0.34 * 0.5)

def firm_value(rng, n: int, exp_range: tuple, breadths: list, median_tenure: float, ai: bool) -> float:
    """Knowledge capital of a firm of n people, in $ billions, net of their wages."""
    total = 0.0
    for _ in range(n):
        e = rng.uniform(*exp_range)
        tenure = min(e, rng.exponential(median_tenure / math.log(2)))
        p = Person(experience=e - tenure, breadth=int(rng.choice(breadths)), tenure=tenure, quit=quit_for(e))
        total += (with_ai(p) if ai else p).value()
    return total / 1e6

if __name__ == "__main__":
    # 1. The optimization matrix: what a new hire's knowledge is worth to the firm, net of wages
    print("New-hire value, $k (rows: years of experience; columns: breadth 1 to 5)")
    for e in (0, 3, 8, 15, 25):
        row = [Person(experience=e, breadth=b, quit=quit_for(e)).value() for b in range(1, 6)]
        print(f"  {e:2d} yrs  " + "  ".join(f"{v:6.0f}" for v in row))

    # 2. Two firms of 10,000: twenty-somethings versus people with 20+ years.
    #    Median tenure follows BLS (January 2026): 3.0 years at ages 25 to 34, 9.6 at 55 to 64.
    for ai in (False, True):
        rng = np.random.default_rng(1)
        young = firm_value(rng, 10_000, (0, 8), [1, 1, 1, 2], median_tenure=3.0, ai=ai)
        vets = firm_value(rng, 10_000, (20, 35), [3, 4, 5], median_tenure=9.6, ai=ai)
        gap = vets - young
        print(f"{'With AI' if ai else 'No AI  '}: twenty-somethings ${young:.2f}B, veterans ${vets:.2f}B, "
              f"gap ${gap:.2f}B, ${gap * 1e6 / 10_000:.0f}k per person")

    # 3. What it costs to lose a 20-year veteran with 10 years of tenure
    stay = Person(experience=10, breadth=4, tenure=10, quit=0.07)
    hire = Person(experience=20, breadth=4, quit=0.07)
    recruit = 60.0   # search fees and interview time
    for label, f in (("no AI", lambda p: p), ("with AI", with_ai)):
        loss = f(stay).value() - f(hire).value() + recruit
        print(f"Cost of losing that veteran ({label}): ${loss:.0f}k, {loss / stay.wage():.1f}x salary")

Save it as knowledge_value.py. It needs numpy, and it prints the matrix in section 4 and the firm comparison in section 6.

4. The new optimization matrix: experience × breadth

If output per head was the old optimization target, the new one has two dimensions: how many years of judgment a person brings and how many domains they can connect. The script prints what a new hire is worth to the firm, net of their wages, across both.

Three things stand out. The best hire on the grid, 25 years across five domains, is worth $840k, 9.7 times the new graduate with one domain at $87k. Experience and breadth are complements: adding three domains is worth $68k to a new graduate and $361k to a fifteen-year veteran, because breadth only pays when there is judgment behind it. And past fifteen years, the gains from more years flatten while the gains from more domains keep coming. For senior people, range is where the remaining upside lives.

Why breadth compounds is simple combinatorics. Suppose a business runs on D knowledge domains and a problem needs m of them at once. A person who holds b domains can solve it alone with probability equal to the share of m-domain combinations inside their own range, and they can connect C(b, 2) pairs of domains in their own head.

With D = 8, a one-domain specialist can never solve a two-domain problem alone and holds no internal pairs. A two-domain person solves 3.6 percent of two-domain problems alone. A four-domain person solves 21.4 percent of two-domain problems and 7.1 percent of three-domain problems, with six internal pairs. A six-domain person solves 53.6 and 35.7 percent, with fifteen pairs. Every problem a person cannot cover alone needs h handoffs, and each one costs coordination time and an error risk ε. At ε = 0.10, a three-domain problem worked by three specialists succeeds at most 81 percent of the time before anyone makes a technical mistake.

The research on discovery points the same way. Uzzi, Mukherjee, Stringer and Jones studied 17.9 million papers and found that work combining conventional knowledge with a small share of unusual combinations was twice as likely to be highly cited. Benjamin Jones showed why breadth became rare: as knowledge accumulates, innovators specialize and work in larger teams to carry the burden. That burden fell on recall, the part of expertise AI now carries. What remains scarce is the person who holds several domains at depth and knows how they connect.

5. Two teams, same payroll: output versus value

The matrix prices individuals. The real test is a team working a real queue. The script below gives two teams the same $1.5 million payroll: six veterans with four domains each, or twelve new graduates with one domain each. Both work the same year-long ticket queue, first in, first out. Sixty percent of problems are routine and worth $2k, thirty percent need two or three domains and are worth $15k, and ten percent are novel, worth $80k when solved and costing $40k when a wrong answer ships. The AI effects come from the studies in section 2: novices handle routine work 34 percent faster, and on novel work outside the frontier, AI-assisted novices are 19 points less likely to be right. The data is simulated, and every parameter is stated in the code.

Two teams on the same $1.5M payroll work the same queue of problems for a
year: six broad veterans or twelve new graduates, with and without AI.
Counts output (problems closed) and value (net dollars). Simulated data;
every parameter is an illustrative assumption stated below.

from math import comb
import numpy as np

D = 8                      # knowledge domains in the business
HOURS = 1_800              # working hours per person per year
HANDOFF_H, HANDOFF_ERR = 8, 0.10   # coordination hours and error risk per handoff

# Problem mix and values ($k). Routine work is codifiable and inside the AI frontier.
MIX = {"routine": 0.60, "cross": 0.30, "novel": 0.10}
VALUE = {"routine": 2.0, "cross": 15.0, "novel": 80.0}
COST_FAIL = {"cross": 5.0, "novel": 40.0}  # rework or an incident when the answer is wrong

# Hours per problem and skill, by profile. AI: novices resolve routine work 34% faster
# (Brynjolfsson, Li and Raymond); outside the frontier, AI users are 19 points less
# likely to be correct (Dell'Acqua et al.). I assume experience lets veterans catch
# those errors (vet_penalty = 0); the last run drops that assumption.
PROFILE = {
    "veteran": dict(n=6, breadth=4, routine_h=10, cross_h=30, novel_h=60, cross_ok=0.95, novel_ok=0.70),
    "new grad": dict(n=12, breadth=1, routine_h=20, cross_h=50, novel_h=80, cross_ok=0.85, novel_ok=0.35),
}

def coverage(b: int, m: int, d: int = D) -> float:
    """Chance one person with b of d domains covers a problem needing m domains."""
    return comb(b, m) / comb(d, m) if b >= m else 0.0

def people_needed(team: list[set], need: set) -> int:
    """Greedy set cover: how many people it takes to cover the needed domains."""
    left, k = set(need), 0
    while left:
        best = max(team, key=lambda s: len(s & left))
        if not best & left:
            return len(need)
        left -= best
        k += 1
    return k

def run_year(kind: str, ai: bool, rng: np.random.Generator, n_problems: int = 1_200,
             vet_penalty: float = 0.0) -> tuple[int, float]:
    p = PROFILE[kind]
    team = [set(rng.choice(D, p["breadth"], replace=False)) for _ in range(p["n"])]
    hours = p["n"] * HOURS
    closed, value = 0, 0.0
    kinds = rng.choice(list(MIX), n_problems, p=list(MIX.values()))
    for k in kinds:                       # first in, first out: a ticket queue
        if k == "routine":
            h = p["routine_h"] / (1.34 if (ai and kind == "new grad") else 1.0)
            ok, gain = 1.0, VALUE[k]
        elif k == "cross":
            need = set(rng.choice(D, rng.integers(2, 4), replace=False))
            hand = people_needed(team, need) - 1
            h = p["cross_h"] + 2 * HANDOFF_H * hand
            ok, gain = p["cross_ok"] * (1 - HANDOFF_ERR) ** hand, VALUE[k]
        else:
            h = p["novel_h"]
            penalty = 0.19 if kind == "new grad" else vet_penalty
            ok = p["novel_ok"] - (penalty if ai else 0.0)
            gain = VALUE[k]
        if h > hours:
            break
        hours -= h
        closed += 1
        if rng.random() < ok:
            value += gain
        else:
            value -= COST_FAIL.get(k, 0.0)
    return closed, value

if __name__ == "__main__":
    print("Coverage of a problem needing m of 8 domains, and internal domain pairs")
    for b in (1, 2, 4, 6):
        print(f"  breadth {b}: m=2 {coverage(b, 2):.3f}, m=3 {coverage(b, 3):.3f}, pairs {comb(b, 2)}")

    rng = np.random.default_rng(3)
    print("\nTeam          AI    closed/yr   net value $k/yr   value per closed")
    for kind in ("veteran", "new grad"):
        for ai in (False, True):
            res = np.array([run_year(kind, ai, rng) for _ in range(400)])
            c, v = res.mean(axis=0)
            print(f"{kind:9s}  {'yes' if ai else 'no ':3s}  {c:9.0f}   {v:15.0f}   {v / c:14.2f}")

    res = np.array([run_year("veteran", True, rng, vet_penalty=0.19) for _ in range(400)])
    c, v = res.mean(axis=0)
    print(f"veteran    yes  {c:9.0f}   {v:15.0f}   {v / c:14.2f}   (veterans also lose 19 points)")

Averaged over 400 simulated years:

This is the whole argument in one table. By the old optimization target, the new-graduate team wins: it closes 11 percent more problems without AI and 18 percent more with it, and every dashboard built on throughput would say so. By value, the veterans deliver twice as much without AI and four times as much with it. AI makes the new-graduate team faster at routine work, which frees hours that flow into novel problems, where AI-assisted guessing ships more wrong answers. Their output goes up and their value goes down.

The veterans barely move with AI in this simulation, and that is deliberate. The field studies found little speed gain for experienced workers on routine tasks, so I did not invent one. Their AI upside sits in leverage, in section 3. One assumption favors them: that experience lets veterans catch the AI’s errors outside the frontier. Drop it, and give veterans the same 19-point penalty, and their value falls to $3,361k. That is still 3.1 times the new-graduate team’s.

6. 10,000 against 10,000: the headline number

Scale the model to two whole companies. The first employs 10,000 early career people, with zero to eight years of experience, mostly one domain each and a quarter with two. The second employs 10,000 people with twenty to thirty-five years of experience and three to five domains each. Tenure follows the Bureau of Labor Statistics: in January 2026, median tenure with the current employer was 3.0 years for workers aged 25 to 34 and 9.6 years for workers aged 55 to 64. Quit hazards fall with experience, from 18 percent a year for the newest workers to 7 percent for the most experienced. Everyone is paid market wages, so the numbers below are knowledge capital net of payroll.

The veteran company carries $8.2 billion more equity value in its people before AI and $11.2 billion more after. AI widens the gap by $3 billion, because it multiplies what experienced people know and gives novices a one-time boost on routine work that fades as they learn. A company that staffs for youth to save on salaries is paying for it on the other side of the balance sheet, in equity value it never sees on a report.

The same model prices the cost of losing one person. Take a veteran with twenty years of experience, ten of them at this firm, and replace them with an equally experienced outside hire. The firm loses the departing veteran’s firm-specific knowledge and pays about $60k to recruit. Net of the replacement’s value, the loss is $499k, 2.2 times the veteran’s salary, before AI and $613k, 2.6 times salary, with it. That is the Jacobson, LaLonde and Sullivan result seen from the firm’s side. The knowledge was specific to the relationship, and it does not transfer.

None of this appears in the accounts. Under IFRS 3, an acquirer can recognize customer lists, technology and contracts as separate intangible assets, but the assembled workforce never qualifies and is subsumed into goodwill (IFRS 3.B37). Internally, the knowledge in people is invisible on the balance sheet, and recruiting, onboarding and mentoring all run through expenses. In The Data Cap Rate’s worked example, 60.8 percent of the insurer’s enterprise value sat in a residual of other intangibles, people and goodwill. This model says that for a knowledge-intensive firm, a large share of that residual is the experience of its people, and that a staffing strategy built around the cheapest producers quietly drains it.

7. The knowledge scorecard

In The Collective Context Window I proposed five dimensions for an organizational knowledge KPI: context density, context diversity, knowledge transfer velocity, judgment surface area and context persistence. The model makes them measurable. These are the metrics I would put in front of a board, next to headcount and payroll.

  1. Knowledge capital per employee. The sum of V across the workforce, divided by headcount. In the comparison above it is $1.06 million for the veteran company and $237k for the young one, before AI. This is context density with a dollar sign.
  2. Position on the optimization matrix. The share of headcount in each experience-by-breadth cell, tracked every quarter. A firm drifting toward the bottom-left corner is trading equity value for payroll savings.
  3. Breadth coverage. For each domain the business depends on, the number of people who hold it at working depth. Any domain held by fewer than two people is a single point of failure. This is context diversity.
  4. Handoffs per cross-domain problem. Pulled from ticket and incident data. Each handoff costs time and adds error risk, and a rising count means the firm is solving connected problems with disconnected people.
  5. Value per problem closed. Throughput’s replacement. In the team simulation it separates the two teams by a factor of two to four, while problems closed separates them by about 10 to 18 percent in the wrong direction.
  6. Judgment surface area. The share of AI output reviewed by someone with depth in that domain before it reaches a customer or a decision. Outside the frontier, Dell’Acqua and colleagues found AI users 19 points less likely to be right, and expert review is the control for that.
  7. Knowledge capital at risk. The sum over people of quit hazard times the cost of losing them. For one twenty-year veteran, that is 7 percent of $499k, about $35k a year of expected loss, which is the right budget yardstick for a retention program.
  8. Context persistence. The share of a departing person’s critical knowledge that is written down, encoded in tools or held by a second person when they leave. Codifying it into firm-specific systems, as The Data Cap Rate argued, turns part of this risk into a data asset.

The first four come from HR, skills and ticket data most firms already have. The last four need a modest amount of new instrumentation. None of them requires counting lines of code.

8. Hiring the super-optimizers

The hiring funnel is the machine that decides where a company sits on the optimization matrix. Every quarter it either adds people to the top-right corner, where experience and breadth compound, or to the bottom-left, where output is cheap and AI is cheaper. Most technology funnels were tuned for the bottom-left, and they are still running.

My jazz series has been building toward this section. Part I, Data Science Is Jazz, and Your Engineers Can’t Play It, set out the relation V ≈ A × C: AI multiplies the context a person brings, so a person with no context gets a large multiplier on very little. Part II, The End of the Vertical Data Scientist, drew the line between vertical players, who spell out every chord correctly and solve each ticket in isolation, and horizontal players, who hear the line running through the changes and find the use case nobody asked for. Coltrane’s Giant Steps is the vertical extreme. Miles Davis’s Kind of Blue is the horizontal one. Horizontal playing has to be earned by mastering the vertical first, and in practice that takes fifteen years or more across eras, industries and functions. Part III, The Caveman Ritual, showed that the standard interview loop tests the vertical skill, live and cold, which is the one skill AI now plays for free. The super-optimizer is the horizontal player. The funnel has to be rebuilt to hear them.

Which funnel finds them: a model

The script below scores the same 20,000 simulated candidates three ways and measures the knowledge capital each funnel actually hires, using the Person model from section 3 with AI switched on. Candidates have zero to thirty years of experience, and breadth rises with experience but varies widely. Each candidate has three latent traits. Execution E is recall, syntax and speed, and it does not depend on experience. Range P is framing and cross-domain judgment, and it rises with breadth and years. Drill is recent puzzle practice, common among recent graduates. The first two score equations are the ones from The Caveman Ritual.

coding loop   = E + 0.8 · drill + noise(sd 1.3)
work sample   = 0.3 · E + 0.9 · P + noise(sd 1.0)
matrix-aware  = work sample + 0.5 · z(breadth) + 0.3 · z(log(1 + years)) + noise(sd 0.5)

The matrix-aware funnel is the work sample plus a structured review of past work that measures breadth and depth directly. Each funnel hires the top 10 percent of the pool.

Which hiring funnel finds the super-optimizers? Scores the same 20,000
simulated candidates three ways and measures the knowledge capital each funnel
hires, using the Person model from knowledge_value.py (same folder).
Score equations follow The Caveman Ritual; candidate data is simulated.

import numpy as np
from knowledge_value import Person, quit_for, with_ai

rng = np.random.default_rng(5)
N, HIRE_SHARE = 20_000, 0.10

# Candidate pool: experience 0 to 30 years; breadth grows with experience but varies a lot.
exp = rng.uniform(0, 30, N)
breadth = np.clip(np.round(1 + exp / 8 + rng.normal(0, 1.0, N)), 1, 5).astype(int)

# True knowledge capital of each candidate as a new hire, with AI ($k).
V = np.array([with_ai(Person(experience=e, breadth=b, quit=quit_for(e))).value()
              for e, b in zip(exp, breadth)])

# Latent traits. Execution E (recall, syntax, speed) does not depend on experience.
# Range P (framing, cross-domain judgment) rises with breadth and years.
# Drill: recent puzzle practice, common among recent graduates.
z = lambda x: (x - x.mean()) / x.std()
E = rng.normal(0, 1, N)
P = z(0.6 * z(breadth) + 0.4 * z(np.log1p(exp)) + rng.normal(0, 0.6, N))
drill = (rng.random(N) < np.where(exp < 3, 0.6, 0.15)).astype(float)

# The Caveman Ritual's two score equations.
coding_loop = E + 0.8 * drill + rng.normal(0, 1.3, N)
work_sample = 0.3 * E + 0.9 * P + rng.normal(0, 1.0, N)
# Matrix-aware funnel: work sample plus a structured review of past work across domains.
matrix_aware = work_sample + 0.5 * z(breadth) + 0.3 * z(np.log1p(exp)) + rng.normal(0, 0.5, N)

def report(name: str, score: np.ndarray) -> None:
    hired = score >= np.quantile(score, 1 - HIRE_SHARE)
    corner = (exp >= 15) & (breadth >= 4)
    r = np.corrcoef(score, V)[0, 1]
    print(f"{name:13s} corr with V {r:5.2f} | mean V of hires ${V[hired].mean():5.0f}k | "
          f"hires with 15+ yrs and 4+ domains {corner[hired].mean():5.1%} | "
          f"hires with under 3 yrs {(exp[hired] < 3).mean():5.1%}")

if __name__ == "__main__":
    print(f"Pool: mean V ${V.mean():.0f}k; share with 15+ yrs and 4+ domains "
          f"{((exp >= 15) & (breadth >= 4)).mean():.1%}")
    report("coding loop", coding_loop)
    report("work sample", work_sample)
    report("matrix-aware", matrix_aware)

    # Multi-round loops compound false rejections: survival = (1 - p)^k
    for k in (1, 3, 4, 5):
        print(f"{k} rounds at p = 0.22: a strong candidate survives {(1 - 0.22) ** k:.1%}")

FunnelCorrelation with knowledge capitalMean knowledge capital per hireHires with 15+ years and 4+ domainsHires with under 3 yearsWhole candidate pooln/a$638k30.4%n/aCoding loop-0.03$611k29.0%15.0%Paid work sample0.54$936k66.7%0.5%Matrix-aware0.75$1,042k85.5%0.0%

The coding loop is no better than chance at finding knowledge capital. Its scores are uncorrelated with what a hire is worth, and its hires average $611k, below the $638k of the pool it drew from, because drilled recall pulls recent graduates up the ranking. The paid work sample hires $936k of knowledge capital per person, and two-thirds of its hires come from the top-right of the matrix. The matrix-aware funnel hires $1,042k per person, 1.7 times the coding loop. Across 100 hires, that is $43.1 million of equity value the old funnel leaves on the table. It works because it measures the two axes of the matrix directly, and that is the whole point of rebuilding the funnel.

The loop also loses people it should hire. interviewing.io’s data shows strong candidates failing a single round up to 22 percent of the time. With k independent rounds, a strong candidate survives with probability (1 — p)^k: 78.0 percent after one round, 47.5 percent after three, 37.0 percent after four and 28.9 percent after five. Every round added to the ritual removes more of the people a firm most needs.

The playbook

  1. Write the job as a list of problems. Name the problems the role must solve and the domains each one crosses. That is the m and D of section 4, and it tells you how much breadth the role needs.
  2. Source for the top-right. Drop filters for years in a named tool, pedigree and degree type. Recruit deliberately from people with fifteen or more years across industries and functions, including consultants, career changers and people returning to work. Screen for experience and range, never for age. In the United States, the Age Discrimination in Employment Act protects workers 40 and over.
  3. Replace the timed loop with a paid work sample. Make it multi-day, on a messy problem that crosses at least two domains, with AI tools allowed, because the job allows them. Retire the timed algorithm round for any role where execution is less than about two-thirds of the work.
  4. Review real work, including failures. Ask the candidate to walk through three problems from different domains: how each was framed, how it evolved, what broke and what they would do differently. In The Collective Context Window I called this the failure portfolio. It is where depth shows.
  5. Ask the five horizontal prompts from Part II. The unasked use case: what would you build that nobody requested? The borrowed method: what technique from another field fits here? The second-season question: what happens after the first win? The guide-tone question: which feedback loop connects this to the rest of the business? The rest: what should we not build?
  6. Test the writing. Have the candidate write the specification an AI agent would need to do the job well. A person who cannot state the problem precisely cannot direct the machines that solve it.
  7. Score with a written rubric and aggregate the evidence. Framing 25 percent, range 20, invention 15, systems view 15, language 15 and restraint 10, with code quality treated as a floor rather than a score. Check references across at least two functions. Remove single-round vetoes, which are how one interviewer’s cold read becomes the whole decision.
  8. Price offers on the matrix. In the section 4 matrix, a hire with fifteen or more years and four or five domains carries $670k to $840k of knowledge capital before AI, against $87k for a new graduate with one domain. Compensation bands keyed to title and tool tenure will lose those candidates to firms that pay for knowledge. Set bands by matrix cell.
  9. Hire juniors as apprentices. Size early-career hiring to the mentoring capacity of the senior bench, and pair every apprentice with a veteran. That is how the next generation of super-optimizers gets built.
  10. Measure the funnel itself. Track the mean modeled knowledge capital of each quarter’s hires and their share in the top-right of the matrix, against the candidate pool. If the funnel is hiring below the pool average, as the coding loop does here, it is destroying value at the front door.

9. Where it breaks

The model is mine, and its parameters are illustrative. The size of the firm-specific rent, the worker’s share of it, the leverage term and the AI multiplier on leverage are all assumptions. A = 1.5 in particular is a judgment about how far experienced knowledge reaches when it directs agents, and no study has measured it yet. The headline moves with these inputs, so I ran a sensitivity check (the script below, with 2,000 simulated people per firm, scaled to 10,000). Setting the AI multiplier anywhere from 1.0 to 2.0 puts the gap between $8.0 billion and $14.3 billion. Halving the leverage rent or raising it by half gives $6.4 billion to $15.9 billion. Moving the worker’s share of firm-specific rent from 0.2 to 0.6 gives $11.8 billion to $10.5 billion, and halving or raising the firm-specific rent by half gives $10.2 billion to $12.1 billion. Setting every one of those inputs at its pessimistic end at once still leaves a gap of $3.6 billion. The size is an assumption. The sign is not. A firm should calibrate the inputs to its own data before quoting its own number.

Sensitivity of the 10,000-vs-10,000 gap to the model's main assumptions.

import math
import numpy as np
import knowledge_value as kv
from dataclasses import replace

def gap(ai=True, **over):
    def fv(rng, n, er, br, mt):
        tot = 0.0
        for _ in range(n):
            e = rng.uniform(*er)
            ten = min(e, rng.exponential(mt / math.log(2)))
            p = kv.Person(experience=e - ten, breadth=int(rng.choice(br)), tenure=ten, quit=kv.quit_for(e))
            p = replace(p, **over)
            if ai:
                p = replace(p, ai_lever=over.get("ai_lever", 1.5), ai_novice=0.34 * 0.5)
            tot += p.value()
        return tot / 1e6
    rng = np.random.default_rng(1)
    y = fv(rng, 2000, (0, 8), [1, 1, 1, 2], 3.0)
    v = fv(rng, 2000, (20, 35), [3, 4, 5], 9.6)
    return (v - y) * 5  # scale 2,000 to 10,000

print(f"base (AI): {gap():.2f}B   base (no AI): {gap(ai=False):.2f}B")
for k, vals in {"ai_lever": [1.0, 1.25, 2.0], "lever": [75.0, 225.0], "beta": [0.2, 0.6],
                "S_max": [60.0, 180.0]}.items():
    print(k, [f"{x}: {gap(**{k: x}):.2f}B" for x in vals])
print("all low (lever 75, S_max 60, beta 0.6, A 1.0):", f"{gap(lever=75.0, S_max=60.0, beta=0.6, ai_lever=1.0):.2f}B")

The field evidence on AI is mixed in a way that matters. Brynjolfsson, Li and Raymond found the largest gains for novices, and if a firm’s work is mostly routine and inside the AI frontier, AI narrows the gap between a new graduate and a veteran rather than widening it. The thesis rests on the claim that the valuable work in most firms sits in cross-domain and novel problems. That is true of the knowledge-intensive firms this piece is about. It is less true of a call center.

Experience is a proxy, and an imperfect one. Twenty years of doing the same narrow job once is not the same as twenty years across domains, and some people stop learning. The matrix is built on breadth and depth for that reason, and hiring should measure both directly rather than reading them off a birth year. Age itself is never the criterion, and in the United States it would be an unlawful one.

The team simulation assumes that veterans catch the AI’s errors outside the frontier. Removing that assumption cuts their advantage from four to one down to about three to one in the simulation, but it does not reverse it.

A firm of veterans also has a pipeline problem. If nobody hires early-career people, nobody becomes a veteran. The model values a single firm, not the economy, and a firm that free-rides on others to train its future seniors is making a choice that does not work if everyone makes it. The apprentice model in section 8 is the answer, and it still hires juniors.

The Great Codification paper cited in section 2 is a new working paper that has not been peer reviewed, and I used it only for the direction of its findings. The tenure figures are national medians, not distributions.

10. The path forward

Knowledge and experience are the new super-optimizers, and a company can start optimizing for them this quarter.

Map the workforce onto the matrix. Pull years of experience and the domains each person holds at working depth from HR records, project histories and a short self-assessment checked by peers. Put headcount into the experience-by-breadth grid and compute knowledge capital per employee with the script in section 3. A firm that has hired for junior throughput for years will find much of its headcount near the bottom-left corner.

Price your veterans. For the twenty or thirty people whose departure would hurt most, estimate the cost of losing them with the same model and compare it with what you spend to keep them. At $499k to $613k per twenty-year veteran, a retention budget that looks generous on a compensation spreadsheet is usually cheap.

Change the hiring funnel. Retire the timed algorithm round for any role where execution is less than about two-thirds of the job, replace it with a paid work sample with AI allowed, and score range and framing explicitly. Hire experienced people across domains on purpose, and hire juniors as apprentices sized to your senior bench.

Change what you measure. Put value per problem closed, handoffs per cross-domain problem and judgment surface area on the same dashboard as throughput, then retire throughput as a target. Promote on leverage.

Then point the AI at the veterans’ knowledge. Every hour an experienced person spends turning what they know into prompts, evaluation sets and firm-specific tools raises the value of the data estate described in The Data Cap Rate and lowers the knowledge capital at risk when that person eventually leaves. The firms that win this decade will hold the most experience per head and connect it most tightly to their machines, and they will look smaller and older on paper than the competitors they beat.

Sources

About the Author

Brian James Curry is a data science and AI leader, hands-on machine learning practitioner, and published applied researcher. He is the founder of Vector1 Labs, an independent lab working on causal inference, marketing economics, cognitive AI architecture, complex systems, and the economics of intelligent automation.

His career combines sustained business and technical leadership across media, retail, industrial markets, hospitality, and telecom. His responsibilities have spanned marketing, operations, finance, sales, product strategy, and organizational development, including director-level leadership at McClatchy and management roles at AT&T and YP. That commercial foundation informs his approach to building data and AI capabilities around business decisions.

At Koch Ag & Energy Solutions, part of Koch Industries, Brian established the data science and ML practice from scratch. He combined practice leadership with hands-on data engineering, modeling, experimentation, and MLOps, leading large-scale initiatives with CEO-level visibility. He evaluated emerging technologies and vendors, integrated new capabilities into existing systems, and developed proofs of concept, frameworks, and tools with technology and research partners, including AWS.

At Tractor Supply Company, he helped lead the development of AI, ML, experimentation, and advanced analytics capabilities across Azure, Databricks, Snowflake, and open-source technologies. At Vail Resorts, he leads the Advanced Analytics/ML capability and the architecture and implementation of app analytics, aligning teams around use cases while delivering solutions across large-scale datasets. Throughout these roles, he has combined future-state planning and technical direction with direct contributions to development and implementation.

His public open-source and private research portfolio includes Papilon, for causal modeling, marketing measurement, and complex-system simulation; PyCausalSim, for simulation-driven causal discovery and counterfactual analysis; OMNI Intelligence, for multi-model AI evaluation; and Memory-Node Encapsulation, for artificial episodic memory. Additional work explores semantic geometry, forecasting, emerging-signal detection, and the economic effects of intelligent automation.

In 2016, Brian founded KC AI Lab, originally the Kansas City Machine Learning Group. The community grew to more than 1,500 practitioners, supporting education, collaboration, and exploration of emerging AI technologies.

He holds a BS in Economics from Kansas State University, where he was a collegiate athlete. He is a musician, composer, and painter, has trained in Brazilian Jiu Jitsu, and is the father of two. He lives in Kansas City.

Vector1 Labs: https://vector1.ai

Substack: https://brianjamescurry.substack.com

Medium: https://medium.com/@brian-curry-research

GitHub: https://github.com/Bodhi8

Related research