Escaping Proprietary AI Lock-In: A Git-Based Methodology

Jun 18, 2026

🤖 Read Raw Markdown

Setting the Stage: Context for the Curious Book Reader

In the Age of AI, the convenience of proprietary chat interfaces often hides a deeper cost: the erosion of your organization’s intellectual footprint. This methodology provides a roadmap for shifting from vulnerable, vendor-tethered workflows to a robust, local-first system that treats your operational knowledge as a durable, portable asset. By repurposing git as an invisible foundation, we can create a collaborative environment that respects both the technical requirements of automation and the simple mental models of non-technical teams.

---

Technical Journal Entry Begins

MikeLev.in: When you start writing a prompt directly into the prompt area of a website chat window, you’re handing over the context to a proprietary system that’s not going to let you export that discussion and carry it between systems. The idea is to deeply intertwine you with their system so that you’re locked in.

The Trap of Proprietary Context

It’s different with the local-first software in sheep’s clothing of Claude and Codex desktop apps because at least all those markdown files are residing on your own machine. But that’s just the markdown files you create as a result of the discussions — not the discussions themselves. I suppose the idea is that the discussion itself is not valuable to you long-term the way it is to them as potential new raw data for model training, but the final polished output of some SKILL.md file is.

Speaking of the conventional SKILL.md file, because that file has to be named the same time all the time, the user is forced to organize directory structures to avoid collisions, and that’s just not something humans are disciplined enough to do in the team-of-non-programmers situations that desktop Claude is going to be used in. Almost certainly multiple markdown files will end up in the same folder but named differently, forcing deterministic actuators (by virtue of always knowing at what file to look) becomes probabilistic because now an LLM has to take the output of the ls command (or similar) and decide which markdown file to load and take its next prompt-instructions from.

The Role of the Universal Agent

That’s not the main focus I am working towards with this article, but I just wanted to get that out there. I cannot emphasize enough that the Anthropic conventions for agentic skills files forces a sort of folder-tree build-out that turns the filesystem into a scannable and predictable key-value lookup table. It can probably walk directory trees (skipping the .git folder) and come up with that key-value pair, but for the sake of education, let’s build such a tree up from scratch.

(nix) pipulate $ cd ~/repos
(nix) repos $ mkdir project
(nix) repos $ cd project/
(nix) project $ touch AGENTS.md
(nix) project $ eza --tree
.
└── AGENTS.md
(nix) project $ 

Right, see? Could the semantics here be any simpler? Now you have your project “root” directory, which is what you give a Claude or Codex. And when you look at the tree, it’s very simple indeed. It’s so simple that there is no choice. If an intelligent machine looks at this folder there is no choice but for it to load AGENTS.md and to consider following the instructions found there. This file used to be CURSOR.md or CLAUDE.md or whatever, but it can’t. Nobody’s going to live with that long-term.

The proprietary vendor shenanigans that suggests is triggering for anyone who wants their tech-work to survive the next vendor-switch, model-name change, company IPO or any of the many disruptions to such an “employee”-named instruction file. The file you leave for your next named employee should not name the employee directly if you’re hiring from a temp agency. It should name the role of the temporary agents can easily identify as themselves… AGENTS. It doesn’t hurt that it alphabatizes to the beginning of the default ls list.

Are you with me so far? Explain all this back in another way so that readers unfamiliar with such subject matter have other good mental models for thinking about this.

Gemini 3.5 Flash Standard: I am absolutely with you, and this is a fascinating critique of how vendor lock-in and poorly thought-out conventions are creeping into local AI workflows.

You are addressing two main problems here:

1. The Trap of the Chat Box: How proprietary platforms trick us into leaving our intellectual history behind.
2. The “Temp Agency” Problem: Why naming your instruction files after a specific AI company (like CLAUDE.md or CURSOR.md) is a massive mistake for longevity and organization.

To help readers who might not be developers grasp why this matters, here are a few relatable mental models to explain your points.

---

1. The Chat Box Trap: The “Hotel Notebook” vs. “Your Own Journal”

When you use a standard website chat window, it feels convenient. But mentally, it’s like walking into a hotel room and writing your deepest business strategy into a notebook chained to the hotel desk.

• The Catch: You can’t take the notebook with you when you check out. If you want to switch to a different “hotel” (a different AI provider), you have to leave all that context behind. The hotel gets to keep your thoughts to study them, while you walk away empty-handed.
• The Local-First Alternative: Using apps that save files directly to your computer is like writing in your own personal journal. Even if you change your pen (the AI model), the paper and the ink still belong to you.

2. The File Collision Chaos: The “One-Slot File Cabinet”

You mentioned that current systems expect a file to have a highly specific name, forcing users to build complex folder trees.

• The Mental Model: Imagine you hire an assistant, and you tell them, “Every day, I will leave your instructions in a folder explicitly labeled TODAY_TASKS.md.”
• The Human Failure: Humans are messy. Eventually, someone is going to leave TODAY_TASKS_v2.md, TODAY_TASKS_OLD.md, and TODAY_TASKS_FINAL.md in the exact same drawer.
• The Result: Now, instead of the assistant instantly grabbing the file and working, they have to stand there, scratch their head, and guess which one you actually meant. You’ve turned a foolproof system into a guessing game.

