AI Writing Extensions Inside Overleaf: What Works in a LaTeX Editor

Overleaf is a browser-based LaTeX editor, which makes it a target for every AI writing extension. Few of them work well there. The reason is structural: Overleaf's editor is a CodeMirror instance, not a textarea, and injected text that ignores the editor's model produces duplicated content, broken undo history, or a frozen document. Understanding the editing surface tells you which tasks to hand to an AI tool and which to keep in your own workflow.

Why naive text injection fails

An extension that inserts text by setting element.value works on a textarea. CodeMirror keeps its own document model and renders only the visible viewport. Writing to the DOM bypasses the model, so the next keystroke reverts your insertion or duplicates it. Worse, it can desynchronize the viewport from the document, which in Overleaf looks like text vanishing from the compiled PDF.

Tools that work use the editor's API, simulate real key events with proper composition events, or copy to the clipboard for a manual paste. The clipboard route is the most reliable and the least magical: generate the text, show it in a panel, let the user paste.

What AI genuinely helps with, and what it handles badly

Rewriting prose inside a section. Select a paragraph, send it out, get a revision. This works because the output is plain prose with no LaTeX structure.

Drafting tables and theorem environments from a description. The model can emit tabular or amsthm scaffolding that is faster to correct than to type.

Translating a paragraph while preserving inline math, which requires the model to treat $...$ spans as opaque tokens; naive translation mangles subscripts.

Explaining compile errors. Pasting an error log into an assistant is one of the highest-value uses. The model recognizes missing \end{}, undefined control sequences, and bibliography issues quickly.

Anything requiring the full document context: citation keys, custom macros defined in a preamble, and cross-references. A model that cannot see \newcommand{\R}{\mathbb{R}} will invent a different notation or fail to compile. Multi-file projects make this worse, since each section is a separate file.

Equation-heavy derivations are also risky. Models produce plausible-looking but incorrect algebra, and LaTeX's visual similarity to math hides the error until review. Use AI for exposition around equations, not for the derivations themselves.

A workflow that avoids corruption

Keep the AI panel separate from the editor. Copy the target paragraph, request a revision with an explicit instruction about preserving math and citation commands, and paste the result back. Commit to Overleaf's history before any large edit so a bad paste is one click from recovery.

For structural work, generate the code in the panel, review it, then paste. Do not let an extension rewrite the whole document; the failure mode is a corrupted .tex file that compiles to a blank PDF minutes before a deadline.

Ask for output that preserves \cite{}, \ref{}, and \label{} commands verbatim. Check the diff in Overleaf's review panel before accepting. Compile after every substantial insertion, not at the end. And keep a local Git mirror via Overleaf's Git integration if the project is important; browser-editor disasters are recoverable, but only if a copy exists outside the tab.

Multi-file projects, comments, and change tracking

A thesis is rarely one .tex file. The model needs to know which macros exist and where sections live before it can write anything that compiles. Keep a single macros.tex imported everywhere, and paste its \newcommand lines into the prompt when asking for code. Without that context, the model invents \R or \E definitions that clash with yours.

Ask for output as a standalone snippet using only macros you have listed. Reviewing a twelve-line snippet is faster than reviewing a rewritten section, and it avoids the model silently dropping a \label you needed.

Overleaf's history is line-based and merges can be messy when two collaborators edit the same paragraph. For AI-assisted edits, work in a branch of the project, paste, compile, and only then merge. If the model rewrites a paragraph, keep the original in a comment above for one revision cycle.

Do not let an extension write directly into the document. Generated text arriving without an explicit paste removes the moment where you notice a dropped citation.

Bibliography, cross-references, and collaboration etiquette

The two most common compile failures after an AI edit are an undefined \ref and a broken \cite. Both come from the model not seeing the .bib file or the labels defined elsewhere. Include the relevant keys in the prompt: "Use only these citation keys: ...".

After any structural edit, run a full compile including BibTeX, and check the log for undefined references. A document can produce a PDF while silently printing ?? where a figure reference should be.

If a co-author is editing the same section, do not run a rewrite over their changes. Overleaf shows cursors, but an AI paste is instantaneous and easy to miss. Announce structural edits in the chat, or work in a branch.

What to keep out of the prompt, and a workflow that meets deadlines

Unpublished data, participant quotes, and anything under a confidentiality agreement should not be pasted into a hosted model. Paraphrase or use placeholders and insert the real content locally.

Draft the structure yourself, use the assistant for prose-level revision and error diagnosis, compile after every insertion, and keep a Git mirror. The mirror is the difference between a bad paste costing five minutes and costing a night.

The final compile ritual, and errors from generated LaTeX

Compile after every paste, read the log for undefined references, and check the PDF page count. A sudden drop in pages usually means content was overwritten rather than edited.

Keep the previous version in history before large changes; recovery is one click instead of an evening.

Unescaped ampersands, underscores in identifiers, and unmatched braces account for most failures. Check the first error, not the tenth — LaTeX cascades.

Compile after each inserted block rather than at the end. Locating a break in one paragraph is minutes; locating it in a chapter is an afternoon.