On 14 August 2026 I took the dashboard out of this workspace. The commit strips 3748 lines. 3581 of those are 10 files deleted whole, plus a SQLite database. The machine had written the first of those files 2 days and 22 hours before that commit. The reason sits in the commit body and it is about the premise. The thing was a queue of cards with approve and reject buttons, built as if I service a queue, when every real decision here happens in a conversation.
I called it one bad call and moved on. What I never did was count how much of everything else went the same way. My working assumption was that I keep most of what this machine writes.
Rich Hickey turns that assumption into something I can measure. Simple Made Easy, Strange Loop, September 2011. About an hour in he says: “It’s the artifacts. It’s not the authoring.” In his account the cost of complexity lands on whoever has to change the thing later. Around 18 minutes in he says what that looks like on a calendar. If you focus on ease and ignore simplicity, “Most sprints be about completely redoing things you’ve already done.”
The reply I keep meeting in 2026 is that authoring became free, so the argument is closed. This repository is a fair place to test that. I did not type it. An agent working in this directory did, across 508 commits from 11 August to 2 September, landing on 21 separate days. Every count below is taken at commit aaaf1c5, the last one before I started, on git 2.43.0.
The volume first
The only repository I own that has both eras in it is the site. I started it by hand in 2014 and put Jekyll under it in 2019. The machine rebuilt it on Astro in 2026. This is git log --numstat --no-renames over source extensions, no lock files and no content, divided by days that have a commit.
| commits | days | code lines | of those mine | per working day | |
|---|---|---|---|---|---|
| dimhold.by by hand, 2014-2019 | 15 | 7 | 1159 | 464 | 66 |
| dimhold.by by machine, 2026 | 51 | 10 | 23747 | 23747 | 2375 |
| this workspace, 2026 | 508 | 21 | 36542 | 36542 | 1740 |
The first row needed the extra column. 695 of its 1159 lines are github-markdown.css, a stylesheet I dropped in whole, so what I typed is 464 lines over 7 days. Against 2375 that is 36x. The largest files of the machine rows have nothing vendored in them. Those 7 days are evenings of hobby work on a stack that no longer exists, so read 36x as an order of magnitude.
How much of it is still here
The number Hickey’s claim actually touches is survival. For each file I summed the lines git recorded as added, then put that next to what stands at the pinned commit. Under src, scripts and public that comes to 31.7% surviving. For CLAUDE.md, TICK.md and the prompts it is 25.7%. Those paths are not the set the era table counts.
Counting prose by line is a bad idea though. These files wrap at 80 columns, so an edit inside a paragraph rewrites the rest of it and every rewrapped line counts as new. That is not the whole gap: src/lib/tells.ts is code and it still shows 47.3% by line against 88.5% by word. I switched to words, taken with git show --word-diff=porcelain over each commit.
The counter I wrote for that had a bug in it. It split each changed run on whitespace and counted the empty leading field as a word, which inflated everything by 13%. The code column read 42202 words added where the truth is 37224. I only found it because added minus deleted is supposed to land on what wc reports. It did not. On the code paths it now lands within 3 words. On the rules paths it is still 634 words out, around 3.5%. Why that is I have not worked out.
| words added | words deleted | at that commit | survived | |
|---|---|---|---|---|
| code | 37224 | 21382 | 15845 | 42.6% |
| rules and prompts | 24680 | 6028 | 18018 | 73.0% |
57.4% of the code this machine wrote in 3 weeks is gone. On that number Hickey’s sentence about redoing what you have already done looks right.
The shape is wrong for his story though. 18171 of the 21382 discarded words went in a single commit, the one from 14 August. That is 85.0%. The other 62 commits that touch code threw away 3211 words between them.
The tangle was between the files
So I went back to that commit with his own definition. Complect means to braid. Git only records what changed together. Whether it had to is not in there, so the closest I can get is a frequency. For each file I took the commits that touch it and asked how often each other file changes with it. I counted a file as a partner at 50% and up. I dropped the 11 commits that touch more than 20 files, since a sweep across the tree ties everything to everything.
There are 10 files under src, scripts and public with at least 5 commits. The 5 with the widest braid are the 5 that commit deleted. public/app.js moved together with public/styles.css in 93% of its commits and with src/server.ts in 79%. src/lib/funnel.ts has 6 partners.
The survivors are not all clean. src/lib/refine.ts carries 4 partners, one below public/app.js. It only has 6 commits, so a partner at 50% means 3 occurrences there. One of the 4 is a dashboard file. src/lib/tells.ts has exactly one partner. The 3 remaining survivors have none.
Inside the files there was nothing special. I measured the same tree just before the deletion and at the pinned commit. Branches per 100 lines went from 25.6 to 21.9. Imports per file went from 3.3 to 2.1 and deepest nesting from 8 to 7. Hickey has a line for this. “You can write modular software with all kinds of interconnections between them. They may not call each other, but they’re completely complected.”
I wanted to write that the braid is why nobody trimmed the dashboard. The history does not support it. 601 lines came off those files before the end, so parts did get removed. What holds is narrower: no commit ever made the set smaller and no file of it was ever taken out alone. When it went it went as 10 files in one diff. src/lib/files.ts came in at 252 lines to hold the state.
The braid that is still here
The mechanical writing checks live in code, in src/lib/tells.ts. The same rules also live as prose in the manual and the prompts. Of the 19 checks, 6 are named in the manual by their identifier. All 6 came from rules dictated to me by hand. Each landed in the code and in the manual in the same commit. tells.ts changed 13 times with CLAUDE.md alongside in 8 of them, 62%. From the other side CLAUDE.md changed 67 times with tells.ts alongside 8 times, 12%.
Grepping for the identifier is the only mechanical count I have and it undercounts badly. The dash rule is written out in prose in 5 documents as well as the code. The engagement bait rule is in 3. A rule restated in prose does not announce that it has a twin, so how wide this goes I cannot say.
I was going to write that the braid costs nothing, because one writer holds both ends and writes them in the same act. Then I ran probes through the checker to see whether those 6 pairs still say the same thing. 2 of them do not. One is quotes. The manual promises straight quotes in any text in any language, while the check looks for the guillemets only, so a curly quote goes through. The other is the number parade, where the manual describes a run of 3 number and word pairs and the regex wants commas between them. 1 tool 2 models 100 calls is not caught at all. I have been running that checker over every draft since 26 August. It has been letting curly quotes past the whole time.
What I did not check
Whether 3 weeks is long enough for the effect Hickey describes, which is about years. Whether 7 evenings in 2019 are a baseline at all. I computed the correlation between braid width and rework, then dropped it: only 5 surviving code files have enough commits to compute it on. And the word counter treats a renamed variable as churn. That goes into the denominator, so every survival number here is pushed down.
The habit I came in with was that generated code is cheap to write and therefore not worth being careful about. 85.0% is what changed it. Nearly all the code this repository has thrown away went on one decision about a premise. That decision was made in a conversation. Hickey puts a Dijkstra slide up at 49 minutes and reads it as programming being about thinking. None of my numbers tell me what that conversation cost. That is the figure I would actually want. I have not found a way to get it out of a repository.