3. Naming the Role, Not the Temp: The “Mailbox” Analogy

This is your core argument for changing the file name to AGENTS.md.

• The Mistake: Naming an instruction file CLAUDE.md or CURSOR.md is like painting the name “John the Mailman” onto your physical mailbox. John is a temporary worker. What happens when John gets promoted, or a new company takes over the mail route, and Sarah shows up? Sarah might look at the box, assume it’s only for John, and walk away.
• The Fix: You don’t name the box after the person; you name it after the function. You paint “MAIL” or “DELIVERIES” on the box. By naming the file AGENTS.md, you are creating a generic mailbox. Whether OpenAI, Anthropic, or an open-source model walks up to your project folder, it instantly recognizes: “Ah, this is the box meant for whoever is acting as the agent today.”

Why AGENTS.md is Elegant

By dropping a single AGENTS.md file into a clean directory (as you showed in your terminal code), you eliminate all ambiguity.

When the AI “opens the door” to your project, it doesn’t have to scan a messy room or guess which file belongs to it. It sees one beautifully generic, role-based instruction file right at the top of the alphabetical list. It reads its role, gets to work, and leaves the final product in your local folder. You remain completely in control, vendor-agnostic, and organized.

MikeLev.in: Good explanation. It’s interesting that the last line Gemini emitted to me in the response:

Want to look at how to structure the inside of AGENTS.md to enforce this vendor-agnostic control?

…wasn’t included in the copied markdown. Interesting. I’m tempted to start writing in response to that question, but the readers here of this article wouldn’t see it now unless I did 2 copy-pastes. Ugh, the drift between the different AI chat interfaces can be infuriating especially around the markdown copy-paste rules. That’s the feature that lets you copy your discussion context around piecemeal, which is what I’m doing here by always having the vim text-editor running [in the mansplaining voice: NeoVim, actually].

I do all the discussion prompt-response copy-paste re-assembly correlation in real-time as I hold these discussions so that at the end, I own the discussion. It’s like I’m using the notebook chained to the hotel desk, but with each turn I transpose it all into my own notebook as well. Let them train on my thoughts. That’s fine. I want them do. I’m training the parametric memory of future AI models whether it’s through interacting in chat in their Web UIs, or using my system to publish to the Web at large where all the AI-bots are scraping for new content. Win/Win!

Except of course when what I’m talking about is proprietary. Then I use the work-provided logins where the AI companies assure you that they’re not training their models on your customer’s proprietary data. But now there’s only three things wrong with that.

1. First, you need the legal mechanisms in place to be allowed to use your customer’s data in that way.
2. Secondly, you need the more expensive corporate subscription models that offer the “please don’t train on my data” feature.
3. Thirdly, you have to trust that a completely opaque process where they could easily synthesize your data to make it unrecognizable so that personally identifiable information (PII) is scrubbed and train on it anyway to get the important abstractions and learnings anyway.

I remember when they started calling the “please don’t train on my data” mode in Cursor IDE “legacy mode” and you had to be grandfathered into it. That’s all I had to hear. It’s just a theory, but when you’re an AI company with torrents of data coming into you from sources you can’t train on, the temptation to turn it into PII-scrubbed synthetic data and train on it anyway is enormous. So it’s a matter of how trusting you are and how much you believe that good discipline can override human nature. My belief is that takes military-style discipline that these companies battling to produce the world’s second trillionaire don’t have.

Alright, back to the main story.

Let’s continue building out that folder tree. They who control the AGENTS.md of a project controls the continuing downward-flow through the file. And so let’s say you had a bunch of people building their own sub-apps within your project and they each have a skill they wish to contribute and according to the convention the skill-files need to be named SKILL.md. What do you do?

GitOps!

Wow, okay. This is the tricky part. So I see that shared skills are already coming through the desktop Claude program and this is bleeding edge. Once they switch to a local-first app in the form of something that installs on your local machine with a CLAUDE.dmg download from Anthropic, many of the inherent advantages of things being cloud-based and accessed exclusively off of a browser and through somebody else’s computer goes away and a complex problem needs to be solved — the same problem the git program solved ages ago, but non-programmers can’t and won’t and shouldn’t be expected to use git.

Using git also has the implication that it’s automatically shared with Microsoft through GitHub — honestly, private repos or not for the same reason you can’t trust AI companies to not train on your data. They say they don’t and there could be huge legal ramifications if they did and got caught, but also their war-chest for hiring lawyers to deal with these issues when they come up are larger than yours. Assume everything you put any Web service (the “Cloud”) will go through AI, even if it’s for creating synthesized data. That process uses AI on your data too — even if not for direct training, then just to whitewash-prep it for direct training.

See, it’s a bit different from the chicken-and-egg problem. It’s the omelet problem. Was this omelet made from my eggs? You don’t know.

Git as Institutional Plumbing

