Vector 1
Organizations & Work

Data Science Is Jazz, and Your Engineers Can’t Play It

Brian J. Curry
Brian J. Curry
October 11, 2026 · 39 min read

Why breakthrough data, analytics and AI work is improvisation built on theory, why your most technical hires deliver your most average outcomes, and how to hire the people who can actually play. For practitioners, hiring managers and executives.

The Reality of Data Science Work Today

Most enterprise data and AI work fails, and it rarely fails for technical reasons. RAND interviewed 65 experienced data scientists and engineers about why AI projects collapse. The most common root cause was that stakeholders misunderstood or miscommunicated the problem the project was supposed to solve.

The generative AI wave repeated the pattern at larger scale. MIT’s Project NANDA reported in 2025 that only 5% of custom enterprise AI tools reach production. Its authors blamed brittle workflows and poor fit with real operations, not weak models.

Organizations keep staffing these failures with the wrong people. They treat advanced analytics, machine learning and data science as an engineering discipline, so they hire engineers. Engineers are trained to turn a specification into working software. At the frontier of data work, there is no specification.

The work is jazz. The theory is real and non-negotiable: the chord changes, the scales, the statistics and the linear algebra. But the value is created in what you play over the changes, in real time, listening to the room.

And the work is far more than models. It spans the whole arc: choosing the question worth answering, designing how to measure it, running the experiment, building the model or the analysis, reading the result honestly and changing a decision because of it. The model is one instrument in the band. The breakthroughs usually come from the question, the framing and the abstraction that reveals a problem’s real structure, long before anyone writes training code.

At the senior end, the role looks less like a modeler and more like a systems architect. Advanced practitioners stitch together cognitive systems: people, data, models, AI agents and decision processes that have to think together across departments. They find new patterns and invent new methods for problems that are systemic, spanning pricing, operations, marketing and finance at once. No ticket describes that work, and no specification can.

Stated plainly: for the seat that decides which question matters, how to frame and measure it, which of a hundred defensible answers to trust and what the business should do next, pure software engineers and pure technicians are the worst hires you can make. They build excellent instruments. They rarely play. Teams built from them converge on the lowest common denominator: the obvious question, the default metric, the textbook model and the dashboard nobody acts on. They almost never produce the large, abstract breakthrough that moves a P&L.

The flip side is just as plain. The premium hires for this work are experienced operators with broad context: musicians, artists, writers and other divergent thinkers. Testing them like software engineers, with cookie-cutter coding interviews, is a recipe for failure and monotone output.

A growing chorus now declares data science dead, killed by AI that writes the code, cleans the data and fits the model. Listen to who is saying it. It is mostly the code monkeys: coders who migrated into data science over the past decade and were hired because they could pass a coding test, with careers built on writing code quickly, memorizing syntax and APIs, and reciting the standard method on cue. They match the weakest-hire profile later in this article almost exactly. For them, the obituary is accurate. The work they did is now done by a machine, and they will fail at what data science becomes.

What is dying is the technician’s version of the field, not the field itself. The code-monkey layer of memorized syntax, boilerplate pipelines and hand-written data wrangling is being absorbed into the tools, the way the calculator absorbed long division without ending mathematics. What remains, and grows, is the work that was always the point: framing the question, seeing the system, choosing among defensible answers and changing a decision.

Data science is moving from a coder-heavy technical practice to a systems practice built on divergent thinking. Its practitioners use AI the way a jazz musician uses an instrument: to play faster and range further, never to decide what to play. The field is not ending. It is changing hands, and the code monkeys who came in through the coding test are the ones who will be weeded out.

This article makes that case with a proposed model and its math, a runnable experiment, and the research behind four harder claims. Creativity and abstraction are formed, not installed. Universities train them out in favor of recall. Divergent thinking is the rarest input in the room, and advanced credentials select against it. And operators with 15 or more years of varied, consequential context are now the premium seat in applied AI. It closes with a hiring playbook you can use this quarter.

The Frame: A Team Is Worth Its Best Idea

A team’s output is set by its best idea, not its average idea. The best idea depends more on how different the ideas are than on how good each one is.

Every hard data problem can be attacked from several directions: a different question, a different measurement, a different data source, a different framing or method. Usually one approach wins and ships. So the quantity that matters is the expected value of the best approach the team can find.

Here is a proposed model. A team generates N candidate approaches. Approach i is worth V_i = μ + σZ_i, where each Z_i is a standard normal draw and every pair of draws has correlation ρ. The correlation measures how alike the team thinks. Shared training, a shared toolkit and shared assumptions push ρ toward 1.

Here μ is the average quality of an idea, σ is the spread of quality, ρ is the correlation between ideas and e_N is the expected maximum of N independent standard normal draws. For N = 10, e_N ≈ 1.54. The intuition is simple: whatever the team shares lifts every idea equally, so it cannot help pick a winner. Only the independent part of each idea competes.

Now a worked example with ten people. The convergent team shares one degree path and one stack, so ρ = 0.8, and its ideas average 0.30σ better than the other team’s. The divergent team has the same technical floor but mixed backgrounds, so ρ = 0.2 and its average idea quality is 0.

The convergent team’s best idea is worth 0.30 + 1.54 × √0.2 ≈ 0.99. The divergent team’s best idea is worth 1.54 × √0.8 ≈ 1.38. The divergent team wins by 0.39σ even though its average idea is worse.

To break even, the convergent team would need every idea to be 0.69σ better on average. Put differently, ten people thinking at ρ = 0.8 produce a best idea worth less than three independent thinkers would (e_2 ≈ 0.56, e_3 ≈ 0.85).

