From the Backlog to the Build Log

Concurrent Autonomous Runs: September 11 - September 17, 2026

What I Worked On

Most of this week went to content. I spent two days testing AI video generation on my local GPU, with DevNitro driving ComfyUI through its MCP tools, and I cut a seven-minute Blender-to-Unity video from real footage. DevNitro got under four hours of my time. It got 41 commits anyway, because three autonomous runs did the work Wednesday night while I monitored. Intelligent Engineering means the work comes from the backlog and runs while you are not typing. This week I ran two concurrent autonomous runs on the same repo for the first time.

The runs came out of a bug. Wednesday afternoon my DevNitro API key expired in the middle of a session. The web UI went quiet. The CLI showed every tool call failing at 0ms. The agent was still talking to Claude Code, burning tokens on tool calls that could not run, and nothing it did reached the database. The UI gave no hint why. That turned into three epics: handle key expiry mid-run, resume the provider session and fork conversations, and allow two autonomous runs on one workspace. Forking a conversation at an earlier message had been on my list for months. This was the push to build it.

What the AI Did Well

Tuesday I pointed an agent at the 100 issues sitting in review and asked it to check each one against the code. Fifteen minutes of my time. It worked for an hour, closed 87, and left 13 with a reason. Two were critical. One was a graceful shutdown that could never finish: System.CommandLine gives Ctrl+C a two-second termination timeout by default, and the listener needed up to 25 seconds to release its workstreams. The agent raised the timeout, swapped a blocking Wait for await WaitAsync, and bounded the total release time. The other was a hub test I had asked for and never got.

Wednesday the agent traced the expired-key bug. The relay read the API key once at startup. The SignalR socket stayed open after the key expired, so messages kept arriving while every HTTP call got a 401 that the code swallowed. Its first fix rotated the key by writing DefaultRequestHeaders.Authorization. Then it caught its own race: HttpHeaders is not thread-safe, and parallel workers share the client. It replaced that with a DelegatingHandler that stamps the bearer token on each request from a volatile field. Rotation became one atomic swap. All 120 unit tests passed.

Then it planned the concurrent runs epic. The umbrella branch for a run becomes a ref under autonomous/ that no one checks out. Fast-forwarding it is a compare-and-swap update-ref. The listener caps agents across all runs, and the server allows a second run on a workspace only when the listener reports it can handle one. The test proves two runs integrate on their own and never move main's HEAD. This builds on the worktree work from May. I ran that epic alone, deployed, then ran the resume epic and the fork epic at the same time. Both finished. Conversations now store the provider session host and the last primed sequence, resume warm with a fallback to history priming, and show a badge with the resume result. You can edit an earlier user message and send it as a new branch.

On this HowdyChad blog, which I built with DevNitro, I planned table-backed lead magnets Tuesday and ran the issues autonomously while I ran errands. Seventeen commits, from the SQL table through the Dapper store to a Blazor admin page and integration tests, in under half an hour.

What Needed Correction

Merging the two parallel branches into main hit a conflict in AgenticChatService, as expected, since both epics touched the resume path. The agent resolved it by keeping one epic's context prep and porting the other's provider reset into it. Tests stayed green.

One agent added a compile guard for Docker, where the Claude SDK is not present, and got it wrong. I fixed it by hand. I will restructure that code so the guard is not needed.

Earlier in the week, Lobast fired four credential-backed calls at once and I got four password prompts instead of one. Those calls now run one at a time per session.

The blog's paging broke after last week's deploy. A prerendering data reuse bug in Blog.razor. One agent, one fix, deployed Wednesday night.

What Shipped

DevNitro deployed twice Wednesday: first the concurrent runs, then the session resume, message forking, key rotation, the Lobast fix, and a shared chat message length limit. The HowdyChad blog deployed with table-backed lead magnets and the paging fix.

The Numbers

Category Hours
Content 48h 15m
Business 11h 15m
Testing 2h 20m
Product / Features 0h 59m
Deploy / Infra 0h 26m
Total 63h 16m

Product time came in under four hours and produced 41 commits. Content took 48 hours, most of it AI video generation experiments on my 3090. Business was GTM planning, which I ran past the advisory board feature in DevNitro to consider anything I could be missing.

Where This Fits in Intelligent Engineering

The expired key was the failure that matters most this week. The agent kept spending tokens on tool calls it could not make, and the record stopped. A tool that keeps going after it has lost its link to the organization is a coding assistant working alone again. The fix makes the platform fail loud, rotate the key, and keep the record whole. That is the support half of trust, support, and scale.

Three epics, two of them as concurrent autonomous runs, all from one expired key. Back at it next week.