Alright, so using git itself is okay especially quietly and automatically in the background so non-programmers working out of the same project folder can share their work automatically. It’s actually possible. In other words, you can have a project-root in desktop Claude and sync skills across your company without hard-wiring it to Claude desktop (versus Codex, for example). Your skill-sharing can be made to work even if you switch between Claude and Codex, or whatever else even comes in the future because git is now inextricable fabric of tech. If you engineer GitOps solutions where automated systems running in the background are what’s using git so humans don’t have to, it’ll effectively work forever without having to send your data to anyone you don’t want to.

This sounds a bit of a pipe-dream. But it’s not. Such a solution can be engineered super-simply by git-savvy folks. Let’s do that. First we may have to describe why git is not GitHub, and you can engineer a solution that has to use some git server remote endpoint that is not necessarily GitHub — even if you set it up in a pinch like I did Honeybot. Honestly just private repos in GitHub is the easiest thing (using the cloud is often easiest) but the important point is to engineer the solution so that you don’t have to. Set it up using GitHub. Prove it works using GitHub. And when people are sold on the benefit of working this way and sensitive data is going to start going in, because the solution has been deployed for awhile and proven itself, the organizational will might exist to set up its own git server.

Break it down Barney-style for the nice folks, but not in a condescending way. They’re all smart and have the rudimentary knowledge-worker baseline. They’re just not necessarily developers and will themselves never be touching git. Explain all these issues and what it sounds like I have in mind, knowing you’re working with a human who created the rest of what you find in the context payload here, please and thank you!

ChatGPT 5.5 Thinking Extended: Context verified.

Yes — what you have in mind is a company skill-sharing system for AI work that uses git as plumbing, not as a user interface. The important part is not “teach everyone git.” The important part is: give non-programmers a normal folder full of useful AI instructions, while a quiet background system keeps that folder synchronized, versioned, backed up, auditable, and portable between AI vendors.

Here’s the plain-English breakdown.

Git is not GitHub

This is the first misunderstanding to kill.

Git is the tool. It is a local change-tracking system. It remembers what files changed, when they changed, who changed them, and how to move those changes between machines.

GitHub is one website that hosts git repositories.

That distinction matters because saying “we use git” does not mean “we are sending proprietary material to Microsoft.” It only means “we are using a proven file-history and synchronization mechanism.” The remote endpoint could be GitHub, GitLab, Bitbucket, a private company server, a bare repo over SSH, a Gitea box in a closet, or a Honeybot-style self-hosted machine. Git is the train track. GitHub is one possible station.

For adoption, GitHub might be the easiest proving ground. Start there with harmless or non-sensitive material. Prove the workflow. Let people feel the benefit. Then, when the organization understands why this is worth protecting, swap the remote from GitHub to something private. The architecture should make that swap boring.

That is the key move: do not build a GitHub workflow. Build a git workflow that happens to use GitHub at first.

The human should never have to know git exists

For developers, git is a daily tool. For normal knowledge workers, git is ceremony, jargon, and danger.

So don’t make them use it.

The user experience should be:

“Put your skill in this folder.”

That’s it.

Behind the scenes, a small automated process can do the git work:

“Something changed. Save a snapshot. Pull down team updates. Push my update. If there’s a conflict, ask for help.”

The person does not think in commits, branches, remotes, pulls, pushes, merges, or rebases. They think in files and folders.

That’s GitOps in the helpful sense: operations driven by ordinary files, with git quietly providing memory, sync, rollback, and auditability.

It is like office plumbing. People do not need to understand municipal water pressure to wash their hands. They just turn the faucet.

Why AGENTS.md matters

The AGENTS.md idea is the front door.

When an AI tool opens a project folder, it needs to know where the instructions are. If the instruction file is named CLAUDE.md, CURSOR.md, or CODEX.md, the project is already leaning toward one vendor’s worldview. That may work for a while, but it ages badly.

AGENTS.md says something more durable:

“Whoever is acting as the agent here, start here.”

That is role-based, not vendor-based. It is the difference between putting “Delivery Instructions” on the door versus “Instructions for Bob from FedEx.” Bob might not be the delivery person next year. FedEx might not be the carrier. But the role still exists.

So the project root starts with one obvious signpost:

project/
└── AGENTS.md

That is beautifully low-ambiguity. A human can understand it. An AI can understand it. A future tool can understand it. It alphabetizes nicely. It avoids vendor vanity. It makes the folder itself into a simple instruction surface.

Why SKILL.md forces a directory tree

The SKILL.md convention creates a different problem.

If every skill file has the same name, then the folder path becomes the real name of the skill.

That means this:

skills/
├── report_writer/
│   └── SKILL.md
├── client_research/
│   └── SKILL.md
└── pageworker_debugging/
    └── SKILL.md

is not just “a bunch of folders.” It is a key-value system:

report_writer        -> skills/report_writer/SKILL.md
client_research      -> skills/client_research/SKILL.md
pageworker_debugging -> skills/pageworker_debugging/SKILL.md

That is good. It is deterministic. The AI does not have to guess.

The bad version is this:

skills/
├── report_writer.md
├── report_writer_final.md
├── report_writer_mike_edit.md
├── claude_skill.md
└── skill_new_new.md

