AI for Small Business: What to Redo When the Model Changes

Eight days before I wrote this, a batch of models was switched off.

Not dramatically — no announcement in your inbox unless you were using them directly. OpenAI published the shutdown date in April, 23 July 2026 arrived, and the models stopped answering. The same page lists what is queued next: a set of GPT-5 and o3 snapshots on 11 December 2026, and three product features on 30 November, including the one that stored reusable prompts on OpenAI's side. The migration advice for that last one is to move the content into files you control.

That is this article's argument, written by the vendor, on the vendor's own page.

Almost everything written about AI for small business stops at month one, and month one is the easy part. You paste your instructions into a chat, it works, you feel clever. Year two is where it gets awkward: the model changes underneath you, you hire your first helper and have to hand the thing over, and you realise you never wrote down which parts contain client names.

This is the last of ten pieces. The other nine each build one file. This one shows the finished folder, a checklist for the day a new model ships, and the list of things to strip out before another human sees it. If you have not read the others, start here — the recap below is enough to follow along.

What you'll take away

• A full folder layout — five parts, all plain text, nothing to install.
• A rerun checklist for the day your model changes generation: three questions, in a fixed order.
• A delete list for handing the folder to someone else, including the strings to search for.
• Why last year's notes are the only way to judge this year's results.
• Where the free tutorials stop and the paid packs start, stated plainly, once.

What a one-person business actually hands over — and what it doesn't

Start with the inventory, because the search results will not give you one. I checked page one for ai for small business on 31 July 2026: the top slot is an AI-generated summary, five of the seven ordinary results are vendor pages selling their own product, one is a government explainer, and one is a Reddit thread of people asking each other what they actually do with it. None of them assumes you have already built something.

Here is the split that matters more than any tool list. The third column is the important one.

The third column is not a matter of taste. In North Carolina, the rule requiring a lawyer to review trust account statements and cheque images each month says the review cannot be delegated — the state bar's handbook explains why: the lawyer is the one who might notice a cheque made out to a member of staff. California's trust accounting handbook makes the same point from the other end: hiring a trained bookkeeper is allowed, and you remain personally responsible anyway. In Florida, a contractor's final payment affidavit must be sworn, and courts have treated serving it as a precondition to enforcing a lien at all.

None of that changes when the model gets better. That is why it goes in writing.

💡 In plain terms: "a folder" means what it sounds like — five or six text files in a directory on your computer, openable in Notes, TextEdit or Notepad. Nothing to install, nothing to log into.

What surprised me while looking for the size of the prize: the American Bar Association's study of malpractice claims from 2016 to 2019 put administrative errors at 19.59% — calendaring failures 7.4%, clerical errors 4.08%, procrastination in follow-up 3.45%, failure to react to the calendar 2.54% — with client relation errors adding another 16.7%. Roughly a third of those claims had nothing to do with whether the lawyer knew the law. That third is the first column above.

The nine files, in the order you write them

Each is its own article. One or two sentences here is enough to know whether you need it.

One — what an assistant actually is. A chat answers one question at a time; give the same tool a goal, a file to read and somewhere to write, and it takes several steps on its own. The difference isn't intelligence, it's whether it can read your files and repeat the job tomorrow — the side-by-side of one job done both ways.

Two — the file that stops you repeating yourself. Every conversation starts from nothing, so the three sentences you retype each morning go into one file it reads first. Five lines is a legitimate start: writing your first rules file.

Three — how your trade says things. A "matter number" in a law office, a "job number" on a build, a "reference" in a ledger: same idea, three vocabularies. Write down your terms, formats and the phrases you never use — getting the wording right for your trade.

Four — steps written for something that won't fill in the blanks. A procedure written for a person can say "review the relevant materials", and a person knows what that means. Write for something that doesn't and every step needs the file to open, the lines to check, what to do when they don't match, and who to ask. The before-and-after of a real procedure is the busiest of the ten, because everyone already has procedures written the other way.

Five — how you check the work. Quality doesn't come from watching every time; it comes from a written list you run before anything goes out — the checking list, including what went wrong before there was one.

Six — the three columns above. Sorting jobs into hand over, draft only, and never is the one to send to whoever in your office worries about risk.

Seven — what it remembers, and where. Two different things wear the same name: what you wrote down travels with the folder, what the assistant worked out about you sits with the vendor. The comparison of what each platform stores shows which half you can take with you.

