From a Shelved App to a Ring on My Desk
I studied mechanical engineering, all the way to a PhD. I took programming classes as an undergraduate, decided it wasn't for me, and dropped it; I preferred mechanics and numerical analysis instead. Working as a researcher left me with one habit: no data, no analysis.
Since the summer of 2025, I have been working with AI coding agents. In that time I have posted one paper on arXiv (not yet peer reviewed), and my repositories have reached twenty-six. This story starts with an app I chose to shelve and ends with a small device on my desk, the hobby I put the most into right now. That device came out of a daily annoyance of mine, and it is also where the ways of working I built up across many repositories came together.
1. The App I Shelved (Summer to Fall 2025)
The AI in the chat window gives you code. Not the whole file, just the part that changed. You hunt for where it belongs, paste it in the wrong place, the app breaks, and you ask again. If you have ever built something with AI, this scene is probably familiar.
I got tired of it too, and in August 2025 I used a coding agent for the first time. I was building a desktop app that handled repetitive Excel tasks through buttons and natural language, and around the same time I first asked what GitHub was. Around then I stopped trusting any single AI. At first it was one AI designing and another implementing; by September, one AI drew up the plan, another argued against it, and a third carried it out. Which one was right, I decided by testing it myself, and when something broke, I pasted the logs as they were instead of describing the symptoms.
The next scene will feel familiar too. A feature that worked yesterday doesn't work today. When you look, the AI deleted that code while fixing something else. My rate-limiting logic quietly disappeared once, and another time the core function of a filter was wiped out entirely.
So I wrote a rules file the agent reads before anything else. Don't delete existing code on your own. Don't leave placeholders that don't run. Don't rewrite documents; edit only what changed. But rules only made accidents less likely; they didn't tell me what had changed when one happened. So in October I added a separate working protocol. After editing a file, the agent had to write down three things: what it changed, how to verify it, and where it left the record.
I never put that app out. In the fall my day job got busy and I set it aside for a while, and when I came back, the research in the next chapter had become the priority. The app had been a bet on a time window from the start. Excel already had Copilot, and I was aiming at the gap before it became good enough: a place where people who find Excel hard could ask for work in plain language. But in the fall of 2025, as Copilot quickly improved at planning and running multi-step tasks inside Excel on its own, I judged that the window had closed. So I stopped development. I still keep that repository, though. The rules file and the protocol were born there, every project since started from there, and the research in the next chapter grew out of it.
2. A Different Answer Every Time — A Paper That Made It Public (November 2025 to July 2026)
The context you explained at length yesterday, the AI doesn't know today. Ask the same question twice and the judgment shifts a little. So you fix the prompt, add more explanation, and ask again.
That was me too. In November I asked an AI whether there was a tool to make my work a bit easier, and things grew from there. A two-line question got back a whole architecture document, and following it I split the AI into three roles: system design, decision support, and thought checking. But the more material I gave each role, the blurrier its judgment became. So I wrote down, as a structure, how I break down problems and in what order I make judgments, and had all three roles read it first.
Then I asked the AI whether this could be a paper. I figured it would only be a paper if there was data to test it, so from late November I started on the formalization and the experimental design. I named it the Cognitive Kernel Model (CKM). Its principles are to keep state outside the conversation and carry it forward, to record decisions and their grounds, and not to mix observed facts with interpretation and emotion.
In December, while deciding what the first experiment should measure, something clicked.
"Oh, right — the CKM core came from me. That's why it separates out emotion and uses facts and interpretation to make the reasoning more consistent and accurate."
I had written down my own way of judging, so I already knew the source was me. What clicked that day was the reason. Why I thought my habit of separating events, interpretation, and emotion could make an AI's judgment wobble less, it came together into one line of thought then. I tested that hypothesis with experiments. I submitted the paper to arXiv in June 2026; in July I first published a reproduction package that lets anyone check the data and recompute the numbers, and then the paper went public on arXiv. It was the first result I put out into the world, but it has not passed peer review, so this isn't the end either.
3. What Carried Over When the Tools Changed (2026)
These days you hear "the AI wrote all the code" everywhere. In February 2026 I moved my main tool to Claude Code, and about two weeks later I had handed over almost all development to it. Other AIs only did verification. Since then, the repositories I started on whatever caught my interest have reached twenty-six. Games, an engineering calculator, a 3D-printed globe, an indoor rover, structural and fluid analysis experiments, a paper-writing pipeline — the fields are all over the place, but the way of working carried through as one. Looking back, that way of working has more than one source.
- Every repository has rules the agent reads first, and irreversible actions are blocked by mechanical safeguards, not by documents. This came from watching code disappear in the first app.
- Claims that involve physical hardware get a verification level. I write separately what is only documented, what has been built, what the device responded to, what I confirmed with my own eyes, and what has been matched for accuracy. I raised the problem of verification claims that kept inflating; Claude Code proposed a format; I chose it and spread it to the other repositories.
- I write down predictions before seeing results, and I don't erase wrong judgments; I append corrections.
- An audit agent with no write access and AIs from other companies review the work separately. This carries over a standard I learned while writing the paper: others must be able to check it again.
- I rebuild the setup for each repository to fit its purpose, and gather what keeps reappearing across repositories into a common template. Telling which of those pieces truly survived because they were useful is still hard.
Written like this, it sounds as if I have the AI tightly tied down, but in practice holes keep showing up. A guard that blocks dangerous commands was checking only terminal commands, and I found out late that commands run through a plugin tool bypassed that check, so I turned the plugin off. Another time, a verification level that wasn't in the definitions table was used in the records for more than a day, until a closing audit run on four different models caught it and I added the definition. Having safeguards and having safeguards that work turned out to be different things. So my work is less about building safeguards and more about keeping the cycle of finding holes and fixing them running.
4. The Hobby I Put the Most Into (July 2026 – )
Run several agents and a certain annoyance appears. One session is done, one is still going, one is waiting for my answer. To check, I flip through terminal tabs one by one, and only much later find the session that had been waiting for me. With more than twenty repositories and five or six running at once, it became a daily annoyance.
I started with an off-the-shelf keypad. Pressing a key ran a script, and the backlight color showed the session state, and that was about it. It couldn't answer questions or approve actions, so in September I switched to a board with a round touchscreen, a knob, haptics, and a ring light. I didn't erase the first version; I moved on to the next one with a record of what it lacked.
As I built it, the device became a place to test everything I had learned in the other repositories at once.
- Watching code disappear in the first app had left me with mechanical safeguards against irreversible actions; here they guard places on the board, like its permanent-write areas, that can never be undone once written.
- The verification levels I refined in other hardware repositories did their job here too. The example code said the ring had thirteen LEDs, but when I opened it up and counted, there were twelve. Color combinations that looked good on my monitor looked weak on the actual ring, so I chose them again based on the real thing.
- The habit of writing predictions before seeing results is what I used to find why the screen stuttered. Instead of fixing by guesswork, I wrote down predictions and then timed things inside the board to tell the causes apart.
- Each time I close out a piece of work, four different models review the records separately, and when the session changes, the work picks up again from records kept outside the conversation. The research in chapter 2 and the methods in chapter 3 are exactly how this device is developed.
Here is how I use it on my desk now. The ring is split into one segment per session, each showing its name and state, and when an agent is waiting for my answer, its segment changes color. I catch it out of the corner of my eye while doing something else, and tapping the segment takes me straight to that session's window. I pick from the options or approve an action right on the device's screen. The same question appears on my PC screen and on the device at once; whichever I answer first is the one that goes in, and the question on the other side withdraws itself. To put it as I have confirmed it: checking status, answering, and approving I use every day, while the shortcut-pad features I put in alongside them I use less than I expected. I am building it so you can watch coding agents from several companies, not just one, on the same ring, and I use it on both Windows and Linux.
This device is called TTAgentRing.
5. So Am I Being Dragged Along by AI?
While putting this together, I asked myself: someone who uses AI this much, am I being dragged along by it?
In execution, I don't think so. I discount the AI's praise, I don't take any single AI's verdict as is, and the final call I make myself, from logs and tests. But in the size of the game, there were moments I was pulled along. Like the two-line question in chapter 2, the AI's response made the work bigger, and the repositories grew to twenty-six. With AI bringing the cost of starting close to zero, it also became easy to get pulled into new branches.
So I decided to ask three questions whenever I start something new.
- Is there still a reason to do this once you take away the AI's evaluation?
- What will I put off if I start this?
- Where does it end?
The first question alone isn't enough. For someone as curious as I am, almost everything passes the first question. Having a reason to start and needing to do it now are different matters.
Here is how TTAgentRing answers the three. Take away the AI's evaluation and the reason remains: it is an annoyance I lived with every day. What gets put off while I do this isn't other repositories, it is my review time. The agents run in several repositories at once, but the person who reads the results and judges whether they are right is just me, so time spent on the ring means results from other repositories pile up waiting for review. And the end is the day this device gets used on someone else's desk, not mine, without me standing beside them explaining it. A tool that only runs in my hands is just fitted to my habits; I think it closes as a thing in its own right only when someone else can use it without a manual. Whether that person keeps using it after that isn't the end but the next question. One is the standard for closing this project; the other measures whether the thing was worth anything.
Looking back, I have gotten used to finding and fixing errors. The records show that. I have also tried deciding when to stop, with the first app; the paper made it out in public; and there are a few tools I built and use every day. What I have not yet done is close something out as a thing that stands on its own in someone else's hands. This time I set that end in advance. Whether I get to that day is the check still left for me.
About This Piece
This isn't a memoir I wrote from scratch. An AI agent gathered the session records from 14 months of conversations with AI and the work records of each repository and reconstructed them into a draft, and I and other AIs revised it while checking the facts. The draft had real errors in several places. The start date was a month late, the paper's publication date was given as its submission date, a habit I don't have had been slipped in plausibly, and the reason I stopped the first app had been guessed as failure from a few scraps of records. The first three were fixed by checking against the records; the last one I fixed myself on reading it. My way of cross-checking with several AIs was used that way inside this piece too.
The dates and events come from the records; the interpretation that ties them into one flow is something I, today, added. Where I wrote "looking back," please read it that way. What this piece shows goes only as far as this: if you keep records outside the conversation, you can take them out and use them again a year later. It isn't proof that my whole way of working is right.
What to build and why, and what is correct, I decide and check myself. Most of the code and documents were written by AI coding agents. About how the device works and performs, I write only what I have confirmed on the real thing.