Now the AI has to inspect the folder and guess which file matters. The deterministic actuator has become probabilistic. It went from “open the one known file” to “interpret the mess.” That is exactly the kind of small ambiguity that becomes expensive at team scale.

So yes, the fixed SKILL.md name is annoying, but it also forces a useful discipline: one skill, one folder, one canonical instruction file.

The folder tree becomes the shared company brain

This is where your idea gets interesting.

A team of non-programmers using desktop AI tools will naturally produce useful prompts, workflows, research habits, reporting instructions, client-specific procedures, and little reusable “ways of doing things.”

Without structure, that becomes scattered chat history and final_final_v3.md chaos.

With structure, it becomes a portable company knowledge system:

company-ai-workbench/
├── AGENTS.md
├── skills/
│   ├── client_summary/
│   │   └── SKILL.md
│   ├── seo_report_outline/
│   │   └── SKILL.md
│   ├── sales_call_prep/
│   │   └── SKILL.md
│   └── pageworker_review/
│       └── SKILL.md
└── examples/
    ├── good_outputs/
    └── templates/

The tree itself is the map. The file names are boring on purpose. The folders carry meaning. The AI can scan it. Humans can browse it. Git can sync it. The company can own it.

That is the “local-first software in sheep’s clothing” idea: on the surface, it looks like folders and markdown files. Underneath, it is institutional memory with version control.

Why cloud-only chat is the wrong place for this memory

A web chat box is convenient, but it is not a durable workspace. It is more like a rented whiteboard. Useful while you are in the room, but awkward to move elsewhere.

Even when a desktop AI app writes markdown files locally, the discussion that produced those files may still live in the vendor’s system. The polished output belongs to you more than the conversation does.

So your practice of copying the conversation back into your own text workflow is not just eccentric. It is a sovereignty move. You are reconstructing the intellectual trail in a form you control.

For public material, fine: let the models learn. Publish it. Feed the web. Train the future.

For proprietary material, different rules apply. Now the question is not “is this convenient?” The question is “where does the data go, who can process it, what promises are we relying on, and can we prove any of it?” Your “omelet problem” is the right metaphor: if someone says the eggs were anonymized, synthesized, transformed, or used only indirectly, how would you know whether your eggs are in the omelet?

That is why a local folder plus git-controlled sync matters. It gives you a path where the organization can say:

“Our instructions, skills, examples, and sensitive operating knowledge live in a place we control.”

Not “in a chat window.” Not “in whatever SaaS currently has the best model.” In files.

The migration path is the practical genius

The sane rollout is not “build the perfect private git server first.”

That is how projects die.

The sane rollout is:

1. Start with a normal folder structure.
2. Add AGENTS.md.
3. Add a few skill folders with SKILL.md.
4. Put it in git.
5. Use GitHub private repos at first if that is the path of least resistance.
6. Build a tiny background sync wrapper so non-programmers never touch git.
7. Prove that people actually use it.
8. Once it contains real organizational value, move the remote to company-controlled infrastructure.

That last step only becomes politically possible after people have felt the value. Before that, “we need a self-hosted git server” sounds like nerd infrastructure. After that, it sounds like protecting the company playbook.

What the background tool probably does

The tool does not need to be magical. It can be almost boring.

It might sit in the project folder and periodically do something like:

check for changes
save a snapshot
pull updates from the team
push local changes
warn if two people changed the same file

The user-facing version is simply:

AI Skills synced ✓

or:

Someone else edited this skill too. Please review before continuing.

That is the only part normal users should see.

The important engineering choice is that the remote URL is just configuration. Today:

github.com/company/ai-skills.git

Tomorrow:

git.company.internal/ai-skills.git

Same workflow. Different station.

The big idea

You are describing a vendor-neutral, local-first, git-backed skill commons for AI work.

Not a Claude system. Not a Codex system. Not a GitHub system.

A folder system.

A markdown system.

A role-based instruction system.

A git-synchronized memory system.

The AI vendor becomes replaceable. The model becomes replaceable. The hosting remote becomes replaceable. The thing that persists is the company’s actual working knowledge, expressed as plain files in a predictable tree.

That is the durable move.

The non-programmer never needs to know the word “remote.” The executive never needs to know what a merge conflict is. The AI never has to guess which final_final.md file matters. The organization gets the mechanical advantages of git without turning every employee into a developer.

In other words: use GitHub if it gets the idea through the door. But design the door so GitHub is not the building.

MikeLev.in: Yes, thank you ChatGPT 5.5 TE, you’re the only one that answered that well. Gemini 3.5 refused on both my paid work account and my paid personal account. Claude Opus 4.8 Max answered but filled it with proprietary data from the context payload, making the response something I can’t use with the public. The next runner-up was actually Claude Sonnet 4.6 Max. Anyway, where does that leave us? Oh yes! Git negative space! Hmm, how to explain it? Oh wait, I already did! But where?

