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 June 19 - June 25, 2026
What I Worked On
This week started with a failure that turned into the best feature of the month, and it sharpened a core rule of Intelligent Engineering which is simply the machine does the work, but it never gets to certify its own work.
I kicked off an autonomous run to build something, and it failed in a way that scared me: the work looked done, but git was a mess, because I had been letting the model drive git directly. An agent that controls your history can leave work stranded, commit to the wrong place, or produce something that does not even build, and still report success. So I changed the architecture. Now the runner, not the model, owns git in autonomous mode. The agent is forbidden from git writes entirely. Each worker's isolated workspace context is the only source of truth about what it did.
Then I added the piece that makes it trustworthy: a green-trunk gate. Completed work only lands if it builds and passes tests, verified against a pinned base commit so the check is deterministic. To make that possible, the build and test commands now live in the blueprint's committed meta file, so DevNitro always knows how to build and test any project made from that blueprint. The agent reports completion through a dedicated tool, and the runner finalizes only on evidence, a green build and green tests, not on the agent's word. This is the direct sequel to the worktree merge bug I fought last week. The lesson compounded: an autonomous run has to prove its work is good, not claim it.
The other big effort was a governance-first trust model for anything loaded from disk. Skills, agents, commands, and personas that come from a repo are now gated by content hash through a permission gateway, unified into a governed set. A skill from a repo is untrusted until it is approved, and the trust is pinned to exactly what it contained when you approved it.
What the AI Did Well
The green-trunk gate is a lot of careful orchestration, worktree git primitives, a base-commit-pinned verifier, a build-and-test wrapper, and the plumbing to persist the outcome server-side, and the agent built it as a tracked set of small, testable steps with almost ten hours of tests behind it. It also added paging to the noisy tools, issues show, list_directory, and the shell tool, so large output gets paged instead of chopped off, which makes the whole thing more reliable.
What Needed Correction
The status system bit me. Rolling issue status up to ancestors, so closing a child updates its parent, started causing database lock contention under load. I moved that rollup out of band and put a connection budget around unit-of-work usage so a cascade of status updates cannot starve the database. It is the kind of problem you only find when the system is doing enough at once to matter, which is a good problem to have.
And a non-code note I want to keep honest: I gave someone a quick demo this week and it did not land. That is on me, not them. It told me my value story still is not tight enough, and no amount of great engineering fixes a pitch that makes people say "that's beyond me." So some of this week went to sharpening how I explain what this is.
What Shipped
Autonomous runs now have a green-trunk gate: the runner owns git, the agent cannot write git, and work only lands if it builds and passes tests against a pinned base commit, with build and test commands declared in the blueprint. Local-disk skills, agents, commands, and personas are trusted by content hash through a permission gateway. Noisy tools page their output, ancestor status rollup runs out of band under a connection budget, and the README is rebuilt around the platform.
The Numbers
| Category | Hours |
|---|---|
| Product / Features | 21h 36m |
| Content | 14h 23m |
| Testing | 9h 34m |
| Docs / Skills | 9h 33m |
| Community | 3h 51m |
| Deploy / Infra | 1h 45m |
| Total | 60h 42m |
Nearly twenty hours on autonomous mode and another ten on tests. The green-trunk gate is the reason you can let a run go and trust what comes back. It still doesn't automatically merge the autonomous branch back into the original branch, because it is up to the developer to verify the work that was done was the work that was desired to be done. That is a critical part of Intelligent Engineering: the system can do the work, but it cannot decide for you that the work is what you wanted.
Where This Fits in Intelligent Engineering
Generation without verification is just activity. The faster an agent writes code, the more that matters, because you cannot read every line it produces overnight. Intelligent Engineering answers that by separating the work from the proof (the agent generates, the runner verifies against a pinned base commit, and only a green build with green tests lands). The agent never grades its own paper. That separation is what turns an overnight run from a gamble into something a team can trust, support, and scale.
An autonomous agent should never be the one to decide its work is good. It builds, the runner verifies, and only green trunk lands.
Curious how this site was built?
Watch the 5-minute walkthrough on YouTube →
0 Comments
No comments yet. Be the first to share your thoughts!
Leave a comment