Fork a Corporation

In 2008, a developer named PJ Hyett pushed a button on GitHub and forked a Ruby library. He didn’t need to call anyone. He didn’t need permission. He didn’t need a lawyer. He took an existing body of work, made a copy, and started building on it. This act — trivial, instantaneous, free — is the foundational gesture of the open-source revolution.

Twenty years later, starting a corporation still requires a lawyer.

Not because the legal concepts are complicated. The Delaware General Corporation Law is well-understood. Standard bylaws exist. Boilerplate articles of incorporation have been refined over decades. The knowledge of how to form and govern a corporation is not scarce. What’s scarce is the infrastructure to encode that knowledge into something executable.

Until you can fork it.

Templates are just the beginning

The obvious application of version-controlled governance is templates. Want to start a standard Delaware C-Corp with a four-year vesting schedule and a standard protective provisions package? Here’s a repo. Clone it. Fill in your names. Done.

This is useful, and it’s something TheCorporation supports today. But it’s also the least interesting implication.

Templates give you a starting point. Forks give you something more powerful: a living lineage.

The governance graph

When you fork a software project, your fork maintains a relationship with its upstream. You can pull improvements. You can contribute back. You can see who else forked the same project and what they changed. The ecosystem of forks creates a graph of experimentation — a distributed search over the space of possible designs.

Now imagine the same dynamic for corporate governance.

A group of founders forks a governance template that includes standard bylaws, a four-person board structure, and monthly compliance cycles. Six months later, they’ve adapted it: they added a provision for asynchronous board votes, changed their fiscal year to match their industry’s cycle, and built a custom equity vesting schedule tied to revenue milestones instead of time.

These adaptations are visible. They’re diffs. Other founders starting similar companies can look at what changed and why. They can cherry-pick the innovations that work for them. The collective intelligence of every corporation on the platform improves the options available to the next one.

This isn’t hypothetical. It’s how open-source software works. The only reason it hasn’t happened for corporate governance is that governance has never lived in a forkable medium before.

Democratizing corporate sophistication

Today, the quality of your corporate governance is directly proportional to how much you can afford to pay lawyers. A well-funded startup gets meticulously drafted documents, carefully structured equity plans, and governance frameworks that anticipate problems before they occur. A bootstrapped founder gets LegalZoom.

This is indefensible. The knowledge required to govern a corporation well is not proprietary. It’s the product of centuries of case law, statutory refinement, and practical experience. Locking it behind billable hours doesn’t protect anyone — it just means that the companies least able to afford mistakes are the ones most likely to make them.

Forkable governance inverts this. The best governance structures — the ones that have been tested, refined, and proven in practice — become available to everyone. Not as a paid template or a gated playbook, but as a living repository that anyone can clone, inspect, and adapt.

A first-time founder in Lagos should have access to the same governance infrastructure as a repeat founder in Palo Alto. Not access to the same advice — advice requires context and judgment. Access to the same machinery. The same bylaws, the same equity structures, the same compliance automation, the same agent configurations.

Branches as governance experiments

In software, you don’t ship directly to production. You create a branch, make your changes, test them, get a review, and merge. If something goes wrong, you revert.

Corporate governance should work the same way.

Want to experiment with a new compensation structure? Branch it. Model the outcomes. Get board approval on the diff, not on a memo. Merge when ready. If the structure doesn’t work, the old version is one revert away.

Want to restructure your board committees? Branch the governance configuration, simulate the new delegation paths, verify that all oversight requirements are still met, and merge only when the new structure is proven correct.

This isn’t theoretical. It’s what branches are for. The only thing novel is applying them to corporate governance rather than to source code.

The network effect of governance

Software ecosystems exhibit powerful network effects. The more people who use a library, the more bugs get found and fixed, the more integrations get built, the more documentation gets written. Each participant makes the ecosystem better for every other participant.

Version-controlled corporate governance creates the same dynamic. Every corporation that operates on this infrastructure generates data about what works: which bylaws provisions create friction, which equity structures attract talent, which compliance automations save the most time, which governance configurations survive their first crisis.

This collective experience, expressed as diffs and commit histories and branch experiments, becomes a shared resource. Not because anyone is giving away trade secrets — the business strategy, the product, the market position are all unchanged. What’s shared is the governance infrastructure of the corporation: the mechanical layer that makes it run.

Open-source won because it’s better

Open-source software didn’t win because it’s free. It won because transparent, forkable, collaboratively-improved software produces better outcomes than proprietary alternatives developed in isolation. The cathedral lost to the bazaar not on price but on quality.

Corporate governance is the last great cathedral. Bespoke, handcrafted, expensive, opaque, and fragile. Every corporation builds its own from scratch, repeating the same mistakes, rediscovering the same solutions, paying the same legal fees for the same boilerplate.

The bazaar is coming.

Fork a corporation. See what happens.