Imagine you are about to renovate a house you have not walked through in a month. You have a list in your head: the kitchen needs gutting, the wiring is probably shot, half the rooms are unfinished. You hire the crew, you order the materials, you are ready to start swinging hammers.
Then you walk the house first. And the kitchen is fine. The wiring is fine. Most of the rooms you thought were bare are actually finished. The only real problem is that none of the rooms connect properly — there are no doorways between them, so the house works but nobody can find their way through it.
That was our week.
The brief we wrote ourselves
We run a ministry training programme that gives real people their own AI assistant and a shared online space to work in. A new group of trainees was on the way, and we had convinced ourselves the welcome experience was rough and unfinished. We had notes describing what was broken. We had a build plan ready. The instinct was to start building.
Before we did, we made ourselves walk the house. Not read our own notes about the house — actually open it up and move through it the way a brand-new person would, on the day, exactly as it really was.
That walk overturned the brief.
What we expected, and what was actually there
We had assumed big chunks of the welcome experience were missing or half-built. They were not. The foundations were far more finished than we had given them credit for. A new person could be invited, could sign in, got their own private space to work in, got their own assistant waiting to talk to them. Most of what we had budgeted to build already existed.
The real gap was not in the rooms. It was in the doorways between them.
A brand-new person signing in for the first time met silence where there should have been a hello. They landed on an empty board with nothing on it to react to. There was no obvious first thing to do — nothing that said "do this one task and you have arrived." And the one-time setup that every trainee has to go through was not yet smooth enough to repeat.
The house was built. What was missing was the welcome at the door that tells a new person the place is alive and waiting for them.
That is a completely different job from the one we had scoped. We had budgeted to lay foundations that were already poured. The actual work was small, and it lived entirely in the gaps between things that already worked.
Five things our own notes had wrong
The more uncomfortable discovery was about our own notes. We had written things down as fact three weeks earlier. When we checked those facts against the live system, five of them were simply wrong — wrong about where something was running, wrong about whether a piece was missing, wrong about why an error kept happening.
None of these were dramatic mistakes. They were the ordinary drift between what you believed when you wrote a note and what the thing is actually doing today. But every single one of them, left unchecked, would have aimed real effort at the wrong target. We would have "fixed" things that were not broken and ignored the things that were.
Why the hour was worth it
Walking the house cost us about a day. Skipping it would have cost roughly two weeks — building foundations that were already there, chasing an error in the wrong place, and polishing a room nobody ever entered.
There is a quiet pull in this kind of work toward starting the build straight away, because building is the visible thing and checking first feels like a delay. Here is the opinion I will stand behind: for anything already up and running, the check is not a delay. It is the cheapest way to find out that the plan you are about to pour weeks into is pointed at the wrong half of the problem. A brief written from memory is a guess. The live system is the only thing that can confirm it.
We rewrote the plan after the walk-through. The new one was smaller, and it shipped. The original — had we run it — would have been bigger and half wasted.
The transferable bit
If you are about to spend weeks improving something you already run, spend a day first checking that it is actually what your notes say it is. Walk it live. Walk it as the newcomer, not as the person who built it. What you find may not be what you set out to fix — and learning that before you start is worth far more than the day it costs.
For the technical reader
The "walk the house" step was a live audit against production, performed the way a first-day trainee would experience the flow, not a read of our own change notes. The platforms underneath were more mature than the brief assumed: invite-to-register worked, each trainee already received their own conversation channel bound to their own agent, login auto-provisioned a workspace, the work-item model worked, and a demo seeder existed for populating a fresh workspace. The gaps were all in the connective tissue — a missing reliable first-contact greeting, a blank board instead of a pre-populated one, no guided first task, and a laptop setup that was not yet repeatable.
The five corrected notes, each confirmed against the running system:
- The primary agent was running on a different server than our notes recorded.
- An orientation capability we had logged as missing was in fact loaded and active.
- A recurring error we had attributed to one component was coming from upstream — restarting the service we suspected would never have fixed it, because that service was not the cause.
- The surface we had described as blank for a new trainee was a different surface from the one that was actually blank (the work-item board, not the workspace).
- Several smaller component-ownership assumptions — which part did what, whether a key was shared or per-trainee, which skill commands actually worked — did not survive contact with the live system.
The reframe (mature platforms, thin seams) reordered the entire build plan and removed roughly two weeks of work scoped against foundations that already existed. The transferable rule: hand-checked or long-lived production state drifts from your documentation faster than you expect, and only a live walk-through as the end user reveals it before it costs you build effort.