To find your files on a laptop after working on a webpage at home and wanting to edit it later, only to realize you can't locate them?

What does this article talk about?

Halfway through editing a webpage on your laptop, returning to the desktop computer only to find either old or corrupted files; or worse, finding no files at all when trying to edit something done on the desktop with the laptop. If you're like me, using Claude and Codex as two AI assistants on each of your two computers means four environments are working on the same project—this is almost guaranteed to happen. This article documents how I moved a webpage project from iCloud to Git in just one night, allowing all four environments to share the same truth. Throughout the entire migration process, you don't need to manually input Git commands; simply give AI instructions and it will handle everything for you.

Who is this for?

People who use multiple computers, such as a laptop while traveling and a desktop at home, rely on services like iCloud or Google Drive to sync files, and already use AI assistants such as Claude Code or Codex to work on web pages or small projects. They often encounter the issue of "I thought I fixed it yesterday," especially if they do not write code but have heard of Git and assume it is only an engineer's tool.
For those who haven’t written code, this familiarity with Git can be a barrier to understanding how to effectively manage their projects. They might find themselves in situations where they think they’ve fixed something only to realize later that the changes were not properly integrated into the project.
Coach Jiang (Coach Jiang) For knowledge workers who haven’t written code, Git can be a confusing tool often associated with engineering tasks. This lack of familiarity can lead to difficulties in managing projects effectively and integrating changes seamlessly.

What will you get?

A guiding principle: What should be stored on iCloud, and what needs to go into Git.
A step-by-step workflow for moving files with a built-in verification method.
"To have rules clearly written down where every AI can access them," Jiang Yude suggests, a three-step approach applicable to any multi-AI environment.

Coach Jiang?Skip straight to "How can you start?"Remove the prompt words first.

Real-world scenario

"Ordinarily, I work on web pages using my laptop with Codex and Claude Code taking turns. On my tablet, I have a separate set of tools as well. On July 11, 2026, at night, I discussed a long-standing issue with the Claude Code running on my laptop: when I use my tablet to make web pages and then want to switch back to my laptop for minor edits upon returning home, it often causes problems. Conversely, if I work on a webpage using my laptop and later try to edit a small part of it on my tablet, it also frequently results in issues."

After taking inventory, my setup looked like this: one desktop and one laptop, each running Claude Code and Codex, for a total of four AI environments. The project files were stored in my iCloud knowledge base, and I assumed iCloud would sync automatically so both computers could see them.

Sounds reasonable, right? I felt the same way until that night when something magical happened.

Two minutes of time difference The AI on the desktop wrote the migration handoff document and saved it to iCloud. I asked the AI on the laptop to read it. The laptop took two minutes to respond that the file had not synced yet and that even the folder did not exist.

The files arrived two minutes late. Don't worry, it'll be fine soon. In code terms, in those short two minutes I continued to modify the old version on the laptop, which created a discrepancy between the two sides. No matter who overwrites whom, it would be a waste of effort.

Problem Source

Let's break it down. The issue lies in three places.

First, iCloud synchronization is designed for files.

iCloud has three features that work well with files but cause problems when used with code:

There’s a delay in the sync process.

That two-minute demo was evidence. Files can wait, but code cannot; you don’t know if you’re editing the latest version.

Conflict resolution is quiet.

Two computers both edited the same file, and iCloud often creates a "File 2" conflict copy or only keeps one; even if you skip past the prompt, it won’t tell you which version is correct.

Files are “thinned out”

To save space, iCloud turns rarely accessed files into cloud placeholders. Users expect to find files on their local machine, but when they encounter a placeholder that hasn’t been downloaded yet, it might fail or become outdated. I dealt with another case just earlier today: A scheduling tool stored in iCloud was disrupted by the placeholder, causing connection issues; ultimately, moving it off iCloud resolved the problem.

Two to four AI environments have disconnected memories

This is a unique issue for multi-AI workers. Here are the four environments I’m referring to:

	Claude Code	Codex
Desktop	Environment ①, a separate memory for oneself.	Environment ②, a separate memory for oneself.
Laptop	Environment ③, a separate memory for oneself.	Environment ④, a separate memory for oneself.

Four quadrants, four separate memories that are not connected. Claude Code on the desktop has its own memory, while Claude Code on the laptop has another one. Codex is completely unable to read Claude’s memory. I established certain rules with Claude on the desktop; none of the other three environments know about it.