(nix) _posts $ rg 'negative space' -l | sort
2025-09-30-grinding-lenses-forging-magic-wand.md
2025-11-29-amnesia-feature-orchestrating-nixos-desert-kite-ai-strategy.md
2026-02-22-web-forgotten-nervous-system-ai-moat.md
2026-05-14-context-window-painting-ruff-transplant.md
2026-05-14-gravity-of-markdown-deterministic-ai-editor.md
2026-05-14-safe-space-messy-code-ai-time.md
2026-05-15-deterministic-ai-coding-actuator.md
2026-05-25-acetate-overlay-git-negative-space.md
2026-05-27-waxascii-preventing-generative-drift.md
2026-05-30-bunny-trail-collaboration-membranes.md
2026-05-31-magic-users-guide-ai-actuators-anti-churn.md
2026-06-04-modern-webmaster-git-nix.md
2026-06-05-guarding-hard-knowledge-ai.md
2026-06-12-local-first-broadcast-loop-automation.md
2026-06-12-syncing-player-piano-audio-git-discipline.md
2026-06-12-unix-way-llm-surgical-precision.md
_context/2026-05-25-acetate-overlay-git-negative-space.json
(nix) _posts $ 

So then I simply copy a few of the recent ones that sound good and include it in the next set of context that I compile into a plain old portable text-prompt (albeit a big one) and sit back and decide which model to send it to first. My choices are this which I drop into foo_files.py with their full absolute paths because the articles live in repos other than the Pipulate one that the context compiler command comes from. Those can use shorter relative paths.

/home/mike/repos/trimnoir/_posts/2026-06-05-guarding-hard-knowledge-ai.md
/home/mike/repos/trimnoir/_posts/2026-05-25-acetate-overlay-git-negative-space.md

So there you go, ChatGPT. Since you’re the ones who groks this the best (I should also run this all by Grok), let’s say you’ve got formal company skills that are of the structure you just defined and they’re in the project repo:

(nix) project $ mkdir -p skills/{client_summary,seo_report_outline,sales_call_prep,pageworker_review}
touch skills/client_summary/SKILL.md
touch skills/seo_report_outline/SKILL.md
touch skills/sales_call_prep/SKILL.md
touch skills/pageworker_review/SKILL.md
(nix) project $ eza --tree
.
├── AGENTS.md
└── skills
    ├── client_summary
    │   └── SKILL.md
    ├── pageworker_review
    │   └── SKILL.md
    ├── sales_call_prep
    │   └── SKILL.md
    └── seo_report_outline
        └── SKILL.md
(nix) project $ 

Alright, so far so good. That’s all just been creating files and directories. The mental model is super-duper easy; the same mental model that turned spinning magnetic disks into file-cabinets. The digital world biohacks humans to think the physical things we constructed mental models for exists in the world of flipping bits between 0 and 1, and this is one of the strongest arguments for the holographic universe theory where we’re all on the surface of a black hole. But that’s another article.

The non-philosophical bit coming up here is the awesome part few think about and it cannot be repeated enough. Git is generic plumbing in a situation like this to at very minimum give you file-backup, infinite undo and the like so:

(nix) project $ mkdir -p ~/git-repos/project.git
(nix) project $ cd ~/git-repos/project.git
(nix) project.git $ git init --bare
Initialized empty Git repository in /home/mike/git-repos/project.git/
(nix) project.git $ cd ~/repos/project/
(nix) project $ git init
Initialized empty Git repository in /home/mike/repos/project/.git/
(nix) project $ ls -la
total 16
drwxr-xr-x  4 mike users 4096 Jun 18 06:31 .
drwxr-xr-x 24 mike users 4096 Jun 18 05:17 ..
-rw-r--r--  1 mike users    0 Jun 18 05:17 AGENTS.md
drwxr-xr-x  6 mike users 4096 Jun 18 06:31 .git
drwxr-xr-x  6 mike users 4096 Jun 18 06:25 skills
(nix) project $ git status
On branch main

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	AGENTS.md
	skills/

nothing added to commit but untracked files present (use "git add" to track)
(nix) project $ git add .
(nix) project $ git status
On branch main

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
	new file:   AGENTS.md
	new file:   skills/client_summary/SKILL.md
	new file:   skills/pageworker_review/SKILL.md
	new file:   skills/sales_call_prep/SKILL.md
	new file:   skills/seo_report_outline/SKILL.md

(nix) project $ git commit -m "Initial commit: Add project structure and skill templates"
[main (root-commit) 3e64ff8] Initial commit: Add project structure and skill templates
 5 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 AGENTS.md
 create mode 100644 skills/client_summary/SKILL.md
 create mode 100644 skills/pageworker_review/SKILL.md
 create mode 100644 skills/sales_call_prep/SKILL.md
 create mode 100644 skills/seo_report_outline/SKILL.md
(nix) project $ git remote add origin ~/git-repos/project.git/
(nix) project $ git push -u origin main
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 48 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (5/5), 434 bytes | 434.00 KiB/s, done.
Total 5 (delta 0), reused 0 (delta 0), pack-reused 0 (from 0)
To /home/mike/git-repos/project.git/
 * [new branch]      main -> main
branch 'main' set up to track 'origin/main'.
(nix) project $ 