Proposed model: the expected value of a team's best idea.

A team generates N candidate approaches. Approach i is worth
V_i = mu + sigma * Z_i, where the Z_i are standard normal with pairwise
correlation rho. Only the best approach ships.
Closed form: E[max V] = mu + sigma * sqrt(1 - rho) * e_N,
where e_N is the expected maximum of N independent standard normals.
"""
import numpy as np

def expected_max_iid(n, n_trials=400_000, seed=11):
    rng = np.random.default_rng(seed)
    return rng.standard_normal((n_trials, n)).max(axis=1).mean()

def best_idea_closed_form(mu, sigma, rho, n):
    return mu + sigma * np.sqrt(1 - rho) * expected_max_iid(n)

def best_idea_simulated(mu, sigma, rho, n, n_trials=400_000, seed=7):
    rng = np.random.default_rng(seed)
    shared = rng.standard_normal((n_trials, 1))      # common training, tools, priors
    own = rng.standard_normal((n_trials, n))         # what each person brings alone
    z = np.sqrt(rho) * shared + np.sqrt(1 - rho) * own
    return (mu + sigma * z).max(axis=1).mean()

if __name__ == "__main__":
    n = 10
    teams = {
        "convergent: same training, same toolkit": (0.30, 1.0, 0.8),
        "divergent: mixed backgrounds, same floor": (0.00, 1.0, 0.2),
    }
    print(f"e_{n} = {expected_max_iid(n):.3f}")
    for name, (mu, sigma, rho) in teams.items():
        print(f"{name:42s} closed form {best_idea_closed_form(mu, sigma, rho, n):.2f}"
              f"   simulated {best_idea_simulated(mu, sigma, rho, n):.2f}")
    e = expected_max_iid(n)
    print(f"break-even mean advantage: {e * (np.sqrt(0.8) - np.sqrt(0.2)):.3f} sigma")
    print(f"e_2 = {expected_max_iid(2):.3f}, e_3 = {expected_max_iid(3):.3f}")

The closed form and the simulation agree to two decimals: 0.99 and 1.38. The shared draw in the simulation is the part of everyone’s thinking that came from the same curriculum and the same tools. The model assumes normal tails, which understates the case. Real breakthroughs are heavy-tailed, and heavy tails reward independent search even more.

The result echoes a well-known formal finding. Lu Hong and Scott Page showed in PNAS in 2004 that a randomly selected team of problem solvers can outperform a team of the individually best performers. The reason is the same: the best performers become similar to one another, and that sameness costs more than their extra ability adds.

The Changes and the Solo

Jazz is the right model for data work because it is rigorous and improvised at once. A jazz musician who does not know the changes is not free; they are lost. A musician who only knows the changes is a metronome.

Neuroscience gives the metaphor some weight. Charles Limb and Allen Braun scanned professional jazz pianists with fMRI, published in PLoS ONE in 2008. Compared with playing memorized sequences, improvising quieted the dorsolateral prefrontal regions tied to self-monitoring. It activated the medial prefrontal region tied to self-initiated, internally generated behavior.

That is two modes of mind, and great data work needs both. The monitoring mode checks assumptions, validates pipelines and catches leakage. The generative mode invents the question nobody asked and the representation nobody tried. Pure technicians are trained almost entirely in the first mode. They execute the memorized sequence beautifully.

The practitioners’ literature says the same thing in plainer words. Pedro Domingos wrote in Communications of the ACM in 2012 that among projects that succeed or fail, “easily the most important factor is the features used.” Features are not code. They are a theory of the domain, written as variables.

The mapping from the bandstand to the work:

  • The changes and the scales: probability, statistics, linear algebra, causal inference, programming.
  • Listening to the room: understanding the business, the users and the decision on the table.
  • The head, the written melody: the question as the stakeholder first states it.
  • The solo: reframing the question, choosing the measurement, inventing the representation.
  • Reharmonization and the contrafact: abstraction. Seeing the structure under the data, and the same structure in another domain.
  • Arranging for the whole band: stitching people, data, models and AI agents into one cognitive system that works across teams.
  • Trading fours: fast iteration with stakeholders. Show, listen, revise.
  • Knowing when to lay out: knowing when the right answer is no model at all.

The first item is learnable by anyone disciplined. Everything after it, the solo and the listening, is where the value sits. It is also where pure technical training is silent.

Abstraction: play the function, not the notes

Jazz runs on abstraction. A great player hears a chord progression as a sequence of functions, tension and release, rather than a list of notes. Once the function is clear, the notes become negotiable.

Three moves from the bandstand show how. In a tritone substitution, a player replaces a dominant chord with the one a tritone away. The two chords share the same guide tones, the third and seventh that carry the tension, so the harmony keeps its function while every surface note changes.

In a contrafact, a new melody is written over an existing progression. Bebop players wrote so many tunes on the chord changes of Gershwin’s “I Got Rhythm” that musicians simply call them rhythm changes. Hear the changes and a new tune is instantly familiar. In modal playing, as on Miles Davis’s Kind of Blue (1959), a band replaces dense chord changes with a few modes held for long stretches: fewer states, more freedom inside each.

Complex-system data problems reward the same moves.

  • Guide tones are leverage points. A few variables carry a system’s behavior. Donella Meadows ranked the places to intervene in a system and put parameters and numbers dead last, while estimating that nearly all attention goes to them. Feedback loops, information flows, rules and goals carry the music. Pure technicians tune parameters. Abstraction finds the guide tones.
  • Substitution is measuring the function, not the surface. When the ideal metric cannot be observed, the abstract thinker substitutes one that plays the same role in the system, the same tension and release, rather than the one that merely looks similar.
  • The contrafact is structural isomorphism across domains: the same changes under a different melody.
  • Modal playing is regime thinking. Replace a thousand-feature description of a system with the handful of states it actually moves between, then model behavior within each.

Here is a contrafact in data. Frank Bass’s 1969 diffusion model describes how a new product spreads, with p for external influence such as advertising and q for imitation through word of mouth.

An epidemiologist modeling an outbreak with imported cases writes the same equation in different words: an importation rate in place of p, a transmission rate in place of q. The script below writes each system in its own vocabulary and runs both.

Same changes, different melody: a product launch and an outbreak.

A marketer models adoption with the Bass diffusion model:
    dF/dt = (p + q*F) * (1 - F)
    p = innovation (advertising), q = imitation (word of mouth)
An epidemiologist models an outbreak with imported cases:
    di/dt = (alpha + beta*i) * (1 - i)
    alpha = importation rate, beta = transmission rate
Written in their own vocabularies, they are one structure.
"""
import numpy as np
from scipy.integrate import solve_ivp

