TL;DR
Ask an LLM to "fix the grammar mistakes" and it starts polishing the text: swapping words for synonyms, restructuring sentences, adding flourishes you never asked for. Two tricks fix this: a precise list of error types that may be corrected, instead of a vague phrase, and feeding it a batch of texts at once rather than one at a time.
The problem is fuzzy wording. When you say "make minimal edits", the model doesn't know where the line for "minimal" is. It either edits too much (changing style, words, structure) or too little, missing real errors. Every model has its own idea of "minimal", and without an explicit list it's guessing.
The fix is two independent levers. First: give the model a specific list of allowed edits (grammar, punctuation, word order, etc.) instead of a generic "fix the errors". Second, and surprising: if you send not one sentence but 10-20 at once, the model fixes less of what it shouldn't, because its "attention" gets spread across the whole batch and there are fewer creative style edits.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Method Blueprint
STEP 1 (one prompt): An instruction with an explicit list of allowed edit types
→ "fix only: grammar, punctuation, spelling, word order [specific list]"
→ "do NOT change the style, do NOT swap words for synonyms, do NOT paraphrase"
STEP 2 (same prompt): A few "before → after" examples for calibration
→ 5-8 pairs of "erroneous sentence → corrected"
STEP 3 (data format): Send a batch of 10-20 texts at once,
as a numbered list, not one at a time
→ the model returns a numbered list of corrected versions
Example in Practice
Task: An English tutor on Preply is grading 15 homework essays. Only grammar and punctuation errors should be fixed, without rewriting the students' style; otherwise the student won't see THEIR OWN mistakes and won't learn.
Prompt:
You are a proofreader. Below is a numbered list of sentences from English learners.
Fix ONLY the following types of errors:
1. Wrong verb tense
2. Missing/extra article (a/an/the)
3. Wrong preposition
4. Subject-verb agreement error
5. Punctuation (commas, periods)
6. Spelling mistakes
Do NOT rewrite the style. Do NOT swap words for synonyms. Do NOT change word order unless it's an error.
If a sentence is already correct, return it unchanged.
Examples:
"She go to school every day." → "She goes to school every day."
"I have visit Paris last year." → "I have visited Paris last year."
Text to check:
1. [student sentence 1]
2. [student sentence 2]
...
15. [student sentence 15]
Return a numbered list of the corrected versions.
Result: The model will return a list of 15 lines in which only grammar/punctuation/spelling is fixed; the students' phrasing and vocabulary stay their own. Compared with checking one sentence at a time, with a batch of 15 the model will "improve" the style less and stick to the boundaries more precisely.
Why It Works
LLMs are bad at guessing the boundaries of abstract instructions like "minimal edits". Without an explicit list, the model swaps in its own idea of "good writing" and starts editing the style. That's its weakness: it's trained to be a helpful editor, not a strict rule-follower.
The LLM's strength is precisely following specific, explicitly spelled-out lists of conditions. The clearer the boundaries, the less it "fills in the blanks" for you.
Batching works differently: the model spreads its "attention" across the whole block of text at once. When there are 15-20 sentences in the context, the model physically has fewer resources for creative edits to each individual one; it's forced to focus on obvious errors instead of polishing style. It's like asking someone to proofread 20 pages in an hour: they catch typos, but they don't rewrite paragraphs.
Control levers: - Batch size: for strict minimal editing, send 10-20 texts at once; for a single text where "smoothness" matters (stylistic editing), send them one at a time. The model then makes more "natural" edits but risks rewriting more than needed. - List of error types: narrow it to your task (only punctuation, only grammar) or widen it. A list that's too long can confuse weaker models, so test it. - "Before → after" examples: add 3-5 of your own examples, as close to your texts as possible. That calibrates the model more precisely than abstract rules.
Prompt Template
You are a proofreader. Fix ONLY the following types of errors in the text:
{list_of_error_types}
Do NOT rewrite the style, do NOT swap words for synonyms, do NOT change sentence structure
unless it's an error from the list above. If a text is already correct, return it unchanged.
Examples:
{example_1_before} → {example_1_after}
{example_2_before} → {example_2_after}
Texts to check:
1. {text_1}
2. {text_2}
...
{n}. {text_n}
Return a numbered list of the corrected versions, keeping the numbering.
What to fill in:
- {list_of_error_types}: a specific list (grammar, punctuation, spelling, agreement, etc.), as narrow as possible for your task
- {text_1...n}: a batch of 10-20 texts at a time (not just one!)
- Examples: 3-8 pairs, as similar as possible to your real texts
🚀 Quick start: paste this into the chat:
Here's a prompt template for minimal proofreading without rewriting the style.
Adapt it to my task: {your task}.
Ask me questions to fill in the fields.
[paste the template above]
The LLM will ask exactly which error types need fixing and how many texts you usually have in a batch, because the precise list and batch size determine how much the model will "polish" the text beyond what's needed.
Limitations
⚠️ It depends on the model: an explicit list of error types helps the most powerful models (top versions of GPT/Claude/Gemini), but for weaker models it can act as noise and even make results worse.
⚠️ Fluency suffers: with a batch of texts the model makes fewer edits, but the text ends up less "smooth": small stylistic rough edges stay untouched. If you care not only about correctness but also about natural-sounding text, large batches won't work for you.
⚠️ Not for creative editing: the method is built for "fix the error, leave the style alone" tasks. If you need to improve a text or rewrite clumsy wording, that's a different task; the method won't help there and will even get in the way.
⚠️ The optimal batch size isn't universal: in the study the best balance was around 15 texts, but for other languages or task types you need to test it empirically.
How They Tested It
The researchers took seven language models (six commercial ones, GPT, Claude and Gemini at different tiers, plus one open model, Qwen) and ran them through five prompt variants: from a generic "fix the errors" to a prompt with an explicit list of 25 grammatical error categories plus examples. They tested on standard text sets with known "correct" fixes (BEA-2019 and CoNLL-2014).
Then came the most interesting part: they varied how many sentences to send in a single request, from one up to 120 at once. It turned out that as batch size grew, the share of "untouched" sentences went up (for one model, nearly doubling), and the number of unnecessary edits dropped. That contradicted expectations: the usual assumption is that more context means worse focus. But here the "scattered attention" worked in their favor: the model stopped butting in with stylistic improvements.
The practical insight: if you need strict, conservative editing, don't send texts one at a time; bundle them into batches. That way the model "gets creative" less and sticks to the task more precisely.
Original From the Paper
Make MINIMAL, PRECISE edits to fix errors. DO NOT rewrite or paraphrase.
[Categories from the ERRANT taxonomy, example from the paper:]
6. DET: Wrong/missing/extra determiner (the → a, ∅ → the, the → ∅)
20. PUNCT: Punctuation errors (! → ., missing commas, extra periods)
Context: These are fragments of prompts A.2 (a declarative "minimal edits" instruction) and A.4 (a list of 25 ERRANT error categories, the standard system for classifying grammatical errors). The full list of 25 categories isn't reproduced in the paper, but the structure ("number: code — description — replacement example") shows how to build your own list for a specific language or type of text.
Adaptations and Extrapolations
💡 Adaptation for business writing: the same principle works for checking candidates' resumes, business emails from employees, and support replies: anywhere it matters to fix errors while preserving the author's voice.
You are a resume proofreader. Fix only: typos, punctuation, subject-verb agreement.
Do NOT change the wording, do NOT add "professional" phrases, do NOT rewrite the structure.
Resumes to check:
1. [candidate resume 1]
2. [candidate resume 2]
...
🔧 Technique: batch size → the balance between precision and naturalness
For strict minimal editing, increase the batch (10-20 texts). For cases where liveliness and naturalness matter (say, final editing of an important email to a client), work with one text at a time and accept the risk of more aggressive edits.
Resources
Larger Context Window, Fewer Overcorrections: Optimizing Prompts and Batching for Minimal-Edit Grammatical Error Correction (accepted to EMNLP 2026 Findings). Authors: Kateryna Karpo (Ukrainian Catholic University, YouScan), Artem Chernodub (Zendesk). Code, prompts and results: github.com/katerynkarpo/llm-en-gec