Eight weeks ago, a productivity floor moved. It hasn’t moved back.
That’s the entire piece, really. The rest is just showing the work.
On March 24, 2026, a single change went live — the platform we call real-time intelligent context engineering; the Loop, for short. The week the Loop went live, my public GitHub contribution calendar logged 599 contributions. The seven weeks after: 776, 845, 1,098, 1,817, 1,852, 1,484, 893.
That’s a trailing-eight-week average of ~1,170 contributions per week, sustained. Not a one-week spike. A new baseline that hasn’t drifted back to the prior level in any week since the Loop went live.
I wrote a longer piece on April 1 about the first 52 weeks of public data showing two productivity step-changes. That post is still up, with an editor’s note now sitting on top. This post is the May update — same data source, eight more weeks of evidence, a much sharper read on what actually happened.
Three eras, on one chart
The /proof page shows the full trailing twelve months. Three colors, three distinct eras:
Gray — the pre-intelligence baseline. May 12 to November 2, 2025. Twenty-six weeks of solo work across multiple codebases. No intelligence-context infrastructure underneath, and — honest about this — no enforced structure either. I was an individual contributor with no review process, no conventions persistence, no compounding across weeks. Output looks like exactly that: bursts of high activity, quiet stretches between, holiday troughs. Average across the window: ~100 contributions per week. The 8-person team baseline on the chart is not a fair comparison at this stage — a team brings discipline that solo-coder me didn’t. The point of this phase isn’t that I was outperforming a team. The point is that nothing compounded, because there was nothing under the work doing the compounding.
Orange — intelligence work began, Loop not yet live. November 9, 2025 to March 15, 2026. Nineteen weeks where the substrate underneath the Loop was being built — storage, retrieval, the classifier itself. The mechanism wasn’t yet running on every request, but the work itself was structured around building a real platform, which forced some of the discipline a platform demands. Average across this window: ~210 contributions per week. Now the team-baseline comparison starts to become fair: this is structured platform work, the kind a team produces.
Blue — Loop live. March 22, 2026 onward. Eight weeks and counting. Average: ~1,170 contributions per week. Same operator. Same hours. The structure underneath the work is now the Loop itself — every request goes through the same disciplined cycle, every output runs against quality criteria, every gated outcome feeds the classifier.
The dated inflection
March 24 is the precise edge. Before that date, the Loop was being built. After it, the Loop was running on every request.
What “the Loop” does, as plainly as it can be said:
- Classify. Every request gets pre-classified in milliseconds before the model runs. The classifier produces a structured directive that tells the model how to approach the work before reasoning begins — the model starts working immediately, instead of figuring out what kind of work the turn is while doing it.
- Deliver. Only the context this specific turn needs gets delivered — assembled in real time, routed to the model just-in-time. Without the Loop, every turn pays a context tax in reasoning tokens, fetch tokens, and retries when the first fetch was wrong. With the Loop, the model goes straight to the work.
- Execute. The agent doesn’t free-run. It works through a structured phase template with enforced planning, so the work proceeds in disciplined steps rather than a single uncontrolled pass.
- Shape. Every output runs against quality criteria set before the work began. The output either meets the gate or it doesn’t ship. Every PASS or FAIL is recorded with evidence.
- Learn. Every gated outcome becomes a signal that feeds the classifier. The next request starts smarter than the last one. The cycle doesn’t just repeat — it levels up.
Five stages, running on every request, every session, every supported AI surface. That’s the mechanism whose dated arrival on March 24 the chart is tracking.
What “holding the floor” actually means
A one-week spike is meaningless. A floor that holds for eight straight weeks at roughly ten times the prior level is something else.
Here’s the math, stated honestly:
- The lowest week since March 22 (Mar 22 itself, the inflection week): 599 contributions — already 3× the prior intelligence-work average of ~210, and 6× the pre-intelligence baseline of ~100.
- The highest week (April 26): 1,852 contributions — roughly 18× the pre-intelligence baseline.
- The 8-week trailing average: ~1,170 contributions per week.
Compare that to an industry reference for what a typical disciplined 8-person dev team produces in a week: ~80 contributions per week total (commits, PRs, issues, and reviews combined), derived from DORA / State of DevOps / GitHub Octoverse benchmarks.
One operator running the Loop is producing roughly 14× a typical 8-person team’s combined output, sustained over two months.
That’s the ceiling, demonstrated.
Reading the conservative claim
The site says a team running the Loop should plan for a 1.5× to 3× sustained throughput multiplier. Some readers ask where that number comes from. Here’s the derivation, from the same chart:
| Operator weekly | vs. ~80/wk team baseline | |
|---|---|---|
| Pre-intelligence (May–Nov 2025) | ~100/wk | 1.25× |
| Intelligence work, pre-Loop (Nov–Mar) | ~210/wk | 2.6× |
| Loop live (Mar 24 – present) | ~1,170/wk | ~14× |
Two things stand out.
First, even before the Loop ran on every request, the same operator running the intelligence-work substrate averaged 2.6× a typical team. So the 1.5–3× claim a budgeted team should plan for sits well below what one operator showed pre-Loop, and dramatically below what one operator shows post-Loop. It’s the conservative range — explicitly so.
Second, this is one operator. The 1.5–3× team claim assumes that conventions, reviews, and onboarding compound at the team level the way one operator’s work compounds at the individual level. That assumption is reasonable but not yet quantitatively proven. Customer team data will close that loop as more teams adopt the Loop. Until then, the 1.5–3× number is the budgetable floor; the operator data is the existence proof that the mechanism delivers at least that much.
What the chart doesn’t measure
Public GitHub contribution counts capture commits to default branches, pull requests, issues, and code reviews. They do not capture the rest of what got built alongside the platform in the same hours: ~90,000 words of researched, EEAT-optimized content across two complete websites and twenty-four pages; production infrastructure rollout and deployment automation; customer-facing operational systems; data pipelines, analytics, and reporting; system design, competitive analysis, go-to-market planning, and investor materials.
Code velocity is the measurable signal — public, dated, week-by-week verifiable. The full productivity story is bigger. The chart shows the floor; what was built on top of that floor spans engineering, content, infrastructure, and strategy.
Why I keep showing my own data
A reader could fairly ask: why isn’t this just survivorship-bias self-promotion?
Two answers.
First: same operator, same skills, same week-by-week effort, only the mechanism underneath changed. That’s the cleanest single-variable comparison a product company can make. Customer team data will eventually replace it. Until that data is in, my own trailing-twelve is the most controlled comparison available.
Second: it’s all public. Anyone can pull gh api graphql and verify the weekly buckets against this post. The methodology is on /proof and the verification path is laid out there too. The contribution calendar is the audit trail.
What comes next
Eight weeks is enough to establish a floor. Twelve weeks will be enough to call it durable. The next milestone on this chart is whether the trailing-eight-week average stays north of 1,000 contributions per week through the end of June.
It will. The mechanism that produced the eight weeks doesn’t have a reason to stop running.
If you want to see the live chart, the methodology, and the team-baseline citation, /proof carries the canonical version. If you want to see what the platform actually does on every request, /how-it-works walks through the five stages.
If you want to try the Loop on your own work, private access is open by application.
The floor your AI ships from today is lower than it needs to be. The chart you just read is what it looks like when a floor moves and stays.