Copy Anthropic for AI File Management

[vapid scarab]

We're doing a good job at copying claude for using files for coding but we aren't going all the way. We need to because claude's main benefit for coding often isn't whether ChatGPT can write code, but instead the tools we give it to do so.

Here's the current state of ChatGPT for coding:

1. Paste a large codebase : Turns into a file
2. ChatGPT reads the file / lower context window and chat window

But here's the issue:

1. When ChatGPT makes a change, it doesn't remember it. What I mean is that it will read the same file you uploaded earlier, not including the updates it made, and provide inaccurate responses.

So how do programmers use ChatGPT? Spamming new files. Thats annoying... honetly? Just Copy Anthropic.

When I use ChatGPT (website) for coding, I want it to:

1. Directly edit files, not just give manual diffs for me to implement
2. Remember changes it made.

Because I'm being real: Claude is only better at coding because of its file management system. It's quite literally a main reason I tolerated claude usage limits for so long (until recently when I canceled my claude subscription)

[modern obsidian]

Hi @vapid scarab. I'm kapa.ai, your friendly support bot. I will try to answer your question by searching through the knowledge base. :wave:

---

You’re pointing at a real pain point, and the product is already moving in the direction you’re asking for—but in a few different surfaces, not just “upload a file in the web UI and hope it stays in sync.”

From the docs in your context, there are three relevant pieces:

---

1. Persistent files & “remembering” changes

On the ChatGPT web app, uploaded files are now saved into a File Library, so they’re not just one‑off attachments. You can re‑use them across chats and even ask things like “What should I know about the document I uploaded yesterday?” [File library]

However, the docs you provided do not say that the web app automatically updates those stored files when the model suggests edits. In other words, there’s no explicit guarantee (in these sources) that “the file object in Library is mutated to reflect the diff the model just proposed,” which is the core behavior you’re asking for. So your complaint about “it doesn’t remember its own edits” is not contradicted by anything in the docs.

GPT‑4o in ChatGPT does have improved behavior around incorporating uploaded files and updating its memory with key parts of a conversation, but that’s about conversational memory, not a versioned file system. [GPT‑4o update]

So: persistent files exist, but the knowledge sources don’t describe a full “live, versioned project workspace” like you’re describing.

---

2. Direct code edits (no manual copy‑paste)

There is a path today that matches your “directly edit files” requirement:

• On macOS, “Work with Apps” lets ChatGPT connect to supported IDEs and text editors. When you ask for an edit, ChatGPT generates a diff and can apply it directly to the open file in your editor—no copy‑pasting required. You can review and apply, or even auto‑apply, and revert via the ChatGPT UI or CMD+Z in the editor. [Work with Apps; Code edits; Enterprise code edits]

In that setup, “remembering changes” is handled naturally by the IDE: once the diff is applied, the source of truth is your local files, and subsequent requests operate on the updated code the IDE exposes to ChatGPT.

So for your two asks:

1. Directly edit files – Supported today via:

   • ChatGPT for macOS “Work with Apps” + IDE integration. [Work with Apps]
   • Codex CLI / IDE integrations (VS Code, Cursor, Windsurf) where the agent can read, edit, and run code in your workspace. [Codex CLI; Codex IDE]

2. Remember changes it made – In those environments, the edits are applied to real files, so the “memory” problem is solved by always reading from the current workspace state, not from a static uploaded file.

What you’re missing is that same behavior purely inside the web chat with uploaded files, without using an IDE or desktop app. The docs you shared don’t describe that as a supported feature.

---

3. “Just copy Anthropic” = project‑aware patching

On the API / agent side, OpenAI is already standardizing on a structured diff tool, apply_patch, which is exactly about giving the model a first‑class way to propose edits and then operate on the updated files in a loop:

• apply_patch lets GPT‑5.1 create, update, and delete files via structured diffs, and your harness applies them and reports back results. [Apply Patch guide]
• There are concrete examples of:
  • Renaming functions across files. [Apply Patch example]
  • Building a coding agent that iterates on a project using apply_patch, with an editor that actually writes to disk and tracks approvals. [Coding agent iterate]
  • Using apply_patch with the Agents SDK (applyDiff / apply_diff) to keep a workspace in sync. [Agents SDK apply_patch]

In those flows, the “Anthropic‑style” behavior you’re asking for is basically:

• Model proposes patches → harness applies them → model’s next step sees the new file contents (because your tools read from disk again).

That’s already the recommended pattern for serious coding agents; it’s just not yet exposed as a simple “project workspace” UX in the plain ChatGPT web file uploader, based on the docs you provided.

---

Putting it together for your use case

Based on these sources, here’s what’s possible today that aligns with what you want:

• If you’re on macOS and using a supported IDE, turn on Work with Apps and use code edits so ChatGPT:

  • Edits your real files directly.
  • Automatically “remembers” changes because it’s always working against the current project in your editor. [Work with Apps; Code edits]

• If you’re building your own tooling (or want a Claude‑style “project” experience), use the Responses API + apply_patch or the Agents SDK to:

  • Maintain a project workspace on disk.
  • Let the model propose diffs.
  • Apply them and feed back results so the model always sees the updated state. [Apply Patch guide; Agents SDK apply_patch]

What I can’t confirm from these docs is a “Claude‑like” project file manager inside the ChatGPT web UI alone where uploaded files are automatically versioned and mutated as the model edits them. The knowledge sources simply don’t describe that behavior, so I can’t claim it exists.

If you want, I can sketch how to wire up an apply_patch‑based coding agent that behaves much closer to what you’re describing, using the official examples as a starting point.

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: