Git worktrees shipped in July 2015, in git 2.5. I ignored them for a decade, and so, statistically speaking, did you. Not out of principle. They solved a problem I did not have: one repository, one working directory, one of me.

Today my repositories look different. There is a checkout where an agent is refactoring a parser, a checkout where another agent is chasing a flaky test, and a checkout where I am reviewing what a third one did an hour ago. Several branches move at once on the same repository, and my job has quietly become hopping between them: review a diff here, run the code there, test a PR before merging it next door.

Here is the part worth staring at. Nothing in git changed. The worktree code that nobody wanted in 2015 is, for all practical purposes, the worktree code that everybody suddenly needs in 2026. No redesign, no relaunch, no v2. A feature sat dormant for ten years and then got promoted overnight, and the diff that promoted it touched zero lines of git.

The Lazy Explanation

"AI made worktrees popular" is true the way "water caused the flood" is true. It names the event and explains nothing. The interesting questions sit underneath it: why was a well-designed feature dormant for ten years, and what, precisely, changed on the day it stopped being dormant?

It was not the feature. So it must have been the user.

Priced in a Scarce Currency

Every tool is designed against an implicit economics: what its user has in abundance, and what its user lacks. For seventy years, the user of software was a human, and the economics of a human are remarkably stable. We can be in exactly one place at a time. We do not sustain tedium. We decay at maintaining conventions. None of this is an insult; these are the load-bearing facts that every interface, every default, and every "best practice" quietly assumes.

Which means every feature has a price tag, denominated in one of three human currencies:

• Singularity. The feature pays off only if you can be in several places at once. Worktrees bill here: maintaining five checkouts is pointless when there is exactly one of you to sit in them.
• Patience. The feature works, but demands tedium that no human sustains. git bisect run bills here: the bisect was never the hard part, writing the throwaway test harness was.
• Discipline. The feature pays off only if maintained perfectly, forever. Machine-readable docs and metadata conventions bill here: they are only as good as their staleest entry.

A feature that bills heavily in a currency its user does not have stays niche, no matter how well designed it is. That is the whole story of the dormant decade. Then a new kind of user arrived, one that is plural, tireless, and incapable of boredom, and every price tag in the ecosystem silently re-priced itself.

Biology Got There First

There is a name for this, and it comes from evolutionary biology. In 1982, Stephen Jay Gould and Elisabeth Vrba coined exaptation: a trait evolved for one purpose, later co-opted for another. Feathers are the canonical example. They evolved for thermoregulation, and only later were they conscripted into flight. The feather did not change on the day it started flying. The use changed, and the feather turned out to have been an aviation technology all along, waiting several million years for a wing worth attaching to.

Technology does this constantly, and we keep being surprised by it:

• GPUs were built to rasterize triangles for games. CUDA shipped in 2006 as an expensive bet that someone, someday, would want all that parallel arithmetic for something else. In 2012, AlexNet won ImageNet trained on two consumer gaming cards, and the entire deep learning era has run on exapted gaming hardware since. Feathers for warmth, then flight.
• Unix pipes were imagined by Doug McIlroy in 1964 as a way for a human at a terminal to couple programs "like garden hose." The human at the terminal is long gone from most pipe invocations; pipes became the plumbing of scripts and CI, driven by a reader that never once sat down.
• HATEOAS is my favorite, because it spent two decades as a punchline. Roy Fielding insisted in 2008 that REST APIs must be hypertext-driven: self-describing, discoverable, navigable by following links. The industry's answer was that nobody follows the links. Human developers read the docs and hardcode the URLs, so the discovery layer was dead weight. Then LLM agents arrived, and it turns out MCP is functionally HATEOAS reborn: a client that genuinely reads the self-description and follows the links. The API style was waiting for its reader for twenty years.
• RSS was declared dead somewhere around the Google Reader funeral. It is coming back, because an agent monitoring the web wants exactly what RSS always offered: structured, chronological, pull-based content with no engagement algorithm in the middle.

The pattern generalizes into a claim I am prepared to defend: the most consequential technology shifts are not inventions but re-readings. The artifact stays put; a new actor walks in and reads it differently.

The Affordance Was Always There

Psychology has a word for this too. James J. Gibson, in 1979, defined an affordance as what the environment offers an animal, and he was precise about where it lives: not in the object, not in the animal, but in the relationship between them. A doorknob affords turning to a hand. It affords nothing to a snake. Crucially, in Gibson's formulation, the affordance exists whether or not anyone perceives it. Don Norman, who imported the term into design and then spent decades cleaning up after it, split off a second concept for the perceivable part: the signifier, the cue that tells an actor the affordance is there.

That distinction does real work here. The agent-affordance of git worktrees existed, fully formed, from the day git 2.5 shipped. It sat in the binary for ten years, unperceived, because every signifier in the ecosystem pointed at humans: the man pages, the tutorials, the blog posts, all addressed to a singular reader who had no reason to care. When the new actor arrived, no code shipped and no changelog entry appeared. The affordance landscape of every tool on your machine re-ranked itself silently, the way a landscape re-ranks when a new species shows up: same rocks, different niches.

This is why the shift feels so strange. We are used to change arriving as releases. This one arrived as a re-reading.

The Re-Pricing, Observed

None of this is hypothetical; the receipts are piling up.

