One hour is enough for one small outcome. Split it 5 minutes to set up, 35 to run the agent, 15 to review the diff, 5 to write a handoff note. By the end of this post you'll have that session on one page, a PROGRESS.md template to paste, and a table that tells you when to accept, fix or throw away what the agent wrote.
Run the whole evening from this one page
The split is my starting layout. Move the numbers around to fit your night.
Before (5 min)
- Commit a working state.
git statusshows nothing pending. - Write the goal in one sentence.
- Write the check: one test, one click path or one command that must pass.
- List only the files and logs the agent needs.
Run (35 min) 5. Ask for one thin slice: requirement, code and test together. 6. Keep the approval prompts on and read each one. 7. No second task in the same conversation.
Review (15 min)
8. git diff HEAD. Compare the changed files to your goal sentence.
9. Look for files you didn't name, a new dependency, a changed build or CI file, or a long random-looking string in a config file. Any of those: stop and deal with it first.
10. Run the check. Then accept, ask for one fix, or throw the change away.
Stop (5 min) 11. Fill in the handoff note below. 12. Close the session. Tomorrow starts from the note, not from the old chat.
The rest of this post is why each step is there and how to do it.
Cut the goal until you can say how you'll know it's done
You don't get a second try at 9 p.m., so the goal has to fit the hour. Writers who work with coding agents recommend one session with one clearly scoped outcome, then a fresh start. Here's the size test: can you say how you'll know it worked in one sentence?
"The signup form saves an email and shows a thank you message" passes. "Build the onboarding flow" doesn't. If the goal needs two sentences, do the first one tonight and write the second into the handoff note.
Cut vertically, not by layer. One slice holds the requirement, the code and the test together. "All the database work tonight, all the screens tomorrow" leaves you with a wide layer that runs nowhere. A thin slice that works end to end is something you can check at 9:40.
Not sure what to hand the agent at all? The 3 question test for which tasks to hand to an AI agent filters that before you write the goal.
Commit first, because the commit is your undo button
A clean working tree gives you a "before" to compare against. It also makes the whole run reversible: commit a working state, let the agent try, and if it goes wrong, git restore puts the files back. Skip the commit and a bad run costs you the run plus the cleanup.
Want the whole hour to live on a branch you can delete? Run git switch -c tonight-session before you start.
Hand the agent only what the change needs. Keep standing rules short in your project rules file (CLAUDE.md or AGENTS.md), and pull in only the files, logs and task context the current change needs. Don't paste the whole repo.
Agent not set up yet? Do that on a weekend, not in your hour. The safe Claude Code setup for non-developers covers it.
Restart at the first repeat, not the fifth
Ask for the requirement, the code and a test in one go. Don't open a second task in the same conversation. When you fully switch tasks, start a new conversation, even in the same repo.
Here's the rule: the moment the agent's answers get worse or start repeating, stop and restart with a short handoff note. Pushing on costs you the minutes you spend arguing with a tired chat, and you still end up restarting. If you use Claude Code, run /context to see how full the context is before quality drops, not after a warning appears.
Keep the permission prompts on for deleting files, running shell commands and installing packages. They cost seconds. A surprise install is exactly what you want to catch.
Never end the hour with an unreviewed diff
At 15 minutes left, stop adding and start reviewing. Read the whole diff, including the boring parts. Two failure types hide there:
- Files you never named. Unrelated edits slip in and surface days later.
- Build or CI changes. A stray edit to a build or CI file can break tomorrow's deploy, and you won't connect it to tonight.
Then run the code. Click the page, call the endpoint, run the test from your check. AI-written code can read fine and still behave wrong. If you haven't run it, you haven't reviewed it.
One more rule: if reading the diff takes longer than the 15 minutes you gave it, the slice was too big. Throw it away and cut tomorrow's goal in half. Don't skim it.
Working in VS Code? The editor's diff view shows agent edits, so the same steps work without a terminal.
Accept, fix or throw it away
| What you see | Do this |
|---|---|
| Diff touches only the files you named, check passes | Commit with the goal sentence as the message |
| Right idea, one file is wrong | git restore path/to/file, keep the rest, rerun the check |
| Agent touched files outside the goal | Revert those files first, then judge what's left |
| New dependency, CI change or key-like string | Stop and sort that out before anything else |
| Wrong or half done, and nothing worth keeping | git restore . and start tomorrow with a thinner goal |
| You can't read the diff in your review block | Throw it away. Cut the next goal in half |
Careful with git restore .. It also throws away edits you made by hand and haven't committed. Commit your own edits first.
Paste this handoff note into PROGRESS.md
The last five minutes are the cheapest and the most skipped. A PROGRESS.md in the working directory holds what was done, decisions taken, current state and next steps, and it replaces the old chat. Keep a session block at the top of the file. Fill in Goal and Check before you start. Fill in the rest at the end.
Goal: [one sentence]
Check: [the test, click path or command that must pass]
Files: [only what the agent needs]
Done:
Decision:
State:
Next:
Example for illustration:
Goal: Signup form saves an email and shows a thank you message.
Check: npm test passes; submitting the form adds a row.
Files: signup.js, db.js, signup.test.js
Done: signup form saves email.
Decision: no confirmation email yet.
State: tests pass, deployed to staging only.
Next: add thank you page.
Tomorrow you open the note, not the old chat, and skip ten minutes of working out where you were.
Three mistakes that eat the hour
- Starting on a messy working tree. Your half-finished edits mix with the agent's, and a restore would throw away your work too. Commit or stash first.
- Relying only on the tool's own undo. Some agent tools have rewind or checkpoints. A git commit works in every tool, so make that your default.
- One long chat across several nights. Answers degrade, so your hour goes to fixing the agent instead of the app.
Some work doesn't belong in a one-hour agent run at all. Read what you should never automate with an AI agent before you point the agent at anything with money, customers or deletion in it.
Do this in the next ten minutes
Open the project you plan to work on tonight. Run git status. If it's clean, create PROGRESS.md and write the Goal and Check lines from the template. If it isn't clean, commit or stash first. That's the whole setup.
Got a task that should already be automated?
If a manual job keeps eating your evenings and you'd rather get it built than chip away at it an hour at a time, email me the task and what you've tried.
