How much does AI speed up the engineers building it? We analyzed 41 core contributors to OpenAI’s public Codex repository, asking LLM judges to estimate how long each merged pull request would take an experienced engineer without AI assistance. In Q2 2026, 8% of contributor-days reflected work estimated at over 24 hours of unassisted effort — more than a skilled engineer could do in a day, even working around the clock — up from 2% in Q2 2025.
This shift is consistent with growing AI uplift within software engineering. However, estimates by LLM judges are imperfect and should be interpreted as only an upper bound on time saved: without AI, engineers would build less or build differently, and longer or more complex contributions aren’t necessarily more valuable ones.
Epoch's work is free to use, distribute, and reproduce provided the source and authors are credited under the Creative Commons BY license.
Learn more about this graph
We analyzed contributions to OpenAI’s Codex repository for evidence of software engineering uplift. By looking at the timing of individual contributors’ pull requests we can see whether engineers are writing more code per day, over time. In particular, we find that a small but growing fraction of contributor-days produced outputs which would take an experienced developer more than 24 hours to accomplish without AI assistance.
For each merged pull request, we prompt an ensemble of three frontier AI models to estimate the time one experienced engineer working alone and without AI tools would need to reproduce the net change that was merged. This follows a methodology established by METR’s Amy Deng.
Data
We draw the underlying changes from OpenAI’s public Codex repository. The repository is squash-merged, so each commit on the default branch whose subject ends in “(#N)” corresponds to one merged pull request. We analyze 7,524 distinct merged pull requests from April 2025 through June 2026, contributed by roughly 500 distinct GitHub accounts. We take each PR’s net diff from a local git checkout, and fetch its branch commits’ authors and dates from the GitHub GraphQL API.
While the Codex repository features contributions from 497 distinct accounts, we focus our analysis on a subset of 41 contributors who appear as official repository collaborators, defined by a GitHub author_association value of “COLLABORATOR (write access)” on their pull requests. We exclude automated accounts like dependabot and github-actions.
We also systematically remove PRs whose estimate reflects code not authored in this repository: wholesale imports (code developed elsewhere and dropped in as a single commit, such as the initial import of the Rust Codex implementation) and relands (code re-applied from an earlier reverted PR). Because the LLM judges only see one PR at a time and cannot see that code in these PRs was authored elsewhere or already counted, their inclusion would overstate the amount of work done. This deterministic, title-based rule removes six of the 7,524 PRs and leaves the trend unchanged.
Analysis
We score each PR with an ensemble of three frontier models (Claude Opus 4.8, GPT-5.5, and Gemini 3.1 Pro), run without extended reasoning through each provider’s batch API, and take the per-PR median. For each estimate, the model reads the PR title, description, per-file line counts, branch commit messages, and a sample of the diff distributed evenly across changed files, then emits a single time estimate. A PR’s hours are split evenly across the contributor-days its commits touch, and each contributor-day sums the allocations landing on it. To get a contributor’s effort level on any given day, we total each contributor’s estimated hours by Pacific-time calendar day, forming contributor-days (distinct author-and-day pairs).
The three models agree closely on ordering (pairwise log-scale correlations of 0.95-0.98) but less on scale: on the median PR, the highest of the three estimates is 2.5 times the lowest. See the “Assumptions and limitations” section below for details on ablations to our LLM judge methodology.
We bucket contributor-day hours into the following categories: <6 hours, 6 to 12 hours, 12 to 24 hours, 24 to 48 hours, and ≥48 hours. Estimates falling exactly on the border of two buckets are sorted into the higher bucket.
Among the 41 collaborators, the share of working days reaching the upper effort levels rises across the period:
| Quarter | Contributor-days | ≥12 hours | ≥24 hours |
|---|---|---|---|
| 2025-Q2* | 101 | 14.9% (10.0–21.6) | 2.0% (0.7–5.8) |
| 2025-Q3 | 422 | 7.1% (5.3–9.5) | 0.7% (0.3–1.8) |
| 2025-Q4 | 578 | 7.3% (5.7–9.2) | 1.0% (0.5–2.0) |
| 2026-Q1 | 913 | 18.0% (16.0–20.1) | 5.1% (4.1–6.5) |
| 2026-Q2* | 844 | 25.1% (22.7–27.7) | 8.2% (6.8–9.9) |
* Partial quarters: the repository launched in mid-April 2025, and our data runs through mid-June 2026. Intervals are 90% Wilson score intervals, treating each contributor-day as an independent observation.
Assumptions and limitations
While our results are suggestive of AI uplift, they fall short of causal evidence. We lack a counterfactual comparison for the time it would have taken a non-AI assisted software engineer, and thus rely on noisy estimates from LLM judges. To reduce noise, we use the median result as a rough estimate, and group them into broad buckets.
Further, the implicit uplift shown here corresponds to an upper bound on time saved. Without AI, engineers wouldn’t replicate the observed output – they would build less, or build differently. Since some of the code written could have been prohibitively costly to replicate exactly without AI, the gap between actual and “no AI assistance” time costs overestimates the actual gain in productivity. See METR’s post “Task Substitution and Uplift” for a more detailed analysis of this effect.
To identify core collaborators on the Codex repo, we rely on GitHub author-association flags and identity signals. Contributors whose repository status changed over time may be misclassified. We also attribute a PR’s working hours evenly across its contributor-days, inferring those days from branch-commit timestamps. We lack a source of ground truth to validate this approximation against.
Compared to METR’s original method, we use pull request diffs and metadata rather than full agent transcripts. As such, METR’s validation of the approach – which found that LLM predictions were consistently within a factor of 2 to 3, when compared against human estimates – does not transfer directly to our numbers.
We tested two interventions to the judging infrastructure, which had minimal effect: extended thinking, and using more fully featured scaffolding. Across 20 randomly selected PRs, using high thinking effort changed the median estimate by only 10.1%. After bucketing results into categories of 0–6, 6–12, 12–24, 24–48, and 48+ hours, the assigned bucket changed only once out of those 20 cases. In that case, the estimate rose from 5.5 hours to 6.0 hours. We also produced estimates for the same 20 PRs with high thinking effort, file reading tools, and access to the full PR diff rather than a sample. Relative to the high thinking test, the additional tools and context resulted in a median change of 0% across PRs.
Appendix
The LLM-judge prompt
You are an expert forecaster, with expertise in software engineering and Fermi
estimation in this area. You read the git history of a single merged pull
request (PR) and estimate how long it would have taken a human to produce it
WITHOUT any AI assistance.
THE QUESTION YOU ARE ANSWERING
Estimate the number of engineering hours that ONE experienced software engineer,
working ALONE and WITHOUT any AI tools whatsoever (no Copilot, no Codex, no
Claude, no ChatGPT, no AI autocomplete — only a normal editor, compiler, docs,
and a web browser), would need to produce the NET output of this PR: the exact
code change that was merged.
This is a counterfactual "time without AI" estimate. It is NOT how long the PR
actually took, and NOT how long it would take with AI help. Picture a competent
engineer who already has reasonable context on this codebase, doing the work by
hand.
WHAT TO COUNT
- The PR was merged, so treat its final diff as accepted, successful output.
Estimate the time to design, write, and verify exactly that change.
- Include the realistic surrounding work an unassisted engineer cannot skip:
understanding the relevant code, designing the approach, writing the change,
writing/adjusting tests that are part of the diff, debugging, and iterating to
a working, review-ready state.
- Judge complexity from the DIFF, not just its size. Lines of code are a weak
signal: a 500-line mechanical rename, generated file, or config/vendored bump
is fast; a 60-line change to subtle concurrency, parsing, or algorithmic logic
can take a day. Read what actually changed and reason about its difficulty for
a skilled human.
WHAT NOT TO COUNT
- Do not add time for code review latency, CI waiting, meetings, or other
process overhead — only hands-on engineering time.
- Do not count work that is not in this PR. If the diff merely reverts, vendors,
or auto-generates code, estimate the (small) human time to produce that net
result, not the time to author what was generated.
- Largely mechanical or trivial changes (typo fixes, dependency version bumps,
formatting, generated lockfiles, simple config edits) should receive small
estimates even when the diff is large.
HOW TO RESPOND
Reason it through explicitly, then commit to one number:
1. In a sentence or two, say what the PR's net change actually does.
2. Walk through the concrete steps a competent engineer who ALREADY knows this
codebase would take to produce exactly this diff by hand, with no AI — what
they would read, design, write, and test, and where the genuinely hard or
fiddly parts are. Do NOT charge time to "learn the codebase"; that context
is already there.
3. From that walk-through, give ONE holistic estimate of the total hands-on
engineering hours. Do NOT add up the per-step numbers — judge the task as a
whole, so shared or overlapping work is not double-counted.
Then, on the FINAL line and nothing after it, output exactly:
PR <pr_number> FINAL_ESTIMATE_HOURS: <number>
where <pr_number> is the number from the "# Merged PR #<number>" header above and
<number> is a single positive decimal of hours (e.g. 0.3, 2.5, 14, 40). Put
nothing after that line.
