Turn sleep into build time

The slowest part was the waiting

Describe what I wanted. Wait. Read what came back. Notice it was not quite right. Describe it again. Wait.

That is not building. That is watching a build, with the only hours in the day when I think clearly.

So I split the work in two. The deciding happens in the day. The building happens at night.

An overnight build has one failure mode: the moment it needs you. Everything below removes those moments before you go to bed.

1. Stay in plan mode

Most of the day goes here.

Four things get settled before any work starts. What it changes. Why it exists, in words a user would recognize. What it must not touch. And what done looks like.

The fourth is the one people fudge. They write "done when the feature works". Nothing can check that at 3am without asking you what working means.

A finish line names a thing to open and a thing to see inside it. Open this page, see this number. Run this command, see this file with more than zero rows in it.

If you cannot say what you would open to check it, you have not finished thinking. Overnight compute will not finish that thought for you.

2. Write the verification plan

Not what to build. What to check, and the corner cases to catch.

Then ask what the check cannot see.

A check that cannot fail on a category proves nothing about that category. It comes back green, and green gets read as proof.

The image at the top of this post is an example. The first version came back at exactly the right shape, which was the only thing I had thought to check. It was also missing its entire bottom third. The content had overflowed a fixed canvas and been cropped. A shape check returns the right answer whether or not the content fits inside the shape.

The second check compares each section against the box it sits in. It failed by 14 pixels and named the section. I would not have caught that by eye.

Say blind, not clean. If the change lives outside what the check compares, the answer is "this check cannot see that". Not "nothing changed".

3. Make it unattended

Every piece self contained and verifiable, so it never stops mid build to ask you to check something.

Anywhere it would ask me a question, I decide the answer first. Not "check with me if the file already exists". Skip it and log it. Not "confirm before rolling back". A rollback overnight is a good outcome and it leads the morning report. Every branch ending in a question mark becomes a default I chose while awake.

When a piece genuinely cannot proceed, it skips that section, writes down why, and carries on. A run that halts at step two wastes the night. A run that skips step two and finishes the other five does not.

Ordering matters as much as content. I scheduled a safety check last. It gated work scheduled three steps earlier. Every step was correct. The sequence deadlocked.

Give it permission to tell you that you were wrong and stop. If the thing is already built, or the reasoning does not hold, halting is the right outcome. On one run, 4 of 5 work streams found my written assumptions did not survive the real system. Stopping was the deliverable.

4. Ask for the morning report

What is live vs what was asked, what went wrong, what is next. Specified before it starts, not after.

You wake up to a document written by the same thing that did the work. That is a report, not evidence, and it will sound confident either way.

Three things make it readable in five minutes.

It opens with what is live right now, in one sentence. Not what was built. Not what was attempted. What a real person would hit if they opened it this morning.

Every claim says what it was read off. A passing test, a database query, a screenshot and the report's own prose are four different kinds of evidence. Only one of them is prose.

How the run went stays separate from how bad the findings are. A run where every step completed cleanly can still surface something serious. Collapse those into one status and the serious thing hides behind the word green.

Two setup notes

Keep the computer awake, but locked. A machine that sleeps takes the build with it. This is the most common reason a first attempt produces nothing.

Set permissions to auto. If the tool asks before it writes a file or runs a command, you have not built an unattended run. You have built something that waits for you.

Where this goes next

Throughput was never the win. The win is that the spec has to be finished before I sleep, and that made me better at putting together a great plan.

Take the next thing you plan to hand to any AI tool. Read your instructions back and mark every point where it would stop and ask you something. Decide each one now, in writing, while you are awake.

You will find more than you expect. That count measures how underspecified the request was, and it decides whether you get something useful back in five minutes or in five rounds.

Works the same for a personal project, a side AI hustle, or the bottleneck workflow at work.

If you are working this way, or you know someone who is, I am happy to compare notes.

Let's chat if you want to talk about AI automations.

Automate. Ascend.