Eight — when one set of instructions gets too big. Splitting a job across several files helps up to a point and then stops helping; when to split and when not to covers the "not", which is the case people skip.

Nine — the same folder on three platforms. Same files, three places, what came out differently, what each cost, how many minutes the move took: the three-platform run is where this article's claim gets tested rather than asserted.

The whole folder, on one screen

Everything those nine produce, in one place. Copy the structure, fill it with your own trade.

my-work/
├── AGENTS.md          ← what it reads first: who you are, how your trade
│                        words things, and where everything else lives
├── jobs/
│   ├── intake.md      ← steps for taking on a new client or job
│   ├── delivery.md    ← steps for getting work out the door
│   └── month-end.md   ← steps for closing the books
├── checks/
│   ├── before-sending.md   ← what must be true before anything leaves
│   └── month-end.md        ← what must reconcile before you close
├── boundaries.md      ← the three columns: hand over, draft only, never
└── memory/
    ├── decisions.md   ← rulings you made once and don't want to remake
    └── runs.md        ← dated notes: what you ran, what came back wrong

The name AGENTS.md isn't mine. It's an open format OpenAI published in August 2025 and handed to the Linux Foundation's Agentic AI Foundation in December 2025 — the same foundation that took over the Model Context Protocol from Anthropic. Checking the standard's own site on 31 July 2026: plain Markdown, 23 named tools listed as reading it, no schema, no required fields, no version number, and an FAQ saying you can use any headings you like. If your tool wants a different filename — some look for CLAUDE.md, some GEMINI.md — the contents are identical and only the name changes. The table at the end covers that.

What it was built for is build steps, test commands and code style; every example on the site is a software repository. I could not find a professional body, trade association or firm publishing anything about using it for the actual work of a practice. That gap is why this series exists — and if it does exist and I missed it, tell me.

Here's the index file that ties the folder together. Copy it and replace the bracketed parts.

# How to work on this

## Who this is for
I run [a two-person conveyancing practice / a residential remodelling
outfit / a bookkeeping desk with 14 monthly clients].
When you help with something here, you are helping with that.

## Words I use
- [Matter number] means [our internal reference, format ABC-2026-001].
- [Punch list] means [items still outstanding at substantial completion].
- Never write [“guarantee”, “we recommend”, or any figure I have not given you].

## Where things live
- Steps for each job: `jobs/`
- What to check before anything goes out: `checks/`
- What you must not do without me: `boundaries.md` — read this one first
- Decisions I have already made: `memory/decisions.md`

## Order of operations
1. Read `boundaries.md`.
2. Read the job file for the task I named.
3. Do the job.
4. Run the matching file in `checks/` and tell me which lines failed.
5. Do not send, file or submit anything. Hand it back to me.

## When something is unclear
Stop and ask. Do not guess a client name, a date, or a figure.

Three things about that file took me a few passes. The order of operations is numbered because unnumbered lists get reordered in practice. Step 5 exists because "do not send" is the single instruction most worth repeating. And there is nothing about which model to use, which is deliberate — that is the part you want to be able to change.

When a new model ships, rerun what you already ran

Here is the maintenance job nobody warns you about when they sell you on AI for small business. It's short.

Why it isn't optional is on the vendors' own pages. OpenAI's deprecation page says older models are retired regularly and software depending on them may need updates to keep working, then sets out the notice: at least six months for generally available models, at least three for specialised variants, and as little as two weeks for preview ones — with a warning against building anything business-critical on the preview tier unless you can move quickly. Anthropic's equivalent page commits to at least 60 days for publicly released models, and its table bears that out: Opus 4 and Sonnet 4 were announced on 14 April 2026 and retired 62 days later, on 15 June.

Both figures come from the vendors' own documentation, checked 31 July 2026. Neither is unreasonable. Together they answer the question you should be asking: how long can I ignore this? Somewhere between two weeks and six months, depending on what you picked.

So when a new generation arrives, take three jobs you have already run — one from each job file — and run them again. Then look at three things, in this order.

One: how would this generation do it now? Not "is it better." Specifically: which steps exist only because the last generation needed hand-holding? A step reading "give it the client name twice, it forgets" was a workaround, and workarounds expire first.

Two: did the thing that used to block me get fixed? Everyone has a job they gave up on. Write those down when you give up — that's what memory/runs.md is for — then retry them unchanged. Highest-value ten minutes of the exercise, because a job you abandoned six months ago is a job you're still doing by hand today.