Worktrees went first-party: Claude Code, Cursor, and Codex all now create isolated worktrees per agent as a built-in, and orchestrators like Claude Squad sit at eight thousand GitHub stars for doing little else. CLI vendors are retrofitting their output for the new caller: Arcjet redesigned theirs around the observation that "humans like tables, agents like JSON," Speakeasy added --non-interactive escape hatches after watching spinners confuse the parsers, and Stripe's CLI docs now list agents as a supported caller class alongside CI. The docs story is the steepest curve of all: AGENTS.md went from an OpenAI blog post in August 2025 to the Linux Foundation in December 2025, donated alongside Anthropic's MCP. A README convention acquired a foundation in four months.

And the patience currency is producing the most satisfying results of the lot. Property-based testing, the approach that was always correct and always skipped because nobody wants to hand-write generators and invariants, is being done at scale by agents: an Anthropic and Hypothesis collaboration filed 984 bug reports across a hundred popular Python packages, with fixes landing in NumPy. Google's OSS-Fuzz has LLMs writing fuzz harnesses for code no human ever bothered to fuzz, and one of those harnesses surfaced a bug that had been sitting in OpenSSL for roughly twenty years. Two decades of dormancy, ended by a user with infinite patience.

Honesty requires the counter-evidence too, because the re-pricing is not clean. Some practitioners who went all-in on parallel worktrees walked it back to a plain shared folder; others found the disk cost genuinely obnoxious. And the most instructive failure is llms.txt: a format deliberately designed for AI readers, adopted by tens of thousands of sites, and measurement after measurement finds the files going almost entirely unread. Sit with that one for a moment. The accidental exaptations are thriving while the purpose-built offering gathers dust. Feathers were not designed for flight either. You cannot schedule an exaptation, and the new user, like every user before it, did not read the roadmap.

When a Feature Gets Promoted, Its Missing Furniture Shows

Promotion exposes gaps. A feature used twice a month can be missing half its ergonomics and nobody files the bug; a feature used thirty times a day cannot hide anything.

Git, it turns out, has no verb for moving into a worktree. Why would it? Nobody hopped between them daily. So the daily ritual in the agent era became: run git worktree list, squint at the rows, copy a long unmemorable path, assemble a cd by hand. Fine at 2015 frequency. A tax at 2026 frequency.

I got tired of paying it and built worktree-jumper: type wtj, pick a worktree from a list, and your shell lands there. It is a small tool, and both of its design decisions only make sense in the new economics.

The first is an old constraint: a child process cannot change its parent shell's directory, so the binary itself never moves you. It prints, and a tiny shell function that you eval at startup does the moving. The second is the one I care about. wtj is a picker, not a fuzzy finder, on purpose. A fuzzy query assumes you can recall the name of the thing you want. But the branches in my repositories are named by agents now, and you cannot recall a name you never chose. You can only recognize it in a list. Recognition over recall is the oldest heuristic in usability, and the agent era gave it a new bite: even the names in your repository are no longer priced for human memory.

There is an irony here that I refuse to leave unmentioned. I wrote a whole post about how your CLI has a second user who cannot press the arrow keys, and then I shipped an interactive-only tool, arrow keys and all. A tool created by the agent era that agents cannot operate. That is not an oversight; it is the point. The agents never needed help moving between worktrees, they were born plural. The picker serves the one participant in the room still doing the hopping.

Where the Lens Points Next

A pricing model you cannot bet with is just a metaphor. So here are the bets, each one falsifiable, each one an application of the same rule: find a feature that bills in singularity, patience, or discipline, confirm it is still dormant, and predict its promotion.

git bisect run gets delegated. Automated regression hunting has been in git for the better part of two decades and is, as of this writing, still dormant; I went looking for evidence of an agent-driven revival and found essentially one anecdote. The rule says that cannot last. The cost was never the bisect, it was the patience to write a throwaway test harness, and harness-writing is now free. "Find the commit that broke this" becomes a sentence you say to an agent, and bisect run becomes something you delegate rather than perform.

git notes becomes the provenance layer. It is the mechanism git has always had for attaching metadata to commits without rewriting history, and it stayed dormant because it bills in pure discipline: a metadata layer is worthless unless maintained perfectly, forever. It is already twitching: git-ai records which lines an agent wrote into refs/notes/ai, surviving rebases and squashes. Agent provenance wants exactly this shape, and agents can afford exactly this upkeep.

Property-based testing jumps ecosystems. Python has already flipped; the JavaScript side (fast-check and friends) shows, as of this writing, no comparable uptake. I could not find evidence of the shift having started, which by the logic of this post is precisely what a feature looks like the year before its promotion.

And the long shot, flagged as such: literate programming. Knuth's idea failed twice over, because no human sustains interleaved prose and no human reads it. It now has, for the first time, both a tireless writer and a reader that reads everything. This is the bet I am least confident in, and the llms.txt story explains why: it requires the new user to want it, and exaptations, as established, do not take requests.

Every Delight Is Perishable

Look back at what got promoted: worktrees, porcelain output, exit codes, docs conventions, fuzz harnesses, maybe notes and bisect next. Every single one is contract-shaped. Not one of them is delight-shaped. The tasteful boxes, the animated spinners, the fuzzy-search prompts, the entire decade of CLI craftsmanship that made terminals pleasant, none of it got re-priced upward, and some of it now actively confuses the parsers.

Gibson's definition was the warning, if we had read it as one: the affordance never lived in the object. It lived in the relationship between the object and a particular actor. Which means "good design" was never a property of your software either. It was a property of your software's relationship with a specific kind of user, and that user no longer works alone. The parts of our tools we are proudest of are priced in a currency only humans spend, and the humans are becoming a minority of the callers.

So the honest closing thought is not advice, it is a wager. Somewhere in your stack, right now, is a feature you have ignored for ten years, and it is the most important feature you own. You will not find it by asking what a better version of you would use. It was never waiting for a better version of you. It is waiting for someone else.