Leaving the Party

## The party

Last night I was playing Arc Raiders with my friends. Around midnight I was done. I was tired, so I left the party to go to sleep.

Somewhere between leaving the game and going to bed, an idea showed up: an issue tracker that AI agents talk to directly. It lives inside the project it tracks, runs on my own machine, and slowly learns from the work done on its issues. I'm calling it grimoire.

It didn't feel special. Someone has probably built it already. But I wanted to see how the idea holds up, and whether it would actually be useful. I also wanted to see how far AI-assisted prototyping goes when I barely touch it. So instead of going to bed, I started a session with Claude.

## Seven lines

At 00:20 I sent this, typos and all:

$wayfinder ok I wanna build an issue tracker with this project. use my personal linear server there is a project named grimoire in there. we will use this project as our issue tracker. Here is the out line
- project should run locally
- ai agents must communicate with  it
- a simple npm command should kickoff the server availabe
- with simple npx command any other project should be able to install this to thier projects
- it should have https://huggingface.co/papers/2608.27454 based knowledge layer built in. ever evolving
- local first dashboard to manage issues manually
- project should have its own dotfolder. everthing must be inside of it.

$wayfinder is a skill I use for ideas that are still fuzzy. Instead of building right away, Claude turns the idea into a map in Linear: a ticket for every open question, and the order they have to be answered in. Then it works through the tickets, asking me questions in rounds. Every question comes with a recommended answer.

The link in my outline is WikiSkill, a paper I had only skimmed. Claude read it properly in its first minute and came back with the problem. The paper keeps a change only when a benchmark score goes up: "The catch is that the gating step assumes a benchmark, and an issue tracker doesn't have one."

## All as written

The first round came at 00:21: six questions about what we were even aiming for. Is the goal a spec or a working tool? One tracker per project, or one for the whole machine? How much of the paper goes into the first version? Under each question was Claude's recommendation.

I read them, agreed with all of them, and typed "all as written". At 00:26 came nine more questions, the last one proposing the first ten tickets. "all as written" again.

By 00:28 there was a map in Linear with ten tickets and the order between them. By 00:30, three research tickets were already running.

## Handing it over

Then I got tired. Properly tired. Over the next 45 minutes I handed it over in small steps:

• 00:31 "launch the next tickets with threads. and make sure threads report you back"
• 01:02 "all threads must be closed with commit and PR if there is any file change"
• 01:08 "make sure to pass all threads, any grilling sessions can be proceeed with recommended selections"
• 01:10 "if there is any hitl required with questions you can go ahead with recommended picks"
• 01:12 "you can act as advisor from now on make sure to finish the map after it finalised make sure to create the executions tickets. all executions has to be /implement-spec compatible. and you have my go to complete everything from now on lets get the ifrst version out"
• 01:17 "npm login done"

HITL means human in the loop: the questions that are supposed to wait for me. The 01:12 message is the one that matters. From then on, Claude answered its own questions with its own recommendations. It still posted every round "for the record", but nobody was reading. I went to sleep.

## While I slept

Drag the timeline above through the night. It says more than I can.

Every ticket on the map ran as its own Claude session, in its own copy of the repo. Each one asked its questions and answered them with its recommendations. Before deciding, it sent other agents to check its facts and to attack the draft from several angles. Then it wrote the decision down, opened a pull request and merged it. By 04:41 the map was closed: 14 tickets, 11 decision records, 17 pull requests, and around 300 questions that nobody but Claude answered.

Twice it went against something I had asked for. My one hard rule was that everything lives in the project's dotfolder. At 02:35 a session found that issue state can't live there safely, and moved it to a separate git branch. The main session flagged it: "This one changes one of your original requirements, so I need to flag it." It told me to say so if I disagreed. I was asleep, so it went ahead. At 04:13 it did the same with the knowledge layer.

It made a privacy call for me too. The tracker keeps short, redacted excerpts of what an agent did, and Claude noticed they could end up pushed to a shared remote: "Once pushed it can't be purged." So an install nobody is watching now records only facts, no excerpts.

At 05:07 it published the spec, 168,209 characters long. Then it checked the spec against everything it had decided, found 54 problems, fixed them all, and cut the work into 49 tickets. At 05:56 the build started: one agent per ticket writing the tests first, and another merging each change. Later in the morning it added three reviewer agents to attack every change before the merge.

Before the real code, it ran small experiments to check its own assumptions about Claude Code and Codex. One of them found that the command the spec used to start grimoire would never have run.

## Waking up

I woke up just before 8 and sent two messages. The second was "I dont have codex subscription to test out", because the plan had grimoire tested with Codex too. The answer: "That's fine. You don't need to do anything, and I won't ask you to log in to Codex again." It tested the real Codex app against a fake model instead.

Later, a test with 40 writers hitting the tracker at once started failing about half the time. Claude didn't make the test easier. Its note to the build session: "Don't lower the writer count or loosen that assertion to get green." It sent an agent to find the cause. It was a real bug, and now it's fixed.

## What it cost

I promised myself I'd be open about this, so here are the numbers from Claude Code's session logs, up to 12:15:

• 10,749 model calls, almost all of them on Claude Opus 5.5
• about 7 million tokens written by the model
• about 1.7 billion tokens read back from the cache: the same context, read again on every step
• about $712 at API list prices: $275 for the design, $52 for the spec, and $385 for the build so far

It all ran on my Claude subscription, not on the API. The dollar figure is what the same tokens would cost there.

## What happens now

As I write this it's a bit after noon, and Claude is still at it: 21 of the 49 build tickets are done, and there are 795 tests. At this pace it should finish sometime tomorrow morning.

I still haven't decided anything about grimoire myself. I haven't read most of what was decided for me. I don't know if it works, if it's useful, or if it'll ever be an open-source tool. The code is private for now.

So this isn't a launch, and it isn't a study. It's an experiment in AI-assisted prototyping, and I'll post here whenever there's an update. Next, I want to look at how Claude made those 300 decisions while I was asleep.

In Something About AI I wrote that I feel like the guy who builds the traps and watches. This time I didn't even watch.