Letting it run.
The first repository built the second one. On the fourteenth of May I asked the wiki system from part one to set up a new repo with a contract in it: what the system was for, what it could touch, what it had to ask about. Then I turned off the permission prompts, and I asked it to read its own rules and tell me where they leaked.
It found eight holes. The first one was the question I had not thought to ask. What counts as the environment? I had written rules about the repository and said nothing about the machine around it. The rest were the same shape. A rule that looked complete from where I stood and had an edge I could not see from there.
That night I made two notes to myself. Stay curious and stay playful. And the human leads. The model never gets to tell you what your goals are. Then I turned the prompts back on and went to read about hooks. A hook is how a rule becomes something a machine checks instead of something a model remembers.
Two weeks later I tried to skip to the end. I had a research project with a design on paper, and I asked the system to fill in the whole thing in a day. It failed the way I had guessed it would before I pressed enter, and I pressed enter anyway. The note afterwards: We have to define the modules. We cannot just have the model fill in the blanks. That is the three-day lesson one level up. Ask the right question, and then ask it for each piece of the thing rather than for the thing.
By the end of June the building blocks existed. Most of them worked on their own. Together they did not, and I wrote it down that way. The calls are not efficient, the tools don't quite see each other. I was solving problems other people have already solved, on purpose, because I wanted to understand them rather than use them. That part I would do again.
The next night I turned the harnesses on and let them run, and I recorded a note I have not been able to soften since. I'm a little bit afraid of what I've made here. There was an entirely different level of force available now, and I could feel how little stood between an instruction and its effect. A week after that I sent six notes in a row asking to take the soft safeguards out and let the system do well-specified work on its own. Both of those are true at once, and I have stopped trying to reconcile them.
The part that worked, worked. The idea that caught me in the first place was a system that takes a task in plain English and picks out the tools it needs by their names. AI2 is genuinely quite good at finding the skills it needs and using them on demand. Just over two thousand commits, thirty-one decision records, standing systems that ran on their own. It was a real thing.
Two problems, and I named them in August, when someone asked me what finished would mean. The first: nothing reviewed the work except me. It was essentially all running through me to determine if the output was good or not. The second: sprawl. Many systems that each worked and were not well linked. There are many different valid paths that work could attempt to flow through. So if I want to get agentic there, I'm essentially taking a dice roll and just hoping that the system picks the path that I had in mind. Or I remembered the exact sequence and dictated it. I was investing most of my decision making just on how to call things.
By late August the contract had grown to thirty-three thousand characters, a rule at a time, every rule with a reason and the whole thing something nobody could hold in their head. The moment it was clearly over was small. A guard I had written blocked a word count of the contract, because the command named the contract. I had an outside model review the whole thing three times over, adversarially. My own verdict at the end was seven words. Intent well understood, implementation bloated and sloppy.
In September I said it plainer, to the system itself. I was becoming caged by my own rules. I had to manually tell the system when and how to run that machinery. I didn't want to have to tell you that. I wanted you to just do it. But it was by my own design.
What I wanted was to let it run. What I built was a system I had to steer by hand through paths I had laid down myself, and check by eye at the end. The fix was not a patch. You cannot loosen a cage by adding bars. So the third repository started with one commit I had to type by hand, because the system was not allowed to install its own rules.
That is part three.