Stop AI from creating duplicate files

1. Limited Context Window

Most AI coding assistants operate with a limited context window that can only “see” a small portion of your codebase at any given time. When you ask to create or modify a feature, the AI might only have access to the currently open files or a narrow slice of your project structure.

2. Incomplete File Discovery

When AI tools do attempt file discovery, they often use shallow methods like searching currently open files, recently accessed files, or basic pattern matching. These approaches miss files that aren’t actively open or have non-standard naming conventions.

3. Naming Convention Mismatches

Different projects use different naming conventions: camelCase, PascalCase, kebab-case, snake_case, or custom patterns. AI tools often struggle to recognize that user-service.ts, UserService.ts, and user_service.ts are all potential matches for a "user service" file.

4. No Pre-execution Validation

Most AI coding tools execute changes immediately without a review step. They generate code and apply it directly to your filesystem. By the time you realize a duplicate was created, the damage is already done. There's no opportunity to catch the mistake before execution.

5. Conflict Avoidance Bias

AI models are often trained with a safety-first approach: when uncertain whether a file exists or what its exact path is, they default to creating a new file rather than risking overwriting existing code. This "better safe than sorry" bias leads to duplicate file proliferation.

Step 1: Install PlanToCode Desktop

Download the PlanToCode desktop application for your platform. The file discovery workflow and implementation planning features are built directly into the desktop client.

Step 2: Configure Your Project Root

Open PlanToCode and select your project's root directory. PlanToCode will validate git repository status and establish the base directory for all file operations. Configure any custom exclusion patterns for directories you want to skip (node_modules, dist, build, etc.).

Step 3: Describe Your Task

Enter a natural language description of what you want to accomplish. For example: "Add JWT validation to the authentication service" or "Implement dark mode support in the theme provider." Be as specific as possible about the functionality you want.

Step 4: Review the File Discovery

PlanToCode will run the 5-stage file discovery workflow in the background. You'll see real-time progress updates as it discovers relevant files. The workflow typically completes in 30-90 seconds depending on codebase size.

Once complete, review the list of discovered files. You'll see which files PlanToCode identified as relevant to your task. This is your first checkpoint to ensure the system has proper context about existing files.

Step 5: Review the Implementation Plan

PlanToCode generates a detailed implementation plan based on the discovered files. Open the plan in the Monaco editor and carefully review:

• • Which files will be modified (look for existing file paths)
• • Which files will be created (verify these are genuinely new files needed)
• • The specific code changes proposed for each file
• • Import statements and dependency updates

Step 6: Execute with Confidence

Once you've reviewed and approved the plan, copy the implementation instructions to your preferred AI coding tool (Cursor, Copilot, Claude, etc.) or execute directly via the integrated terminal. Because PlanToCode has already done the heavy lifting of file discovery and planning, execution becomes a straightforward process of applying well-defined changes.

Does PlanToCode work with Cursor and GitHub Copilot?

Yes. PlanToCode is designed as a planning layer that works alongside your existing AI coding tools. You use PlanToCode to discover files and generate implementation plans, then execute those plans using Cursor, GitHub Copilot, Claude Code, or any other AI assistant. The file discovery and planning prevent duplicates regardless of which tool executes the code.

How long does the file discovery workflow take?

File discovery typically completes in 30-90 seconds for medium-sized projects (500-2000 files). Very large monorepos with 10,000+ files may take 2-3 minutes. The workflow runs in the background, so you can continue working while it executes. Progress updates appear in real-time.

What if I have a huge codebase? Will discovery time out?

PlanToCode includes intelligent timeout management and caching mechanisms. For extremely large codebases, you can configure custom timeout values and use exclusion patterns to skip irrelevant directories (vendor code, generated files, etc.). The system also caches discovery results per session, so subsequent plans in the same session reuse the cached file context.

Can I still create genuinely new files when needed?

Absolutely. PlanToCode's file discovery doesn’t prevent creating new files—it prevents creating duplicate files. When your task genuinely requires a new file (like adding a completely new feature module), PlanToCode will propose creating it in the implementation plan. The difference is you'll see the proposal and can verify it's truly new functionality rather than an accidental duplicate.

Does this work for non-JavaScript projects?

Yes. PlanToCode's file discovery is language-agnostic. It works with Python, Go, Rust, Java, TypeScript, JavaScript, Ruby, PHP, C++, and any other text-based codebase. The regex generation and AI relevance assessment adapt to the specific languages and frameworks in your project based on the task description and discovered file extensions.

What happens if the AI still proposes a duplicate in the plan?

This is rare because the file discovery provides comprehensive context, but if it happens, you'll catch it during the review step. Simply reject the plan, refine your task description (be more specific about which existing files to modify), or manually adjust the file selection. The key advantage is catching duplicates before execution rather than after the damage is done.

Is there a cost for running file discovery?

File discovery does use AI for the relevance assessment stage (Stage 3), which incurs small API costs. However, the cost is minimal (typically $0.01-0.05 per discovery run) and the system provides cost estimates before execution. The investment is worthwhile compared to the 2-4 hours of manual cleanup time saved by preventing duplicates.

Can I use PlanToCode for refactoring existing duplicates?

Yes. If you already have duplicate files in your codebase, you can use PlanToCode to plan their consolidation. Describe the task as "Merge duplicate authentication services into authService.ts" or similar. The file discovery will find all related files, and the implementation plan will show you exactly how to consolidate them cleanly.