So, even if the move was done correctly, as long as the "where is the new home" information only exists in a single AI's private memory, the other three environments will still follow their old paths to go and update the old files.

Three, old paths will remain embedded in various documents.

In my knowledge base, there are index pages and operation manuals that mention "the source code is located in a certain folder." After the move, these sentences all become landmines. Any AI that reads them will be directed to the wrong place.

Mechanism Solution

Core Principle: Store indexes in iCloud, and store codes in git.

The judgment method is simple. Ask yourself this question: Can I spot a small malfunction?

DOCUMENT · iCloud File: iCloud Two-Way Rock-Paper-Scissors

Documents, notes, meeting minutes. Sync two minutes late, occasionally creating a conflicting backup; it’s obvious how to handle them. Storing in iCloud is fine.

CODE · git Code: Central Reconciliation in Git

Web projects, scripts, configuration files. A single mistake can ruin everything silently; Git works by reconciling: pull from the central repository before starting work (pull), and push your changes back after finishing (push). If both sides have modified the same place, it clearly tells you where the conflict is, allowing you to choose; as long as there’s a commit, both sides’ content can be retrieved.

Moving Process (the version I personally walked through that night)

STEP 1 Inventory

List all web projects in their respective locations, identifying which ones are still active and which have become history. I had the AI scan the entire knowledge base to find the active projects residing on iCloud.

STEP 2 Copy, don't delete yet.

Copy the project to your local Developer folder, create a git repository, and compare it with the original files for consistency. Keep the original directory intact; this is your fallback option in case of any issues.

STEP 3 Push to the private GitHub repository

Private means that only you can see the source code; the website was meant to be deployed publicly, and visitors won't be affected at all.

STEP 4 Tag the old folder with a new name

Leave a README file in place, clearly stating "This folder is frozen. The truth lies in the XYZ repo; updating here won't work." Anyone who passes by your old home will be redirected to the new one.

STEP 5 Update all old paths.

Change any sentences in the index page and user manual that mention old locations, replacing them with the correct new location. Ensure no outdated references remain.

STEP 6 Clone laptops, double-check both machines.

Test on a laptop, write a test line, push it up; then pull down from the desktop machine to review and delete the test line before pushing back. Completing this loop confirms that the synchronization link is working smoothly.

That evening's real-time testing completed the entire process in less than an hour, with both machines passing the double-check successfully.

Where should rules be written: Three layers

A key lesson in multi-AI environments: The scope of a rule depends on where it is written.

Global Rules File

All AI will read this master file first, which contains the rule "Code should be git and stored locally by developers." This rule applies to all four environments.

Address Card

Rules that follow files are written in old folders. No matter which AI or path you use to access an old file, the warning will be your first sight.

AI Private Memory

What AI remembers is only useful to itself. Convenient, but make sure you don’t store critical information like “Where’s the Truth?” in just this layer.

Here’s my order: start with a door card, then update global rules, and use private memory as a cache. Here are three steps:

Where are the global rules stored and how to write them Claude Code will automatically read the CLAUDE.md file in the project directory, while Codex will automatically read the AGENTS.md file. My approach is to maintain a single AGENTS.md file in the root knowledge base directory (where the rules are stored as documents and can be synced via iCloud), with just one line: "Read AGENTS.md first." The content should be straightforward and itemized, such as: "All web projects go into ~/Developer/, managed with git; always pull from remote before starting work and push back after finishing."

What is a door card? A basic instruction document was placed in an old folder after a move. I gave it a more noticeable name: "⚠️ Doorplate: This Folder Has Been Moved." The content consists of three sentences: this folder is frozen and should not be modified; the source code's truth can be found in which repository; if you need to take over, clone from where. It guards the last checkpoint: no matter what AI or even a month later when you forget about it, anyone who follows the old path will be guided to the new home upon first glance.

How to manage AI private memories Anything you instruct an AI to "remember" in your conversation is stored within that tool on the specific machine. It won't be readable by another computer or a different AI. The management principle is simple: treat private memories as cache. Any cross-environment rule worth adopting should be written into the global rules file right away; information tied to a specific folder should be documented in doorplate cards. Memories are only responsible for accelerating, while files and rules handle the truth.

Routine after that: One Rule