Three: what is newly risky because it got stronger? The one people skip, and the one that bites. A more capable model attempts more: it will have a go at the step where it used to stop and ask, produce a more confident wrong answer, fill in a client reference it inferred rather than leaving it blank. Every check you wrote because the old model was cautious needs rereading, because it is no longer cautious.

Copy this into checks/switching.md.

# When the model changes generation

Date: ____________
Old: ____________  New: ____________

## Rerun (one job from each file)
- [ ] Intake job:      ______________  result: same / better / worse
- [ ] Delivery job:    ______________  result: same / better / worse
- [ ] Month-end job:   ______________  result: same / better / worse

## 1. What can I now delete?
- [ ] Steps that existed only to work around the old model
- [ ] Repeated instructions that are no longer needed
- [ ] Examples added because it kept getting the format wrong

## 2. What was blocked that isn't now?
- [ ] Reread `memory/runs.md` for every job marked "gave up"
- [ ] Retry each one unchanged
- [ ] Note which now work — these are the wins

## 3. What is newly risky because it is stronger?
- [ ] Does it now attempt steps where it used to stop and ask?
- [ ] Does it now fill in blanks it used to leave empty?
- [ ] Does anything in `boundaries.md` need stating harder?
- [ ] Reread every check written because the old one was cautious

## Record
- [ ] Add a dated entry to `memory/runs.md` — including what stayed the same

🔍 Why that order: do question three first and you will panic and over-restrict. Do question two first and you will get excited and skip the cleanup. Clearing out stale workarounds first makes the other two answers legible, because you are no longer reading instructions that stopped mattering.

[NEEDS REAL RUN: the actual findings from a generation change — the three jobs rerun, what each returned differently, which workarounds turned out to be dead weight, and the one thing that got worse. Requires taking three jobs that ran on a previous generation and rerunning them unchanged on a current one, keeping both outputs side by side.]

Last year's records don't expire — they turn into the baseline

The instinct after a model change is to bin the old notes. They describe something that no longer exists, so what use are they?

They are the only thing that lets you judge the new one. "Better" is not a property of an output you're looking at alone — every output looks reasonable in isolation, which is the specific failure mode of this technology. Better exists only as a comparison, and a comparison needs the other half. If you kept a dated note saying the intake job missed the opposing party's name in two runs out of five, you can now say something concrete. If you kept nothing you have a feeling, and your feeling about a new model in week one is worthless, because it is new and therefore feels good.

This is also why those notes belong in your own files rather than in whatever the assistant remembers. Cursor removed its entire Memories feature in a 2.1.x release, and the path staff gave affected users was to export what was there and paste it into markdown rules by hand. GitHub Copilot's user-level preferences are owned by the billing entity that issued your licence, and are deleted automatically after 28 days of disuse. Neither is a scandal. Both are reasons the notes you care about should sit in a file with a date at the top.

memory/runs.md can be this crude:

## 2026-06-14 — month-end job
Ran on: [model]
Result: reconciled 11 of 14 clients. Failed on the three with
sub-ledgers. Gave up on those — doing them by hand.
Note: it invented a reference number once. Caught by checks/month-end-close.md line 4.

Four lines. In eight months it is the most valuable file you own.

Handing it to a second person

Eventually somebody else runs this — a part-time assistant, a new hire, a partner. The good news is the handover is a file copy. The rest of the news is that a file copy is not a working setup.

What you hand over. The folder, minus the next section. Plus one thing not in the folder: fifteen minutes watching them run one job while you say nothing. Everything wrong with your instructions surfaces there and nowhere else.

How they make it theirs. Don't ask them to adopt your wording. Ask for three things in week one: put their own name and role at the top of the index file and fix any sentence assuming it is you; rewrite one job file in their own words without changing a single step, because a step they can't restate is a bug in your writing; and add one line to memory/decisions.md for the first thing they had to ask you, because that question is the first gap.

What does not transfer. Say these out loud rather than letting someone discover them. The assistant's accumulated impressions of you don't move — no vendor offers an export format, and the closest thing two of the largest offer is a prompt you paste into a competitor's chat asking it to write out what it remembers, which you then copy back. The project container doesn't move either: the files inside are yours and already on your disk, but the container, its instructions and its history are not something you export and reload elsewhere. And where licences are issued centrally, material stored under the previous holder may simply be unreachable to the new one.

