How to Upload Your Entire Codebase to ChatGPT, Claude or Gemini

Sometimes the thing you want to ask about is not one file, it is the whole project: how the pieces fit, where a bug is hiding, whether an approach holds across the codebase. For that, the model needs to see the repo, not a snippet of it.

This guide covers how to upload your entire codebase to ChatGPT, Claude or Gemini: why pasting the raw folder rarely works, how to cut it down to what matters, and how to pull a repo straight from a URL. There is a spot to try it on your own repo partway down.

When you try to give ChatGPT or Claude your whole codebase by selecting the project folder and pasting everything, two things go wrong.

The first is noise. A working checkout is mostly not your code: node_modules, build output, lock files, the .git directory, vendored dependencies, generated assets. Paste all of it and the signal you care about is buried under the parts you do not.

The second is size. Every model has a ceiling on how much text it takes at once, and an installed repo runs past it easily. Fitting a large codebase into a context window is really a filtering problem, not a copy-paste one: the dependencies alone are usually larger than a chat box will accept.

my-app/
node_modules/     # thousands of files
dist/             # build output
.git/
package-lock.json
src/              # the part you want
README.md

my-app/
src/
package.json
README.md

Those figures are illustrative, and which one you are looking at depends on whether the project is installed. On a working checkout, node_modules really is the bulk of the bytes. On a fresh clone it was never committed, so there is nothing there for a filter to take out: across 60 public repositories the defaults stripped a median of 22.7% of tokens, and most of that was test files dropped by name rather than dependencies. Either way what is left is the source you wanted the model to read, but only one of the two starts out enormous.

The fix is to send a curated snapshot: your source, your config, your docs, and nothing that a fresh install or a build would regenerate.

FileConcat does this by default. It leaves out lock files, build output, binaries, and the usual dependency directories, and it respects your .gitignore on top of that. The bundle starts as the signal, and you add back anything you actually want.

You do not need the code checked out locally. Paste a public repository URL and FileConcat pulls the files, filters them the same way, and hands back one bundle. For most projects this is the best way to share a codebase with ChatGPT or Claude, and the fastest way to convert a GitHub repo to text for either one.

1. 1

   Paste the repository URL

   A public GitHub, GitLab, or Bitbucket URL is enough. FileConcat resolves the default branch and lists the files. See importing from GitHub.

2. 2

   Let the noise fall away

   The same default filter runs on the fetched tree, so dependencies, build output, and lock files never make it into the bundle.

3. 3

   Copy the bundle

   You get one structured document with every file labeled by its path, plus a running token count so you know it fits before you paste it.

In ChatGPT and Claude the whole codebase goes in as the one bundle file, attached or pasted, and it counts as one file against their upload caps; ChatGPT's are the tightest. Gemini is the one that takes a repository itself: one code folder or one GitHub repository per chat, up to 5,000 files and 100 MB, as of September 2026. The bundle still helps there when the repository is larger than that, or when you want tests and lock files out before the model reads it. NotebookLM reads only the text of a page given as a link, so a GitHub URL brings in the text of that one page and not the files behind it; set Format to Plain and the bundle goes in as one source instead. The steps are on adding a GitHub repo to NotebookLM.

Drop a project folder below, or open the full tool to paste a repository URL. It runs in your browser, there is no account, and nothing is uploaded to us.

Bundling a codebase into one prompt is the right move when you want a model to reason over a snapshot: review an approach, explain a module, find where something is defined. It is not the right move for everything.

If the repo is too large to fit even after filtering, or you want the model to edit across many files and iterate, a single paste is the wrong shape. An agentic coding tool that reads files on demand, or a retrieval setup that fetches only the relevant parts, will serve you better there.

Command-line packers like Repomix, gitingest and code2prompt cover the same bundle-a-git-repo need from the terminal. We ran all three against FileConcat over the same 60 repositories, and at the median the four bundles land within 8% of each other, so the choice is rarely about size: what each tool costs on the same repository has the distribution and the one case where the gap reached 16.4x. FileConcat's own difference is the browser, documents alongside code, and a token count that moves as you build.

Because the ceiling is real, it helps to know the size of a bundle before you paste it. FileConcat counts tokens live as you include and exclude files, so you can trim until it fits instead of finding out when the chat box refuses it.

How large is a repository, in practice? We bundled 60 public ones and counted: the median came out at 236,218 tokens, and only 23 of the 60 fit inside a 128K context window. That is the number worth having before you plan a paste, and how many tokens a codebase is has the whole distribution with the four common context windows drawn across it.