Start work by pulling, finish by pushing. That's it. When you leave with a laptop: pull, modify, push. At home on your desktop: pull first, then proceed to work. It doesn't matter which machine or AI is used; I also asked the AI to prepare a nightly check task at 10 PM, reminding me if any changes were made but not pushed. Note: The translations maintain the original structure and markers as specified in the input.

What it guarantees and what it doesn't guarantee

What is guaranteed: As long as you follow the "pull open work, push close" workflow, the silent accidents like iCloud's "silent merge, silent divergence" will no longer occur. Git keeps a record of every commit, even if there are conflicts, it presents them to you so you can choose; anything that has been committed is recoverable.

Honest Boundaries It can't fix forgetting to push. If you edit on your laptop and forget to push back home, the desktop won't see the changes. This is a discipline issue, tools can only remind you. Additionally, all files with old paths need to be updated during a move; missing one file is like leaving a landmine behind. I still have two more items in my to-do list that are waiting for updates using doorplate cards.

How do you start?

Your first step could be to let your AI help you inventory. Pass this section to your Claude Code or Codex:

# Tasks to Copy Directly
My project files are stored in a synced folder on iCloud (or Google Drive). I use multiple computers to edit them. Please help me:
1. Inventory all code-based projects (web pages, scripts, settings) in the synced folder.
2. List each project: location, status, and whether it has Git.
3. Provide a migration checklist: which should be moved into a Git repository and which can stay as is.
Only inventory; do not move any files yet.

After completing the inventory, pick one of the most active projects to migrate first. Let AI assist with this process, moving one project at a time:

# Migration Execution Prompt
Please move [project directory path] into Git management:
1. Copy it to ~/Developer/[project name]/, do not move the original folder yet.
2. Initialize Git and perform the first commit, ensuring consistency with the original files.
3. Create a private GitHub repository for this project (confirm before creating).
4. Leave a note in the original directory explaining that it is frozen and where the actual content resides in the repository.
5. Provide me with a list of all notes or documents containing old paths; I will confirm them and update them later.
Report results after each step without deleting any files.

After thorough verification, scale up to other projects. After migration, remember three things: label the old directories, add a global rule, and update all documents with old paths.

Recap

Two computers four AIs on the same project, synced via iCloud is destined to cause conflicts because its synchronization was designed for files.
The principle of judgment: if a small segment of code that humans can't see is broken, hand it over to Git.
Six steps for moving house: inventory, copy without deleting, push private repository, hang door tags, update old paths, double-check with another machine.
Rules are written where they decide who sees them: global rules file for all AIs, door tags follow the files, private memory acts as a cache.
A daily rule: start work by pulling and finish by pushing.

Common Traps (and Countermeasures)

Move everything and delete old folders immediatelyFreeze and hang signs, review the new workflow over a week to ensure it's working before deleting. Deleting is like putting in the trash bin; not directly erasing.

Only move files, don’t update rulesIf any of four environments still remembers the old paths, they will revert and change the old files. Moving and updating rules are two sides of the same coin.

Confusing Deployment with SynchronizationGit manages synchronization between you and your machine. For website deployment, follow the original process; these two things do not interfere with each other.

Use "small changes directly to iCloud" for quick updates.All truths are born in parallel. Even the smallest modifications must go through the repository.

Remind myself of my positioning.

This article addresses a technical problem, but its core aligns with what I've been talking about: no matter how smart AI is, it still needs you to set up your environment properly. Four AI environments won't conflict if they all adhere to the same rules, have one shared truth location, and follow a simple rule that's easy to remember. Setting a solid foundation for the environment allows AI to truly help you accumulate knowledge, and this accumulation happens across all four environments.

AI workflowMulti-device CollaborationgitiCloudClaude CodeCodex

I am Coach Jiang

Learner of Tacit Knowledge and AI Application Strategist. I regularly host two free online lectures each month to share practical experience and methodological insights. If you are interested in these topics, want to continue learning, or have consulting needs, feel welcome to start from the community.

Main discussion: Leveraging AI as a thinking partner to enhance decision quality and depth; transforming knowledge and experiences into prompts, skill packages, and knowledge bases so that AI can be flexibly applied.

Join LINE Community

Interested in AI × Knowledge Management and Tacit Knowledge Extraction? Start here.

Join the Community →

After creating a webpage using Codex at home on your desktop computer, trying to edit it with a laptop later results in not being able to find the files. The issue is that you've stored the project in the wrong place.