A boundary that survives the handover. Delegation moves the work, not the responsibility. The California trust accounting handbook is blunt: you may hire a properly trained bookkeeper, and you remain personally responsible to your clients and the state bar for the money regardless. boundaries.md says this in your own words, and it is the file the new person reads first.

[NEEDS REAL RUN: what actually went wrong the first time this folder was handed to a second person — the questions asked in week one, the instructions read differently than intended, and the steps that turned out to be unwritable without me in the room. Requires actually handing it over and taking notes.]

What you delete before you hand it over

This is the section with consequences.

Your folder accumulates specifics. That's what makes it useful and what makes it dangerous to copy. Before it goes to another person — or into a shared drive, an email attachment, or an account that isn't yours — run this.

# Before this folder leaves my hands

## 1. People and matters
- [ ] Client and customer names, including in examples
- [ ] Matter, case, job and invoice numbers
- [ ] Addresses, property references, site addresses
- [ ] Opposing parties, opposing counsel, third parties
- [ ] Anything about a prospective client who never became one
- [ ] Sample documents pasted in "just as an example"

## 2. Anything that acts as a key
- [ ] API keys, tokens, connection strings
- [ ] Usernames, passwords, portal logins, PINs
- [ ] Bank, trust and merchant account numbers
- [ ] Anything in a file named `.env`, `config`, or `local`

## 3. House style that isn't for sharing
- [ ] Fee rates, discount rules, what you charge which client
- [ ] Internal notes about specific clients ("always chases on Fridays")
- [ ] Positions you'd never put in writing to a client
- [ ] Anything about staff

## 4. Strings to search for before calling it done
- [ ] Your own name and email
- [ ] "@" — catches every email address in one pass
- [ ] Your area or country dialling code
- [ ] Your three largest clients' names
- [ ] Currency symbols followed by a digit
- [ ] The year, four digits — catches dates in stale examples

## 5. The part that isn't in the folder
- [ ] Clear or delete past conversations in the assistant itself
- [ ] Check any automatic memory feature and clear it
- [ ] If you're handing over an account rather than files, stop
      and create a new one instead

Section one deserves a note for anyone in a regulated practice. The duty to protect information from someone who consulted you and never became a client is not the weaker cousin of the duty to a client — the American Bar Association's model rule on prospective clients is unconditional, and the disqualification it triggers can be attributed to an entire firm. Kentucky's ethics opinion on intake goes further in the practical direction: the form it publishes carries a warning telling the prospective client not to hand over confidential information until the conflict check is finished. If your intake job file has a worked example in it, that example is exactly what the rule is about.

⚠️ The mistake that makes the rest pointless: deleting files does not delete what you typed. Every conversation where you pasted a client letter is still in that account's history, and on some platforms it is also feeding an automatic memory you cannot fully see — one vendor's own FAQ says the summary it shows you doesn't include everything it has stored. Hand over the folder, not the account. If it's the account, make a new one.

