archlang is my open-source language that lets AI write architectural floor plans as code: a .arch file compiles to an SVG plan. It is a TypeScript monorepo with a compiler core, a CLI, an MCP server, a VS Code extension, a 3D package and two deployed sites (the docs and a live playground).
Almost none of its code is typed by me. Claude Code sessions plan the work, and subagents in their own git worktrees write the code, run the checks and open the pull requests. Between 25 June and 16 November 2026 the repository took about 4,160 commits and more than 750 pull requests. On busy days it merged 30 PRs and ran 60 to 160 CI runs.
That rate breaks a CI pipeline that was designed for people. This post is the history of how the pipeline was rebuilt, in seven stages. For each stage it covers what hurt, what was measured, what was changed and what the change bought. It also covers the ideas I declined, and why, because at this scale most of the good decisions were refusals.
All the numbers come from the repository's own records: the GitHub Actions API, git log, and two plan documents in the repo (docs/plans/ci-throughput.md and docs/plans/ci-throughput-research.md). Where a number was a prediction that later missed, I say so.
The short version#
| Measure | Late October 2026 | Mid November 2026 |
|---|---|---|
| CI wall clock on a code PR | median ≈ 43 min (24–60) | 4.7 min |
| CI on a docs/records-only PR | ≈ 43 min | ≈ 2 min |
| Full run (every Node version + Windows) | ≈ 43 min | 7–9 min |
CI on the push to main after a merge |
≈ 43 min | 24–30 s (proven by the PR run, see stage 6) |
| Merge to production deploy finished | not tracked | 2 min 5 s |
| Local check before a push | full suite, 822 s, laptop frozen | check:quick, about a minute |
Three lessons sit under all of it:
- The bottleneck moves. First it was one slow test step. Then the number of CI legs. Then my laptop. Then, once CI was fast, it was serialisation: every PR waiting for the one ahead of it and fixing merge conflicts. Each stage started by measuring again, because the previous stage's fix had moved the problem somewhere else.
- Never speed up by quietly testing less. Every change kept three written laws (below). Where a change did weaken a guarantee, the trade-off was written down, accepted by me as the owner, and paired with a detector.
- Test the tree, not the commit. The biggest single win was noticing that a merge commit whose file tree is byte-identical to a tree CI already tested does not need testing again.
The three laws#
Before any option was considered, three rules were written into the plan, and every later change had to keep them or ask me to change them explicitly:
- A merge is pinned to the reviewed commit. The merge command is
gh pr merge <n> --merge --match-head-commit <full sha>, after areviewed <sha>comment. If anyone pushes after the review, the merge fails instead of shipping unreviewed code. - CI is the full gate. A narrowing may skip only work that the change cannot affect.
- After
mainis merged into a PR, the merged head is reviewed again, and that head is the one pinned.
These sound like bureaucracy. In practice they were what made it safe to let agents merge on their own. Speed work that breaks one of them is not speed, it is debt.
Stage 0 (June–October): every gate was right, the sum was not#
archlang's first workflow, on 25 June, ran a type-check and the tests on Node 18 and 20. Over the next four months it grew, one sensible commit at a time:
- Node 22 in the matrix, a Biome lint gate, and drift gates that fail when a generated file (the grammar, the JSON schema,
llms-full.txt, the language spec for LLMs) differs from its generator's output. - Least-privilege permissions, SHA-pinned actions and Dependabot.
- Workspace builds, a Windows leg, coverage reporting, a Playwright E2E job for the playground and another for the docs site.
- A
check:test-wiringguard so that no test file can exist without ever running. - A nightly workflow: a production smoke test, an audit, gitleaks, the full matrix, deep fuzzing.
Each addition caught real bugs. The total, measured over 15 runs in late October, was 24 to 60 minutes per run, median about 43. And because the agents' PRs touched shared records (the CHANGELOG.md, plan and handoff files), the next PR usually could not merge until the previous one had finished. My main session, the coordinator, spent its day waiting about 43 minutes per dependent PR.
The friction here was not a bad decision. It was the absence of a moment where someone looked at the whole pipeline as a cost.
Stage 1 (27 October): measure first, then cut the long pole#
The first step was a plan document with the measurements, the three laws, and seven options (A to G) in a recommended order, each with its expected effect, what it needs and a "reverse if" condition: the observation that would prove the option wrong and send it back.
The per-job numbers for one run told the story at once:
| Job | Minutes |
|---|---|
| Node 22 | 43.3 |
| Docs site E2E | 22.1 |
| Node 18 | 20.5 |
| Windows | 18.7 |
| Node 20 | 15.3 |
| Playground E2E | 11.4 |
The long pole was one step: npm run test:coverage on Node 22, 42.5 to 43.1 minutes, against 15–20 minutes for the uninstrumented npm test on the other Node versions. And coverage was report-only: it gated nothing. Two more findings: the E2E jobs' apt step sometimes took 10–18 minutes, and most of the coordinator's own PRs changed only records.
Four options landed, A by repository setting and B, C, D together in PR #290:
A. Branch protection plus SHA-pinned merges. The gating jobs became required checks on main.
B. A concurrency group per PR. A new push to a PR cancels that PR's superseded run. Pushes to main are keyed on the commit, so a main build is never cancelled:
concurrency:
group: ci-${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
cancel-in-progress: ${{ github.event_name == 'pull_request' }}The keying on github.sha for pushes matters more than it looks: GitHub replaces a pending run in the same group even when cancel-in-progress is false, so a shared group for main can silently drop a build.
C. A records-only fast path. A first changes job (dorny/paths-filter, SHA-pinned) decides whether every changed path is a "record": Markdown that nothing publishes. The interesting part is how the set was chosen. It was not guessed. Every fs read of the full test suite was traced per test file, and that showed that seven suites compile every arch code fence in every Markdown page under docs/. So published pages, ADRs and the README are code, not records; plan notes and the changelog are records. On a records-only PR the heavy jobs skip their steps and a small docs leg runs only the suites that read records.
One design choice saved a lot of pain: every gating job keeps its check name and guards its steps instead of being skipped by name. Branch protection needs required checks to report; a renamed or missing check leaves a PR pending forever. Keeping the names meant the protection rule did not need editing at all.
D. Coverage to nightly. Coverage, its summary and its artifact moved to a nightly job. Node 22 runs plain npm test like the others.
Results: on records-only PR #302 CI took 2.1 minutes, against about 20 for a code run. Code PRs' jobs now took 13–21 minutes each.
Two options were deliberately deferred: E (GitHub's merge queue) and F (per-PR changelog fragments). The plan said to wait until the conflict rate after A showed whether they were needed. That turned out to be the right call, for reasons that only appeared in stage 5.
Stage 2 (31 October): stop running the same proof three times on every PR#
After stage 1 each code PR still ran the whole suite four times: Node 18, 20, 22 and Windows, 14–22 minutes each. Almost no change breaks on one Node version and not another. So PR #385 (option G) did two things:
- Node 18, Node 20 and Windows left PRs. They run on every push to
mainand nightly. On a PR they report green with a one-line summary. - Node 22 was sharded with
vitest run --shard=N/3, behind an aggregator job that keeps the required nameNode 22.
The aggregator pattern is worth copying. A required check that is skipped counts as passing, so an aggregator must not trust a skip blindly. It runs with if: always() and checks the exact result it expects from each job it depends on:
node-22:
name: Node 22 # the required check name, unchanged
needs: [changes, node-22-checks, node-22-tests]
if: ${{ always() }}
runs-on: ubuntu-latest
steps:
- run: |
want=success # or "skipped" on a records-only PR
if [ "${{ needs.node-22-checks.result }}" != "$want" ] ||
[ "${{ needs.node-22-tests.result }}" != "$want" ]; then
echo "::error::A Node 22 job did not give the expected result ($want)."
exit 1
fiAnd it fails open: if the changes job itself fails, every leg runs.
This is the first change that weakened a law, and the plan said so in writing. A break that only shows on Node 18 or Windows now appears after the merge. I accepted that as the owner, with three detectors: the push run on main, nightly's full matrix, and the release checklist as the only hard stop. It did happen once: a toReversed call (Node 20+) reached main and went red on Node 18. It was fixed in the next PR, and the lesson went into the gotchas file ("run a changed generator under Node 18 before merging a tooling PR").
Before trusting the shards, the PR proved they were safe to split: no test passes state to another, tests write only to temporary directories, nothing builds dist/ during the suite, and vitest isolates each file in its own process. Two throwaway commits deliberately failed a shard and forced the records-only verdict, then were reverted, to prove the aggregator really fails.
Result: 10 m 52 s for a code PR, against 14–19 minutes for one Node leg before. The shards took 5.6, 4.7 and 10.5 minutes. They were unbalanced, because vitest --shard splits by hash, not by time. That got fixed in stage 4.
Stage 3 (4 November): the laptop froze, so the local gate changed#
The next friction was physical. Agents were told to run the full check before pushing. A full local npm run check took 822 seconds, pinned the CPU, and with several agent sessions running at once the laptop froze. Meanwhile one CI run took 7–13 minutes and covered every platform. Running the suite locally was slower and proved less.
So I set a rule: tests do not run on this machine; GitHub CI is the full gate. Then the agents built the tooling to make the rule real.
check:quick, a local gate sized to the change. It looks only at what the branch changed against its merge base with origin/main: Biome on the changed files, the type-check they need, the drift check, and the nearest tests. Those are the changed test files, then tests ordered by import distance from the changed modules, then tests whose string literals name a changed non-code file. It is capped at 20 files and prints what it cut. Its first run on its own branch took 61 seconds.
A hook that enforces it. Writing "don't run the full suite" in an instruction file was not enough: agents under pressure to "verify" kept reaching for npm test. A Claude Code PreToolUse hook (.claude/hooks/local-gate.mjs) now blocks vitest, npm test, npm run check, the e2e and bench commands, with an explicit escape tag for release prep. A rule that a machine enforces does not drift.
Risk tiers by change, not by author. scripts/risk-tier.mjs classifies a PR by the paths it touches. Prose is low tier and merges on green CI. Code, tests and tooling are medium and add one independent fresh-context review against REVIEW.md, two rounds at most. CI, release workflows, agent permissions and hooks are high. The highest path wins, and an unclassified path counts as medium. REVIEW.md lists what breaking each hard rule looks like in a diff, and also what is not a finding, so reviews stop circling on style.
Detection after the merge. A main-red.yml workflow opens one pinned issue when a push run on main fails and closes it on the next green run. The agents' settings deny pushes to main and force-pushes. The PR template gained Risk and How to revert sections.
The friction this stage exposed: a targeted local subset misses corpus-wide guards. On 28 October five agent PRs went red only under the full suite. They had broken digest tables, fixture corpora and a hand-maintained size check, none of them near the changed files by imports. That is why a check:quick pass is never merge evidence here. It exists to catch the cheap mistakes before a push, and only the PR's CI green may merge it.
Stage 4 (9–10 November): balanced shards, and the day strict came back#
An engineering-health programme added several CI fixes in one day:
- Five shards balanced by recorded duration instead of by hash. A committed
test/.durations.jsonand a custom sequencer deal files across shards by their past runtime. The 98-second net-area oracle corpus was split so one file could not set the floor. - Flaky tests made visible. Playwright retries hid flakes, so a step now reports every case that passed only on a retry.
- Every red issue labelled
ci-red, with a comment on every red run. A pinned issue that is edited in place notifies nobody. One had sat open for days on a red secret scan. - Mistake hooks. A hook refuses hand edits to generated files, filtered snapshot updates (
vitest -u -tdeletes every snapshot the filter skipped), and deletes through a Windows junction. - A CHANGELOG check: every PR's lines must land under
[Unreleased]. A union merge past a release otherwise slides a branch's entry into the released section, without any conflict.
Then two pairs of PRs that were each green merged one after the other and broke main together. Each PR was right on its own, and the combination was not. This is the classic semantic conflict, and it is the problem merge queues exist for.
The workflows were made queue-ready (merge_group triggers on every workflow that produces a required check). Then the API refused: a merge queue needs an organization-owned repository; on a user-owned repo the ruleset call returns HTTP 422. The fallback was GitHub's "require branches to be up to date" setting, called strict. A PR behind main cannot merge until it includes main's tip and CI has run again on that tree.
Strict closed the hole. It also opened the next bottleneck.
Stage 5 (12–14 November): the bottleneck is serialisation, not CI#
By now a PR run took a median of 9.6 minutes, and yet PRs still felt slow. So before building anything else, an agent ran a read-only research pass over the data: the last 799 CI runs, all 688 PRs at the time, and every merge on main since 29 October. It also read what other teams had published.
What the data said#
| Measure | Value |
|---|---|
| PR CI wall clock | median 9.6 min, P90 13.1 |
Push to main |
median 27.1 min |
| Runner queue time per job | median ≈ 3 s |
| PR open → merge (7 days) | median 33 min, P90 ≈ 2 h |
PR merges vs "merge main into branch" commits (2 weeks) |
297 vs 266 |
| Sync merges that needed hand-resolved files | 165 |
…of which only CHANGELOG.md and generated files |
82 (50%) |
| PR CI failure rate | 23% |
main red rate |
4.8% |
Runners were not scarce: about 3 seconds in the queue. The time went into syncing. Every merge made the other open PRs "behind"; each then merged main in, fixed conflicts, re-ran CI and got re-reviewed, and often another PR merged first and the loop repeated. After strict went on, CI runs per PR went from 2.11 to 3.02 and P90 open-to-merge from 113 to 755 minutes. That was a three-day sample with other changes in the same window, so it shows a direction, not a proven cause.
And the conflicts were boring. CHANGELOG.md had been hand-resolved in 98 merges, the generated module map in 42, llms-full.txt in 32, the generated error-code page in 23. Half of all hand resolutions needed no judgement at all.
What others do#
The research collected published practice into four groups. This framing was the most useful thing in it:
- Verify less: test impact analysis and affected-only runs. Anthropic's test impact analysis (CI jobs up 25× in six months, Claude authoring about 80% of the code), Meta's predictive test selection, Stripe's selective test execution, Turborepo's
--affected, Vitest's affected-tests recipe. - Verify faster: caching, shards, better runners. Linear's discussion on Hacker News reported Vitest
isolate: falsesaving about 17% of monthly cost. - Verify earlier: local and in-agent checks, AI review. The Anthropic article's line "give agents a specific set of valid tests so they can self-verify" is exactly what
check:quickdoes. How the Claude Code team does code review sets risk tiers by the change, not the author, and treats revert and incident rates as the guardrail. archlang had arrived at the same rule independently in stage 3. - Merge without serialising: merge queues (GitHub's own: about 2,500 PRs a month from 500+ engineers, average wait down 33%; Shopify's; Uber's SubmitQueue), stacked PRs, or post-merge verification plus revert. Anthropic's source-control redesign argues a classic merge queue stops making sense at 30,000 merges a day.
It also kept the pushback: DORA 2025 finds AI adoption improves delivery throughput and increases delivery instability, and a comment under the Linear thread asks why faster shipping has not made products visibly better. Throughput is not value. That is why the measures below always pair speed with the main red rate and the revert rate. If those rise, the time was moved, not saved.
The research also found that most of the industry list was already in place: path filtering, concurrency, sharding, a local gate, risk tiers, post-merge alarms. What was missing was the merge strategy and the conflict handling.
What was taken, and what was declined#
I delegated every item to the coordinator session, with the instruction to decide it or schedule it. Each verdict was recorded with its reason and a reopen trigger, a measurable condition that would bring it back. These are the ones worth learning from:
| Idea | Verdict | Why |
|---|---|---|
A script that syncs main and resolves mechanical conflicts |
Built (npm run sync:main) |
Removes about half the hand resolutions. Also, gh pr update-branch was wrong here: GitHub's textual merge of a generated file is not the generator's output, so the updated head failed the drift check. |
| Turn strict off | Declined | It came back because green PRs broke main together. Its cost is extra CI runs, which are free on a public repo. |
| Move the repo to an organization for the merge queue | Declined | The npm trusted publisher, the MCP registry name (io.github.ChanMeng666/..., published via GitHub OIDC), repository.url and every registry listing are bound to the owner name. A move breaks the release chain to save a few minutes. |
| A third-party merge-queue app | Declined | It would hold write access to a repo whose main deploys two sites. |
Changelog fragments (changelog.d/) |
Declined | The scripted union merge plus the [Unreleased] check resolves the 98 conflicts without changing the rule that release notes live only in CHANGELOG.md. |
| Affected-only tests on PRs | Declined | It narrows law 2 to save compute, and compute was neither scarce nor queued. The PR wall clock was set by E2E, not by the suite. |
Vitest isolate: false |
Declined | The suite leans on per-file isolation (a memoised parse stage, module state); verifying 544 files one by one costs more than the ~17% it might save. |
Auto-revert on a red main |
Deferred | The one long red main that week was a broken apt mirror, which a revert would not fix. Also, a PR opened with GITHUB_TOKEN starts no CI. |
| Bazel / Nx / remote caching, custom runners | Declined | Workspace builds took 2.4 minutes. Self-hosted runners on a public repo are a security risk GitHub itself warns about. |
| Shard the Playground E2E, shard the main-only legs | Built | The Playground E2E was the PR's long pole at 8.8 min; main took 27 min, which delays both deploys and red-main alarms. |
One declined idea taught the most. It was tempting to automate "does this sync even need a re-review?" by checking whether the files main brought in overlap the PR's files. The research found the case law 3 exists for: a PR calls doorSwing() while a parallel PR changes what doorSwing() does. No shared file, a clean merge, a green suite, and a wrong drawing. A file-overlap test cannot see that. So sync:main prints a focus list for the reviewer (files both sides changed, hand-resolved files, imports between changed files, exports main changed whose callers the reviewer should grep), and never a verdict. A focused re-read is cheaper. Skipping it is not safe.
The first readings after sync:main (#754) and the new shards (#755) were a 7.3-minute PR run and a 12.8-minute push run on main, down from a 28.1 median. They also exposed a bug: the sequencer put every file recorded at 0 seconds into one shard, which made shard 1 twice as slow as shard 2.
Stage 6 (15 November): build your own merge train, and prove pushes instead of re-running them#
Strict plus sync:main was correct, but each PR still went through its own full sync → CI → re-review cycle, one at a time. A merge queue would test several PRs on the merged tree at once, and GitHub would not give this repo one. So the agents built the parts of a queue that mattered, as ordinary scripts and an ordinary PR.
The merge train#
npm run train -- <pr> <pr> ... (#788):
- cuts a branch
train/<UTC stamp>fromorigin/mainin its own worktree; - merges each member PR's reviewed head, resolving generated files and
CHANGELOG.mdbysync:main's rules, and drops any PR with a real conflict; - runs every generator once on the tip, pushes, and opens the train PR with the record in its body;
--land <pr> --waitre-checks the three laws and merges the train PR with--match-head-commit. The member PRs show as merged on GitHub by themselves, because their commits are now inmain. Cleanup happens only after the state readsMERGED.
A train PR is the one place where Node 18, Node 20 and Windows run before the merge (a branch name starting train/ turns them on), so a train restores law 2 for those legs too. Every git and gh call in the script passes a forbidden() filter first: no force push, no --admin, no --auto, no squash or --delete-branch, no non-GET gh api call.
The proven push#
Once a train merges, the push to main used to run the whole full matrix again on code CI had just tested. #785 added scripts/ci-proven.mjs. A push to main is proven, and skips its work, when all of these hold for its commit M:
- M is a two-parent merge, and the push's
beforeis M's first parent; - tree(M) = tree(M^2): the merged files are byte-identical to the train head;
- M^1 is an ancestor of M^2, so the train already contained everything on
main; - a successful
pull_requestrun ofci.ymlon M^2, from atrain/branch intomain, ran every job of a full run (checked against a pinned list of job names, with no "nothing to run on this leg" marker step) and is under 24 hours old.
Then every required check reports success with a line naming the run that proved it. Any error or doubt runs the push in full. This is "test the tree, not the commit" in code. Git already gives you a content hash of the whole tree, so it would be wasteful not to use it.
Shorter runs, too#
The same day, #794 fixed the sequencer (a 2-second per-file overhead, and unrecorded files placed at the table's median), went to 7 Node 22 shards and 5 per main-only leg, split the docs E2E into three jobs with explicit spec lists and the 3D package check into two passes, and made the informational benchmark unable to fail a run. #798 split the 216-second finish.test.ts, the floor of every shard, into four files and its sibling into three, as a pure move: 19,030 tests passed before and after.
#795 re-tuned the local gate from evidence. The agents replayed recent red CI runs through the gate's selection to see which ones it would have caught. It now also picks the source-tree scanner guards, tests named after a changed module and the cheapest corpus pins, all within fixed budgets. A typecheck:all step and a build inside the gate were built, measured and removed. The replay showed the type-check reds came from one Dependabot PR plus two files the old gate already compiled, and a build inside the gate deleted the dist/ that nested worktrees resolve to.
Measured, and where the predictions missed#
| Measure | Before (after stage 5) | After |
|---|---|---|
| PR code run | median 7.2 min | 4.7 min |
| Full run (train PR) | 12.3–14.6 min | 7.0–8.7 min |
Push to main after a train |
median 12.3 min | 24–30 s (seven trains, all proven) |
| Merge to deploy finished | ≈ 13.7 min | 2 min 5 s |
Seven trains landed that day. The predictions were too optimistic, and the record says so: #794 predicted a 3.7–4.2-minute PR run and a 6.4–6.6-minute full run, and measured 4.7 and 8.4–8.7. The test-file split showed no gain on its own PR run, because each new file starts cold (summed test time rose from about 318 to about 389 seconds) and the slowest shard ran on a slow runner. Two more findings:
- Runner noise follows the job, not the file. With identical files, one shard ran 1.79× the Node 22 time on Node 18 and 1.03× on Node 20, and another shard the reverse. So a per-leg duration table, which looked like the obvious next optimisation, would have fitted noise. It was designed and not built.
- The concurrent-job limit binds now. A train PR peaks at 38 parallel jobs against the account's limit of 40 concurrent jobs, so a train plus one ordinary PR run queue for up to 79 seconds. I took no action yet. The reopen trigger is a median queue time over a minute.
Stage 7 (16 November): a speed sprint leaves the docs lying#
After the train session, an independent audit read the instruction and contributor files against the actual CI. It found 16 untrue statements and 16 misleading omissions. Several files still said PRs need not be up to date with main, though strict had been on for six days. Shard counts were the old ones, and AGENTS.md, the file every agent reads first, did not mention the train at all.
For human contributors, stale docs are an annoyance. For agents, they are instructions. An agent that reads "PRs need not be up to date" will act on it. The fixes went out as one low-tier and one high-tier PR, landed by a train. The merge machinery itself (the train, sync:main, the CI proof) was then classed as high tier, because a bug there can merge unreviewed code.
What I would tell anyone shipping at AI speed#
1. Measure before every stage, because the last fix moved the bottleneck. The pole went from one coverage step to Node legs, to a laptop, to E2E, to syncing. Pulling raw data from the Actions API and git log takes minutes. The research doc in the repo includes the exact gh api and jq commands, so the measurement is repeatable.
2. Write the laws first, and write "reverse if" next to every change. A speed change without a stated guarantee and a stated failure condition cannot be judged later. Most of my decisions were refusals, and each refusal has a reopen when trigger, so none of them is a permanent no.
3. Keep required check names stable; use aggregators that fail open. This one pattern let path filters, shards, main-only legs and proven pushes all land without touching branch protection once.
4. A skip must be earned by measurement. The records-only set came from tracing every file the suite reads, not from what seemed obviously harmless.
5. Give agents a fast, honest local gate, and enforce it with a hook, not prose. Size it to the change, cap it, print what it cut, and never let it count as merge evidence. Tune it by replaying real CI failures through it.
6. Classify risk by what changed, not who wrote it. When almost every author is an agent, "who wrote it" carries no signal. Low tier merges on green; review effort goes where a bad diff can do damage; review rounds are capped.
7. When CI is fast and PRs are still slow, look at serialisation. Count sync merges and hand-resolved files. If half of them are generated files and a changelog, a script removes half of your friction, and a regenerate step beats a textual merge every time.
8. Test the tree, not the commit. If a merge produces a tree CI has already tested, prove it with git's hashes and skip the run. Fail open on any doubt.
9. Pair every speed number with a stability number. main red rate and revert rate. If they rise, you moved the cost to later; you did not remove it.
10. After a speed sprint, audit the docs. Agents follow instructions literally, so docs that describe last week's pipeline will produce last week's mistakes.
Where it stands#
The open items are written down as cards with their own triggers: a week-long re-measurement of the train (PR and train medians, open-to-merge P90, share of pushes proven, train reds and their causes, the red and revert rates), the job-concurrency ceiling, and a records-only fast path for pushes to main. The two plan documents linked at the top hold every number in this post, the commands to refresh them and the full list of declined ideas with their reopen triggers. If your repo is starting to feel AI-speed pressure, I hope they are useful to copy from.