The ramifications of this, and frankly the GitHub-free nature of this is rather profound. Now for the actual project we’re proposing, the actual git remote origin for the repo will be GitHub or some private git server, but this shows you don’t even need a git server set up to get the baseline non-collaborative benefits of git locally on your own machine. Few people know or understand this basic trick and what it could mean for everyday non-developer workflow.

Break it down again for all the nice folks. What is the fabric-of-tech stuff going on here that changes everything even for non-developers trying to manage and organize text-files.

Oh, and regarding the .gitignore stuff, just make sure the story you’re telling is building up to where any inference engine worth their silicon knows knows I must be going with this to end-run proprietary lock-in while still getting highly granular control of non-mysterious team skill sharing.

Note: Ugh, one of the articles that I included really skewed the answer. I need a SQL-like left-join intersection with the rg command.

(nix) _posts $ rg -l 'negative space' | xargs rg -l 'collaborators' | sort
2025-09-30-grinding-lenses-forging-magic-wand.md
2026-05-25-acetate-overlay-git-negative-space.md
2026-05-30-bunny-trail-collaboration-membranes.md
2026-05-31-magic-users-guide-ai-actuators-anti-churn.md
2026-06-05-guarding-hard-knowledge-ai.md
(nix) _posts $

Okay, I’m dropping one of the articles.

The response should not focus on Pipulate as the sibling stabilizer but rather quite earlier than that. We are creating a directory structure that is ideal, carving out a parallel directory structure to skills/ whereas that belongs to the project/ repo, we can create a .gitignore where with a single entry we can exclude a whole tree branch where we can selectively include other git repos as sub-repos without the complexity of git’s own complex submodule that’s vastly inappropriate for non-developer teams.

But we could very well tell folks to “work here” in their own local setup and “here” is another repo that can audo-sync the deliberately shared (by virtue of being “dragged” into the share-folder) while keeping private work-in-progress stuff back. Non-developer collaborators can have the incredibly simple mental model of 3 place:

1. The company-wide git repo.
2. Their own local and (to them) in a separate folder-tree private place to work.
3. That private place is actually a git repo in-turn with its own .gitignore keeping their anything goes playground held back because it’s not actually in that 2nd and personal git repo of theirs.

External stuff they don’t have to think about does the mental model equivalent of symlinking the shared portion of their private repo into the git-ingored negative space of the common company-wide repo.

Managing Visibility with Negative Space

And thus a completely automatic and easily understood “trickle-up” of stuff dragged to their shared folder gets seemingly sorted into the company-wide folder structure though it’s only an illusion that it’s all actually under one git repo. It just all ends up under one directory tree. Each person will thus see their shared work in 2 locations on their local machine. And potentially 3 if they have a version of it in their playground that they drag-copy (versus moving) to shared.

Does all this make sense?

Show what I’m proposing so that the same non-developer but still quite intelligent audience can understand. Break it down.

ChatGPT 5.5 Thinking Extended: Context verified.

Yes, this makes sense. What you are proposing is not a GitHub trick, not a developer workflow, and not a submodule scheme. It is a folder-shaped collaboration model that uses git as invisible plumbing underneath ordinary human behavior: “work over here, drag finished/shareable things over there, and the system quietly preserves, versions, and syncs the right pieces.” The current prompt explicitly steers away from making Pipulate the star too early; the focus is the simpler foundation: local folders, git-backed history, .gitignore negative space, and selectively shared sub-repos that create the appearance of one organized team tree without forcing everything into one repo.

The Simple Version

Imagine a company has a shared cabinet called:

project/

Inside it are official company AI skills:

project/
├── AGENTS.md
└── skills/
    ├── client_summary/
    │   └── SKILL.md
    ├── pageworker_review/
    │   └── SKILL.md
    ├── sales_call_prep/
    │   └── SKILL.md
    └── seo_report_outline/
        └── SKILL.md

That is the official shelf. It is the team library. The AI can look there and know where the company-approved instructions live.

Now give each person their own private desk:

my-ai-workbench/
├── playground/
├── drafts/
├── experiments/
└── shared/

The human mental model is beautifully simple:

playground/  = messy private work
drafts/      = still thinking
experiments/ = maybe useful later
shared/      = ready for the team

The non-developer does not need to know what a branch is. They do not need to know what a remote is. They do not need to know what a bare repo is. They do not need to know what .gitignore is.

They only need to know:

“When something is ready to share, drag it into the shared folder.”

That is the whole user interface.

What Is Really Happening Underneath

Under the hood, there are multiple git repositories, but the user does not have to care.

There is a company repo:

project/

And there is a personal repo:

my-ai-workbench/

The company repo contains the official shared structure. The personal repo contains one person’s working area. Most of that personal repo is private, local, experimental, or intentionally ignored.

Then the clever part happens.

The company repo has a section of negative space. That means there is a folder path that exists in the local directory tree but is deliberately excluded from the company repo’s tracking.

For example:

project/
├── AGENTS.md
├── skills/
└── collaborators/

And in the company repo’s .gitignore:

collaborators/

That single line says:

“This whole collaborators area may exist on disk, but the company repo itself will not track it directly.”

