After `pip install -e .`, which kinds of project change still require re-running the install?

### Editable means "imports are redirected", not "the project is re-read" It is easy to hear "editable" as "pip keeps watching my project". It does not. `pip install -e .` runs once, the build backend produces an editable wheel once, and pip installs its contents once. Everything that was decided during that run is frozen until the next one. What survives editing is only the thing that is resolved lazily, at import time: the content of a `.py` file that the redirection points at. Drawing that line makes the reinstall rules fall out rather than needing memorisation. ### Metadata is a snapshot The `.dist-info` directory written at install time carries the distribution's name, version and requirements. Change the version in `pyproject.toml` and `importlib.metadata.version()` keeps reporting the old one — which quietly matters, because a service that logs or reports its own version through that call will report a stale value all afternoon. Add a dependency and nothing installs it; your imports fail until you re-run the install, and the failure is confusing precisely because the declaration is right there in the file. Console-script entry points are the sharpest version of this. When you declare one, the installer generates a small executable wrapper in the environment's script directory and records the entry point in metadata. Both happen at install time. Add a new command and it simply does not exist on your path; rename one and the old wrapper stays behind, still pointing at a function you deleted. Anything that discovers plugins through entry points behaves the same way — a newly declared plugin is invisible to the discovery call until the distribution is reinstalled, because discovery reads installed metadata rather than your source. ### Compiled code is not source If the project ships an extension module written in C, the editable install maps the *built* artefact. Editing the C source does nothing at all; the compiled object on disk is unchanged. You need a rebuild, which for most backends means re-running the editable install so the build step executes again. Candidates who only ever ship pure Python often miss this, and it is worth saying out loud because the symptom — an edit that has no effect — looks identical to the stale-import symptom while having a different cause. ### New files depend on the redirection's shape This is where the two forms of editable install diverge. A permissive mapping put a directory on `sys.path` through a `.pth` file, so anything you later create inside it is importable immediately — new modules, new subpackages, no reinstall. A strict mapping enumerated the modules the project declared into a generated finder; that mapping is a list, and a file created afterwards is not on it, so the import fails until you reinstall. Neither is wrong: strict trades convenience for an import surface that matches the wheel. Knowing which one your project got explains an otherwise baffling `ModuleNotFoundError` for a file you can see on disk. A related case bites both forms: adding a whole new top-level package. Even under a permissive mapping the file resolves fine, but the packaging configuration may not include it — automatic discovery ran during the install — so it will be missing from the wheel you build later even though it imports perfectly today. ### And the boring one: restart the process A module already imported lives in `sys.modules` until the process exits. An edit to existing source is picked up by the next process, not the current one. That is not a reinstall, but it is the same question in the interview — "my change did nothing" — and it is worth separating cleanly from the metadata cases. ### The practical habit Re-running `pip install -e .` is cheap and safe, so the useful rule is simply: touched `pyproject.toml`, added a command, added a dependency, changed compiled code, or created a file that will not import — reinstall. Touched only the body of an existing module — restart the process. Teams that write this down stop losing afternoons to it, and in CI the question does not arise at all, because the pipeline installs a freshly built wheel from a clean environment every time.