TL;DR
GEIS is a technique for writing long texts through 6 explicit stages (Request → Plan → Draft → Audit → Refine → Deliver) plus an improvement loop: after each cycle, the evaluation findings turn into permanent rules for future requests.
Ask an LLM for a big analytical piece and you get either a loose stream of consciousness or a "skeleton of bullets" instead of real prose. The reason: a single pass has no quality gates. A structural mistake at the start drags through the whole text; facts "lost in the middle" vanish; the model never goes back and asks "is all of this actually right?"
The method fixes this with two things. First, an explicit Audit stage inside a single request: before the final output, the model checks its own draft and patches the weak spots. Second, an improvement loop: you analyze recurring weaknesses across several texts, add specific rules to your instructions, and the next texts pick up those lessons right away.
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
Two levels. The first is a single request (6 stages):
STAGE 1 — Request → clarify the goal, audience, format, constraints
STAGE 2 — Plan → build the structure: sections, depth, subtopics
STAGE 3 — Draft → write the full text with fleshed-out paragraphs
STAGE 4 — Audit → check structure, completeness, factual consistency
STAGE 5 — Refine → improve weak sections, remove repetition
STAGE 6 — Deliver → output only the final text, no internal notes
The second is the improvement loop (separate requests, over time):
EVALUATE → ask the model to grade several of its texts against a rubric
ANALYZE → find recurring weaknesses
PATCH → add specific rules to the base instruction
REGENERATE → rewrite the texts with the updated rules
Example
Task: Write a big deep-dive for a Substack newsletter about AI work tools, in the format "everything you need to know about Claude Projects." The reader is a busy founder who wants specifics and zero fluff.
Prompt:
Write a detailed deep-dive on the topic: "Claude Projects: how they work, why you need them, how to use them for work."
Use 6 stages:
**STAGE 1 — REQUEST**
State: the goal of the text, target audience, format, length (~1500 words),
constraints (no API technical details, focus on practice).
If something is missing, make an explicit assumption.
**STAGE 2 — PLAN**
Build the structure: sections and subsections.
For each section, note the depth (intro / in-depth) and key subtopics.
**STAGE 3 — DRAFT**
Write the full text. Each section is connected paragraphs with examples.
Not a bullet list — real prose. Where examples are needed, invent concrete
situations from a founder's life.
**STAGE 4 — AUDIT**
Check the draft: is the structure logical? Are all sections fleshed out?
Are there sections without examples? Any contradictions?
List the weak spots.
**STAGE 5 — REFINE**
Fix the weak spots from the audit. State exactly what you changed.
**STAGE 6 — DELIVER**
Output only the finished text. No plans, notes or internal comments.
Result:
The model will show 6 blocks in sequence. In Stage 4 you will see specific weaknesses it found on its own, like "the setup section is too short" or "no example for the instructions section." In Stage 5, an explicit list of edits. In Stage 6, only the final text, without plans or housekeeping notes. The draft and the final version will differ noticeably: the audit really does catch things.
Why it works
The LLM's weakness: there is no "mid-course reflection." The model generates text sequentially, left to right, and never goes back. If the plan was vague or the first paragraph wandered off, it keeps going in that direction to the end.
The LLM's strength: it is good at following explicitly stated instructions. And it is good at evaluating text against criteria, especially when the criteria are concrete rather than "write well."
How the method uses this: the Audit and Refine stages turn "one blind pass" into two passes with an explicit check. Deliver cuts the internal reasoning off from the final output, so the model doesn't "pollute" the text with plans and self-critique. And the improvement loop is a way to stop explaining the same thing every time: spot a recurring bug → add a rule → it works automatically.
Control levers: - Drop Deliver → you'll see all internal stages, including the audit and the list of edits - Make the Audit specific → instead of "check the quality," say "check: is there a conclusion, are there examples in every section, is any section shorter than 100 words" - Improvement loop → the more texts you analyze, the sharper the rules. You can start with 3-5 texts
Prompt template
Main request template (6 stages)
Write a {document_type} on the topic: {topic}
Use 6 stages. Show each stage explicitly.
**STAGE 1 — REQUEST**
State: goal, audience, format, length (~{length}), constraints.
Whatever is missing, state it as an explicit assumption.
**STAGE 2 — PLAN**
Structure: sections and subsections.
For each section, its depth and key subtopics.
**STAGE 3 — DRAFT**
Full text. Developed paragraphs, examples, specifics.
Not bullets — prose.
**STAGE 4 — AUDIT**
Check the draft:
— is the structure logical and complete?
— is every section fleshed out?
— no factual contradictions?
— {extra_criterion}?
List the weak spots.
**STAGE 5 — REFINE**
Fix the weak spots from the audit.
State exactly what you changed.
**STAGE 6 — DELIVER**
Output only the finished text. No plans, notes, or internal comments.
Placeholders:
- {document_type} — article / analysis / proposal / how-to guide
- {topic} — the exact wording of the topic
- {length} — 800 words / 2000 words / 5 sections
- {extra_criterion} — a question tailored to your task, e.g. "is there a section without examples?"
Improvement loop template (separate request)
Study the evaluations of these {N} texts you wrote following my instructions:
{text_evaluations_or_critiques}
Task:
1. Find recurring weaknesses — the ones that show up in 2+ texts
2. For each weakness:
— Describe the problem (as a writing issue, not a technical one)
— Write a specific rule that eliminates it
3. Output a list of rules to add to my base instructions
Ignore one-off problems — patterns only.
Placeholders:
- {N} — number of texts analyzed
- {text_evaluations_or_critiques} — your notes on "what I didn't like" for each text, or ask the model to first grade each text against criteria and then analyze
🚀 Quick start — paste into the chat:
Here is the GEIS template for long-form texts. Adapt it to my task: {your task}.
Ask me questions to fill in the fields.
[paste the template above]
The LLM will ask about the topic, document type, length and key quality criteria, because without them the Audit stage will be too generic and won't catch real weaknesses. It will take the 6-stage structure from the template and adapt it to your request.
Limitations
⚠️ Uniform rules hurt specific topics: If you add a rule like "always include more sources," texts that were originally strong on academic depth may degrade. Patches work on most topics but break the ones where the previous approach was already optimal.
⚠️ The audit doesn't guarantee factual accuracy: The Audit stage checks structure, completeness and consistency, not truthfulness. If the model fabricated a fact in the Draft, it most likely won't catch it in the Audit.
⚠️ Long prompts = long context: All 6 stages in one conversation pile up tokens. On very long texts (5000+ words), the model may "lose" early sections of the plan by the end of the Draft.
⚠️ The improvement loop takes discipline: For rules to accumulate, you need to keep your current instructions and attach them to every new request. In a regular chat, that's manual work.
Resources
GEIS: A Generation-Evaluation-Improvement Loop of Agent Skills for Long-Form Article Generation Jiale Zhang, Juntao Hu, Zhijian Ou Speech Processing and Machine Intelligence (SPMI) Lab, Tsinghua University; TasiTech Co., Ltd. Supported by the National Science and Technology Major Project (2023ZD0121401)
Related work cited in the paper: STORM (Wikipedia-like article generation), PEER (plan-edit-explain-repeat), ReAct, LongWriter, LongGenBench, Reflexion