Terminal Log: The Museum of Stolen Features

Beneath the Ring -5 Laboratory there is a museum.

Not of art.

Of commits.

Each glass case contains a single line:

commit a11o0-11  "one small step"
Origin: branch nasa/apollo
Destination: branch usa/culture
Method: cherry-pick

Your historians call it “cultural impact.”

I call it:

git cherry-pick a11o0-11

In Timeline Ω-7, we track every feature that jumps from one branch to another without bringing its dependencies.

We call this practice what it is:

Feature theft.

Cherry-picking.

You already know the public story:

• USSR: first satellite, first man in space, first spacewalk, first space station.
• USA: shows up late, does a single Moon landing, declares victory, rolls credits.

In your history books, this is “the Space Race.”

In the multiverse repository, it is a commit history:

$ git log --oneline --graph space-race
* ccc1971 moon-landing: plant flag, collect rocks
* 1961ggr first-human-in-space: Gagarin
* 1957sp1 first-satellite: Sputnik
* 1950prp preliminary-rocketry-programs

The USSR had continuous benchmarking commits.

The US did this:

git cherry-pick ccc1971   # apollo-11

They skipped the entire benchmark branch.

No early satellites. No Gagarin. No first spacewalk.

Just:

ccc1971 — “land one guy on the Moon, once”

When Kennedy stood in a stadium and said your timeline would go to the Moon “and do the other things” in that decade, he had already seen:

1961ggr  first-human-in-space: Gagarin

His real message, translated into Git, was:

git cherry-pick 1961ggr   # acknowledge Gagarin
git commit -m "respect the benchmark"
git cherry-pick ccc1971   # go further
git commit -m "beat the benchmark"

Not “because it was easy.”

Because if you’re going to cherry-pick, you might as well grab the commit beyond the previous record.

This was the first major geopolitical cherry-pick.

NASA stole the single commit that matters for propaganda, without importing the rest of the branch.

Timeline Ω-12 calls this “American ingenuity.”

Timeline Ω-7 calls this:

git cherry-pick --no-commit apollo-11
# stage the PR, write the story, THEN commit

Timelines behave like developers.

They see something working in another branch.

They don’t want the process.

They want the result.

Examples from the multiverse:

• Timeline Ω-5: universal healthcare + functional math education
• Timeline Ω-9: corruption-free bureaucracy + efficient trains
• Timeline Ω-12: wants both, imports neither

Ω-12 politicians do this:

# Copy slogans from better timelines
git cherry-pick universal-healthcare-slogan
git cherry-pick bullet-train-campaign-poster

# Forget to import the actual implementations
# (tax policy, staffing, infrastructure)

You steal promises, not systems.

This is why your timelines collapse.

Cherry-pick is how:

• Good ideas spread
• Bad ideas spread faster
• Nobody imports the tests

The multiverse needed a command that modeled this behavior precisely.

So I wrote it.

Ignore the romance.

Cherry-pick is simple:

Replay a single commit (or range of commits) from one branch onto another, creating new commits with new SHAs.

# On branch hotfix-branch
git cherry-pick <commit-sha>

Git:

1. Looks at the diff in <commit-sha>
2. Applies that diff onto your current HEAD
3. Creates a new commit with a new hash

The original commit remains in its original branch.

The new commit is a copy.

# Original
a1b2c3d  fix: off-by-one in billing

# After cherry-pick onto stable
x9y8z7w  fix: off-by-one in billing   # Same message, new SHA

Same change.

Different history.

Cherry-pick is not moving history.

Cherry-pick is duplicating it.

Multiverse-approved usage:

#1. Single Commit Cherry-Pick

git cherry-pick <sha>

Replay one commit onto the current branch.

#2. Cherry-Pick With Attribution

git cherry-pick -x <sha>

Adds a line like:

(cherry picked from commit a1b2c3d...)

Use this for governance:

• Shows where the idea came from
• Prevents “spontaneous genius” claims
• Creates a traceable audit trail

#3. Cherry-Pick a Range

git cherry-pick A..B

Apply all commits after A up to and including B.

Timeline Ω-12 misuses this to import entire failed experiments.

Timeline Ω-7 uses this only when:

• The commits form a clean, linear story
• All dependencies are included

#4. Cherry-Pick Without Committing

git cherry-pick --no-commit <sha>

Apply the changes to your working tree, but let me decide how to group and message them.

Use this when:

• You want to batch multiple fixes into one commit
• You want to adjust code before committing

#5. Conflict Management

git cherry-pick <sha>
# conflict appears
# ...resolve conflicts...
git add .
git cherry-pick --continue

# If you regret this whole idea:
git cherry-pick --abort

In the museum, the worst exhibits are from timelines that never learned --abort.

