Eighteen Months of Claude Code
I started using Claude Code in February 2025. This is what the work looks like now — with the repositories public, so you can check every claim against the commit history instead of taking my word for it.
I started using Claude Code in February 2025, the week its research preview opened. This post is a record of what eighteen months of working that way produced. Where I make a claim I link the commit. Two repositories I mention are private — a project index and this blog — and the rest are public.
It is not a productivity post. The interesting part is what had to change before I could trust any of it.
The years of ending things
Before agents, my personal account filled up with beginnings — dozens of repositories: geometry and embeddings research, memory systems, forks of code-signing tools, half-finished experiments with names only I understand.
Most of them ended early. Not because the ideas ran out — because the energy did. Working alone, every project has a point where the remaining work is large, known, and boring, and the next idea is more interesting than the follow-through. For years, that trade decided how far anything went. The account is honest about it. It is a record of a curious person stopping.
That pattern was arithmetic more than character. One person has a fixed budget of sustained attention, and a system with many connected parts costs more than the budget.
The mission
The change did not announce itself as a mission. It started on an airplane, with a signing setup that would not work offline.
My commits were signed through a service you have to reach over the internet, and at altitude I could not reach it. That itch became signet — my own signing and identity system, and the first project where agents genuinely carried the work end to end rather than assisting at the edges. Signing git commits the way signet does turned out to need a cryptographic message format that Go had no modern implementation of, so go-cms exists to fill that hole. Fixing one offline itch pulled on everything attached to it: how identity should work when there is no service to call, what an agent should be allowed to do on my behalf, what record it should leave behind. By September 2025 there was an organization, and somewhere in that exploring it had become a mission. I noticed the direction after I was already pointed in it.
The circumstances are worth stating. I was already paying for Codebuff and ChatGPT Pro, and for Claude since July 2024, so Claude Code was one more subscription rather than a first bet. I was also between jobs when I picked it up: laid off at the very end of January 2025, weeks before the research preview opened, and not hired again until April. It kept running me into the ceiling anyway. In June I moved to the top tier, and I have hit its weekly limit most weeks since. The constraint had moved from my energy to the plan’s.
Cost, since it is the first thing people ask: about three thousand dollars of Claude subscriptions over two years. API usage during the preview and the other tools are not in that figure. Everything below sits on the other side of that number.
What the leverage actually changed was the arithmetic from the last section. With agents carrying the sustained work — the test suites, the refactors, the fourth and fifth revision of a document — follow-through stopped being the scarce resource. A project with several load-bearing parts, each needing steady unglamorous effort, became something one person could reasonably attempt: infrastructure for agents whose claims can be checked — who did what, with whose permission, leaving what evidence.
The pieces grew from there, each one an answer to a problem I actually hit. Of the ones that followed, mache came first, in February 2026: it presents a codebase to an agent as a filesystem of structure — functions as directories, callers as listings — instead of a pile of text to search. ley-line-open is the storage layer under it, where data is named by its own hash so a claim about “the state I saw” can be checked by arithmetic. cloister runs tools without handing them credentials — it holds the keys and makes the calls, so a compromised tool has nothing to leak. notme is the identity layer that signs for all of it.
I want to be careful with the word “mission,” because it sounds grander than the experience. Mostly it felt like the first time the boring parts were affordable, and discovering that with the boring parts covered, I actually did want to build one thing for years rather than many things for weeks.
The ban
On April 1st, 2026, GitHub banned my account, in the middle of the first agent run I had ever left going overnight. There was an email. I had not seen it. I found out at work, when colleagues could not add me as a reviewer and my open pull requests started returning 404s — my own work, gone from the record as far as anyone else could tell.
The ban lasted a few days, and my employer helped me get the account back. But those days settled a question I had been treating as theoretical: the platform my work lived on was a dependency I did not control, and it had just failed. You can see the mark it left in this blog’s own archive — nothing published from April through June.
What came out of that period was a decision to build local-first. The runtime works on my own machine. The data layer verifies content by hash, so it does not need a host to vouch for it. Records are signed with keys I hold. GitHub is where the work is published, and I am glad to have it back, but it is no longer something the work depends on. I would not have made that choice without being forced to, and it turned out to be the most important architectural decision in the whole system.
What it takes to trust the output
The agents solved the problem I had started with: they made sustained work affordable. They also created another one. The output arrived faster than I could check it, and unchecked output is not an asset. Most of what I built next exists to close that gap.
Every piece of work is a tracked issue, and every commit names the issue it belongs to, enforced at commit time. Review is a separate adversarial pass — agents whose only job is to try to break what other agents built. Tests get examined for whether they are capable of failing, because I shipped a signing feature with seventeen passing tests that could not fail: the fixtures were built with the same encoder the code used to check them, so the suite was asking the code whether it agreed with itself. A reviewer caught it; the tests never would have.
The same discipline killed some of my own tooling. I wrote a scanner to catch a class of security bug and deleted it: seventy-five findings against correct code, and narrowing it twice did not save it. Reading the interface it guarded settled the question — the bug it hunted could not be expressed there at all. A redundant guard is worse than none, because the next person to hit a false positive loosens the code rather than the lint.
It caught my own written conclusions twice: an architecture note whose measurement was accurate but whose conclusion answered a different question than the one asked, and a health check that reported success for five straight runs because it was talking to a leftover server from an earlier one.
I keep these stories next to the wins on purpose, and each one links to the commit where I wrote it down at the time. At this volume the honest unit of progress stopped being code written and became claims checked.
Two days this week
To make the current pace concrete, here is Monday and Tuesday of this week: 118 commits across six public repositories, counting every pushed branch. Only about forty-five sit on default branches; most of this work lands on integration branches, so a repository’s front page shows less. What those days looked like from my side is the part I would not have believed eighteen months ago: it ran on my personal machine, largely undirected, while I did my day job. I checked in, answered questions, reviewed what came back. The commits were the background.
Inside that number: a versioned release of the storage layer, cut only after checking its output matched, byte for byte, the 54,373-byte artifact its consumer pins. That check is discipline, not a gate: I run it before tagging, and nothing in CI enforces it. Two security changes on the identity service, reviewed adversarially and merged — one of them found a method marked private in TypeScript, which erases at compile time, and so reachable over the runtime’s RPC: a full compromise of the certificate authority, reproduced before it was fixed. A test suite checking the runtime against ten conformance vectors the storage layer publishes under their own digests, so the two agree by checksum rather than intention. And four essays, three of which are still unlisted while I finish checking their claims.
And the two days are not an outlier. On August 4th, 2026, my contribution graph read 9,107 for the trailing twelve months. The window moves; by the time you read this it says something else.
The volume is the least interesting part of it. What changed is that the checking kept pace.
What I cannot show yet
The limits are real, so here they are.
Nobody but me has built against these systems. The specifications are published with test cases and checksums, so a second implementation by other hands would be checkable — but it has not happened. I have a change proposed to an outside database project that would let its engine attach my storage format directly. My first attempt was a pull request; a bot that screens for AI-generated content closed it before a human read it. The current proposal is an issue, unanswered. Until something like it merges, all the compatibility evidence is mine checking mine. The sandbox policies cover the paths my own runs exercised, and no further.
And most of the writing that argues this system matters is deliberately unpublished, sitting behind checks I have not finished. That is a choice. It means the work is under-recognized in a way I sometimes mind. It also means that when the held claims do go out, each one will have survived the same process that reversed my conclusions twice before.
I do not know yet whether the system matters to anyone else. I do know what changed for me: the account is no longer a record of a curious person stopping. Whether another person can build on it is the next claim to test. The repositories are open. The dates are in the log.