PerFine: Personalizing Text Through Iterative Critique

ITERATION 0 (initialization):
Generator → draft y₀ (based on samples of the user's style)

ITERATIONS 1-5 (refinement loop):
STEP 1: Critic → feedback on 4 criteria
  - Tone (emotional coloring, formality)
  - Vocabulary (level and character of word choice)
  - Sentence structure (length, complexity)
  - Topic relevance (completeness, accuracy)

STEP 2: Generator → revised version y_new

STEP 3: Critic → knockout (compare y_new with y_prev)
  → if y_new is better → y_new moves on
  → if y_prev is better → keep y_prev

[The loop repeats 3-5 times]

Important: Each step runs as a separate request. Critic and Generator can be the same model (self-refinement) or different ones.

⚠️ Where the method shines: Tasks where you have concrete samples of the target style (the user's own texts, writing samples). The method works worse if there are few samples (<3) or they vary a lot in style.

The task: Write a Google Maps review of the Blue Bottle Coffee café in the style of someone who writes detailed, honest, slightly ironic reviews with an eye for the details of the service.

Input data:

• Place: Blue Bottle Coffee in the West Village
• Rating: 4 stars
• Samples of the user's style:
  • "Nice interior, but the AC hummed like an old fridge"
  • "The servers were all smiles, even though they forgot the sugar — I had to remind them twice"
  • "Tasty cappuccino, but it came in a thimble-sized cup for $6.50"

Prompt (first iteration):

You are a generator of personalized texts.

TASK: Write a Google Maps review of the Blue Bottle Coffee café in the West Village.

RATING: 4 stars

SAMPLES OF THE USER'S STYLE:
- "Nice interior, but the AC hummed like an old fridge"
- "The servers were all smiles, even though they forgot the sugar — I had to remind them twice"  
- "Tasty cappuccino, but it came in a thimble-sized cup for $6.50"

INSTRUCTION: Keep the tone, vocabulary and sentence structure as in the samples. Describe the atmosphere, the food and the service.

Critic prompt (after generation):

You are a critic of personalized texts.

TASK: Evaluate how well the review matches the user's style.

SAMPLES OF THE USER'S STYLE:
[the same samples]

GENERATED TEXT:
[paste the generator's text]

EVALUATION CRITERIA:
1. TONE: Does the emotional coloring match (ironic, honest)?
2. VOCABULARY: Does it use casual vocabulary ("hummed", "thimble")?
3. STRUCTURE: Are there contrasting sentences ("nice, but...")?
4. TOPIC: Are the important aspects covered (atmosphere, food, service)?

GIVE FEEDBACK: What should be improved to nail the style?

Result:

The model will go through 3-5 iterations, where:

• Iteration 1: The Critic notes that the tone is too neutral and lacks the signature irony
• Iteration 2: The Generator adds contrasting constructions ("but..."), and the Critic approves the direction
• Iteration 3: The Critic asks for more detail (specific dishes, prices), and the Generator revises
• Iterations 4-5: Knockout keeps the better version if the new one is worse

The final text will hit the style much more precisely: casual vocabulary, contrasting sentences, attention to small details, light irony at 4 stars.

The LLM's weakness: Models drift away from the target style during generation. Even when the prompt includes samples, the model tends toward regression to the mean: averaging out the tone, simplifying the structure, losing distinctive details. Retrieval provides context but doesn't guarantee faithful style. Single-pass generation is a balancing act between "don't forget the topic" and "stick to the style", and style often loses.

The LLM's strength: Models are excellent at analyzing and comparing texts. Give an LLM two versions and samples of the target style, and it will tell you precisely which one is closer. Models are also good at generating structured feedback: they can not only say "the tone is off" but explain "it needs a more ironic tone, like in the sample about the AC".

PerFine's mechanics:

1. Separating roles: The generator focuses on writing, the critic on checking the match. That removes the cognitive load of "doing everything at once".
2. Structured feedback along 4 dimensions: Instead of an abstract "make it better", the critic gives concrete directions ("dial up the irony in the tone", "add more casual words"). That reduces uncertainty for the generator.
3. Knockout protects against regression: Comparing versions prevents a fix to one aspect (say, tone) from breaking another (say, structure). The best version across all iterations survives.
4. Iteration gives incremental improvement: Over 3-5 rounds, the text gradually converges on the target style. The study showed improvements hold steady up to 3-5 iterations and then plateau.

Prompt control levers:

Generator (iteration 0):

You are a generator of personalized texts.

TASK: {task description}

SAMPLES OF THE USER'S STYLE:
{sample_1}
{sample_2}
{sample_3}

INSTRUCTION: Write the text, strictly following the tone, vocabulary and sentence structure of the samples.

Critic (iterations 1-5):

You are a critic of personalized texts.

SAMPLES OF THE USER'S STYLE:
{sample_1}
{sample_2}
{sample_3}

GENERATED TEXT:
{generator_text}

EVALUATION CRITERIA:
1. TONE: Does the emotional coloring match the samples?
2. VOCABULARY: Does it use the user's signature vocabulary?
3. STRUCTURE: Do sentence length and complexity match the samples?
4. TOPIC: Are all the important aspects of the task covered?

GIVE CONCRETE FEEDBACK on each criterion: what should change to nail the style?

Generator (revision):

You are a generator of personalized texts.

TASK: {task description}

SAMPLES OF THE USER'S STYLE:
{sample_1}
{sample_2}
{sample_3}

PREVIOUS VERSION OF THE TEXT:
{generator_text}

CRITIC'S FEEDBACK:
{feedback}

INSTRUCTION: Revise the text based on the feedback. Keep the strengths, fix the weaknesses.

Knockout (comparing versions):

You are an arbiter who picks the better text.

SAMPLES OF THE USER'S STYLE:
{sample_1}
{sample_2}
{sample_3}

VERSION A (previous version):
{previous_text}

VERSION B (new version):
{new_text}

QUESTION: Which version matches the user's style more closely across all 4 criteria (tone, vocabulary, structure, topic)?

ANSWER: A or B + a brief justification.

Placeholder notes:

• {task description} — what needs to be written (a review, an email, a post)
• {sample_1, 2, 3} — real texts by the user (at least 3)
• {generator_text} — the output of the previous step
• {feedback} — the critic's structured response

🚀 Quick start: paste this into the chat:

Here's the PerFine template for personalizing text. Adapt it to my task: [describe what needs to be written and in what style]. 
Ask me questions to fill in the fields.

[paste the template above]

The LLM will ask for samples of your writing (at least 3) and details of the task, because the method runs on comparing styles. It'll take the "generate → critique → revise → knockout" pattern and adapt it to your specific task.

⚠️ Too few samples: The method works worse if there are fewer than 3 style samples or they vary a lot. You need a stable baseline to compare against.

⚠️ Subjective criteria: For creative tasks without a clear target style (e.g., "write an inspiring text"), the method can get stuck looping between different interpretations.

⚠️ Cost of iterations: 5 iterations = 5x the LLM requests. With expensive models (GPT-4), that's a noticeable hit to the budget.

⚠️ Cold start: If the user has no writing history (a new account), the method loses its basis for personalization.

The researchers took three review datasets (Yelp for restaurants, Amazon for products, Goodreads for books) with 2,500 users each. For every user they built an interaction graph: nodes are users and items, edges are reviews. That made it possible to retrieve not just the user's own texts but also reviews by "neighbors" (other people who rated the same items) to enrich the topical context.

The baseline method (PGraphRAG) worked like this: retrieve the top 4 texts by the user + top 4 by neighbors → generate the review in a single request. PerFine started from that output and ran the refinement loop. Three variants were compared:

1. LaMP (only the user's texts, no neighbors) — baseline
2. PGraphRAG (user's + neighbors' texts) — improved baseline
3. PerFine + Knockout (PGraphRAG + iterative refinement) — the new method

What they measured: GEval (an LLM-as-a-Judge metric where GPT rates quality on a scale) and METEOR (an automatic metric of similarity to a reference).

Key findings:

• PerFine is consistently better by +7-13% on GEval (Yelp: 0.400 → 0.441, Goodreads: 0.445 → 0.480, Amazon: 0.410 → 0.465)
• Plateau effect: Improvements show up through 3-5 iterations, then plateau; further revisions add nothing
• Critic size matters: Scaling the critic model from 7B to 32B parameters monotonically improves results (Yelp: 0.431 → 0.470). Bigger critics give more precise feedback.
• Self-refinement works: Even when the generator and critic are the same model (Llama-3.1-8B), the method beats the baseline. That saves memory (no second model needed).
• Best-of-N adds +2%, but it's expensive: A variant that generates 3 versions per iteration and has the critic pick the best showed +2% quality but tripled token usage. Knockout (comparing just two versions, new and previous) delivers 95% of the effect at half the cost.

Why the results came out this way: Retrieval provides context but doesn't steer generation directly. The model "sees" the samples, but while writing it can drift toward an averaged style. The critic, by contrast, evaluates the whole text after full generation and gives concrete directions, which works better than trying to "account for everything at once" in a single prompt. Knockout protects against regression: if the new version is worse (say, the tone got fixed but the structure broke), the previous one stays. That produces monotonic improvement across iterations.

A curious detail: Topic Extraction (giving the critic a summary of style and topic instead of raw texts) showed similar quality with -30% tokens for the critic. But total usage went up because of the upfront topic-extraction stage. It's a trade-off: compact context vs preprocessing overhead.

Context: The researchers tested PerFine on a review-generation task. Here's the prompt for the Critic LLM, which gives structured feedback on 4 personalization criteria.

You are a personalized content critic. Your task is to evaluate the generated text 
for alignment with the user's writing style and provide constructive feedback.

USER PROFILE (sample texts):
{user_history_texts}

NEIGHBOR PROFILE (sample texts for topic context):
{neighbor_texts}

QUERY (item to review):
{item_description}

GENERATED TEXT:
{generated_review}

EVALUATION CRITERIA:

1. TONE CONSISTENCY:
Evaluate whether the tone and sentiment align with the user's writing style.
- Does the emotional tone (enthusiastic, critical, neutral) match the user's typical style?
- Is the level of formality consistent?

2. VOCABULARY MATCH:
Evaluate whether the vocabulary level is consistent with the user's lexicon.
- Are the word choices similar to those in the user's previous texts?
- Does it use domain-specific terms the user typically employs?

3. SENTENCE STRUCTURE:
Evaluate if the sentence lengths, complexity, and syntactic structures align 
with the user's style.
- Are sentences simple or complex, similar to the user's writing?
- Does the text use similar punctuation patterns?

4. TOPIC RELEVANCE:
Evaluate if the generated content is relevant to the query, free of off-topic 
information, and inclusive of important aspects.
- Does it address the key aspects of the item being reviewed?
- Is there any irrelevant or missing information?

PROVIDE FEEDBACK:
For each criterion, state:
- What is done well
- What needs improvement
- Specific suggestions for refinement

Format your feedback as:
TONE: [feedback]
VOCABULARY: [feedback]
SENTENCE STRUCTURE: [feedback]
TOPIC RELEVANCE: [feedback]

Knockout prompt (comparing two versions):

You are an arbiter that compares two text generations and selects the more 
personalized one based on the user's writing style.

USER PROFILE (sample texts):
{user_history_texts}

VERSION A (previous iteration):
{text_v1}

VERSION B (current iteration):
{text_v2}

TASK:
Compare both versions across four dimensions:
1. Tone consistency with user's style
2. Vocabulary match with user's lexicon
3. Sentence structure alignment
4. Topic relevance

SELECT: Which version (A or B) better aligns with the user's writing style overall?

RESPOND:
Selected version: [A or B]
Reason: [brief explanation of why this version is more personalized]

💡 Adaptation for content marketing:

Instead of reviews, generate social media posts in the brand's voice. Style samples = the company's previous posts.

TASK: Write a post for [Company name]'s LinkedIn page about a new product feature.

SAMPLES OF THE COMPANY'S STYLE:
[3-5 posts from the page's archive]

[Next: the standard PerFine loop with a critic]

The upside: Content managers get drafts that don't need heavy style edits, just a fact check.

💡 Adaptation for legal documents:

Generate contracts or letters in a specific lawyer's style, using their signature phrasing.

TASK: Draft an amendment to a lease agreement.

SAMPLES OF THE LAWYER'S STYLE:
[3-5 excerpts from this lawyer's previous contracts]

CRITERIA (adapted):
1. TONE: Formality, level of assertiveness
2. TERMINOLOGY: Use of characteristic legal constructions
3. STRUCTURE: Clause numbering, paragraph length
4. COMPLETENESS: All necessary terms are present

The upside: Automates the routine while preserving the specialist's individual style.

🔧 Technique: Drop the knockout → watch the style evolve

If you skip the knockout (don't compare versions), you can track how the text changed across iterations, which is handy for learning to write.

[The standard PerFine loop, but WITHOUT the knockout step]

After 5 iterations, ask:
"Show all 5 versions of the text side by side and explain what changed at each step"

Effect: The user sees the refinement process, which is genuinely instructive for copywriters and students.

🔧 Technique: Characters instead of faceless roles → sharper critique

Swap "critic" for a specific character with personality.

You are William Zinsser, author of "On Writing Well". Your task is to check the text 
against the user's style and give feedback the way you always do: 
bluntly, concretely, with examples.

[Next: the standard critic prompt]

Effect: The critique gets tougher and more precise: the model slips into the role of a specific character better than into an abstract "critic".

Iterative Critique-Refine Framework for Enhancing LLM Personalization
Authors: Durga Prasad Maram, Dhruvin Gandhi, Zonghai Yao, Gayathri Akkinapalli, Franck Dernoncourt, Yu Wang, Ryan A. Rossi, Nesreen K. Ahmed
University of Massachusetts Amherst, Adobe Research, University of Oregon, Cisco AI Research

Relevant references from the paper:

• PGraphRAG (graph-based retrieval for personalization)
• LaMP benchmark (personalized generation)
• SELF-REFINE (self-critique for improving outputs)
• G-Eval (an LLM-as-a-Judge evaluation metric)