[NEEDS REAL RUN: which lines on this list were learned the hard way rather than reasoned out in advance — what turned up during a real pre-handover clean-up that wasn't already on the checklist. Requires doing one clean-up on a folder that has been in daily use.]

Three desks, one folder

The same five parts, reached from three starting points. If your trade isn't here the shape still holds — pick the equivalent of "the job I do every week and never enjoy."

A solicitor taking on new clients. Start with the order, not the content. The sequence in a law office isn't negotiable: minimum information, conflict check, and only then the story — because a lawyer who has heard the story cannot un-hear it, and the disqualification that follows attaches to the whole firm. So jobs/client-intake.md is a hard sequence with a stop in the middle: collect these fields, run the check, do not proceed until I confirm. boundaries.md says the conflict decision is mine. checks/delivery-check.md says the engagement letter doesn't go out until the written fee terms are in it — in California, an agreement that should have been in writing and isn't can be voided by the client, leaving the firm arguing about a reasonable fee instead of the agreed one. Three files, one afternoon.

A contractor closing out a job. Start at the end, where the money is. That sequence is fixed too: the contractor prepares the initial list of outstanding items, the architect verifies and amends it, then owner, architect and contractor each sign. So jobs/delivery-check.md covers list preparation and nothing else — signing is not something to hand over. The standard closeout certificate carries a line worth stealing into your own checks: the list may not be complete, and leaving something off it doesn't reduce the contractor's obligation to finish the work under the contract. Put that in checks/delivery-check.md and the assistant stops treating its own list as authoritative. boundaries.md gets the affidavit: in Florida it must be sworn before a notary, and courts have treated serving it as a precondition to enforcing the lien at all. Three files, one afternoon plus a closeout to test on.

A bookkeeper closing the month. Start with the thing that has a deadline. jobs/month-end-close.md follows the order a real policy uses — post everything, reconcile against the finalised ledger, close, and post nothing afterwards. One university's published policy states that last part in a single flat sentence, and that is exactly the kind of sentence that belongs in a file rather than in someone's head. checks/month-end-close.md carries the three-way comparison: ledger total, sum of individual client balances and adjusted bank balance must all agree, and where they don't the difference is explained in writing. boundaries.md carries the two things that stay yours — the monthly review of statements and cheque images, explicitly non-delegable for a lawyer's trust account, and payroll tax, where liability under the trust fund recovery penalty reaches an individual personally, can be assessed against more than one person in full, and survives bankruptcy. Three files, one month-end.

Same shape all three times. The folder is small. The sequence is written down, because the sequence is the part carrying the consequence. And the "never" column exists before the "hand over" column does.

Where the free part ends and the paid part starts

Once, plainly, then never again in this series.

Everything in these ten articles is the empty version, free and staying free. Follow them and you have a working folder and owe nobody anything. That isn't a loss leader with a catch — it is the whole demonstration.

The line is: what has been demonstrated is not held back; what takes additional assembly is what costs money. If a section of this article had been left vague so you had to buy something to complete it, that would be the other kind of business.

Two honest notes. The paid packs use the same file format as the free one, so if you buy one and later dislike us the folder still works — a design decision, not generosity. And the yearly one is worth nothing unless the rerun is real, which is the thing marked above as not yet done. Judge it on that when the numbers are published.

If you want the skeleton, the email box is at the bottom of this site. No account to create.

The bill

Cost is why most people search for AI for small business in the first place, so it deserves a straight answer rather than a range.

Structurally: this approach has no software cost, because the folder is text files. You pay for the assistant subscription you were already paying for, plus usage if you go past a consumer plan. No per-seat licence on a folder, no annual renewal on a text file, and no migration cost when you change assistant, because the files don't change.

The parts I can't yet give you honestly:

[NEEDS REAL RUN: the actual twelve-month bill — subscriptions, usage on top, and any one-off costs, broken out by month, for a small business running this folder. Requires exporting a real year of billing statements.]

[NEEDS REAL RUN: how long the whole thing took to build from an empty folder — total hours, split between the index file, the job files, the check lists and the boundaries file. Requires rebuilding it from scratch with a timer.]

And the number that matters most for the claim in the title:

[NEEDS REAL RUN: minutes to move the same folder between three platforms, and what came out differently on each. This is the ninth article's measurement and it does not exist yet — until it does, treat "it still works if I switch" as a design intention, not a measured result.]

I would rather leave three holes in an article than fill them with plausible numbers. If you have run something like this for a year, your figures are more useful than mine would be.

What I got wrong, and what I still haven't tested

The receipts, including the unflattering ones.

Checked 31 July 2026, and this matters because it changes: the standard's site lists 23 named tools, not the "30+" that circulates. The adoption figure everyone quotes — over 60,000 open-source projects — is the number published with the December 2025 foundation announcement, and the site has not revised it since, so treat it as a floor rather than a current count. It also counts files, not projects; one large repository can contribute dozens.

Three approaches I tried and rejected.

One file for everything. The first version was a single long document. Reads well, works badly: you can't hand someone one section of it, you can't tell what changed between versions, and past a certain length the later sections stop being treated as instructions. Splitting into a folder isn't tidiness — it's the only reason the handover section of this article is possible.

Letting the assistant maintain its own notes. Tempting, and it writes neater summaries than I do. Rejected because the point of memory/runs.md is to be evidence about the current model, and evidence written by the thing being evaluated isn't evidence. On the platform I looked at most closely those notes sit on the local machine and explicitly don't sync across machines, so it isn't even a backup.

Putting the model's name in the files. Every early draft said which assistant to use — the first thing to go stale, and the one line guaranteeing the folder needs editing on the day you switch. The index file above says nothing about which model runs it.

What is not tested, plainly. I have not run this folder for a full year. I have not been through a generation change with it and measured the differences. I have not handed it to a second person. I have not moved it across three platforms and timed the moves. Those four gaps are marked where they belong, and none is filled with an estimate.

And the thing worth saying out loud: I am not a solicitor, a contractor or a bookkeeper. I don't carry the assumptions of any of these trades, which is why I keep asking why a step exists rather than how to make it faster. Everything in the three-desk section is built from public material — published ethics opinions, a state bar's own handbook, contract documents filed in municipal council records, statutory text. I read the rules and built the folder around them. If you do one of these jobs and I've got a sequence backwards or missed something that matters in practice, tell me. That correction is worth more to this series than another thousand words from me.

If you're on Claude, ChatGPT, or something with a command line

It's all plain text, so the only question left is how your particular tool picks it up. Honest ratings: ✅ reads it as-is, 🟡 works but needs a step, ❌ this one doesn't exist.

That second-to-last row is the reason the folder exists. Instructions have a shared format. Memory does not, at any vendor, in either direction. Anything you want to still have next year belongs in the first category — in a file, with a date on it.

Which is the conclusion the vendors reached about their own products. When OpenAI announced it was retiring the feature that stored prompts on its side, the advice was to move that content into files you control. That is the whole of AI for small business in year two, in one sentence, from the people renting you the model.

The folder is yours. The model is rented. Read the lease — six months' notice on one platform, sixty days on another — and keep the folder somewhere the landlord can't reach.

Frequently asked questions

Do I have to rewrite everything when a new model comes out?
No. Rerun three jobs, then work the three questions above. Most files survive untouched. The ones that change are the workarounds written for a weakness that no longer exists, and the checks written assuming it would stop and ask.

Which AI is best for a small business?
In year one, whichever you'll actually open. In year two that's the wrong question — ask instead whether it will read a folder of plain files, how much notice its vendor gives before retiring a model, and how many minutes it takes to move the same folder somewhere else. All three are answerable from public pages before you commit.

How can AI be used for a small business?
Look at the first column of the table near the top: reformatting, checking against a written list, spotting a missing or expired date, turning notes into your standard form. Anything where a rule names a person rather than an office stays in the third column permanently.

What do I delete before I share the folder with an employee?
Client and matter identifiers, anything functioning as a key, and the house style that isn't for sharing. Then run the string search — the "@" pass alone catches more than people expect.

Will my assistant's chat history follow the folder?
No, and neither will anything it worked out about you on its own. Files move; accumulated impressions don't. Plan the handover as: here are the files, here's what's missing, let's run one job together.

How much does AI for small business cost to run for a year?
Nothing for the folder itself — it's text files. The cost is whatever assistant subscription you already pay for, plus usage above a consumer plan. The real twelve-month figure is marked above as unmeasured rather than estimated.

Do I need a developer to set this up?
No. The main path here is a chat assistant's project feature, which means uploading files through a browser. The command-line options in the table are for people who already work that way.

If I switch from ChatGPT to Claude, do I start over?
The files move as they are. What doesn't move: anything the assistant remembered on its own, and the project container. Expect to spend the first session re-establishing context you'd built up in conversation — a good argument for writing that context into memory/decisions.md while you still have it.

Before you close this tab

• [ ] Make a folder called my-work with the five parts above, even if four are empty
• [ ] Copy the index file and replace the bracketed parts with your own trade
• [ ] Write the three columns — hand over, draft only, never — before writing any job steps
• [ ] Copy the model-change checklist into checks/switching.md now, while you're not in the middle of a model change
• [ ] Copy the delete list into the folder too, so it's there the day someone asks for a copy
• [ ] Open memory/runs.md and write one dated line about the last thing that went wrong

Stay in the loop (no account signup)

This site does not ask you to create a product account. Free readers just leave an email—or follow where the build is posted.

No paywall on this article. No "sign up for access." If you only want one next step: use the email box at the bottom of the site, or follow on X if you prefer the timeline.

— hh

Sources checked 31 July 2026: the AGENTS.md site and its FAQ; Claude Code's documentation on how it loads instructions; OpenAI's and Anthropic's published deprecation pages; the American Bar Association's malpractice claims profile and model rule on prospective clients; the Kentucky Bar Association's intake ethics opinion; the North Carolina and California bars' trust accounting rules and handbooks; AIA's published guidance on substantial completion certificates and a signed one filed in a municipal council record; Florida's lien statute; a published university bank reconciliation policy; and search data pulled the same day.