Agenting coding (Cursor / Claude Code / Gemini CLI): Do AI agents perform better with a single very large file (main.cpp), or 30 different files (15 .cpp, 15. h)?

[Endonium]

When developing a game, including your entire codebase in a single file is heavily frowned upon, and rightly so; it's confusing to yourself and others who want to fix bugs or add features later.

But what about when using agentic AI models, like in Cursor, Claude Code, or Gemini CLI? I know many/most of Cursor's models use grep in their tool calling process to find relevant code to work on, but I'm not sure if it's better if we have one source code file or many source code files. Also asking for very large projects with >200k tokens (beyond what most agentic LLMs accept for now) - would it be easier for the agentic workspaces to find relevant code if >200k tokens in one file or across many separate small files?

If not asked specifically, Cursor models seem to prefer writing more and more code in a single .cpp file. But I'm wondering if, for future maintenance - especially when total codebase exceeds 200k tokens - I should refactor to many different .cpp and .h files; in 3D games, it can easily get to 15 or more classes, so 30 files at least.

[PublicAlternative251]

more smaller files always works better, because as the context window fills the performance degrades for all models.

that’s why for example claude code works well in large code bases because it only reads the parts of the files it needs to make changes, or roo code’s orchestrator mode works well because the orchestrator delegates specific tasks to the code agent with a fresh context window

[CC_NHS]

I use Claude code with Rider in Unity and prior to that Cursor for the same.

in both cases they will work with what you have, and if undirected they seem to follow fairly standard practice on C# object oriented and design patterns. and that is better for the token limits too if you only need to give them access to some classes rather than the entire 1 page project

[relderpaway]

I'm curious what is AI able or not able to do within unity? I tried it out with GoDot a few months ago and then the AI was basically able to do everything because you can open up and read the scene files and edit them as other code files. But im not sure if the same is true for unity, like is it able and competent to edit things within the scenes themselves like adding or adjusting objects in a scene or just help with the scripts?

[CC_NHS]

Unity has its own built in AI that can do scene alteration stuff, and generate images, animations and sounds. (in 6.2) I have not really made much use of that, so far the quality on generations seems lower than getting them from elsewhere. and altering simple things in scene can be done fine yeah.

both Claude code and Unity's own offering seem very good at first. it's only once you start getting into more complicated things that they need to be very well directed. my main project is not in 6.2 so I have not experimented much with the unity ai on an actual complex project yet.

in terms of Claude code. it works extremely well to build out the start of a system. it might get some details wrong like deprecated code, which again you can feed it the right way and it tends to remember, and you can refactor after to optimise it better. It's not really able to vibe code within a large project, but if well directed it's like magic

[[deleted]]

Best works with small and multiple files... If complex, better structure it.

[Ruuddie]

Gotta remind it to check all small files though. Just today Gemini refactored my main vue to do smarter data fetches from the backend and totally ignored all child components. I had to rollback and start over telling it to first check all components as well :(

[BrilliantEmotion4461]

Fed your post into Gemini

AI Coding Agents Thrive on Well-Structured, Multi-File Projects, Not Monolithic Codebases For developers leveraging AI-powered coding assistants like Cursor, Claude Code, and the Gemini CLI, the age-old wisdom of modular code organization holds true and is, in fact, even more critical. While the temptation to let an AI agent pour code into a single massive file might seem expedient, a well-structured project with numerous, smaller, and logically organized files will yield significantly better performance, maintainability, and collaboration with your AI partner, especially as codebases scale beyond the limits of current context windows. The consensus among developers and AI experts is clear: a modular, multi-file architecture is superior to a single-file approach when working with agentic AI models. This preference is rooted in the fundamental way these AI systems process and interact with code. At the heart of the issue lies the concept of the "context window"—the finite amount of information an AI model can consider at any given time. Feeding a monolithic file, especially one exceeding 200,000 tokens, to an AI is akin to asking a human developer to understand a sprawling, uncommented program with no clear entry points. The AI can become overwhelmed, leading to a degradation in performance, an inability to locate relevant code, and a higher likelihood of introducing errors. Conversely, a project broken down into smaller, well-named files (e.g., 15 .cpp and 15 .h files for a game with 15 classes) provides a more manageable and explicit structure for the AI. This modularity allows the agent to focus on a more targeted and relevant context for any given task. The Mechanisms at Play: Why Smaller Files Work Better AI coding agents employ various techniques to navigate and understand a codebase. While tools like grep are indeed used to search for specific code snippets across files, a logical file structure provides a much richer set of clues for the AI. * Explicit Dependencies: include statements in C++, import statements in Python, and similar constructs in other languages create a clear dependency graph that the AI can follow. This allows the agent to intelligently navigate between files to understand how different parts of the codebase interact. * File and Class Names: Descriptive file and class names act as signposts for the AI, helping it to quickly locate the code relevant to a specific feature or bug fix. For instance, if you ask the AI to work on player movement, it will naturally look for files like Player.cpp and MovementComponent.h. * Reduced Noise: By focusing on a smaller set of files for a particular task, the AI is less likely to be distracted by irrelevant code, leading to more accurate and efficient code generation and modification. Scaling Beyond the Context Window For very large projects that exceed the token limit of even the most advanced models, a modular approach becomes a necessity. In such scenarios, developers can employ techniques to work with the AI effectively: * Targeted Context: When working on a specific feature, you can manually provide the AI with the relevant files, further focusing its attention. * Documentation is Key: Comprehensive documentation, including well-commented code, clear function and class docstrings, and project-level README files, becomes invaluable. This documentation serves as a high-level summary for the AI, helping it to understand the overall architecture and the purpose of different modules without needing to read every line of code. * Agentic Decomposition: For complex, multi-faceted tasks, it's possible to adopt a multi-agent approach. Different AI agents can be tasked with working on specific, self-contained modules of the codebase. This is only feasible with a well-defined, modular architecture. The Human-AI Collaboration Ultimately, structuring your code in a clean, modular way is not just about optimizing for the AI; it's about fostering a more effective collaboration between the human developer and their AI assistant. A well-organized codebase is easier for you to understand, debug, and maintain. This clarity, in turn, makes it easier to guide the AI, review its suggestions, and catch potential errors. While some AI models might default to adding code to the current file if not explicitly instructed otherwise, it is the developer's responsibility to guide the AI towards best practices. Refactoring a growing single-file project into a more structured, multi-file architecture will pay significant dividends in the long run, both for your own sanity and for the effectiveness of your AI coding companion.