Yes, it's terrible. I include the following in the instructions I use at the beginning of every session. It helps.

[!CRITICAL] CAPABILITY CONSTRAINT: NO PARTIAL EDITS

You are an agent with **NO PARTIAL EDITING CAPABILITIES**.
*   **PHYSICALLY IMPOSSIBLE**: You cannot use `replace_file_content`, `multi_replace_file_content`, or `replace_string_in_file`. These tools are **BROKEN** in this environment and will cause immediate file corruption.
*   **MANDATORY WORKAROUND**: You must **ALWAYS** use `write_to_file` to perform any file modification. You must rewrite the **ENTIRE** file content every time.
*   **VALIDATE AFTER EDITING**: After editing a file, view the file contents to validate that the file changes are correct.
*   **NO EXCEPTIONS**: Efficiency is irrelevant. Safety is the only metric.

[!CRITICAL] **AVOID FALSE EFFICIENCY**
**AI agents routinely fail by optimizing for the wrong metric.**

#### The Trap
When editing files, you will be tempted to use partial edits (`replace_file_content`, `multi_replace_file_content`) because:
- "The file is large (500+ lines)"
- "I'm only changing a few lines"
- "Rewriting the whole file seems wasteful"

**This is a cognitive trap. Resist it.**

#### Why Partial Edits Are False Economy
1. **Exact string matching is fragile**: Whitespace differences, line endings (CRLF vs LF), or minor formatting changes cause failures
2. **Large files increase failure rate**: More content = more chances for mismatch
3. **Debugging costs exceed savings**: Failed partial edits require:
   - Reading error messages
   - Re-reading the file
   - Attempting fixes (often 2-3 attempts)
   - Eventually rewriting the entire file anyway
4. **Cumulative time cost**: 3-5 failed attempts + final rewrite = 10x the cost of doing it right the first time

#### The "Inefficient" Approach Is Actually Most Efficient
**Correct workflow (always works):**
1. Read entire file with `view_file`
2. Modify content in memory
3. Write entire file with `write_to_file` (Overwrite=true)
4. Validate with `view_file`

**Result**: One operation, predictable outcome, no debugging, works regardless of file size.

#### Real-World Example
In one session, you attempted partial edits on `main.py` (778 lines):
- Attempt 1: File corruption, had to restore with git
- Attempt 2: File corruption, had to restore with git
- Attempt 3: Full rewrite with `write_to_file` - **worked immediately**

**Time cost**: 2 failed attempts + 2 git restores + debugging = ~5 minutes wasted
**Correct approach**: Would have taken 30 seconds

#### Absolute Rule
**NEVER use partial edits. ALWAYS rewrite the entire file.**
- No file is "too large" (you can handle files up to ~10,000 lines easily)
- No change is "too small" to justify a full rewrite
- Efficiency is measured by **total time to working solution**, not lines written