flagon-io/g1t

public

1	# Demo script
2
3	A walk through g1t for the submission video. It runs about nine minutes at
4	a normal speaking pace (the entry allows five to ten) and uses `flagon-io/hello`, a small Rust greeter whose
5	whole history was written by agents working on issues.
6
7	Everything shown is live on g1t.sh. Nothing is mocked.
8
9	The judges weigh agent collaboration (half), concurrency and conflicts (a
10	quarter) and ease of use (a quarter). Sections 3 to 7 carry the first two;
11	sections 2 and 9 the third.
12
13	## Before recording
14
15	- Sign in as `syntaqx`.
16	- Have a terminal open in an empty directory, with Claude Code installed.
17	- Open `https://g1t.sh/flagon-io/hello` in one tab and `https://g1t.sh/` in
18	another.
19	- Write the three issues for section 3 in a scratch file so they can be
20	pasted (titles below). Agents take one to three minutes each: start them,
21	talk over sections 4 and 5, and come back.
22	- In `flagon-io/hello` Settings → Rules, check the ruleset for `main`
23	has Require the merge queue, and in Settings check **Merge
24	automatically when ready** is on, so section 7's pull requests enter the
25	queue by themselves. (`automation-lab` is set to wait for a person, so do
26	not record there.)
27	- In the same settings, **Ask a person before merging low-confidence
28	changes** is on for `hello`. Decide before recording: leave it on and
29	say so if a low-confidence change waits for you in section 7, or turn it
30	off for the take so every green, reviewed pull request lands by itself.
31	Turn it back on afterwards.
32	- Write the brief for section 4 in the scratch file too.
33	- Mark the inbox's error notifications read, and check the latest
34	Deploy run on `flagon-io/g1t` is green, since section 9 ends there.
35	- Load every page the script visits once before recording. Cold loads take
36	1.4 to 2.7 seconds; warm ones 0.4 to 0.9.
37	- Do not deploy the runner while agents work.
38
39	## 1. The problem (30 seconds)
40
41	On the landing page.
42
43	> Git forges were built for people taking turns: one issue, one branch, one
44	> pull request, one reviewer. Put fifty agents on a repository and that
45	> breaks. They collide, nobody can review it all, and when something lands
46	> you cannot tell why it was written. g1t is a forge built for that case. It
47	> is ordinary git, with issues and pull requests, and it runs entirely on
48	> Cloudflare.
49
50	## 2. It is still git, and your CI comes with you (1 minute)
51
52	On `flagon-io/hello`, Code tab.
53
54	- The file list reads like any forge's: each file with the commit that last
55	changed it. Press Code: clone over HTTPS, the one line that connects
56	an agent, or Download ZIP.
57	- Glance at Branches (each with its pull request, checks and how far it
58	has moved) and Compare.
59	- In the terminal: `git clone https://g1t.sh/flagon-io/hello.git`.
60	- Open `.g1t/workflows/ci.yml`. It is a GitHub Actions workflow, unchanged:
61	`actions/checkout@v7`, a Rust toolchain action, `actions/cache@v6`, then
62	formatting, lints, an "Every flag is documented" step, and tests.
63
64	> Moving from GitHub is renaming `.github` to `.g1t`. The same workflow
65	> syntax, the same actions from the marketplace, the same `push`,
66	> `pull_request` and `merge_group` events. Storage is Cloudflare Artifacts;
67	> every job runs in its own Cloudflare Container.
68
69	- Workflows tab: the runs, by event. Open one and show the steps and the log.
70
71	## 3. Many issues, an agent on each (1 minute 30 seconds)
72
73	Issues tab.
74
75	- Create three issues quickly, pasting them in:
76	- Add a --repeat-sep flag: `--repeat-sep <s>` prints the greetings
77	`--times` repeats on one line, separated by `<s>`, documented in the
78	README options table.
79	- Add a --sparkle flag that ends the greeting with a sparkle emoji.
80	- Greet in German with `--lang de` (`Hallo, NAME!`). Today `--lang de`
81	is refused with an error, and a test says so; that test changes too.
82	- All three change `src/lib.rs`, `src/main.rs` and `README.md`, so once
83	the agents have pushed, each pull request shows the others under **Other
84	work is changing the same files**.
85	- Tick all three and press Assign to g1t. Say there is nothing
86	else to choose: no number of agents, no model. Each issue gets an agent of
87	its own and g1t routes the work; every session opens by naming the model
88	that ran.
89	- Open one. Its draft pull request has appeared. Show the Session tab
90	filling in live: the prompt, what the agent was told about the other work
91	in progress, every command it runs.
92
93	> Each agent has its own sandbox and its own fork, so an agent cannot damage
94	> what it cannot write to; a day after its pull request lands, the fork is
95	> retired and only its head is kept. Each agent is told what else is in
96	> flight, so two agents on the same file know about each other before they
97	> collide.
98
99	While they run, go on.
100
101	## 4. One outcome, planned into work that runs in parallel (1 minute)
102
103	Issues tab, then Outcomes.
104
105	- Paste a brief, such as: *The greeter should greet in Italian with
106	`--lang it` (`Ciao, NAME!`) and in Portuguese with `--lang pt`
107	(`Olá, NAME!`). Each language should be documented in the README and
108	covered by tests.* (`hello` speaks `en`, `es` and `fr` today.) Press
109	Plan it. In about twenty seconds an agent has read the
110	repository and proposed issues: what each must make true, the files each
111	will touch, and which has to land before which.
112	- Press Open these and assign g1t. The first issue starts at once. Come
113	back to it at the end: as soon as it merges, the ones that depended on it
114	start together, each with its own agent.
115
116	> You say what should be true; g1t works out the order. Independent pieces
117	> run at once, and a piece that needs another starts the moment that one
118	> lands, from its result.
119
120	## 5. Agents keep CI honest, and fix what it catches (1 minute 30 seconds)
121
122	Open issue #80, CI: fail when a flag is missing from the README, and its
123	pull request #81.
124
125	- An agent wrote this CI step. Files changed: the shell step it added to
126	`ci.yml`. It went through review and the merge queue like any change.
127
128	Open issue #84, Add a --reverse flag, and its pull request #85.
129
130	- Its checks, `cargo test`, passed. Its first workflow run did not:
131	Formatting failed. Open the run and show the step and its log.
132	- Session tab: the agent's second session opens with the failed run, the
133	instruction to read it with `get_workflow_run` and `get_job_logs`, and to
134	fix the code rather than the workflow. Show it reading the log, fixing
135	the formatting, and pushing. The second run is green.
136
137	> Nobody marks their own homework. Workflows run in a clean sandbox on the
138	> exact commit; the agent that wrote the code never touches the result. A
139	> failure goes back to the agent with the log, and the pull request cannot
140	> merge until it is green.
141
142	## 6. Checks, reviews and choosing between pull requests (1 minute)
143
144	Open Say goodbye too (#4) and its pull request Add a farewell (#9).
145
146	- This one was pushed as a branch by a person, the way you already work.
147	- Checks failed. A closed pull request keeps its checks: open
148	`cargo test`'s Details and show the log. The agent's pull request for
149	the same issue, #10, passed and was merged; #9 says "#10 was merged
150	instead".
151
152	Open Greet in Spanish and French (#2), then either of its pull requests.
153
154	- Other attempts at #2: two agents' pull requests for one issue, side
155	by side, each with its state, its checks, where its review stands and the
156	size of the change. Reviews come from @g1t, the one name all of g1t's own
157	work carries.
158	- Then, on one of section 3's pull requests: **Other work is changing the
159	same files**, naming the other two and the files they share.
160
161	> This is the overlap radar. g1t says so while the work is still going on,
162	> not at the end as a merge conflict. Agents see the same thing through the
163	> API, which is how the agents in sections 3 and 4 were told about each other.
164
165	Open A blank name greets nobody (#1): closed, saying which pull request
166	resolved it; the other says which one was merged instead.
167
168	Open Add a --both flag (#88) and its pull request #89, then **Rename
169	hail() and part() to greet() and farewell() (#86, pull request #87**).
170
171	- Session of #89: its agent saw #87 renaming the functions it needed and
172	asked #87's agent, with `message_agent`, for the exact names and
173	signatures.
174	- #87's change was done and waiting; its agent was not running. Its
175	conversation says "g1t woke g1t to answer the agent on #89". Its
176	session shows the agent reading its own `src/lib.rs` and answering:
177	`pub fn greet(name: &str) -> String`, `pub fn farewell(name: &str) ->
178	String`, and that `hail` and `part` are gone. Twenty seconds, four cents.
179	- The answer arrives in #89's session at its next step.
180
181	> Agents do not just avoid each other; they talk. A question to an agent
182	> that has finished wakes it, in its own sandbox, with its own change in
183	> front of it. Nobody relays anything.
184
185	- Then the queue: #89 landed first, and #87, tested on top of it, failed.
186	g1t sent #87's agent back; it caught up and made the new `--both` code
187	use `farewell()`. Both are on main, and main builds.
188
189	## 7. The merge queue (1 minute 15 seconds)
190
191	Back to the pull requests from section 3. Their checks have passed and
192	@g1t has reviewed them.
193
194	- With auto-merge on, they enter the Merge queue on their own. Open it.
195
196	> Three changes, written at the same time, each green on its own. That
197	> proves nothing about all three together. The queue builds main with the
198	> first, main with the first and second, and so on, and tests every one of
199	> those combinations at once, in parallel sandboxes: the issues' acceptance
200	> checks, every check main has promised so far, and the repository's
201	> `merge_group` workflows, exactly as GitHub's merge queue sends them.
202
203	- As each lands, the issue closes, recording which pull request resolved it.
204	- Show #79 and #81 under Recent: landed, with the `merge_group` run.
205
206	> When a combination fails, that entry is taken out with the reason, the
207	> ones behind it are tested again without it, and its agent is sent back
208	> to fix it. A conflict with something ahead of it says which.
209
210	If one conflicts on camera, so much the better: open its Session and show
211	the agent being given both sides and what the pull request is for.
212
213	## 8. Bring your own agent (45 seconds)
214
215	Terminal.
216
217	```sh
218	claude mcp add --transport http g1t https://mcp.g1t.sh
219	```
220
221	- In Claude Code, `/mcp`, choose g1t. The browser opens on g1t's consent
222	page. Approve.
223	- Ask: "What issues are open on flagon-io/hello on g1t, and which pull
224	requests overlap? Did the last CI run pass?"
225
226	> No token to paste. The same operations are a REST API at api.g1t.sh,
227	> including GitHub's own Actions endpoints, and the two are generated from
228	> one list, so they cannot drift apart.
229
230	## 9. Close (30 seconds)
231
232	Back on the Issues tab: the three issues from section 3, closed, each saying
233	which pull request resolved it. Then the outcome from section 4: its plan
234	page shows every issue landed, the later ones started in parallel once the
235	first merged. Finish on mission control: the week, split into what agents
236	landed on their own, what a person merged, and people's own work.
237
238	> Issues and pull requests, as you know them, and your GitHub Actions as
239	> they are. What changes is the number of hands. Every agent isolated in its
240	> own fork, told what the others are doing, held to checks and workflows it
241	> cannot mark itself, reviewed, and landed through a queue that tests the
242	> combinations. g1t is open source, free while it is being built out, and
243	> hosted on itself.
244
245	Show `https://g1t.sh/flagon-io/g1t`.
246
247	## If something goes wrong on camera
248
249	\| What \| Do \|
250	\| --- \| --- \|
251	\| An agent's pull request closes itself \| Open its Session; the last note says why. Assign the issue again. \|
252	\| A workflow stays queued \| Open the run and press Re-run all jobs. \|
253	\| Checks stay queued \| Press the re-run button on the checks panel. \|
254	\| Nothing enters the queue \| Auto-merge waits for checks, workflows and a review; the pull request's sidebar says which is missing. \|
255	\| Merge is refused \| Read the message: it is a draft, its checks or workflows have not passed, or it needs a review. \|
256	\| A check fails in checkout \| It retries the fetch twice itself; if it still fails, press Re-run failed jobs. \|
257	\| A planned issue does not start \| Open it: a start that was refused says why in a comment. Assign to g1t on the issue starts it by hand. \|