def bass_adoption(t, F, p, q):
    return (p + q * F) * (1 - F)

def outbreak(t, i, alpha, beta):
    return (alpha + beta * i) * (1 - i)

if __name__ == "__main__":
    p, q = 0.03, 0.38                     # typical durable-goods values, per year
    t = np.linspace(0, 20, 2001)
    launch = solve_ivp(bass_adoption, (0, 20), [0.0], t_eval=t, args=(p, q), rtol=1e-10, atol=1e-12)
    epidemic = solve_ivp(outbreak, (0, 20), [0.0], t_eval=t, args=(p, q), rtol=1e-10, atol=1e-12)

    gap = np.max(np.abs(launch.y[0] - epidemic.y[0]))
    rate = bass_adoption(t, launch.y[0], p, q)
    print(f"max difference between the two curves: {gap:.1e}")
    print(f"peak adoption rate at t = {t[np.argmax(rate)]:.2f} years "
          f"(closed form ln(q/p)/(p+q) = {np.log(q / p) / (p + q):.2f})")
    print(f"share adopted at the peak: {launch.y[0][np.argmax(rate)]:.2f} "
          f"(closed form (q-p)/(2q) = {(q - p) / (2 * q):.2f})")

With the typical durable-goods values p = 0.03 and q = 0.38, the two curves are identical to machine precision. Adoption peaks at 6.19 years, with 46% of the market already reached, exactly as the closed forms predict.

The equation is not the insight; recognizing it is. A practitioner who hears a product launch as an outbreak inherits nearly a century of epidemiology: superspreaders, adoption thresholds, targeted seeding, the timing of saturation. That leap is abstraction, and no amount of training inside one domain’s toolkit produces it.

Same Data, Different Music

The same dataset, handed to competent analysts, produces materially different answers. The data does not choose the answer. The analyst’s judgment does.

The definitive demonstration is the many-analysts study led by Raphael Silberzahn and Eric Uhlmann, published in 2018. Twenty-nine teams, 61 analysts in all, received one dataset and one question: do soccer referees give more red cards to dark-skinned players? The teams used 21 different combinations of covariates. Their estimates ranged from an odds ratio of 0.89 to 2.93, with a median of 1.31.

Twenty teams (69%) found a significant effect and nine (31%) did not. Neither the analysts’ prior beliefs nor their level of expertise explained the spread. Technical skill was not the variable that mattered. Framing was.

The effect is easy to reproduce. The script below asks one question of scikit-learn’s bundled diabetes data, 442 patients with 10 baseline measures: how much does disease progression rise per standard deviation of BMI? It then runs every specification a careful analyst could defend.

Specification multiverse: how many defensible answers does one dataset give?

