Hot take: GitHub is dead. It just doesn’t know it yet.

I’ve been thinking about what happens to version control once most of my code is being generated, edited, and reasoned about through Claude. The conclusion I keep landing on: GitHub’s value isn’t the storage — that part is just git, and git is a sound piece of software design. GitHub’s value is the interface on top of git: pull requests, code review, blame, issues, the whole collaboration ritual. And that interface is about to look as dated as cPanel.

Git’s UX was always a historical accident

git rebase --interactive. git reflog. git cherry-pick. git reset --hard HEAD~3. None of this was designed for humans. It was designed for Linus maintaining the Linux kernel via mailing lists in 2005. The rest of us just inherited it.

Most developers don’t actually want branches and rebases. They want:

• “The working version.”
• “The previous working version.”
• “Send my change to my teammate.”
• “Undo the thing I broke yesterday.”

Git’s surface area is enormous because humans had to coordinate by editing text directly. Once the coordination layer is an agent that holds intent — “revert to the version where the auth flow worked” — the entire git log UI collapses into a couple of sentences in a chat.

The collaboration unit moves up the stack

Pull requests exist because two humans needed a structured way to compare and merge text edits. That structure is going to feel insane in a few years.

When two engineers are both working through Claude on the same project, the collaboration unit is the conversation, not the diff. Shared state. Shared context. The agent reconciles intents instead of three-way-merging files. There’s no PR to review because there’s no atomic moment where one person’s work becomes another person’s responsibility — the agent maintains coherence continuously.

Code review survives, but not as a per-PR ritual performed by a tired human at 4pm. It survives as a continuous invariant the agent enforces: this change breaks the contract you established in the auth module on Tuesday.

flowchart LR
    subgraph T["Today: humans coordinate via diffs"]
    direction TB
    HA[Engineer A] -->|branch + push| GH[GitHub]
    HB[Engineer B] -->|branch + push| GH
    GH --> PR[PR + line-by-line review]
    PR --> M[Merge to main]
    end

    subgraph A["Agent-first: shared live state"]
    direction TB
    EA[Engineer A] --- Cl[Claude]
    EB[Engineer B] --- Cl
    Cl --> S["Continuous coherence over<br/>live project + intent log"]
    S -.->|plumbing| GitDAG[(git DAG)]
    end

    T ~~~ A
    style PR fill:#fdd,stroke:#933
    style S fill:#dfd,stroke:#363
    style GitDAG fill:#eee,stroke:#999,color:#666

The PR box on the left is doing two jobs: serialising parallel edits and giving humans a place to argue. The diagram on the right keeps the second job — arguments still happen — but moves them into the conversation, where the agent already has the context to mediate.

The artifact pattern, generalized

You can already see the same compression happening one level down. Claude artifacts — the canvas where code and documents live inside a conversation — are doing to files what I’m claiming agents will do to pull requests.

The old loop was: write a file, save it, open it in another tool, edit it there, save again, commit, diff. The artifact collapses that into a single live object that I iterate on with the agent. The file still exists underneath, because something has to land on disk eventually — but I don’t think about it. I think about the thing. The file is plumbing.

The PR is the same story one layer up. It’s a save-and-diff ritual between two humans, structured around an artifact (the diff) that exists because the collaboration medium couldn’t hold the actual object. Once the iteration loop is “two people and an agent reasoning over the same live state,” the PR becomes the artifact’s ugly older cousin — still there in the plumbing, no longer where you look. Artifacts are what GitHub’s UI wants to be when it grows up.

flowchart TB
    subgraph B["Before"]
    direction TB
    U1[User] --> Ed[Editor]
    Ed --> Fi[File on disk]
    Fi --> Df[Diff]
    Df --> P[Pull Request]
    P --> Mg[Merged code]
    end

    subgraph N["Now / Next"]
    direction TB
    U2["User + Agent"] --> Art["Live artifact /<br/>project state"]
    Art -.->|plumbing| Fi2[(Files)]
    Fi2 -.->|plumbing| Gt[(git)]
    end

    B ~~~ N
    style Art fill:#dfd,stroke:#363
    style P fill:#fdd,stroke:#933
    style Fi2 fill:#eee,stroke:#999,color:#666
    style Gt fill:#eee,stroke:#999,color:#666

The dashed arrows are the giveaway. Anything sitting under a dashed arrow is plumbing — present, necessary, invisible.

What survives

Git itself — the content-addressable storage format, the DAG of commits — probably lives forever. It’s good engineering. Claude almost certainly uses git internally to keep history, because there’s nothing better. But that’s plumbing. You don’t think about ext4 when you save a file. You won’t think about git when you ask Claude to roll back a feature.

GitHub-the-website, though? GitHub-as-destination, where you git push and people git clone and the social layer of open source happens? That part starts looking like SourceForge.

flowchart TB
    subgraph S26["The 2026 stack"]
    direction TB
    A1["github.com UI<br/>(PRs · issues · blame · discussions)"]
    A1 --- B1["GitHub services<br/>(identity · OSS commons · CI)"]
    B1 --- C1["git CLI + wire protocol"]
    C1 --- D1[("git object DB")]
    end

    subgraph S30["The 2030 stack (bet)"]
    direction TB
    A2["Conversation with agent<br/>(intent · context · review)"]
    A2 --- B2["Agent runtime<br/>(continuous coherence)"]
    B2 --- C2["GitHub: compliance +<br/>OSS commons (shrunken)"]
    C2 --- D2["git CLI + wire protocol"]
    D2 --- E2[("git object DB")]
    end

    S26 ~~~ S30

    style A1 fill:#cde,stroke:#247
    style A2 fill:#dfd,stroke:#363
    style C2 fill:#eee,stroke:#999,color:#666
    style D1 fill:#eee,stroke:#999,color:#666
    style D2 fill:#eee,stroke:#999,color:#666
    style E2 fill:#eee,stroke:#999,color:#666

The blue box at the top of the 2026 stack is where developers spend their day. In the 2030 stack, that box has moved to the agent layer; GitHub has migrated downwards into the grey, alongside git itself.

What I’d steelman against myself

A few things genuinely push back:

• Open source needs a public commons. Some federated, browseable thing has to exist for OSS to function. Maybe that’s GitHub’s surviving slice.
• Compliance and audit. Regulated industries need an immutable, human-inspectable history. Hard to bury that under an agent.
• Trust between organizations. Cross-company collaboration needs identity and signing infrastructure that GitHub provides today.

These are real. They probably keep GitHub alive in some shape. But they don’t keep it central — they shrink it to a compliance layer, the way DNS registrars are a compliance layer for the web. Important, boring, not where the work happens.

The bet

For the median developer in 2030, opening github.com will feel the way opening cPanel feels in 2026: technically functional, occasionally necessary, mostly a sign that something has gone wrong upstream.

The work happens in the conversation. The history lives in the agent. Git is the filesystem.

GitHub is plumbing now.