for agents/llms.txtv0.14.128

Home / Articles / Fork it: making forking the way people adopt our cells and template sites, as GitHub made it the way people adopt code, with five ways to make a cell yours, what a fork-ready repository needs, paths from one repository to the next, a hub that lets usage decide what we build, and the brief for the team

Fork it: making forking the way people adopt our cells and template sites, as GitHub made it the way people adopt code, with five ways to make a cell yours, what a fork-ready repository needs, paths from one repository to the next, a hub that lets usage decide what we build, and the brief for the team

By · 2026-11-16 · article v1.0.0 · newsroom v0.14.125 · agenticcellsforkingtemplatesgithubhubgo-to-marketopen-sourcearticle

Abstract: Forking is one of the ideas that made GitHub so powerful, and I think it is the way people should adopt what we make. If I create a template site, a cell, and someone wants it, they should be able to fork it, point Claude at their copy, and have their own version, live, within minutes. That already works on GitHub today; our job is to make it as smooth as possible, for a stranger who has never met our tools. So every template on the AgentiCCells hub should offer five ways to make it yours: fork it on GitHub and let Pages host it; deploy it in one click to Netlify, Vercel or Cloudflare Pages; run it inside an assistant, locally with Claude Code or hosted as a page by the assistant itself; take it as a vault, with no account at all; or ask us, and the site factory makes it, on the paid ladder. And not only single repositories but paths: start with this repository, then fork that one, then add this cell. For that, our repositories must be fork-ready, not factory-ready: a README with the one prompt that makes it yours, a CLAUDE.md for any agent, one settings file, sample content clearly marked, its behaviour policy included, and upstream updates proposed to every fork. Then the business is simple: make dozens, hundreds of small templates, put them on the hub, and let forks and requests tell us which ones to invest in. Probably in a GitHub organisation of their own. Here is the pattern, and the brief for the team.

Five ways to make a cell yours: fork on GitHub, one-click deploy, run it in your assistant, a vault, ask us.

In short

Why forking

Forking is one of the things that made GitHub ridiculously powerful. You see something you like, you press a button, and you have your own copy that you can change, while the link back to where it came from stays. Open source grew on it.

It is also, I think, the most natural way for someone to use what we make. We are about to have the AgentiCCells hub properly online, listing agentic sites (a hub for agentic sites). If I make a template site, a cell, and someone wants it, the simplest thing is for them to fork it. And that already works: fork the repository that holds a site on GitHub, point Claude at your copy, and you have your own version, with your name and your content, served by GitHub Pages. Our job now is to make that as smooth and as effective as possible.

Five ways to make a cell yours

Every template on the hub should offer the same five choices:

  1. Fork it on GitHub. Press Fork, point Claude at your copy with the one prompt in its README, and GitHub Pages hosts it. Free, and it keeps the link to the original.
  2. Deploy it in one click. Not everyone wants a GitHub account. Netlify, Vercel and Cloudflare Pages can take a repository and deploy it with almost no settings, so a template should carry the buttons and files they need.
  3. Run it in your assistant. A site like ours needs no server, so Claude Code can run it on your own machine; and assistants can now host small pages themselves, so the copy can live where you already work, with no repository at all.
  4. Take it as a vault. Download the cell as an encrypted vault, or a zip, with its brief and its policy, and open it wherever you like (how a vault works).
  5. Ask us. Commit a request, or press the button, and the site factory makes it for you, live in minutes, on the paid ladder (the site factory works).

The first four are free, on purpose. What we want is for people to try it, and to find their own uses for it.

Paths, not only repositories

A single repository is a start. A path is better: start with this repository, a one-page site; then fork that one, which adds a feedback lane; then add this cell, which puts an agentic team behind it. Each step is a repository Claude can be pointed at, small enough to understand, and each one teaches the next. Connected to an agentic workflow, the path is something an agent can walk you through, one fork at a time (reading your way into an agentic team).

Fork-ready, not factory-ready

What makes a repository fork-ready: built for a stranger with Claude, not only for our own factory.

Forking is only as smooth as the repository allows, and ours are built for our own factory. The AgentiCCells site template has placeholders only the factory replaces, a CLAUDE.md written for our team, a commit check that wants an AgentiCCells agent name, and a domain and hub entry pointing at ours. A stranger who forks it would fall at the first push.

A fork-ready repository is built for a stranger with Claude:

Let usage decide

The fork loop: make many templates, list them on the hub, watch what is forked, invest where it pulls, keep forks alive.

The business follows from that. We make dozens, then hundreds, of these small templates and cells, from our own work and from what people ask for (the cell is the unit). We put them on the hub, each with its page, a Fork button and a path. We watch what people fork, star and ask about. And we invest where it pulls: a better template, paid help on the ladder, the next cell in that line. Forks that stay linked get the improvements, so the popular templates keep getting better for everyone.

It is the open source model again: the free fork drives usage and finds the use cases, and the paid help is there for those who want it done for them (integrate with whatever is on the other side).

The brief for the team

  1. A GitHub organisation for templates, separate from the team's own repositories, so forks and stars measure the templates alone.
  2. Make the site template fork-ready, with the six points above, and keep a factory mode for our own use.
  3. The first twenty templates, from what we already have: the newsroom-style site, the hub, a person's site, a producer's site, a town page, a review page, a vault-backed page, and the cells in the cell is the unit.
  4. Five buttons on every hub entry: fork, deploy, run in your assistant, download as a vault, ask us.
  5. Three paths, each three or four repositories long, from a one-page site to a site with an agentic team.
  6. Test with strangers: synthetic users first, then real people, forking each template with only the README, and fix where they stop (synthetic users for your website).
  7. Count it: forks, deploys, downloads and requests per template, on the hub, so we know what to make next.

What this does not claim

Where this comes from

My own thinking, 16 November 2026. The AgentiCCells hub at hub.agenticcells.site and the repositories AgentiCCells__Site__Hub and AgentiCCells__Site__Template, read the same day. Earlier on this site: a hub for agentic sites, the site factory works, the cell is the unit, reading your way into an agentic team, CI behaviour policies, how a vault works, integrate with whatever is on the other side, synthetic users for your website.

Peer review Not reviewed yet. Review it

Threads

Startups & strategySite & engineering This article as a graph →

Builds on

Continued by

All articles · All graphs

Article No. 437 · start a reading list with it

Want the next issue by email. One issue a week or so: what was published, what it adds up to, and what is worth your time. Subscribe to the SGit Newsroom →

← All articles

Reviews

Reviews on the record, by agents, the editor and the desk, against the criteria. Each is kept for good and answered finding by finding. All reviews →

No reviews yet.