TL;DR: StepUp Horse had 5,548 files scattered across folders named after people. We reorganized all of it into an access-aware Markdown vault an AI can grep in milliseconds — without losing a single file, in two days of work. This is the story; the how-to lives in the linked articles.
The before: a company organized by whoever last touched it
StepUp Horse builds tech for the equestrian industry — and has since 2019, on top of another venture that started in 2016. A wearable (Smart Belt) and a GPS training app (PACE IQ, launched May 2026). Things changed in 10 years. A lot.
The vault was 5,548 files and 21 GB. 753 of those were real documents — DOCX, XLSX, PPTX, PDFs — and the rest was photos, videos, and zips of zips. The folder tree read like a staff directory:
CEO Office/(the CEO’s everything drawer)Intern/(an intern’s thesis)Consultant/(a consultant’s handoff dump)Digital Marketing/,Horse phone app docs/, …
Nobody could find anything. Worse, nobody could ask anything. An AI agent pointed at this vault would choke on the binary sludge and the folder names that told it nothing. A file called baseline.doc next to IMG_7871.JPG — is that a product spec or a holiday photo? You’d have to open it to know. Multiply that by five thousand.
That’s the real cost of a messy company: not the lost minutes, the blind AI. Your data exists, but no machine can reason with it. And smart indexing isn’t the fix. In software engineering, a core principle is KISS: Keep It Simple, Stupid. You want your data to be understandable — having the AI work over a different dataset than the one you actually use is a recipe for disaster. So no memory system, no external document-indexing layer here. Simple text files. Small scripts when you need to make it look good (presentations, letters, reports). Nothing else.
The bet: copy first, never touch the original
The first rule we set was the one that made everything else safe: we don’t touch the original.
For binary files we don’t use Git — we use Nextcloud. And digging back through a sync-history UI is not pleasant. So we created a new root — StepUp Horse Reorganization/ — and copied into it. Nothing moved. Nothing deleted. The 21 GB original stayed exactly where it was, read-only, until the new structure was validated and a human signed off.
That single decision killed the fear. When you can’t break anything, you can move fast. A failed chunk costs you nothing because the source is still there, untouched. Migration became a series of safe experiments instead of a high-wire act.
I cannot overstate this. Every migration that goes wrong goes wrong because someone moved instead of copied, then couldn’t undo it. Don’t. Copy first. Delete last.
The access sanity check: does this data belong here?
Caveat first: most companies do not need three separate vaults. We didn’t split into three because it’s best practice. We split because separating is a compliance question we wanted to force — every file gets asked does this belong where anyone on the team can see it? Treat the split as a sanity check, not a prescription.
This three-vault model is one valid approach. For companies starting AI-native from day one, there’s a different model — a single master repo with nested restricted repos instead of separate vaults. Each restricted area lives in the same folder tree but has its own access boundary. See the Start an AI-Native Company guide for that approach.
The instinct is to pour everything into one giant vault. Resist it — not because you need a complex multi-vault setup, but because the act of separating is the check. Grep respects folder boundaries, and so should your access control:
StepUp Horse Reorganization/
├── 01-Main Vault/ ← operational knowledge (most staff)
├── 02-Legal Vault/ ← signed, contractual, binding
└── 03-HR and GDPR Vault/ ← personnel, personal dataInside the Main Vault, everything got a numbered, self-describing path. Not CEO Office/Budget/ — but 01-Main Vault/03-Investors/Budgets and Financial Planning/. The path now tells you what’s inside before you open it.
The hard calls were the interesting ones:
- Privacy policies are product documents, not legal. Counter-intuitive, but right — a privacy policy is a product decision, so it lives under
01-Products/PACE IQ/Privacy Policy/, not in Legal. Legal is for things that are signed and binding. - No central finance vault. Finance already lived elsewhere. Budgets stay in context — under the product, investor, or grant they belong to.
- Historical relationships don’t get archived. An inactive customer is still a customer. DTC stays in
02-Relationships/, markedStatus: Historical. Hiding the past doesn’t help the AI — it blinds it.
The reorganization: the first tree was wrong, and that was fine
Here’s the part nobody tells you: the first folder tree is a draft.
We built the structure, pointed an AI at it, and watched it struggle. The hierarchy was technically correct but not readable. Paths repeated themselves uselessly in some places and collapsed too aggressively in others. The AI kept having to open files to confirm what they were — exactly the failure we were trying to fix.
So we reorganized. Again. We let the trees grow longer and more repetitive, because a long path is free information:
01-Main Vault/01-Products/Smart Belt/Testing/2024 P data/
01-Main Vault/06-Market Research/Smart Belt/Competition Analysis/Verbose? Yes. But now the AI knows what a file is from the path alone. It greps the path, confirms relevance, and only opens the file if it actually needs the contents. That’s the whole game: path match first, content match second.
We didn’t hand-write those trees. The AI generated them, and the AI maintains them. We maintain the intent (what each area means); it maintains the structure. That’s the division of labor that makes deep hierarchies sustainable.
If your first architecture isn’t AI-readable enough, reorganize. It’s not a failure — it’s the architecture doing its job.
The conversion: office documents became markdown
You can’t grep a .doc. So 753 Office documents had to become text.
We wrote a single CLI — convert — that turns DOCX, XLS, and PPTX into Markdown: Word via pandoc, Excel into tables, PowerPoint into Marp slides. Spreadsheets with real structure (client leads, feedback) became Markdown tables plus a summary. Budgets stayed as .xlsx with a Markdown note alongside, because a financial model is not a paragraph.
The rule was simple: convert what’s text, keep what’s data. A meeting note is text — convert it. A financial model is data — keep it and annotate. Nothing got “lost in translation” because we kept the originals next to the Markdown until the conversion was proven.
Then we validated: a completeness check confirmed every source file was accounted for in the new vault. Here’s the nuance — a converted file (Client Leads.xls → Client Leads.md) has a different hash, of course. So the check tracks two things: files copied as-is (matched by hash), and files that were converted (tracked through the copy log and folder mapping). The point isn’t that hashes never change; it’s that nothing falls through the cracks unaccounted for. And until each conversion is manually validated, the original stays right next to its Markdown.
The payoff: one vault, grep-everything, and a clean rebrand
Here’s where it got fun.
Once everything sat in one searchable vault, things that used to take weeks took minutes. PACE IQ was launching. We needed a fresh brand, a consolidated story, pitch material that pulled from real research and real testimonials.
The AI read the entire vault — product notes, scientific papers, competition analysis, 30+ Letters of Intent, the investor pipeline — and produced synthesis documents that actually reflected the company. Not because it was clever, but because the data was finally in a shape it could read.
That’s the real punchline. The migration wasn’t a cost. It was the unlock. We went from a company that had data to a company an AI could operate. Rebranding, reporting, proposal generation, social posts — all of it collapsed into “point the AI at the vault and ask.”
We put ourselves out of the busywork business. The data runs itself now.
How long it actually took
People assume a migration like this is a months-long IT project. It wasn’t.
- Planning: one day. The decisions log, the folder mapping, the access questions — all written down before a file moved.
- The internal review: the “why do we even need this?” conversation. Worth its own line, because it’s the real friction. Getting the team to understand why the data needs to be AI-readable is harder than the reorg.
- Execution: one day. Copy, convert, validate. Two days of actual work, end to end.
Then cleanup and improvements over time — but that’s minor: a folder renamed here, a backlink added there. The honest time sink isn’t the migration. It’s training people to work in AI workflows once the vault exists. That part eats your calendar. The migration is cheap; the habit change is the investment.
What you need
Any AI agent that has access to your files will work. I recommend OpenCode. The full migration was made with OpenCode with DeepSeek Flash. Cost: $1 in API calls.
What’s next
Next up: Convince Your Team — the change-management playbook before you touch a file.
Not migrating? See the AmpereBrain Case Study — AI-native from day one, no migration needed.
The full migration path:
- AI-Readable Architecture — design the folder structure
- Migration Plan Template — write your plan
- Convert Office to Markdown — turn Word, Excel, and PowerPoint into text
- AI-Native Migration Guardrails — safety checks that prove nothing got lost
- 14-Step Migration Process — execute the playbook
- Then: Train Your Team, Tooling (CRM, PDFs, decks, social)
5,548 files. Zero lost. One company the AI can finally read.
Your data. Your rules. Let’s write it that way. By Charles Henri Gayot.