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 April 24 - April 30, 2026

What I Worked On

Last week an autonomous run edited the wrong issues. This week was my answer to that: make the thing trustworthy, which is unglamorous and non-negotiable.

The biggest single push, over seventeen hours, was the test suite. I rebuilt it to run in parallel: reworked the xUnit fixtures, isolated test data through a factory so runs cannot collide, and made the schema scripts and foreign-key logic idempotent so a shared database does not become a source of flakiness. I will let you know how that went below.

The more important work was guardrails. After last week's incident, I hardened the agent's built-in tools. Shell execution got real security checks, including shell-metacharacter detection so an agent cannot smuggle a second command into one it was allowed to run, plus proper Unix-to-PowerShell translation so cross-platform commands behave. I added an IssueTool with its own security and filtering tests, and embedded a built-in IssueSwarm skill so the agent works its own backlog through a governed interface instead of poking at the database. An agent you let run autonomously needs the same kind of permission boundaries you would give a junior engineer with production access.

I also gave the agent eyes on the web: a browser-based search provider running through Playwright, with snippet cleaning to actually get results.

What the AI Did Well

The agent did the wide, careful work I lean on it for: the parallel test refactor, the idempotency logic, model-override support so a provider instance can pin a specific model, and OpenTelemetry wiring so I can actually observe what the system is doing in production. It also refactored the worker loop onto per-thread dependency scopes with event-driven signaling, which matters a lot for running several agents at once without them stepping on each other. This would have been a week of just that work, but I also had it build the web search provider and the IssueSwarm skill, which are both wide features with their own security and test requirements.

What Needed Correction

First, parallel tests got worse before they got better. At one point I was down to a stubborn four failing tests and the suite was taking longer than it did before I parallelized it, around five minutes versus four and a half. Parallelism is not free speed. It is a tradeoff you have to earn by killing every shared-state assumption, and I had more of those than I thought.

Second, autonomous mode ran only one worker at a time when it should have run several. The cause was subtle: the first issue blocked the others, and by the time it finished, the idle workers had already stopped looking for work. I fixed the worker lifecycle so idle workers keep watching for newly unblocked issues. When I set up a run having the blocker issue complete, all three workers ran in parallel exactly as they should.

What Shipped

DevNitro has a parallel test suite with isolated data and idempotent schema logic. The agent's shell and issue tools have real security guardrails and tests, and it works its backlog through a built-in IssueSwarm skill. It can search the web through a Playwright provider if a Brave Search API key isn't provided. It's not as good, but it does return results. The worker loop runs on per-thread scopes with event-driven signaling, model overrides are supported, and OpenTelemetry is wired in.

The Numbers

Category Hours
Testing 17h 27m
Product / Features 8h 24m
Content 8h 24m
Deploy / Infra 6h 50m
Docs / Skills 1h 21m
Community 1h 5m
Business 0h 26m
Total 43h 57m

Seventeen hours of testing and most of the product hours spent on guardrails. Not a feature-launch week. A make-it-trustworthy week, which is the harder and more valuable kind.

The three-word test I hold DevNitro to is software a team can trust, support, and scale. Trust is not a vibe. It is guardrails on the tools, isolation between parallel workers, and a test suite that tells the truth. That is what this week bought.

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

An AI built this blog (but not this post)

This entire blog system (domain models, database, services, UI, auth, etc.) was built by DevNitro on its own in 95 minutes. I recorded every second.

    We respect your privacy. Unsubscribe at any time.

    Built with Kit