- Using AI when you inherit someone else's system means reading the thing before you change it, and the artifact knows more about itself than anyone left in the building.
- Inheriting a mess is most people's first serious encounter with a system they didn't build, and the gap is never skill. It's context.
- Old outputs state rules the formulas don't. Fifty input and output pairs will give up the exception nobody wrote down.
- Version history is a decision log. Parts edited in one week were a project; a rule untouched for three years names a vendor you left.
- The build item is documentation generated from the system itself, so the handover page can't drift the way the last one did.
- Honest closer: some of what you inherited should be deleted rather than documented.
Somebody left. The spreadsheet stayed. Using AI when you inherit someone else's system means pointing it at the thing you now own and didn't build: forty tabs, an automation nobody can explain, a client file with no history, a folder scheme that made perfect sense to a person you've never met.
Here's what makes this different from learning any new tool. A tool has documentation. An inherited system has a previous owner, and the previous owner is gone. In the 2026 Stack Overflow Developer Survey, 61% of more than 12,000 respondents said important context lives in people's heads, the second most common barrier to getting the context they need for work, behind information simply being incomplete. That's the whole problem in one line. The knowledge wasn't destroyed when the person walked out. It was never written down.
Which turns this into archaeology, and archaeology is reading, ranking, and translating. Every idea below treats the system as evidence about itself. None has appeared in this column before, each one ends with something you can do this afternoon, and where a step needs no AI, it says so.
1. Get It Explained Back to You, Part by Part
Marcus took over the pricing workbook on a Tuesday, three days after its author's last day. Nineteen tabs. One of them was called "DO NOT USE (old)" and was referenced by four live formulas. His instinct was to open each tab and read down the column, which is how you spend a week and learn nothing.
Paste the structure instead and ask for a walkthrough built one part at a time: for each tab, rule, or automation step, what goes in, what comes out, and what breaks if it's missing. Three fields per part. The output is a map rather than an essay, and you can read a map.
The move most people skip is the second half of the prompt. Ask it to finish with a numbered list of everything it couldn't determine from what you gave it. That list is the actual deliverable. It's your agenda for the one call you get with the person who left, or for the afternoon of digging that replaces that call. A model will describe a formula confidently whether or not it understood the sheet it points at, so the gaps matter more than the summary.
One thing to check in the first hour, before any of this: who owns the connections. Zapier's help center has a whole article on this because automations commonly run on the departing person's account, and deactivating their login stops the workflow with no error anywhere.
Start today: paste the tab list plus the formulas from one important column. Ask for inputs, outputs, and breaks-if-missing per part, then a numbered list titled "what I cannot determine from this."
2. Map What Depends On It Before You Call Anything Unused
The dangerous question isn't what the system does. It's who's downstream. An inherited spreadsheet usually feeds a report, a billing run, a mail rule, a dashboard someone screenshots for a board deck, or a client who gets a PDF every Friday and would tell you loudly if it stopped.
Ask for the dependency list in the direction people forget. Not what this file reads, which is the easy half, but what reads this file. Give it the tab names, the external references, and the list of scheduled jobs or automations in the account, and ask it to name every consumer it can see plus the kind of consumer it would expect for a system like this. Expected consumers are a checklist to go verify.
Then confirm with the application's own tools, which are more reliable than any description. Excel draws arrows between a formula and the cells it uses through Trace Precedents and Trace Dependents, documented in Microsoft's support documentation, and the external links list shows the other workbooks reaching in. Those features need no AI at all. AI's job is turning the result into sentences you can send to the four people who turn out to be affected, and the spreadsheet jobs that come back every month are the ones worth handing off once you know who they feed.
Start today: run Trace Dependents on the three cells that look most important, then open the external links list. Paste both results and ask which consumers are implied that you haven't accounted for.
3. Read the Dates as Decisions
Every part of an inherited system carries a timestamp, and nobody uses them. Version history, last-modified dates, comment threads, and run logs will tell you when each piece was last touched, and that single axis separates deliberate from merely old faster than any amount of reading.
Parts edited within the same week were one project, done by one person with one goal in mind. A rule untouched for three years that names a vendor you stopped using in 2024 is dead weight wearing a uniform. The exception handler added the day after a bad month is somebody's scar tissue, and it's load-bearing.
So export the change log and ask for it grouped into episodes: clusters of edits close together in time, each with a one-line guess at what prompted it and which parts it touched. Google's version history keeps this for Docs and Sheets, and Google Docs Editors Help covers naming versions and seeing who changed what. Ask for the guess and the evidence separately, because the guess is a story and you only want to keep the evidence.
Start today: open version history on the inherited file, copy the list of dates and editors, and ask for the edits grouped into episodes with the apparent reason for each. Mark anything whose last edit predates a system you've since replaced.
4. Generate the Handover Doc From the System Itself
Here's why the handover you didn't get never existed. Documentation written from memory is accurate for about a month. Then somebody adds a tab, the doc doesn't change, and within a year the doc is one more artifact nobody trusts. The previous owner probably wrote one. It's probably in a folder. It's probably wrong.
The version that survives is generated from the thing it describes. A standing job reads the system on a schedule and writes the current state into one page: tab and step names as they are now, the formulas or rules in each, when each part was last changed, which accounts the connections run on, and who has access. Nobody maintains it, because nothing about it is typed by hand. This one you hand off rather than keep doing, and it goes in the place people already open, so the wiki page updates itself instead of waiting for whoever remembers.
It pays off twice. Once now, while you're still learning the thing, and once on the day you move on, which is the day the whole problem repeats with you cast as the person who left.
Start today: write down the five facts you'd want on one page about the inherited system, then describe where each one can be read from automatically. Those two lists are the whole specification.
5. Find the Rule in the Old Outputs
Teodora inherited a shipping fee sheet that was right about nine times out of ten. The tenth invoice came out wrong and no formula explained why. She read the sheet four times. The answer wasn't in the sheet.
Every system that ran for years carries behavior nobody wrote down: one customer billed at an old rate, a rounding convention from a finance lead who retired, a row type that gets skipped, a minimum nobody mentions. That behavior lives in the outputs, not the logic, because the logic is where somebody's intention was recorded and the outputs are where reality was.
Give it fifty real pairs from the archive, inputs beside the results the system produced, and ask what single rule would produce all fifty. Then ask the better question: which rows does the stated rule fail to explain. Those rows are your undocumented behavior, and now you can go ask one specific question instead of a vague one. The sheet said 12%. Teodora's unexplained rows were all one freight class, which turned out to be a verbal agreement from 2023 that somebody honored by hand each month.
Start today: export fifty historical records with both the inputs and the result. Ask for the rule that explains all of them, then for the list of rows it can't account for. Work the second list.
6. Write Both Cases for Deleting It
The honest closer on this topic: some of what you inherited should be deleted rather than documented. Writing a careful explanation of a report nobody has opened since 2023 is work that produces a new maintenance obligation.
Take the part nobody can explain and ask for two short documents. First, the case that it's dead: no reads in the run history, no downstream references, no edits in three years, no mention in any message you can find. Second, the strongest case that it's load-bearing, written as though its removal already caused an outage and the model has to explain how. Reading them side by side is faster and more honest than deciding alone, because your bias when inheriting a mess runs hard toward delete.
If both documents come out thin, you don't know enough yet. That's a useful answer too. And note what AI can and can't do here: the evidence lives in run logs and access reports, which you pull yourself. AI assembles the argument from the evidence, and the argument is the part that's hard to write when you're new and nervous.
Start today: name the one component you understand least. Pull its last run date and any references to it, then ask for the dead case and the load-bearing case in under 150 words each.
7. Keep a Confusion Log While You're Still New
You get about two weeks. In that window you can see exactly what's confusing about the system, because you're confused by it. After that you adapt, the weird parts stop looking weird, and you quietly become the person whose context lives in their head.
So keep a log while the confusion is fresh. One line every time something doesn't make sense: what you expected, what you found, and what it turned out to mean once you knew. Thirty seconds per entry, no formatting, no structure. A notes file is fine.
At the end of the second week, hand the log over and ask for it turned into an orientation page ordered by what trips a newcomer first, with your "what it turned out to mean" lines kept as the answers. It writes itself from material that only exists because you were new, and it belongs somewhere the next person will search rather than in your downloads folder. This is the one idea here that costs you nothing and pays somebody you'll never meet.
Start today: open a blank file called confusions.txt and add the first entry now. Expected, found, meant. Set a reminder for two weeks out to turn it into the page.
Pick One
Seven ideas, one inherited mess. Don't run all seven at it. If something is due this week and you're scared to touch it, start at number two and find out who's downstream. If it mostly works but lies occasionally, number five will find the lie. If you're three days into the job and drowning, number seven costs thirty seconds a day and is the only one that gets harder the longer you wait.
Sunday's roundup reports what changed in AI, Wednesday's Loop builds one workflow end to end, and this column hands you the ideas sitting between the two. The repeating half of owning a system you didn't build, the filing and the watching and the keeping-current, belongs in the agent workflow directory rather than on your calendar every Friday.
Let the System Write Its Own Handover Page
Point BYOBot at the spreadsheet or automation you took over and say what you'd want to know about it on a Monday morning. It builds the agent that reads the thing and keeps that page true.
Frequently Asked Questions
- Document the parts you can see and keep an explicit list of what you cannot determine yet. A full write-up before you touch anything stalls for weeks, because some of the behavior only reveals itself when you use the thing. Explain it back to yourself part by part, map what reads from it, then work with the unknowns list open beside you and close entries as you learn them. The version that stays true is generated from the system rather than typed.
- The artifact is still a record of its own history. Version history tells you when each part was last touched, run logs tell you what fired and what stopped, comments and sheet names carry the vocabulary the previous owner used, and old outputs show the rules the formulas don't state. Those four sources answer most of what a handover conversation would have covered, and you can read them without anyone's help.
- It reads what you paste, which means it can't see the links you didn't include, and it will describe a formula confidently whether or not it understood the sheet it points at. Use the application's own dependency tools for anything load-bearing and treat every explanation as a hypothesis to confirm. The habit of checking its claims against a source is a skill in its own right, covered in what to do after it gets something wrong.
- Less than you'd think. Version history, run logs and trace tools are features you already pay for, and reading them needs nothing but a free afternoon. AI earns its place on the translation jobs: forty formulas into a plain-language map, three years of edits into a short list of episodes, fifty old outputs into one stated rule. The repeating parts, especially keeping the documentation current, are the ones worth handing off to an agent.
