Nightshift: Let the Fleet Work Overnight Without Letting It Run Wild

There is an appealing version of autonomous software development that sounds like this: give an AI the backlog, close the laptop, and wake up to a finished product.

There is also the version that can actually be trusted.

TransistorKit’s Nightshift is our attempt to build the second one. It turns a project’s planned backlog into a bounded overnight work queue, gives each item to a builder, tests the result, and keeps the work isolated on a dated Git branch. In the morning, it reports what genuinely shipped, what failed, what it cost, and exactly where the changes live.

The important part is not that Nightshift works while you sleep. The important part is that it knows when not to claim success.

The backlog is the contract

Nightshift does not begin with an open-ended prompt like “make the app better.” It begins with the project backlog.

Before a run, TransistorKit computes an eligibility queue from the open items already attached to that project. The queue can require planned status and acceptance criteria, skip work that is blocked or still needs human input, filter by platform, and sort by priority. A maximum-item limit prevents a long backlog from silently becoming an unlimited overnight mandate.

The eligibility screen shows both sides of that decision. Users can see which items are ready, change which eligible items are included tonight, and inspect why the others were skipped. An item may be missing acceptance criteria, blocked by a dependency, waiting for clarification, outside the chosen platform set, or simply beyond the run’s item cap.

This matters because autonomy is much safer when the selection rules are visible before execution. Nightshift should not invent scope at 2:00 a.m. It should execute work that has already been described well enough to judge.

One backlog item at a time

TransistorKit normally talks about fleets, but Nightshift deliberately processes its queue sequentially.

One backlog item is dispatched for its relevant platform target or targets. The builders get the project context and the item’s goal, and Nightshift waits for that item’s result before advancing the queue.

Parallelism is wonderful when a person is present to compare attempts, answer questions, or stop duplicated work. Overnight, it can amplify cost and confusion. Sequential execution makes the budget attributable, keeps the working tree easier to reason about, and lets each result determine whether the run should continue.

It also gives the failure circuit breaker meaning. One bad item can be parked and the queue can move on. Several failures in a row are evidence that the assumptions, environment, or provider may be wrong, so Nightshift stops instead of spending the rest of the night proving the same point.

Every night gets its own branch

Before a run touches the project, Nightshift creates or switches to a branch named with a configurable prefix and the current date:

nightshift/2026-07-31

The branch is cut from the project’s current branch and becomes the boundary around the entire run. Nightshift never treats main or master as a valid place for an overnight commit. It checks again at commit time, not merely at startup, because a safety rule that is only verified once is mostly a wish.

If the worktree is no longer on the expected Nightshift branch, the result is parked rather than committed. The morning report retains the base branch so it can calculate the real diff and tell the user what to review.

This is the same principle we use throughout TransistorKit’s Git integration: experiments belong on branches, and consequential merges belong to the user. Nightshift can prepare a branch worth keeping. It cannot decide that sleeping through the review counts as approval.

“Accepted” has a strict meaning

The core Nightshift loop has two meaningful outcomes: accept or park.

An item is accepted only when the builder finishes successfully, its build and self-test are green, the worktree is still on the Nightshift branch, and there are real changes to commit. Nightshift then creates a Git checkpoint for that item and records the actual commit SHA. Only after that does the backlog item become done.

No commit means no shipped claim.

That rule catches a surprisingly important edge case: an agent can finish with a confident summary while producing no committable change. A conversational success message is not an artifact. Nightshift refuses to put such an item in the shipped column.

Each accepted item receives its own commit. The branch history therefore maps directly back to the overnight queue, making it possible to inspect, cherry-pick, revert, or discuss one result without treating the night as an indivisible blob.

Failure is parked, not disguised

If a builder fails, is stopped, produces no changes, or misses the required green self-test, Nightshift parks the item.

Parking does three things:

• It records the failure reason in the Nightshift run.
• It adds an honest Nightshift comment to the backlog item.
• It returns the item to a planned state for human review or another attempt.

The item is not marked done. It does not appear under “shipped” in the morning report. Its failed attempt is not silently dropped.