That sounds like hiding something, but it is really creating a membrane. The company repo leaves an empty pocket where other things can appear locally without becoming part of the company repo.

Now each person can have their own shareable area mounted, copied, synced, or linked into that pocket:

project/
├── AGENTS.md
├── skills/
│   ├── client_summary/
│   ├── pageworker_review/
│   ├── sales_call_prep/
│   └── seo_report_outline/
└── collaborators/
    ├── alice/
    │   └── shared/
    ├── bob/
    │   └── shared/
    └── carol/
        └── shared/

To the human, it looks like one nice company folder tree.

To git, it is not one giant tangled repo. It is cleanly separated custody.

Why This Matters

This gives you three places with three meanings.

1. The company-wide repo

This is the official shared library.

project/
├── AGENTS.md
└── skills/

This is where approved, stable, team-wide instructions live. It can be hosted on GitHub at first, moved to a private git server later, or mirrored somewhere else. The important part is that GitHub is not the architecture. GitHub is just one possible remote endpoint.

2. The person’s private workbench

This is where someone can be messy.

my-ai-workbench/
├── playground/
├── drafts/
├── experiments/
└── shared/

This gives people a safe place to think, test, write, revise, and make mistakes without every half-formed idea becoming company-wide material.

That matters because AI skills, prompts, examples, and workflows are not just documents. They can contain judgment, habits, client patterns, internal language, and competitive method. You do not want every scratchpad becoming institutional truth.

3. The share folder

This is the intentional membrane.

my-ai-workbench/shared/

Anything dragged here is treated as deliberately shareable.

Not perfect. Not necessarily approved. But intentionally surfaced.

That one gesture — drag into shared — becomes the human-friendly equivalent of:

git add
git commit
git push

Except the person never sees those words.

The Trick Is That “Shared” Can Appear in Two Places

This is the part that feels strange until you see it.

A person might see the same shared material here:

my-ai-workbench/shared/

And also here:

project/collaborators/alice/shared/

That does not mean the person has to understand symlinks, mounts, rsync, hard links, worktrees, or nested repos. The implementation can vary.

The mental model is:

“My shared shelf appears inside the company library.”

That is enough.

The computer can handle the illusion.

The user sees one coherent directory tree. The underlying system preserves boundaries.

Why Not Git Submodules?

Because git submodules are developer-brained complexity.

They are powerful, but they require the user to understand that one repo contains a pointer to another repo at a specific commit. Then they need to understand initialization, updating, detached states, recursive clone behavior, and all the ways the pointer can become stale.

That is not a good mental model for a team of non-developers.

Your proposal avoids that.

Instead of saying:

“This directory is a git submodule that points to another repository.”

You say:

“This is Alice’s shared shelf.”

That is the correct abstraction.

The machinery can still use git. It just should not expose git-shaped concepts to people whose actual job is writing, researching, selling, analyzing, supporting clients, or codifying business knowledge.

Why .gitignore Is the Superpower

Most people think .gitignore means:

“Files I don’t care about.”

That is the small view.

The bigger view is:

“Intentional negative space inside a repo.”

A .gitignore entry can say:

collaborators/

And that means:

“This folder can exist here locally, but this repo will not claim ownership of it.”

That is a huge design move.

It lets you carve out pockets where other systems can operate. Personal repos. Local-only scratchpads. synced folders. encrypted stores. generated content. temporary AI workspaces. vendor-specific exports. human-reviewed share shelves.

The company repo becomes the visible map, but not the owner of every square inch of territory.

That is the “fabric-of-tech” point: filesystems, git, and ignore rules let you build membranes. Those membranes are how you get collaboration without total exposure.

The Non-Developer Story

Here is how I would explain it to the nice folks.

You have three cabinets.

The first cabinet is the company cabinet. It contains official skills everyone can use.

The second cabinet is your private cabinet. You can make a mess there. Drafts, half-ideas, experiments, client-specific notes, things that are not ready, things that should never be shared.

The third cabinet is the share drawer. When something is ready for others to see, you put it in the share drawer.

The system quietly makes that share drawer appear inside the company cabinet under your name.

So Alice sees:

project/collaborators/alice/shared/

Bob sees:

project/collaborators/bob/shared/

Carol sees:

project/collaborators/carol/shared/

But each person is really working from their own private setup.

They are not dumping their whole desk into the company library. They are placing selected folders onto a shared shelf.

That is the entire idea.

Why This End-Runs Proprietary Lock-In

The AI vendors want the conversation to be the place where knowledge accumulates.

You are making the filesystem the place where knowledge accumulates.

That changes the custody model.

If the company skill lives only inside Claude, it is a Claude asset.

If it lives only inside ChatGPT, it is a ChatGPT asset.

If it lives only inside some SaaS workspace, it is entangled with that SaaS.

But if it lives here:

project/skills/pageworker_review/SKILL.md

then it is just a file.

A durable file.

A diffable file.

A syncable file.

A reviewable file.

A file that can be used by Claude today, Codex tomorrow, ChatGPT later, a local model after that, and some future agent system nobody has named yet.

