When Gemini Let Me Upload Several Code Files at Once, I Stopped Selecting by Folder

Listing callers mechanically

Tracing by hand guarantees omissions, so I wrote a small dependency-graph script — short enough that its output can serve directly as the attachment list.

# deps.py — list the callers and dependencies of one file
# usage: python3 deps.py src/lib/content.ts
import os, re, sys
 
ROOT = "src"
EXTS = (".ts", ".tsx")
CANDIDATES = (".ts", ".tsx", "/index.ts", "/index.tsx")
 
files = [
    os.path.join(d, f).replace("\\", "/")
    for d, _, fs in os.walk(ROOT)
    for f in fs if f.endswith(EXTS)
]
 
def resolve(spec, frm):
    """Resolve an import specifier to a real file. '@/' is the src alias, '.' is relative."""
    if spec.startswith("@/"):
        base = "src/" + spec[2:]
    elif spec.startswith("."):
        base = os.path.normpath(os.path.join(os.path.dirname(frm), spec)).replace("\\", "/")
    else:
        return None  # external packages are never attached
    for ext in CANDIDATES:
        if base + ext in files:
            return base + ext
    return base if base in files else None
 
out = {f: set() for f in files}   # what f imports
inn = {f: set() for f in files}   # what imports f
for f in files:
    src = open(f, encoding="utf-8", errors="ignore").read()
    for spec in re.findall(r'from\s+["\']([^"\']+)["\']', src):
        r = resolve(spec, f)
        if r and r != f:
            out[f].add(r)
            inn[r].add(f)
 
target = sys.argv[1]
kb = lambda fs: round(sum(os.path.getsize(x) for x in fs) / 1024, 1)
callers, deps = sorted(inn[target]), sorted(out[target])
print(f"callers {len(callers)} / {kb(callers)} KB")
for f in callers:
    print("  <-", f)
print(f"dependencies {len(deps)} / {kb(deps)} KB")
for f in deps:
    print("  ->", f)

Run it on src/lib/content.ts and you get 19 callers and zero dependencies. Zero dependencies because that module only reads HTML through the Cloudflare ASSETS binding and imports nothing of my own. What needed attaching was upward, not downward.

Cutting external packages inside resolve is deliberate. There is no room to attach node_modules, and the model already knows the types and behaviour of public libraries reasonably well. I would rather keep the attachment budget for information that exists only in my repository.

One hop, or two

Having decided to attach callers, the next question was depth. Should the callers of the callers come along too?

The measurement on the same repository was clear enough.

One extra hop takes the attachment to nearly half the codebase. At that point it is hard to claim you selected anything; you are effectively sending the whole thing.

The 14 files added at hop two were, in my case, almost all UI components. When the article-retrieval contract changes, the first hop is what breaks directly, and the second hop settles once the first is fixed. So I stop at one hop now, and add named files only when something feels missing.

Long context is the other option, and I used to think that if it fits, it goes in. But the wider the slice, the harder it becomes to check which part the answer actually rested on. Narrowing the range is not about saving money. It is what makes verification possible.

Order of attachment, and the first sentence

How you hand the files over turns out to matter too. This is the routine I follow.

1. Pick one file to change and run deps.py to list its callers.
2. Keep only the callers that contain lines the change could affect. Tests and type-only files stay out at this stage.
3. Attach the file being changed first, then the callers. Order should not affect the result, but it makes the thread easier to re-read later.
4. In the first sentence, say which file is the target and which are callers. Something as plain as "I am changing content.ts; the rest are callers and stay as they are" is enough.
5. Ask for "the places that break, with file names and the role of the lines." Ask for abstract improvements and abstract improvements are what arrive.

Skip step four and you get rewrite suggestions for the callers as well. They are not bad suggestions, but what I wanted was the blast radius, not a redraft. Declaring roles up front made that mix-up almost disappear.

Two things that did not work

The first was attaching generated files. My repo has a JSON file of article metadata that is, on the dependency graph, a genuine caller. Its contents are a machine-emitted array, and reading it gave the model nothing to reason with. Generated files are now excluded, replaced by a single line describing their shape.

The second was underrating configuration. middleware.ts has zero callers and only two dependencies. Small on the graph, yet the branching there decides how pages behave. A small number on a dependency graph and a small blast radius are not the same thing. I made a comparable misjudgement about API keys, which I wrote down in why a replaced Gemini API key still loses to the old one.

Counting earns its keep precisely when the numbers disagree with your assumptions. The same habit shows up in taking stock of standard API keys across three layers and in how many assistant-dependent lines are still in your app. Inventory work is dull, and as an indie developer there is nobody else to do it.

Where I draw the line now

Uploading a set of files removed the pasting, and nothing else. What it added was the work of choosing — and that work is answered by the shape of the repository, not by the model.

Choose the attachments from where things break, not from where you are typing. That order is the one thing I keep even on a rushed day.

Pick the file you touch most often, run it through deps.py, and see how many of its callers sit in the same folder. That single number tends to explain every attachment that has ever missed.

Thanks for sitting through a piece that is mostly counting.