This distinction sounds obvious, but it is one of the hardest product problems in agentic software. AI systems are very good at narrating progress. A trustworthy build system has to grade artifacts and outcomes, not tone.

Nightshift’s report is built from the persisted result records themselves. The shipped list contains only accepted items with real commit SHAs. The parked list contains the corresponding reasons. The headline counts are derived from those same arrays, so they cannot drift into a more flattering version of the night.

Budgets are stop conditions, not suggestions

An unattended run needs hard edges.

Nightshift can stop on four independent rails:

• A wall-clock limit.
• A token limit.
• A TransistorKit coin limit.
• A configurable number of consecutive failures.

The default configuration allows up to six items across a four-hour window and stops after three consecutive failures. Token and coin caps are optional, so a user can set the ceiling that matches the provider and project.

The engine checks these rails before dispatching every new item and again on a timer while a builder is active. That second check matters: a wall-clock cap would be meaningless if one long-running builder could sail past it simply because the queue had not advanced.

Users can also stop a live run manually. Nightshift cancels the active builder, finalizes the work completed so far, marks untouched queue items as skipped, and still produces a report. Stopping the night does not erase its history.

Follow the normal model—or pin one for the night

Nightshift can follow the project’s normal provider and model selection, or pin a specific model for overnight work. It can also limit the queue to selected project platforms.

This gives the user control over a practical tradeoff. Routine backlog cleanup may not need the strongest model available. A difficult native feature or constrained retro build may justify one. The decision belongs in the run configuration, where it can be reviewed alongside time and spending caps, rather than hidden inside each dispatched prompt.

The configuration is per project and stored beside the project under .transistorkit/nightshift.json. Run history and morning reports live in a separate sidecar. Atomic writes keep a crash during persistence from truncating the record.

You can watch without having to babysit

Nightshift includes a live observatory for the nights when “unattended” still means “I am curious.”

It shows the active branch, current builder, elapsed time, token and coin usage, queue progress, item phases, and self-test results. The user can open the underlying agent transcript or stop the run.

The screen is deliberately observational. Nightshift is supposed to reduce the need for constant steering, not turn overnight work into another dashboard that demands attention. Its job is to make the current state legible when someone chooses to look.

When the run finishes, TransistorKit can post a local notification. The durable report remains available even if the notification is missed.

The morning report is the handoff

The morning report is the payoff—and the final safety boundary.

It names the Nightshift branch and shows a real Git diff summary: files changed, insertions, deletions, and commit count. Accepted items appear with their short commit SHAs and self-test summaries. Parked items appear separately with the reason each one returned to the backlog.

The report also shows time used, the configured time cap, tokens and coins spent, and the stop reason. A cleanly exhausted queue looks different from a run stopped by budget, repeated failures, user action, or an internal error.

From there, the user can review the branch with TransistorKit’s normal Git and GitHub tools, open the diff, publish it, create a pull request, or merge it after inspection. Parked items can be re-queued into a fresh run without pretending the earlier attempt never happened.

Nightshift does not automatically merge into main. Waking up to a reviewable branch is the feature. Waking up to an irreversible decision would be a failure of product design.

Why we built it this way

The tempting way to design overnight AI work is to optimize for spectacle: more agents, more parallel tasks, a triumphant notification announcing how much shipped.

We optimized for a quieter thing: confidence.

That led to a set of rules:

• Start from approved, legible backlog work.
• Show what was excluded and why.
• Process unattended work sequentially.
• Put the entire night on a dated branch.
• Require a green result and a real commit before calling anything shipped.
• Return failed work to the backlog with an explanation.
• Stop on time, spending, or repeated-failure limits.
• Persist enough evidence to reconstruct the night.
• Leave the final review and merge to a human.

Autonomous development should not mean removing judgment from software creation. It should mean moving human judgment to the places where it matters most: defining the work, setting the limits, and deciding what becomes part of the product.

Nightshift handles the hours in between.

You go to sleep with a backlog. You wake up with a branch, a report, and the truth about what happened.