Question: how much does disease progression rise per 1 SD of BMI?
Dataset: scikit-learn's bundled diabetes data (442 patients, 10 baseline
features, outcome = disease progression one year later). No download needed.
Every specification below is one a competent analyst could defend.
"""
from itertools import combinations, product

import numpy as np
from sklearn.datasets import load_diabetes
from sklearn.linear_model import HuberRegressor, LinearRegression

data = load_diabetes(as_frame=True)
X, y = data.data, data.target
controls = ["age", "sex", "bp", "s1", "s5"]           # candidate adjustment set
outcomes = {"raw": y, "log": np.log(y)}                # target transform
trims = {"keep all": np.ones(len(y), bool),            # outlier rule
         "drop |z|>2.5": np.abs((y - y.mean()) / y.std()) <= 2.5}
models = {"OLS": LinearRegression,
          "Huber": lambda: HuberRegressor(max_iter=1000)}

def bmi_effect(cols, target_name, keep, model_name):
    Xs = X.loc[keep, ["bmi", *cols]]
    Xs = (Xs - Xs.mean()) / Xs.std()                   # effect per 1 SD
    yt = outcomes[target_name][keep]
    fit = models[model_name]().fit(Xs, yt)
    beta = fit.coef_[0]
    if target_name == "log":                           # back to % change
        return 100 * (np.exp(beta) - 1), "%"
    return 100 * beta / y.mean(), "%"                  # raw units as % of mean

results = []
for k in range(len(controls) + 1):
    for cols in combinations(controls, k):
        for t, trim, m in product(outcomes, trims, models):
            eff, _ = bmi_effect(list(cols), t, trims[trim], m)
            results.append(eff)

results = np.array(results)
print(f"specifications: {len(results)}")
print(f"BMI effect, % change in progression per 1 SD:")
print(f"  min {results.min():.1f}  median {np.median(results):.1f}  "
      f"max {results.max():.1f}  ratio max/min {results.max() / results.min():.2f}")

The run produces 256 specifications. The estimated BMI effect ranges from 17.8% to 37.9% per standard deviation, with a median of 23.9%. The largest defensible answer is 2.1 times the smallest, from one clean, public dataset with no missing values.

Which answer is right depends on a question no library can settle. Blood pressure may sit on the causal path from BMI to disease progression. Adjust for it and the simple OLS estimate falls from 29.7% to 24.7%; adjust for all five controls and it falls to 18.8%. Whether that adjustment is correct is a judgment about the body and the decision being made, not about the code.

Scale that up to an enterprise: dozens of systems, shifting definitions, feedback loops between teams. The space of defensible answers widens, and the person choosing among them matters more than the person typing them.

Why Pure Technicians Converge

Pure technical teams converge on average outcomes for four reasons. They are trained toward one correct answer, hired through a filter that rewards sameness, placed in the wrong position in the organization’s network, and sold a skill that AI is making cheap.

Trained for the spec

Software engineering turns a specification into correct code, and a test suite says whether it worked. Data work rarely has that oracle; the experiment above has 256 passing implementations. Engineers carry the spec habit into ambiguity: take the request as written, reach for the standard tool, optimize the stated metric.

RAND’s interviews name this exact anti-pattern. Failing projects chase the newest technology instead of the problem, and the successful ones stay fixed on the problem itself. A team that starts from the tool will reliably find a use for the tool.

The coding interview manufactures sameness

Most technical hiring still runs through closed-book algorithm puzzles, and the evidence against them is old and consistent. In a 2013 New York Times interview, Google’s Laszlo Bock said the company’s data showed brainteasers predicted nothing, and that it had found a “zero relationship” between interviewers’ scores and later performance. The industry copied Google’s interview and ignored Google’s retraction.

The tests are not even reliable on their own terms. An interviewing.io analysis of 299 interviews found only about 25% of candidates performed consistently across interviews. Strong candidates, averaging around 3 on a 4-point scale, could fail a single interview up to 22% of the time.

The mismatch is structural. The job is exploratory and open-book; the test is closed-form, closed-book and timed. Modern AI writes the optimal puzzle answer in seconds, so a clean pass now certifies a depreciating skill. It is a legacy-skill assessment.

The deeper damage is to ρ. Hire everyone through the same puzzle bank and the team shares one way of thinking, which in the frame above pushes ρ toward 1. The filter admits the code monkeys and rejects the improvisers. It works as an adverse-selection engine pointed at the employer’s own future. Over the past decade it waved a generation of software engineers into data science on the strength of puzzle scores alone, and that cohort is now the most exposed in the field.

Wrong position in the graph

Earlier Vector1 Research work modeled the organization as a directed multigraph of human and AI nodes, O = (V, E, τ, ω), and classified the human personas that make it work. Breakthroughs in systemic problems come disproportionately from two of them. Bridges span the gaps between clusters. Vacuum Nodes pull new knowledge in from outside the organization.

Network research backs this up. Ronald Burt studied 673 supply-chain managers at a large US electronics company (American Journal of Sociology, 2004). Managers whose networks spanned structural holes were more likely to have their ideas rated valuable by senior judges. They also earned more, received better evaluations and were promoted more often.

The personas that matter, and how often a pure technician fills them:

  • Bridge (high betweenness, low clustering): connects marketing, operations and finance data and sees the systemic pattern. Rarely a pure technician.
  • Vacuum Node (many edges across the organization’s boundary): imports methods from economics, epidemiology, ecology and music. Rarely a pure technician.
  • Orchestrator (high out-degree on delegation edges): designs human and AI workflows and stitches the cognitive system together. A pure technician can orchestrate pipelines, rarely decisions.
  • Gardener (creates edges between other nodes): grows the network that lets an insight travel and get used. Rarely a pure technician.
  • Expert Hub (high in-degree within one domain): deep technical calibration and the quality gate for outputs. A strong fit for a pure technician.

The pure technician is typically an Expert Hub: deep, valuable and local. Hire that persona to build and calibrate the instruments. Do not hand it the arrangement for the whole band.

The one thing they sell is getting cheaper

Generative AI is compressing execution skill. In a study of customer-support agents, Brynjolfsson, Li and Raymond found an AI assistant raised productivity 14% on average and 34% for novice and low-skilled workers, with minimal effect on experienced ones. AI packages the patterns of top performers and hands them to everyone.

The same compression is under way in code. When the pandas wrangling, the SQL and the scikit-learn pipeline are what AI writes best, hiring someone whose whole value is producing them means paying for a code monkey when AI is the cheapest, fastest code monkey ever built.

What Cannot Be Taught, and Where It Gets Trained Out

The capacities that produce breakthroughs, abstraction, creative reframing and taste, are formed over a life, not installed by a curriculum. Formal education does more to suppress them than to build them.

The decline starts early

Kyung Hee Kim of the College of William and Mary analyzed nearly 300,000 Torrance Tests of Creative Thinking collected from 1968 to 2008. Scores rose for decades, then began falling in 1990, and the decline appeared in every age group. It was steepest from kindergarten through third grade, the years when schooling shifts hardest toward standardized answers. Kim published the work as “The Creativity Crisis” in the Creativity Research Journal in 2011.

The university does not reverse it

Richard Arum and Josipa Roksa tracked more than 3,000 students at 29 four-year colleges and universities for Academically Adrift (2011). After two years, 45% showed little or no measurable improvement in critical thinking, complex reasoning and writing. After four years, 36% still showed no significant growth.

The mechanism is the grading model. Closed-form exams reward recall of the known answer and penalize the defensible alternative. Students learn that the scarce resource is the instructor’s expected response, then spend years optimizing for it. That is the same habit the coding interview selects for, and the same habit that fails in open-ended data work.

Credentials do not predict judgment

The many-analysts study makes the point sharply. Analysts ranged from doctoral students to full professors, yet neither expertise nor prior beliefs explained why their answers diverged. A degree certifies that someone learned the changes. It says nothing about whether they can play.

Divergent Thinking: The Rarest Input in the Room

Divergent thinking, the capacity to generate many genuinely different approaches to one problem, is the scarcest input in data and AI work. It is rare in adults, it erodes with formal schooling, and the PhD, the credential most often used to screen for it, tends to select against it.

Two kinds of thinking

Convergent thinking finds the one correct answer to a well-posed problem. Divergent thinking produces many possible answers to an open one, then finds the question behind the question. Exams, coding interviews and dissertations reward the first. Breakthroughs come from the second.

The frame makes the difference precise. Convergent skill raises μ, the average quality of an idea. Divergent capacity raises N, the number of genuinely distinct approaches, and lowers ρ, their correlation. The worked example showed that N and ρ beat μ when only the best idea ships.

Near universal at five, rare by adulthood

George Land designed a creativity test for NASA to select innovative engineers and scientists, then gave it to 1,600 children (Land and Jarman, Breakpoint and Beyond, 1993). At age five, 98% scored at the creative level. At 10, 30% did. At 15, 12% did. Among 280,000 adults, 2% did.

Land’s conclusion was that non-creative behavior is learned. Read alongside Kim’s Torrance data, the pattern is hard to miss: the capacity is nearly universal at five and rare by adulthood, and the years in between are spent in school.

More credentials, less of it

Dean Keith Simonton studied more than 300 eminent creators born between 1450 and 1850, including Leonardo, Galileo, Beethoven and Rembrandt. Creative eminence formed an inverted U against formal education. It peaked around the middle of college and declined with every level of schooling beyond that.

The most creative minds in that record had enough formal training to learn the changes and stopped before the training learned them.

Expertise entrenches

Merim Bilalić, Peter McLeod and Fernand Gobet gave chess players problems with a familiar but inferior solution and a better, unfamiliar one (Cognitive Psychology, 2008). With the familiar solution on the board, expert players performed like players roughly three standard deviations weaker. The known answer arrived first and blocked the better one.

A PhD is five or more years spent mastering one paradigm’s familiar solutions. It is the credentialed, institutional form of that trap: depth that makes the known answer arrive first and stay.

The academy rewards consolidation

Michael Park, Erin Leahey and Russell Funk analyzed about 45 million papers and 3.9 million patents across six decades (Nature, 2023). The disruptiveness of papers fell by 91.9% to 100% across fields from 1945 to 2010. For patents it fell by 78.7% to 91.5% from 1980 to 2010.

Work increasingly consolidates existing knowledge instead of redirecting a field, and researchers draw on narrower slices of what is already known. Publish-or-perish pressure leaves little time for wide reading. The institution that trains PhDs has spent sixty years producing steadily less divergence.

What the PhD actually certifies

The PhD certifies convergent mastery: the ability to extend a known paradigm rigorously. That is a real skill, and it belongs in the Expert Hub seat. It is not evidence of divergent capacity, and it is often evidence of the opposite. The many-analysts study already showed that credentials do not explain whose answers differ.

The rare divergent operator usually has a non-linear path: several industries, several disciplines, and a serious life in some other craft such as music, athletics or writing. What marks them is range, not rank.

How to see it

In the work sample, require three genuinely different approaches before the candidate chooses one, and count how many differ in kind rather than in parameters. Ask how an economist, an ecologist and a musician would each frame the same problem. A convergent thinker returns three versions of one pipeline. A divergent thinker returns three different questions.

Then test for abstraction, the partner of divergence. Ask what the problem is an instance of, and in which other field it has already been solved. Divergent thinking generates many approaches; abstraction recognizes which ones are the same tune in disguise and which are genuinely new.

The Fifteen-Year Ear

In applied AI, the premium operator is the practitioner with 15 or more years of varied, consequential context. Below that line, a practitioner is working with a handicap that AI widens rather than closes.

AI multiplies context, and zero context multiplies to zero

This builds on a series of earlier Vector1 Research essays. The first, “AI Is a 100X Multiplier, But 100 Times Zero Is Still Zero,” argued that AI amplifies what a person already brings. The second argued that AI ended Silicon Valley’s youth premium: the stamina to produce high volumes of code was the junior engineer’s main asset, and it is now the cheapest thing in the market. A third proposed measuring an organization’s collective context window as a core KPI.

As a proposed model, the value of AI-assisted work is roughly a product, V ≈ A × C. A is the multiplier the tools provide, and it is now close to equal for everyone. C is the context the human brings: problems seen, systems watched failing, domains connected. When A is the same across a team, the spread in outcomes is the spread in C.

Why fifteen years

Fifteen years is the operating threshold. It is roughly the time needed to see a domain through several technology eras and at least one or two downturns from a working seat. A practitioner who started in 2011 has lived through on-premise to cloud, classical machine learning to deep learning, and the generative AI wave, plus the 2020 shock.

That breadth is what lets an operator recognize a pattern from another era in today’s data. In the terms of the frame, it lowers ρ with the rest of the team, because the operator’s ideas come from somewhere the team has not been. It also raises N, because an experienced operator recognizes more candidate approaches before writing a line of code.

The market evidence points the same way. Pierre Azoulay, Benjamin Jones, J. Daniel Kim and Javier Miranda studied 2.7 million US founders using Census Bureau data on businesses launched from 2007 to 2014. Founders of the fastest-growing 0.1% of firms averaged 45 years old at founding. A 50-year-old founder was 1.8 times as likely as a 30-year-old to build one of them, and prior experience in the same industry more than doubled the odds.

English is the new code, and the logophiles hold it

Andrej Karpathy put the shift in one line in 2023: the hottest new programming language is English. In his 2025 Software 3.0 keynote at Y Combinator’s AI Startup School, he described LLMs as a new computer programmed in natural language.

Take that seriously and the talent map inverts. If the programming language is English, the strongest programmers are the strongest readers and writers. They are the well-read, broad-context people with large vocabularies and a habit of analogy across fields. They can specify a problem precisely, name a subtle failure, and recognize when fluent output is wrong.

The cognitive science lines up with this. Joshua Hartshorne and Laura Germine found, using data from nearly 50,000 online participants, that processing speed peaks around age 18 or 19 (Psychological Science, 2015). Vocabulary and crystallized knowledge kept rising, peaking in the late 60s or early 70s.

Put the two findings side by side. The timed coding puzzle tests the faculty that peaks at 19 and that AI has already replaced. The work now rewards the faculty that peaks near 70 and that AI cannot supply on its own. The older, creative logophile, well read, widely experienced and precise with language, is the top operator of the English-programmed computer.

Who Plays Best: The Premium Hire

The best data science, advanced analytics, ML and AI hires of the next decade will combine years of broad context, a serious creative practice and demonstrated divergent and abstract thinking. Testing them like software engineers is a recipe for failure and monotone output.

The profile

Four traits define the premium hire, and each one follows from the argument so far.

  1. Years and range: 15 or more years across technology eras, industries and functions. That is a larger C in V ≈ A × C, and a lower ρ against everyone else on the team.
  2. A serious creative practice: music, visual art, writing or performance, pursued for years. It is daily rehearsal of the loop the work demands.
  3. Divergent and abstract thinking: many genuinely distinct approaches to one problem, and the ability to hear the structure beneath the data.
  4. Command of language: when the programming language is English, precision in words is precision in the system.

Technical fluency is the floor. It is checked, not used to rank.

Best and worst backgrounds for the AI-augmented seat

The premium background and the weakest one differ on every dimension that now matters. Set side by side, the contrast is stark.

  • Experience. Premium: 15 or more years across technology eras, industries and functions. Weakest: three to five years out of school, one industry, one era.
  • Path. Premium: non-linear, crossing several disciplines such as economics, marketing, operations, music and data. Weakest: linear, from degree to PhD or bootcamp straight into a technical role.
  • Training. Premium: theory learned, then tested against real systems failing in real ways. Weakest: recall of known answers, with one paradigm mastered deeply in a PhD or one stack in software engineering.
  • Creative practice. Premium: serious music, visual art, writing or performance, pursued for years. Weakest: none, or kept walled off from the work.
  • Thinking mode. Premium: divergent and abstract; asks what the problem is an instance of. Weakest: convergent; asks which library solves it.
  • Relationship to AI. Premium: AI as a complement; directs it, questions it and hears the wrong note. Weakest: AI as a substitute; trusts fluent output and competes with it on execution.
  • Language. Premium: a precise reader and writer who specifies problems in English. Weakest: code-first, where the ticket is the specification.
  • Network position. Premium: a Bridge, Vacuum Node or Orchestrator. Weakest: an Expert Hub inside one cluster.
  • Context, C. Premium: large and diverse. Weakest: small and narrow.
  • Typical output. Premium: a reframed question, a method borrowed from another field, a decision changed. Weakest: the textbook model, the default metric and the dashboard nobody acts on.

Why musicians and artists

Robert Root-Bernstein and colleagues compared Nobel laureates in science with members of the Royal Society, the US National Academy of Sciences, Sigma Xi and the general public (Journal of Psychology of Science and Technology, 2008). Laureates averaged 0.94 arts or crafts avocations, against 0.33 for the average scientist, nearly three times as many.

The gaps by discipline are wider still. Compared with the average scientist, laureates were at least 2 times as likely to be practicing musicians, 7 times as likely to be visual artists, 12 times as likely to write poetry or fiction and 22 times as likely to perform.

The link is not decoration. A musician rehearses the exact loop this work requires: master the theory until it is automatic, improvise over it in real time, listen and adapt to the rest of the band, all under immediate feedback. A composer or arranger does systems work every day, holding many voices inside one structure and managing tension and resolution across time. That is the job of the person who stitches together a cognitive system across an organization.

Monotone in, monotone out

Generative AI pulls output toward the middle. Anil Doshi and Oliver Hauser had 300 writers produce short stories with and without AI-generated ideas (Science Advances, 2024). AI help raised novelty ratings for the least creative writers by 10.7%, yet the AI-assisted stories were more similar to one another. Each writer gained; the collection lost its range.

Every competitor now has access to the same models. If the humans are also selected through the same puzzle bank, then the ρ of the tools and the ρ of the team both climb toward 1. The organization ships the same features, the same dashboards and the same answers as its rivals. Differentiation lives almost entirely in people who bring different context and different abstractions to the same tools.

The widening gap

AI does not lift both personas equally. It moves them in opposite directions at once, and the gap between them grows with every improvement in the tools.

For the technical persona, AI is a substitute. The skill it sells, turning a clear specification into working code, is exactly what the tools now do best. The customer-support study showed AI packaging expert execution and handing it to novices. As the tools improve, execution moves toward a commodity price, and so does the persona whose value is execution.

For the divergent, broadly experienced logophile, AI is a complement. What this persona brings is context, abstraction, a precise command of language and an ear for when fluent output is wrong. Those are the inputs AI multiplies, so better tools raise the return on them.

The proposed model makes the divergence concrete. Take two practitioners with the same technical floor. The technician brings context C = 2 and the operator brings C = 8, in illustrative units. On execution work, AI makes the output nearly free for both, so neither gains an edge. On framing work, value is A × C.

With no tools, A = 1 and the gap is 8 − 2 = 6. At A = 5 the gap is 30. At A = 10 it is 60. The ratio stays fixed at four to one, but the absolute gap grows tenfold. Every improvement in the tools is a raise for the operator and a price cut for the code monkey.

The field evidence shows where the gap opens. Fabrizio Dell’Acqua and colleagues ran a preregistered experiment with 758 Boston Consulting Group consultants (Navigating the Jagged Technological Frontier, HBS, 2023). On 18 tasks inside AI’s capability frontier, consultants using AI completed 12.2% more tasks, worked 25.1% faster and produced significantly better work.

On a task just outside that frontier, consultants using AI were 19 percentage points less likely to reach the correct answer than those working without it. The frontier is jagged and invisible, and fluent output looks the same on both sides of it. Knowing which side a problem sits on is judgment built from context, which is the operator’s asset. The code monkey trusts the output. The operator hears the wrong note.

The cookie-cutter interview selects against all of it

The timed coding round screens out every trait in the profile.

  • Experience: it tests processing speed, which peaks around 18 or 19.
  • Range: a non-linear career or a non-computer-science background reads as a gap on the screen.
  • Creative practice: a lifetime of music or art is invisible to an algorithm score.
  • Divergence: it rewards the one known optimal answer and penalizes the alternative.
  • Language: it is closed-book code with no writing at all.

What survives the filter is a team of code monkeys and convergent specialists, screened identically and running identical AI tools. That is how an organization buys failure and monotone output at full price. The hiring process later in this article is built to find the opposite.

Who Plays Worst: The Weakest Hire for the AI-Augmented Seat

The weakest hire for the seat that frames problems is the code monkey, the context-light technician: three to five years out of school, a PhD trained in one paradigm, or a software engineer trained to the spec. Each brings exactly what AI now supplies and lacks exactly what AI multiplies.

The profile

Four traits define the weakest hire, and each is the mirror image of the premium profile.

  1. Little context: a few years in one industry and one technology era. That is a small C in V ≈ A × C, and a high ρ with everyone else hired the same way.
  2. A linear credential path: degree, then PhD or bootcamp, then a technical role, with no detour through another discipline or a business function.
  3. Convergent, single-paradigm training: rewarded for recalling the known answer and for depth in one method, one stack or one literature.
  4. Code-first, with no serious creative practice: the ticket is the specification, and nothing outside work trains the ear.

The recent graduate

Three to five years out of school, the recent graduate has the smallest context window in the building. Their strongest faculty is speed: processing speed peaks around 18 or 19, and the timed coding round rewards it.

That is exactly the faculty AI has overtaken. In the customer-support study, the AI assistant delivered its largest gains to novices because it packaged the patterns of experienced workers. The tools now hand everyone the execution a recent graduate was hired to supply. What remains scarce is the context they have not had time to build.

The graduate is also the hire most exposed at the jagged frontier. With little experience of systems failing, they have no reference point for when fluent AI output is wrong. Inside the frontier they look productive. Just outside it, they ship the error with confidence.

The PhD

The PhD is the most misread credential in data hiring. It certifies convergent mastery: years spent extending one paradigm rigorously. That is real depth, and depth of that kind is what the Einstellung research shows blocks the better, unfamiliar answer.

The broader record points the same way. Simonton’s eminent creators peaked at mid-college and declined with each level of schooling beyond it. The academy that trains PhDs has produced steadily less disruptive work for six decades while narrowing the knowledge each paper draws on. And in the many-analysts study, credentials did not predict whose answers diverged.

Inside an organization, the PhD tends to reproduce the dissertation: a sophisticated method applied to the question as given, optimized against the metric as given. The work is defensible and publishable. It rarely changes a decision.

The software engineer

The software engineer is trained to turn a specification into correct code, and is usually hired through the puzzle bank that rewards it. In data work there is no specification, so the engineer supplies one: the request as written, the standard tool and the stated metric. RAND’s failure research describes the outcome, projects that chase the technology instead of the problem. This is the migration wave of the past decade: engineers who moved into data science because they could pass its coding test, and who were never asked whether they could frame a problem. They are the code monkeys of the field, and they will be the first weeded out.

In the AI era the engineer’s core product is also the one AI substitutes most directly. When the programming language is English, writing code from a clear spec is the commodity layer. The engineer is an excellent Expert Hub and builder of instruments. Placed in the framing seat, the engineer builds the instrument and never plays it.

Four examples from the field

These composites show the pattern in practice. Each is common, credentialed and well paid, and each lacks the breadth the seat requires.

The five-year FAANG engineer. Five years at a top technology company, promoted on schedule, fluent in distributed systems and the internal toolchain. They have shipped at enormous scale, but always against a specification written by a product manager, inside infrastructure built by thousands of others. Hired into an analytics or AI leadership seat at a retailer or manufacturer, they rebuild the data platform first, because that is the problem they know how to solve. Eighteen months later the platform is excellent and no business decision has changed. Scale is not context. Five years inside one company’s systems is one era, one industry and one way of working, however impressive the logo.

The new graduate with an advanced degree. A master’s or PhD in machine learning, a strong publication or two, top of the class. They know the newest architectures cold. They have never watched a forecast fail in a recession, sat in a pricing meeting or seen a model quietly decay as customer behavior shifted. They bring the most sophisticated method in the room to the question exactly as first stated, and they optimize the benchmark metric, because that is what graduate school graded.

The veteran of the coding moat. Twenty years in, but every year spent in the same lane. This is the person who could write the hardest code, owned the legacy system nobody else understood and gated every change to it. Their moat was the scarcity of a technical skill, and AI is draining it: code that once only they could write, a model now drafts in seconds. This persona proves the experience thesis is about range, not years. Fifteen years of one skill repeated is one year of context, lived fifteen times.

The memorizer. The code monkey in its purest form, with a career built on recall: certifications stacked, algorithms memorized for interviews, frameworks and theories recited on command. They excel at every closed-book test the industry offers, because every one of those tests rewarded exactly this. But recall is the first thing AI made free. A model retrieves any algorithm, theory or API instantly and without fatigue. A career built on remembering answers has nothing left to sell when the answers are free, and nothing in it ever trained the skill of asking a new question.

What the weakest hire produces

The signature is consistent across all three backgrounds.

  • The question answered exactly as it was asked, never reframed.
  • The default metric optimized, whether or not it drives the decision.
  • One approach, executed well, with no alternatives considered.
  • The method from the last project or the dissertation, applied again.
  • AI output accepted at face value, including outside the frontier.
  • A model or dashboard that is technically sound and changes nothing.

Multiply that by a team hired through one filter and running one set of AI tools, and the result is the monotone output this article opened with.

How to spot it in an interview

The weakest hire shows the same tells in every loop. They ask for the exact specification before engaging with the problem. They name a library or a model before they name a question. They offer one approach and defend it rather than generating three. They cannot describe a system they watched fail outside their own stack. Their written specification for an AI agent is vague where it needs to be precise.

None of this is a judgment of talent. The same people make excellent Expert Hubs who build and calibrate the instruments. It is a judgment of fit for the seat that frames problems, arranges the cognitive system and decides what the organization does next.

Hiring for the Bandstand

Hire for the solo with a structured interview and a realistic, AI-allowed work sample, scored against a written rubric. Drop the algorithm round for any seat that frames problems.

What the selection science says

The most rigorous recent review is Sackett, Zhang, Berry and Lievens in the Journal of Applied Psychology (2022). Correcting a long-standing statistical overcorrection, they lowered most validity estimates by 0.10 to 0.20. Structured interviews came out on top at 0.42, with an 80% credibility interval of 0.18 to 0.66. Work samples landed at 0.33 and general cognitive ability at 0.31.

Validity converts directly into the quality of the people hired. If a firm hires the top 10% of applicants on a score with validity r, the average hire lands r × 1.755 standard deviations above the average applicant’s job performance. At r = 0.42 that is 0.74 standard deviations. At Bock’s “zero relationship,” it is nothing at all.

The process

  1. Remove the algorithm puzzle for research, analytics and strategy seats. Keep a short, open-book code review for instrument builders.
  2. Run a paid, timeboxed work sample of 2 to 4 hours on a messy, systemic problem with several data sources and no stated question. Allow AI explicitly, because the job does.
  3. Put most of the weight on a structured debrief. Ask every candidate the same three questions: why this approach, what did you validate, and where does this analysis break?
  4. Add a writing test, because English is now the code. Have the candidate write the specification an AI agent would need to run the analysis, then score its precision.
  5. Ask structured context questions: describe a system you watched fail, from two eras of your career. Ask for one method borrowed from outside the field. That is the Vacuum Node test.
  6. Check the network signal. Ask for references from at least two different functions; Bridges are known on both sides of the gap.
  7. Compose the team for low ρ. Mix personas and backgrounds deliberately, and keep the Expert Hubs building and calibrating the instruments.

The rubric

  • Framing, 25%: restates the problem as a sharper question than the one given.
  • Systems view, 20%: names feedback loops, incentives and second-order effects across teams.
  • Measurement, 15%: chooses what to measure and explains what the metric will miss.
  • Alternatives, 15%: considers several defensible specifications and says why one wins.
  • Language, 15%: writes a precise, testable specification for people and AI agents.
  • Restraint, 10%: knows when the answer is a simpler analysis or no model at all.

Code quality is not on the list. It is a floor checked in the open-book review, not a differentiator scored against judgment.

The Path Forward

The organizations that win the next decade of applied AI will staff the solo with experienced, broad-context improvisers and give them excellent instruments. Each audience has concrete moves to make this quarter.

Executives should audit where their data and AI initiatives actually stall. If the answer is the question, the framing or adoption, more engineering headcount will not fix it. Fund a small number of senior, systems-minded operators with cross-functional reach, and treat retaining them as a strategic priority, because each departure takes context the organization cannot rebuy.

Hiring managers should stop hiring code monkeys for framing seats, retire the algorithm round this quarter and replace it with the paid work sample and structured debrief described above. Measure team ρ informally: list how each person was trained and hired, and count how many arrived by the same route. If most did, the next hire should come from somewhere else.

Practitioners should run the multiverse script on their own flagship analysis and report the range, not just the point estimate. They should read far outside the field, write more and with more precision, and build a record of systems they have seen fail. In an era when English is the programming language, range and language are the technical skills.

The changes still matter. Nobody plays jazz without them. But the value was never in running the scales. It was always in what a seasoned player does over them, listening to the room.

Sources

Brian Curry writes on applied AI, analytics and the economics of data work at Vector1 Research. Subscribe on Substack at brianjamescurry.substack.com.

Related research