From the Backlog to the Build Log

An Autonomous Run Builds a GTM App: September 18 - September 24, 2026

What I Worked On

Monday evening I handed DevNitro a plan for a new GTM app on Blazor, had it write the issues, and left my desk. By 11 that night an autonomous run had built the app one vertical slice at a time: 49 commits in about five hours, from the SQL tables to the integration tests. That is the point of Intelligent Engineering. The work runs from the backlog whether or not you are sitting there.

The rest of the DevNitro week went into the platform itself. A Friday autonomous run split the Core project, and a database update I skipped showed me an agent could still run with no record, so I fixed that first. Thursday I moved role admin into the GlobalCove Technologies Framework (GCT), the shared library under every DevNitro app.

What the AI Did Well

The run worked through the slices in order: companies and CSV import, contacts, company detail, the research handoff, an evidence check, and an overview dashboard. Each slice got its SQL, domain models, Dapper stores, services, controllers, Blazor pages, and integration tests before the next one started. I checked on it from my phone a few times. It never needed me.

The evidence check is where Jev comes in. I got access to Jev this week and used it to decide company fit. The app never asks Jev whether a company is a good fit. It asks four narrow questions. Jev answers each one from a packet of evidence the app builds, and code makes the call. A company only gets suggested as Qualified when Jev has high confidence of certain values for those questions. Tuesday I added a bulk assessment dialog so I could run a whole list through Jev at once and auto-qualify the ones that passed.

Tuesday night I gave the run a second plan: research runs, a hosted worker with restart recovery, and a queue for the work a person still has to do by hand. About three hours and fifteen more commits.

Inside DevNitro, an agent fixed a slow spot in the conversation log. Each append loaded the full log text, added a line in C#, and wrote the whole value back, so every append cost more than the one before. Now the database does the append, with .WRITE on SQL Server and || on PostgreSQL and SQLite, chosen through the dialect. Thursday another agent moved user and role admin out of DevNitro and BlankSite into GCT and added a guard: an admin can only manage a user or role when that admin holds every privilege the target carries. While it was in there it caught user IDs typed as int in one controller when it should have been a long.

What Needed Correction

The GTM app came out more complex than it needed to be, and the UI flow is clumsy. The run built what the plan asked for, so the fix starts with the plan. Next time I'll likely start with a UI/UX-focused plan to simplify the app from the outset.

The first version of the Jev questions came back "unclear" far too often. I rewrote the policy twice. Now the companies are being flagged as a fit or not in a manner that makes sense to me. Though, there are a couple of times that Jev didn't provide the answer I would have expected. But it was just a couple out of the couple hundred.

Friday's DevNitro refactor deployed fine, but I forgot to run the database update. DevNitro could not create the conversation record, logged a warning, and dispatched the agent anyway. The agent worked with no transcript and no link to its issue, the same kind of failure last week's expired key caused. A failed conversation create is now fatal. The same run added a deploy preflight gate that builds DevNitro.Application with the Dockerfile's flags before the Docker build starts.

Wednesday I added four models: Opus 5.5, GPT 6 Sol, GPT 6 Luna, and Grok 4.7. Grok has been a provider since August. Grok 4.7 stopped midway through one run in the DevNitro harness, but I've not carved out time to determine why yet.

What Shipped

The GTM app runs on my machine, and I used it later in the week to work through companies. DevNitro deployed Friday after a refactor of some code, plus the fatal conversation check. It deployed again Thursday with the four new models, the log append fix, and the shared role admin. BlankSite and the blueprint took the same framework update.

The Numbers

Category Hours
Content 23h 1m
Business 16h 35m
Testing 6h 9m
Product / Features 2h 59m
Deploy / Infra 0h 45m
Total 49h 29m

Content took the largest share of the week, most of it scripting and planning a content queue. DevNitro product, test, and deploy time came to 9h 53m, and most of the testing hours went to running the GTM app through DevNitro.

Where This Fits in Intelligent Engineering

The Jev check is the idea this week. The AI supplies evidence, and a rule I can read makes the decision. When the answers went wrong, I did not argue with the model. I changed a versioned policy and ran it again, and every cached answer refreshed. That is what a check that runs looks like, and it is the trust half of trust, support, and scale.

One evening, one autonomous run, and an app I used all week. Next, I trim the plan it came from.