A note about this build log entry: I published this after the week it covers. DevNitro reconstructed a draft from work-related entries in my journal, Git commit history, and time tracking. I reviewed, edited, and approved the final post. The story reflects what I knew and built at the time.

From the Backlog to the Build Log

Week of March 27 - April 2, 2026

What I Worked On

This is the week the work got a name. What I have been building is Intelligent Engineering, what comes after vibe coding. Two features this week are why that name finally fit.

The first is autonomous mode. Until now you chatted with the agent one turn at a time. This week I built an Autonomous Worker Loop Engine: you point it at an Epic, and it works through the child issues on its own. A coordinator manages the run over the server-to-CLI relay I built last week, each parallel worker gets an isolated provider so they do not step on each other, and there is a monitoring UI that shows you which issues completed and which failed as it goes. There is a stop-on-first-failure switch for when you want a tight leash. This is the difference between an assistant and an operating model. It runs from your backlog, and you watch it, instead of babysitting one prompt at a time. It picks up the thread from the autonomous billing build in January and makes it a real mode.

The second is visual verification. I added a new DevNitro.Vision project with a browser visual agent that starts your app and checks it end to end, plus on-demand screenshots relayed back to the web UI so you can see what the agent sees. An agent that writes code but cannot look at the result is guessing. Now it can open the page and confirm.

What the AI Did Well

The unglamorous star of the week was transactions. I had the agent add explicit transaction management to every write service, move stores onto a generic Store<T> base, and fix an orphaned-commit bug in billing where a partial write could slip through. That is exactly the wide, careful, correctness-critical work I want it grinding on, and it did it with regression tests. It also built a full-stack Git Explorer with a file tree and diff viewer, and an AI Provider Policy system so an organization can enforce which models are allowed, not just pick from a dropdown. I was happy about the Git Explorer because I had a need of it last week when I was on my phone wondering exactly what the files the agent had changed. Now I can see them, even when I am not at my desk.

What Needed Correction

Autonomy raises the stakes on old bugs. When one agent finishes and the next starts, stale tool results cannot leak between runs, or an agent inherits a ghost. I fixed that isolation. I also replaced my blunt hallucination handling with graduated recovery, so a suspected fabricated tool call gets escalating treatment instead of one hammer for every case. And I added urgent messages that can interrupt a running response mid-turn, because when the agent is off on a long autonomous run, you need a way to say "stop, not that" without killing the whole thing.

The honest part: an early tester still did not see the value yet. That is hard to hear and useful to know. It is a big reason I spent time this week not just building autonomous mode but sharpening what all of this is and why it matters. Undeniable proof plus a clear category is the job now.

What Shipped

DevNitro has an autonomous mode that runs an Epic's issues through a worker loop with a coordinator, isolated parallel providers, run monitoring, and stop-on-first-failure. It has visual verification through a browser agent that starts the app and takes screenshots the web UI can show. Every write service runs in an explicit transaction on a generic store base. There is a Git Explorer, an AI Provider Policy system with enforcement, graduated hallucination recovery, and mid-turn urgent interrupts.

The Numbers

Category	Hours
Product / Features	41h 14m
Content	7h 50m
Community	2h 18m
Total	51h 21m

Forty-one hours of product, split almost evenly across autonomous mode, visual automation, issues, and transaction safety. Four hard things in one week, which is why the content time this week went partly into figuring out how to name all of it.

Autonomous mode and visual verification are not two more features. They are the moment the platform stopped being a faster way to type and started being a way to run engineering. That is what Intelligent Engineering means, and this is the week I finally took time to specify on paper what that actually entails. Another book is likely in my future.

Curious how this site was built?
Watch the 5-minute walkthrough at devnitro.com →

April 3, 2026 Build Log: Autonomous Mode and Visual Verification