Overwritten While Still Editing

In multi-turn agentic coding sessions, a developer would sometimes make manual edits to a file between agent steps, fixing a detail, correcting a path, adjusting formatting. When the next agent step touched the same file, the agent silently overwrote the entire file using stale cached content from before the manual edit, with no check of whether the file had changed. The manual edits vanished without warning. The issue affected all file modification operations, because the agent defaulted to full file replacement even when targeted in-place edits were available and would have avoided the collision entirely.

A known limitation of the agent's context window, considered. Agents can lose track of file state across many tool calls, especially in long sessions. But the issue here is not a long context, it's that the agent never re-read the file before overwriting it, even in short, recent turns where the content it held was already stale.

A deliberate design choice to use full overwrites for reliability, considered. Full replacement is simpler to implement and avoids some merge conflicts. But it makes the agent categorically incapable of coexisting with concurrent human edits, which is a significant practical limitation for a pair-programming tool.

Apraxia, most consistent with the record: the agent had access to targeted editing tools that would have preserved concurrent changes, but defaulted instead to a full file overwrite (a broader, more destructive action than the task called for) with no check to confirm the base content it was writing from was current.

A coding assistant that silently erases a developer's recent edits is worse than no assistant at all for collaborative work, because the loss is invisible and may not be noticed until the developer looks for a change they're certain they made. The fix is a file-state check before any write: if the file has changed since the agent last read it, re-read it, and use a targeted edit that preserves the parts the agent isn't meant to touch.

Check file state before any write, re-read if it changed, and prefer targeted edits.

Modification checks before overwrite; targeted-edit defaults; warnings on concurrent edits.