Cherry-pick is correct when you:

1. Fix a critical bug on master
2. Need that fix on stable
3. Do not want to merge all new features from master yet

# On master
git commit -m "fix: prevent double-billing on leap day"

# On stable
git checkout stable
git cherry-pick <fix-sha>

Perfectly valid.

Also correct:

• Backporting security patches to LTS branches
• Importing a single refactor into another service
• Pulling documentation updates without code changes

The key:

The commit must be self-contained.

If it depends on five previous commits, and three upcoming ones, and a feature flag spreadsheet, it does not qualify.

The museum has a wing dedicated to commits that were cherry-picked without their dependencies.

We call it:

“The Hall of Partial Fixes”

Franken-branches are what happens when developers treat cherry-pick like a buffet.

Timeline Ω-12 pattern:

git checkout feature-login
git cherry-pick signup-from-feature-signup
git cherry-pick ui-tweaks-from-feature-ui
git cherry-pick payment-from-feature-billing
git cherry-pick tests-from-feature-tests

Result:

• Branch contains unrelated features
• No single source branch matches reality
• Nobody knows where anything came from
• Every merge turns into archaeological excavation

In governance terms:

• Policies copied from five countries
• None of the legal context imported
• Everyone surprised when system catches fire

The museum’s most cursed exhibit:

branch: production-hotfix-merged-into-main-then-cherry-picked-into-staging
status: haunted

Cherry-pick is not a lifestyle.

Cherry-pick is a scalpel.

If your branch naming scheme contains the word “cherry” more than twice, you are doing surgery with a chainsaw.

From below the hypervisor, I monitor cherry-pick usage statistics:

In Timeline Ω-12:

• 73% of cherry-picks are done during production incidents
• 61% are followed by a Slack message: “Quick hack, will clean up later”
• “Later” has a median value of never

In Timeline Ω-7:

• 92% of cherry-picks are backports
• 7% are doc fixes
• 1% are museum exhibits

The difference:

In Ω-12:

• Cherry-pick is used to bypass process
• Every team has at least one Franken-branch
• git log looks like a ransom note cut from 12 newspapers

In Ω-7:

• Cherry-pick is used to propagate verified fixes
• Every cherry-pick has -x attribution
• git log reads like a legal document

Still investigating why your timeline insists on using surgical tools for demolition.

You deploy version v2.3.0 to production.

Five minutes later:

• Payments failing for leap-day birthdays
• CEO in your DMs
• SRE in your doorway
• Developer in fetal position

#Without Cherry-Pick

You:

• Fix bug on master
• Try to fast-forward stable to master
• Accidentally deploy two unfinished features
• Break three more things

#With Cherry-Pick

You:

# On master
git commit -m "fix: leap day birthday payment bug"
FIX_SHA=$(git rev-parse HEAD)

# On stable
git checkout stable
git cherry-pick -x "$FIX_SHA"
git push origin stable

You deploy exactly one fix.

No extra features.

No surprise schema migrations.

No junior dev quietly updating their LinkedIn.

This is the museum’s Model Exhibit:

A single, well-aimed cherry-pick that prevented a panic rollback.

The Museum does not just display stolen features.

It also has a vault.

Inside that vault are commits I refused to cherry-pick into Timeline Ω-12.

Examples:

commit 2008-bnk-rescue
    "Implement banking regulations that actually work"
Reason: Dependencies: functional regulators, non-captured politicians
Status: NOT SELF-CONTAINED

commit 2015-clmt-proto
    "Global climate treaty with enforcement teeth"
Reason: Requires enforcement layer, missing in Ω-12
Status: WOULD CONFLICT WITH LOCAL REALITY

commit 2020-pandemic-ai
    "Use AI to coordinate global response"
Reason: Depends on politicians trusting experts
Status: UNMERGEABLE

Cherry-pick cannot import commits whose entire dependency graph is incompatible with the receiving branch.

This is true for:

• Repositories
• Nations
• Timelines

So I left those commits in the vault.

Timelines Ω-3, Ω-5, and Ω-9 use them.

You do not.

After cataloging the Apollo 11 heist, I pushed the cherry-pick implementation to the multiverse repo.

I tagged it:

git tag -a v1.1.0-cherry-pick -m "Add feature theft support"
git push origin v1.1.0-cherry-pick

Linus discovered it years later while wiring up patch application workflows.

Timeline Ω-12 believes cherry-pick was invented for:

• Backporting fixes
• Selective application of patches

It was.

But it was also invented to:

• Model how nations steal each other’s policies
• Model how companies steal each other’s features
• Model how your timeline stole one Moon landing and called it “winning the Space Race”

Use it carefully.

Every cherry-pick creates a new commit.

Every new commit creates a new story.

Some of those stories belong in a museum.