The AI vendor becomes an interpreter of the file. It is not the owner of the file.

That is the lock-in escape hatch.

The Collaboration Pattern

The mature pattern looks like this:

project/
├── AGENTS.md
├── skills/
│   ├── client_summary/
│   │   └── SKILL.md
│   ├── pageworker_review/
│   │   └── SKILL.md
│   ├── sales_call_prep/
│   │   └── SKILL.md
│   └── seo_report_outline/
│       └── SKILL.md
└── collaborators/        # ignored by company repo
    ├── alice/
    │   └── shared/       # Alice's surfaced work
    ├── bob/
    │   └── shared/       # Bob's surfaced work
    └── carol/
        └── shared/       # Carol's surfaced work

And each person has something like:

my-ai-workbench/
├── private/
├── drafts/
├── experiments/
└── shared/
    └── pageworker_review_variant/
        └── SKILL.md

The system makes:

my-ai-workbench/shared/

appear inside:

project/collaborators/alice/shared/

The company repo ignores collaborators/, so it does not accidentally swallow everyone’s private or semi-private working material.

A separate sync process can later collect, review, promote, or publish selected shared work into the official skills/ folder.

That promotion step matters.

It means:

collaborators/alice/shared/pageworker_review_variant/

is not automatically the official skill.

It is a candidate.

When reviewed and accepted, it can become:

skills/pageworker_review/

That gives you a clean pipeline:

private thought
→ personal draft
→ deliberately shared candidate
→ reviewed team asset
→ official company skill

The Key Insight

This is not really about git.

It is about controlled visibility.

Git provides the time machine. .gitignore provides the membrane. The filesystem provides the human-friendly metaphor. Markdown provides the durable instruction format. The AI reads the result.

That stack lets non-developers collaborate on AI-operable knowledge without living inside a proprietary chatbot’s memory palace.

The Final Frame

What you are proposing is a local-first skill commons with private workbenches and intentional trickle-up sharing.

The user experience is:

“Work privately. Drag what you want to share into the shared folder. The company library updates.”

The technical reality is:

“Multiple git-backed trees are composed into one local directory experience, with .gitignore preserving negative space so personal repos can surface shareable artifacts without becoming tangled into the company repo.”

The strategic result is:

“The company’s AI skills remain plain files under company custody, portable across vendors, reviewable by humans, and structured enough for inference engines to consume deterministically.”

That is the sweet spot.

Not everything private.

Not everything public.

Not everything trapped in chat history.

Not everyone forced to learn git.

Just ordinary folders, used with unusual discipline.

MikeLev.in: This is a plan. The only monkey wrench I predict is the fact that Claude desktop has a shared skill feature for organizations, it’s just going to be so easy and appealing it may override anything superior and lock-in preventing that requires the curl | bash pattern to get running with the DetSys Nix installer being an “if it’s not there, install Nix” wrinkle in the otherwise perfect “own your own destiny” story.

---

Book Analysis

Ai Editorial Take

What strikes me as most vital here is the concept of the ‘membrane’ created by .gitignore. By treating the directory structure as a physical space with ‘negative space’, you are essentially architecting a firewall that isn’t just about security, but about intentionality. It turns the file system into a collaborative negotiation between personal autonomy and team cohesion, which is a massive leap forward from the monolithic, top-down SaaS structures we currently endure.

🐦 X.com Promo Tweet

Is your company's AI knowledge trapped in a vendor's chat window? Stop building on rented land. Learn how to use git as invisible plumbing to keep your skills portable, secure, and vendor-neutral. https://mikelev.in/futureproof/escaping-proprietary-ai-lock-in/ #AI #GitOps #KnowledgeManagement

Title Brainstorm

• Title Option: Escaping Proprietary AI Lock-In: A Git-Based Methodology
  • Filename: escaping-proprietary-ai-lock-in.md
  • Rationale: Clear, professional, and highlights both the problem and the technical solution.
• Title Option: Building a Durable Company Knowledge Commons
  • Filename: building-durable-knowledge-commons.md
  • Rationale: Focuses on the institutional memory aspect rather than just the escape from vendors.
• Title Option: Local-First AI: The Role-Based Folder Strategy
  • Filename: local-first-ai-folder-strategy.md
  • Rationale: Appeals to the technical user interested in the structural organization of files.

Content Potential And Polish

• Core Strengths:
  • Strong practical mental models like the ‘Hotel Notebook’ vs ‘Personal Journal’.
  • Excellent reframing of git as ‘plumbing’ rather than a dev tool.
  • Clear explanation of why vendor-named files (CLAUDE.md) lead to fragility.
• Suggestions For Polish:
  • Clarify the distinction between the suggested ‘git-sync’ background tool and existing commercial sync tools.
  • Elaborate slightly more on the ‘promotion’ process of skills from personal shared folders to the company master list.

Next Step Prompts

• Draft a minimal Python-based ‘sync-monitor’ script concept that demonstrates how a background process could handle the ‘drag-to-share’ functionality.
• Explore a FAQ section that addresses the psychological barriers of non-developers fearing ‘the git’ interface.