TICKing All the Boxes: Generated Checklists Improve LLM Evaluation and Generation

## Abstract

Abstract Given the widespread adoption and usage of Large Language Models (LLMs), it is crucial to have flexible and interpretable evaluations of their instruction-following ability.
Preference judgments between model outputs have become the de facto evaluation standard, despite distilling complex, multi-faceted preferences into a single ranking.
Furthermore, as human annotation is slow and costly, LLMs are increasingly used to make these judgments, at the expense of reliability and interpretability.
In this work, we propose TICK ( T argeted I nstruct-evaluation with C hec K lists), a fully automated, interpretable evaluation protocol that structures evaluations with LLM-generated, instruction-specific checklists.
We first show that, given an instruction, LLMs can reliably produce high-quality, tailored evaluation checklists that decompose the instruction into a series of YES/NO questions.
Each question asks whether a candidate response meets a specific requirement of the instruction.
We demonstrate that using TICK leads to a significant increase (46.4% → → \to → 52.2%) in the frequency of exact agreements between LLM judgements and human preferences, as compared to having an LLM directly score an output.
We then show that STICK ( S elf- TICK ) can be used to improve generation quality across multiple benchmarks via self-refinement and Best-of-N selection. STICK self-refinement on LiveBench reasoning tasks leads to an absolute gain of + + + 7.8%, whilst Best-of-N selection with STICK attains + + + 6.3% absolute improvement on the real-world instruction dataset, WildBench. In light of this, structured, multi-faceted self-improvement is shown to be a promising way to further advance LLM capabilities. Finally, by providing LLM-generated checklists to human evaluators tasked with directly scoring LLM responses to WildBench instructions, we notably increase inter-annotator agreement (0.194 → → \to → 0.256).

## 1 Introduction

Instruction-tuned Large Language Models (LLMs) are widely used as conversational assistants, where users expect responses to closely follow their intents (Wei et al., ; Mishra et al., ; Bai et al., ; Ouyang et al., ). The broad usage of LLMs creates a critical demand for reliable, flexible, and transparent ways of evaluating their instruction-following abilities. However, standard evaluation methods, such as preference labeling (Ouyang et al., ), direct scoring (Novikova et al., ; Wang et al., ), and Elo rating (Bai et al., ; Glaese et al., ), tend to obscure the reasoning behind evaluations. These methods also often result in significant disagreements, both among human annotators (Hosking et al., ) and between models and humans (Qin et al., ; Zheng et al., ).

To address these limitations, we introduce TICK (Targeted Instruct-evaluation with ChecKlists), a novel approach to LLM-as-judge evaluation that uses the judge LLM to decompose instructions into checklists consisting of a series of YES/NO evaluation questions. These checklists provide interpretable, fine-grained assessments of whether a model response satisfies specific requirements of the instruction. Crucially, TICK eliminates manual effort in checklist creation, a substantial cost for existing checklist-based benchmarks (Qin et al., ; Wen et al., ). We rigorously demonstrate that current LLMs can already generate checklists matching the quality of human-written ones.
In experiments, we show that using TICK leads to an absolute increase in the frequency of exact agreements between an LLM judge and human preferences of 5.8%.

Figure: Figure 1: Left: Diagram of TICK and its downstream uses of augmenting human evaluation, performing self-refinement, and response filtering. Right: Example of a generated evaluation checklist.
Refer to caption: extracted/5902375/figures/diagram.png

Building on this, we introduce STICK (Self-TICK), an approach to in-context self-improvement where LLMs iteratively refine their responses based on TICK self-evaluations. We demonstrate that STICK enables LLMs to achieve significant performance gains across several benchmarks without the need for dataset-specific prompting or pre-existing human-written checklists. Specifically, Command-R+ shows a 6.5% absolute improvement on InFoBench (Qin et al., ) and a 7.1% absolute gain on WildBench (Lin et al., ), outperforming vanilla Self-Refine (Madaan et al., ).
On LiveBench (White et al., ), STICK refinements enable Command-R+ to achieve a 3.8% improvement and GPT-4o to gain 0.8%, whereas vanilla Self-Refine leads to substantial degradation.
These improvements span tasks for which in-context self-improvement has previously proven challenging, such as mathematics, reasoning, and coding (Huang et al., ; Kamoi et al., ; Tyen et al., ), as well as amplifying improvements on tasks that have previously been shown to benefit from self-critiques, such as constrained instruction-following (Madaan et al., ). When used for Best-of-N response self-selection, STICK improves on greedy decoding by 5.1% on InFoBench and 5.3% on WildBench, and even outperforms selection by a general-purpose reward model. Finally, we explore whether LLM-generated checklists can assist human evaluators by augmenting the annotation process and find significant improvements to inter-annotator agreement.

In summary, we make the following contributions:

- 1.
We rigorously show that LLMs can generate evaluation checklists similar in quality to those written by trained human annotators across multiple diverse instruction-following datasets.
- 2.
We introduce TICK, a checklist-based, automatic evaluation protocol that yields stronger agreement with humans than other general-purpose LLM-as-judge evaluations. Because TICK can be fully automated, it is cheaper and faster to run than existing checklist-based evaluations, and can be applied to arbitrary instruction-following datasets.
- 3.
We leverage Self-TICK (STICK) to substantially improve instruction-following ability via self-refinement and Best-of-N selection on multiple challenging benchmarks.
- 4.
We explore using LLM-generated checklists to assist human evaluators tasked with directly scoring an LLM output, and find that this improves inter-annotator agreement.

## 2 Related Work

##### Instruction-Following Evaluation:

There have been many efforts to improve the evaluation and benchmarking of LLMs’ instruction-following ability. Some of these benchmarks aggregate instruction sets from a diverse range of sources to measure general instruction-following ability and use a judge LLM to score outputs (Li et al., ; Chia et al., ; Lin et al., ). Others decompose instructions into checklists, made up of YES/NO questions or PASS/FAIL criteria that a response should meet (Zhou et al., ; Jiang et al., ; Qin et al., ; Wen et al., ).
For example, the WildBench (Lin et al., ) dataset pairs its instructions with checklists (generated by two LLMs, then reviewed by humans) that are
included in the evaluation prompt to get a score or preference from a judge LLM, but not explicitly answered or used to form a metric.
Approaches to evaluation used in these works are therefore hard to make use of outside of the benchmarks themselves, relying heavily on humans for instruction and checklist curation. We instead design a dynamic evaluation protocol that can be employed on-the-fly and therefore seamlessly integrated into custom evaluation workflows, or used to steer high quality generation. Meanwhile, we avoid the cost of having humans in the loop and enable our evaluation quality to improve as LLMs improve.

**Table 1: A single step of self-refinement on LiveBench with Command-R+ and GPT-4o, using STICK to form self-critiques. Unstructured self-critiques are included as a baseline (Self-Refine), along with each LLM’s base performance.**
| Tasks | Command-R+ | GPT-4o |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| Base | Self-Refine | STICK | Base | Self-Refine | STICK |  |
| Overall | 32.0 | 23.7 ($\downarrow$ 8.3) | 35.8 ($\uparrow$ 3.8) | 55.4 | 47.1 ($\downarrow$ 8.3) | 56.2 ($\uparrow$ 0.8) |
| Coding | 18.8 | 9.1 ($\downarrow$ 9.7) | 22.7 ($\uparrow$ 3.9) | 50.4 | 36.4 ($\downarrow$ 14.0) | 51.6 ($\uparrow$ 1.2) |
| Data Analysis | 25.9 | 5.3 ($\downarrow$ 20.6) | 29.8 ($\uparrow$ 3.9) | 52.4 | 27.2 ($\downarrow$ 25.2) | 52.5 ($\uparrow$ 0.1) |
| Instructions | 69.6 | 60.5 ($\downarrow$ 9.1) | 75.8 ($\uparrow$ 6.2) | 73.3 | 62.8 ($\downarrow$ 10.5) | 76.2 ($\uparrow$ 2.9) |
| Language | 24.6 | 13.8 ($\downarrow$ 9.8) | 24.1 ($\downarrow$ 0.5) | 50.9 | 51.4 ($\uparrow$ 0.5) | 50.4 ($\downarrow$ 0.5) |
| Mathematics | 23.7 | 23.6 ($\downarrow$ 0.1) | 25.5 ($\uparrow$ 1.8) | 52.3 | 51.8 ($\downarrow$ 0.5) | 53.1 ($\uparrow$ 0.8) |
| Reasoning | 29.2 | 30.0 ($\uparrow$ 0.8) | 37.0 ($\uparrow$ 7.8) | 53.3 | 52.7 ($\downarrow$ 0.6) | 53.3 (0) |

##### Language Critiques:

LLM critiques are an intuitive way of addressing the “black box” nature of evaluations. These critiques are intended to point out the strengths and weaknesses of outputs generated by the same LLM, or a different LLM. Critiques can be used to improve the quality of overall evaluations performed by an LLM judge or reward model (Ankner et al., ; Bai et al., ; Wang et al., ; Ye et al., ; Sun et al., ), inform human evaluations (Saunders et al., ; McAleese et al., ), or provide feedback that can be used to refine a response in-context (Scheurer et al., ; Tian et al., ; Madaan et al., ; Yuan et al., ). Meanwhile, a number of papers provide evidence that naively prompting LLMs to self-correct or find reasoning errors can lead to performance degradation (Huang et al., ; Tyen et al., ; Kamoi et al., ). By using the targeted and structured nature of checklist-based evaluations, we achieve self-refinement that outperforms unstructured feedback and works on a broad range tasks.

## 3 TICK: Targeted Instruct-evaluation with ChecKlists

We present an approach to automatically and robustly evaluating instruction-tuned LLMs that is not restricted to any particular dataset. To do so, we use an LLM to generate checklists of targeted YES/NO evaluation questions for a given instruction. We then also use an LLM to evaluate responses with respect to each checklist question, exploiting the fact that the decomposed task of answering a single, targeted question is much simpler than coming up with a holistic score or preference ranking. Individual checklist answers can then be aggregated to produce an overall score or preference. In this section, we provide details for each of these steps and experimentally validate their effectiveness by analysing agreement between LLMs and a pool of trained human annotators at each stage. All prompts used are included in Appendix G.

### 3.1 Approach

#### 3.1.1 Generating Checklists

For a given instruction, we seek to generate a checklist, i.e. a list of YES/NO questions that each ask about a different requirement of the instruction. As in Qin et al. (), we enforce that each question should be phrased such that an answer of YES corresponds to correctly meeting the requirement that the question is targeting.
To obtain these instruction-specific checklists, we prompt an LLM with a few-shot template that specifies the instruction and the YES/NO constraint. This prompt also mentions that checklists should cover all criteria explicitly stated in an instruction, as well as any implicit criteria that are generally important for an instruction’s problem domain.
Figure 1 shows an example instruction and an LLM-generated checklist.

#### 3.1.2 Using Checklists

Once we have generated checklists, we prompt a judge LLM with each checklist question to evaluate the quality of a response. TICK uses the same LLM to generate and answer checklists, but different LLMs may be used for each step.
We denote $a_{i,j}$ as the answer to the $j$-th question in the checklist for the $i$-th instruction.
The quality of a response for a single instruction $i$ is measured using the checklist Pass Rate (PR), defined as $\text{PR}=\sum_{j}a_{i,j}/n_{i}$, where $n_{i}$ is the length of the $i$-th checklist and $a_{i,j}\in\{0,1\}$ (i.e., NO $\to$ 0 and YES $\to$ 1).
The aggregate instruction-following quality across all examples in a dataset of instructions is measured using the Decomposed Requirements Following Ratio (DRFR; Qin et al., ), defined as $\text{DRFR}=\sum_{i,j}a_{i,j}/\sum_{i}n_{i}$, i.e., the percentage of total checklist questions that were correctly answered from the model’s responses.

### 3.2 Validation

#### 3.2.1 Generating Checklists

##### Similarity to human checklists:

To verify that LLM-generated checklists are high quality, we compare them to checklists written by trained annotators on Internal, an internal test set of 612 instructions.(^1^11We will be open-sourcing this dataset plus the generated checklists for use by the research community.)
These instructions have been written by the same pool of annotators, and are intended to resemble complex, real-world use cases of instruction-tuned LLMs, ranging from open-ended question answering to highly structured outputs.
Sample instructions are available in Appendix D. For each instruction in Internal, we collect three checklists written independently by different annotators.
The annotators are given precise requirements for writing checklists as well as a set of high quality examples (see Appendix H.1).
From these checklist triplets, we form a set of human-written ground-truth checklists $\mathcal{H}^{*}$ by manually selecting the one that best meets the annotation requirements for each instruction in the dataset. In rare instances where none of the checklists fully meet the specified requirements, we select the best and manually make corrections.
We use the remaining two checklists for each instruction to form a set $\mathcal{H}^{\prime}$ of alternative human-written checklists.

**Table 2: Similarity between checklists from various sources, human-written ground-truth checklists ($\mathcal{H}^{*}$), and alternate human-written checklists ($\mathcal{H}$’) in terms of word overlap metrics and question count.**
| Checklist Source | Similarity to $\mathcal{H}^{*}$ |  |  |  |  |
| --- | --- | --- | --- | --- | --- |
| BLEU | ROUGE-1${}^{\text{F1}}$ | ROUGE-2${}^{\text{F1}}$ | ROUGE-L${}^{\text{F1}}$ | Count MAE |  |
| GPT-4o | 0.759 | 0.621 | 0.417 | 0.593 | 1.410 |
| Command-R+ | 0.709 | 0.570 | 0.357 | 0.534 | 1.416 |
| Llama3.1-70B | 0.759 | 0.623 | 0.418 | 0.593 | 1.459 |
| $\mathcal{H}^{\prime}$ | 0.733 | 0.611 | 0.399 | 0.583 | 2.158 |

We generate checklists with GPT-4o (OpenAI, ), Command-R+ (Cohere, ), and Llama3.1-70B-Instruct (Dubey et al., ) (we omit the “Instruct” for brevity). We compare these checklists, as well as $\mathcal{H}^{\prime}$, against $\mathcal{H}^{*}$ in terms of BLEU (Papineni et al., ), ROUGE (Lin, ), and question count.(^2^22For further analysis of the lengths of generated and human-written checklists, see Appendix B.1.) Since $\mathcal{H}^{\prime}$ is comprised of two checklists per instruction, we compare each to $\mathcal{H}^{*}$ and take the average of each metric. For consistency, we also generate an second checklist for each instruction from each LLM, and also average results over the two checklists.

Results for this experiment are shown in Table 2.
We find that GPT-4o and Llama3.1-70B generate checklists that more closely match those in $\mathcal{H}^{*}$ than the alternative human-written checklists in $\mathcal{H}^{\prime}$ do.
There is particularly high variation between $\mathcal{H}^{\prime}$ and $\mathcal{H}^{*}$ in terms of question count, which we observe to be because different annotators assumed different levels of granularity when writing checklists. Command-R+ has the lowest string-level similarity, but is close in terms of question count.
These results indicate that LLMs can produce checklists that strongly resemble the best human-written checklists. Examples are available in Appendix E.

**(a) Pearson correlation between Command-R+ checklist pass rates when evaluated with LLM- and human-written checklists. We use annotators and GPT-4 to answer checklist questions for Internal and InFoBench respectively.**
| Checklist Gen. | Score Correlation |  |
| --- | --- | --- |
| Internal | InFoBench |  |
| GPT-4o | 0.772 | 0.853 |
| Command-R+ | 0.713 | 0.776 |

##### Impact on scores when replacing human checklists:

We also verify the quality of LLM-generated checklists by checking whether they can produce comparable pass rates to human-written checklists when used either by human annotators or an LLM-as-judge.
This is meant as another validation of checklist generation alone, and does not yet consider how well the LLM generating the checklist can answer that same checklist.
For Internal, we use the pool of trained human annotators to answer checklist questions using either a set of model-written checklists or $\mathcal{H}^{*}$. Each evaluation is performed independently by three annotators and the majority vote for each question is used to compute pass rates.
To consider the impact of LLM-generated checklists when using an LLM-as-judge, we also generate checklists for prompts from InFoBench (Qin et al., ). InFoBench is a instruction-following benchmark that provides instruction-specific evaluation checklists written by expert human annotators. To answer InFoBench checklist questions, we follow the recommended evaluation protocol of using GPT-4 (OpenAI, ) as a judge with the benchmark’s official prompt.

Table 3(a) shows that the pass rates when using checklists generated by GPT-4o or Command-R+ are highly correlated with pass rates when using $\mathcal{H}^{*}$, with GPT-4o checklists exhibiting the strongest correlation.
This result demonstrates that LLM-generated checklists are functionally similar to human-written checklists, further validating their use.

#### 3.2.2 Using Checklists

##### Question-level agreement with humans:

To verify that an LLM can reliably answer generated checklist questions, we first investigate how well the generated answers agree with those of trained human annotators. We use the previously gathered set of human majority vote answers for Internal as ground truth and compute the accuracy of checklist answers generated by GPT-4o, Command-R+ and Llama3.1-70B. Table 3(b) shows that each of the LLMs considered achieves reasonable question-level accuracy, but that GPT-4o is the strongest in this regard. In Figure 2, we show how GPT-4o’s accuracy changes under different evaluator settings with varying inference costs. Having the evaluator output a Chain-of-Thought (CoT) (Wei et al., ) prior to making a final judgement substantially improves accuracy. Sampling $k$ evaluations, with CoT included, and taking a majority vote (maj@k) yields further improvement, with higher $k$ leading to a more substantial increase. These results demonstrate that TICK becomes more reliable as we scale inference compute.

##### Pairwise agreement with humans:

Next, we investigate how well TICK agrees with human pairwise preferences, which is the de facto standard for human evaluation of model outputs.
To produce a preference judgement between two responses, we score each response using TICK and say that the response with the higher checklist PR is preferred.
To gather human preference pairs, we provide annotators with a pair of responses from different models for a given instruction from Internal, then ask them to indicate their preference on an integer sliding scale from 1, meaning “Response A is much better than Response B”, to 5, meaning the reciprocal strong preference (further details in Appendix H.2). Each response pair is triply annotated and we compute the average preference score $\bar{p}$ across these three annotations. We then bin each average preference into a win ($1\leq\bar{p}<2.5$), tie ($2.5\leq\bar{p}\leq 3.5)$, or loss ($3.5<\bar{p}\leq 5$).

Figure: Figure 2: Question-level accuracy of GPT-4o checklist answers on Internal.
Refer to caption: extracted/5902375/figures/evaluators_new.png

We follow Qin et al. () and use the Pairwise Label Distance (PLD) to measure agreement between TICK and human preference labels.
PLD is a metric designed to capture the intuition that predicting a win as a tie is not as bad as predicting a win as a loss.
It takes a label and a prediction, and produces a value in $\{0,1,2\}$.
A PLD of 0 indicates the exact match of a preference label (win, loss or tie), (i.e., PLD-0 is equivalent to label accuracy in this setup).
A PLD of 1 implies a misclassification in scenarios where the ground truth label was a tie.
A PLD of 2 corresponds to an inverted preference relative to the human preference label (e.g., predicting loss when the ground truth label is win).
The Weighted Pairwise Label Distance (WPLD) is then defined as $\text{WPLD}=\sum_{i=0}^{2}\frac{i}{N}\sum_{j=0}^{N}\mathbb{I}[\text{PLD}_{j}=i]$, where $N$ is the number of instructions. The WPLD thus ranges from 0 – 2, with a lower value indicating stronger agreement.

**Table 4: Agreement between different LLM-as-Judge evaluations and pairwise preferences from trained human annotators on Internal. GPT-4o is used as the judge LLM.**
| LLM-as-Judge Eval. | Pairwise Agreement w/ Humans |  |  |  |
| --- | --- | --- | --- | --- |
| PLD-0 | PLD-1 | PLD-2 | WPLD |  |
| Preference | 0.293 | 0.497 | 0.210 | 0.917 |
| Direct Scoring | 0.464 | 0.488 | 0.048 | 0.583 |
| Check-then-Score | 0.487 | 0.472 | 0.041 | 0.553 |
| TICK | 0.522 | 0.443 | 0.035 | 0.514 |

We compare making preference judgments via TICK against directly prompting the judge LLM to express a preference (Preference) and scoring each response individually (Direct Scoring).
For direct scoring, we prompt the judge LLM to produce a 1 – 5 score for each response, and we say the higher scoring response is preferred.
We also include a hybrid of TICK and direct scoring (Check-then-Score), where checklists are included in the judge prompt, but judges are not required to explicitly answer each checklist question, similar to how curated checklists are used in WildBench Lin et al. ().
We have the judge LLM use CoT in all cases, but do not use majority voting.
Response pairs are formed out of generations from Command-R+, GPT-4o and Claude-3-Sonnet (Anthropic, ). We use GPT-4o as the judge LLM.

In Table 4, we see that TICK agrees most strongly with human preferences, in terms of achieving the lowest overall WPLD.
TICK is also the only LLM-as-judge evaluation to achieve a PLD of 0 more often than not.
Check-then-score also agrees more strongly with humans than direct scoring, which confirms the general utility of checklists in evaluation.
However, the fact that Check-the-Score still lags behind TICK provides evidence that explicitly answering and aggregating checklist answers is necessary to fully utilise checklists.
Despite the fact that preference judgements are very common, prompting the judge to directly produce a preference produces low agreement with humans.
Overall, these results show that LLM-as-judge evaluations benefit from a more precisely structured and granular scoring protocol, even when that protocol is task-agnostic and generally applicable, as in the case of TICK.

## 4 In-Context Self-Improvement with STICK (Self-TICK)

Having shown that TICK provides a signal of model response quality on par with trained human annotators, we investigate how it can be used to improve responses.
We first explore using STICK (Self-TICK) evaluations as feedback for self-refinement. Our hypothesis is that because STICK is targeted and interpretable, it is more informative for response refinement than unstructured feedback such as vanilla Self-Refine (Madaan et al., ).
Secondly, we investigate STICK’s effectiveness at Best-of-N selection.
In both cases, we are using the generating LLM as its own test-time judge.

### 4.1 Self-Refinement with Checklists as Feedback

##### Approach:

Given an instruction, we first generate an initial response from an LLM. We then use the same LLM to generate a checklist and evaluate its original response against this checklist. As checklist evaluations contain precise information about how a response succeeded or failed, they can be used as targeted, actionable feedback. Whenever the previous response did not pass all checklist evaluations, we prompt the LLM with a refinement prompt template (see Appendix G), which contains the instruction, the previous response, and the STICK evaluations, in order to generate a refined response. This process can be optionally repeated for several iterations.

##### Validation:

We compare self-refinement with STICK against the use of unstructured feedback
gathered by prompting the LLM to provide a detailed critique of its previous response.
We refer to this baseline as vanilla Self-Refine (Madaan et al., ).
We first run four iterations of self-refinement using each approach on InFoBench, and WildBench (Lin et al., ), which is a dataset of real-world user queries.
InFoBench evaluates responses using DRFR with its own expert-written checklists.
WildBench uses WB-Score, a 1-10 LLM-as-judge rating for each response. We use GPT-4 as judge for each benchmark and evaluate the self-refinement of Command-R+.

Figure: Figure 3: Four iterations of self-refinement with Command-R+, using STICK to form self-critiques. Unstructured self-critiques are included as a baseline (vanilla Self-Refine). Multi-turn conversations are excluded from the WildBench evaluation. GPT-4 is used as the judge LLM for each benchmark.
Refer to caption: extracted/5902375/figures/refinement_delta.png

In Figure 3, we show that STICK significantly improves responses across multiple iterations of self-refinement, and is considerably more effective than Self-Refine.
This improvement holds across InFoBench ($+$6.5%), which evaluates with a human-written checklist not seen during self-refinement, and WildBench ($+$7.1%), which uses a holistic response score that is in line with how LLM judges are commonly used.
By the fourth iteration, we see response quality start to plateau or even regress, highlighting that sustaining purely in-context self-improvement remains a significant challenge.

We then consider whether STICK refinements can improve responses in strictly verifiable settings, such as math or code generation, where response correctness is deterministically evaluated. We choose the challenging benchmark LiveBench (White et al., ) to test this. LiveBench contains frequently updated questions, spanning six task categories, and answers are scored automatically according to objective ground truth values. Self-refinement in this setting is therefore equivalent to self-correction. We report the results for both Command-R+ and GPT-4o in Table 1, again comparing to vanilla Self-Refine. We find that responses improve with a single iteration of STICK, but start to degrade thereafter.
With unstructured self-critiques, responses immediately degrade in most categories.
Command-R+, for which base performance is considerably below that of GPT-4o, benefits the most from STICK refinement, makes a particularly large gain on reasoning tasks.
Both LLMs also benefit considerably on explicit instruction-following, which is where checklist-structured feedback is most predictably useful, being the setting in which prior work on checklist-based evaluations have been focused (Qin et al., ; Wen et al., ).

### 4.2 Best-of-N Selection with Checklist-Based Scores

##### Approach:

A common approach to maximising response quality for a given LLM is to sample $N$ responses to an instruction, and then use a scoring function, such as a reward model or LLM-as-judge, to select the best responseBest-of-N selection thus produces higher quality responses at the cost of additional inference compute (Snell et al., ).
Focusing specifically on self-selection, as this assumes no access to an external reward model or superior LLM, we use STICK for Best-of-N selection by generating $N$ candidate responses to an instruction from an LLM, using the same LLM to self-evaluate each candidate with STICK, and using the STICK score for selection.

##### Validation:

We compare STICK for Best-of-N selection against direct self-scoring (i.e., prompting for a single holistic score). We include using an external reward model, ArmoRM-Llama3-8B-v0.1 (Wang et al., ), as an additional baseline, despite the fact that doing so breaks the assumption of only having access to the generating LLM for scoring responses.
We evaluate on InFoBench and WildBench, again evaluating by using each benchmarks’ standard evaluation metric (defined above).
For each score function, if multiple generations have the same maximum score according to that score function, we keep all of the tied responses. We then compute the true score according to the task’s actual evaluation protocol, and average across all selected responses in the case of ties.
We also compute the precision of each score function. When there are no ties under the Best-of-N selecting score function or the ground truth score function, computing precision reduces to computing accuracy. When there are ties, precision penalises selecting any additional responses that are not the best, or tying for best, under the ground truth score function. However, unlike recall, precision does not penalise failing to select more than one response out of any that are tying for best under the ground truth score function.
We use Command-R+ to generate responses, as well as self-evaluate responses with STICK and direct self-scoring.(^3^33We repeat this experiment with Llama3.1-70B in Appendix C.)

In Table 5, we show results for $N=8$ and observe that each method improves on the performance of greedy decoding. STICK achieves the most significant improvement on each benchmark, with gains of $+$5.1% on InFoBench and $+$5.3% on WildBench. STICK is the most precise scoring function, meaning that it most closely aligns with selections made under each benchmarks’ ground truth evaluation. STICK is more precise on InFoBench than WildBench, whilst the inverse is true for the other scores. This is likely because InFoBench scores responses against evaluation checklists, like STICK, whereas WildBench scores responses with a holistic rating, like direct self-scoring.

**Table 5: Best-of-8 selection on InFoBench and WildBench using Command-R+ with STICK, compared with direct self-scoring and an external reward model (ArmoRM), as well as greedy decoding. Multi-turn conversations are excluded from the WildBench evaluation.**
| Scoring Function | InFoBench | WildBench (Single-Turn) |  |  |
| --- | --- | --- | --- | --- |
| DRFR | Precision | WB-Score | Precision |  |
| Greedy Decoding | 0.843 | N/A | 64.9 | N/A |
| Reward Model (ArmoRM) | 0.863 | 0.306 | 67.5 | 0.323 |
| Direct Self-Scoring | 0.848 | 0.191 | 65.7 | 0.258 |
| STICK | 0.894 | 0.611 | 71.2 | 0.528 |

## 5 Assisting Human Evaluators with Generated Checklists

### 5.1 Motivation

In spite of recent progress in automatic evaluation (Ankner et al., ; Chiang & Lee, ; Verga et al., ; Vu et al., ; Wang et al., ; ; Ye et al., ), human evaluation remains a critical component of LLM quality assessment.
We thus investigate whether LLM-generated evaluation checklists can help with arriving at a consistent score for a given response. Using checklists partially decomposes the annotation task to be more cognitively feasible, and helps to ensure that specific considerations relevant to each instruction are not missed.

### 5.2 Case Study: Scoring Responses to WildBench Instructions

We conduct two rounds of human evaluation on a set of Command-R+ responses to WildBench instructions. In both rounds, annotators provide an integer score from 1-5 for each response (further details in Appendix H.3). In one round, annotators are asked to first answer checklist questions generated by GPT-4o before providing each overall score (i.e., check-then-score). Annotators are instructed to use the checklists to inform their score where appropriate, but not to limit their assessment to the checklists. This holistic scoring is important for human evaluation, as we found that a number of edge cases arise that can lead evaluators to answer most checklist questions with YES and still justifiably provide a low overall score (see Appendix H.4 for an example).
Each response is triply annotated and we compute inter-annotator agreement using Krippendorff’s alpha (Krippendorff, ).

**Table 6: Inter-Annotator Agreement (Krippendorff’s alpha) among triply annotated labels when providing a 1-5 score for Command-R+ responses to WildBench instructions. The average score given to Command-R+ is also reported.**
| Eval. Protocol | Inter-Annotator Agreement | Command-R+ Avg. Score |
| --- | --- | --- |
| Direct Scoring | 0.194 | 3.347 |
| Check-then-Score | 0.256 | 3.351 |

Results in Table 6 indicate that annotating the checklist before scoring yields stronger agreement among evaluators than direct scoring.
We also find that the average evaluation score for Command-R+ across both settings stays consistent, implying that the increase in agreement corresponds to variance reduction without having a biasing effect on the aggregate score. However, we note that agreement is still low, despite being improved, which highlights the challenges of gathering annotations with strong agreement on real-world instruction data.

## 6 Conclusion

We introduce TICK, a fully automatic evaluation protocol that structures evaluations with an LLM-generated, instruction-specific checklist.
We show that LLMs can produce high-quality checklists that improve agreement between judge LLMs and humans.
Because TICK is fully automatic, it can easily and cheaply be applied in new settings, avoiding the need for humans to write or review checklists.
We next demonstrate that STICK (Self-TICK) can be used for in-context self-improvement by either self-refinement or by Best-of-N selection.
Our experiments show that both strategies of employing STICK lead to substantial improvements over baselines on multiple diverse instruction-following datasets, including LiveBench, which covers challenging math, code, and reasoning prompts that baselines fail to improve on.
Finally, when we provide human annotators LLM-generated checklists for evaluating LLM outputs, we find inter-annotator agreement improves considerably.
Overall, we show that LLMs are capable of accurately evaluating instruction-following ability when using structured checklists, and demonstrate the potential of this rich fine-grained feedback to further improve LLM capabilities.

### Limitations and Future Work

TICK and STICK are useful tools for evaluation and self-improvement, respectively. However, we acknowledge that checklists are only one heuristic for structuring evaluation; learned or discovered evaluation structures are an exciting direction for future work. Checklist evaluations do not present an advantage in all settings, especially given the additional inference cost of generating the checklist. For example, basic knowledge retrieval is best evaluated as simply correct or incorrect. Relying on LLMs at all steps in the evaluation protocol may also propagate, and even exacerbate, LLM biases.
In this work, we do not investigate self-improvement by fine-tuning on synthetic, STICK-selected data, but doing so is a natural next step.
Training reward models to condition on, or jointly produce, checklist evaluations is also a promising direction for future study.

## Appendix A Using TICK for Categorical Evaluations

We additionally investigate whether TICK’s checklist evaluations can be used to provide aggregate feedback on specific model capabilities, by grouping instructions with similar requirements together. For Internal, we thus define the following instruction categories, corresponding to distinct LLM capabilities that are relevant to the instruction set: [Classification, Concision, Data Manipulation, Document Generation, Exclusion: Keyword, Exclusion: Topic, Extraction, File Formatting: JSON, File Formatting: TSV/CSV, Formatting: General, Inclusion: Keyword, Inclusion: Topic, Knowledge Retrieval, Length, Subjective QA, Tone].

For 100 samples from Internal, we collect annotations labelling each checklist question with appropriate categories. This task is performed by three annotators per checklist, and we take the intersection of chosen labels to be ground truth set. We then prompt GPT-4o to generate labels for the same set of checklist questions based on the available categories. Table 7 shows the performance of GPT-4o on this category classification task, both for the subset of Internal, as well as an equivalent task on InFoBench, where category labels are already provided for each checklist question. Notably, InFoBench only defines five categories, making the classification much easier, which is reflected in the results.

**Table 7: GPT-4o classification performance when labelling checklist questions with a fixed set of pre-determined categories.**
| Dataset | Precision | Recall | F1 |
| --- | --- | --- | --- |
| Internal | 0.687 | 0.708 | 0.680 |
| InFoBench | 0.824 | 0.819 | 0.793 |

Given the reasonable classification performance of GPT-4o on Internal (especially given the large number of categories with which to label each question) we use GPT-4o to generate category labels for the full dataset. In Figure 4, we show how Command-R+ performs across all checklist questions for a particular capability, according to the pass rate for checklist questions within that category. The weakest capability by categorical TICK evaluations is Length; given that specific length control is known to be a limitation of current LLMs, this result seems consistent.

Figure: Figure 4: Command-R+ pass rate for checklist questions on Internal, spanning different performance categories. Questions were labelled with relevant categories by GPT-4o.
Refer to caption: extracted/5902375/figures/tag-chart-command_r_plus.png

## Appendix B Further Analysis of Generated Checklists

### B.1 Comparison of Human-Written and Generated Checklist Lengths

In Figure 5, we show histograms of the lengths of human-written and GPT-4o generated checklists for Internal instructions. We see that the distribution of checklist lengths is similar across human and generated checklists, with the main difference being that generated checklist lengths are more peaked near to the mode.

Figure: Figure 5: Histograms of checklist length of human-written (left) and GPT-4o generated (right) checklists for Internal instructions.
Refer to caption: extracted/5902375/figures/human_hist.png

### B.2 Relationship Between Checklist Length and Task Difficulty

For both InFoBench and WildBench, we compute the Pearson correlation between generated checklist length and the benchmark score achieved by a Command-R+ response to the corresponding instruction. This gives us correlations of $-$0.001 and 0.028 for InFoBench and WildBench respectively, thus indicating that there is no clear relationship between task difficulty and the length of generated evaluation checklists.

## Appendix C Additonal STICK Best-of-N Results

In Table 8, we include a repeat of the experiment in 4.2, but with Llama-3.1-70B in place of Command-R+.

**Table 8: Best-of-8 selection on InFoBench and WildBench using Llama3.1-70B with STICK, compared with direct self-scoring and an external reward model (ArmoRM), as well as greedy decoding. Multi-turn conversations are excluded from the WildBench evaluation.**
| Scoring Function | InFoBench | WildBench (Single-Turn) |  |  |
| --- | --- | --- | --- | --- |
| DRFR | Precision | WB-Score | Precision |  |
| Greedy Decoding | 0.778 | N/A | 65.0 | N/A |
| Reward Model (ArmoRM) | 0.803 | 0.343 | 66.7 | 0.366 |
| Direct Self-Scoring | 0.780 | 0.242 | 66.8 | 0.319 |
| STICK | 0.817 | 0.676 | 69.4 | 0.545 |

## Appendix D Internal Instruction Set Examples

## Appendix E Generated Checklist Examples

Here we include examples of evaluation checklists generated by GPT-4o using the prompt in Appendix G.1.

### InFoBench

### WildBench

### LiveBench: Coding

### LiveBench: Math

### LiveBench: Reasoning

## Appendix F STICK Self-Refinement Examples

Here, we include examples of self-refinement using STICK with Command-R+.

### F.1 WildBench

### F.2 LiveBench

## Appendix G Prompt Templates

### G.1 Checklist Generation

Please help judge an AI assistant’s response to an instruction by  providing an evaluation checklist.  To write a specific evaluation checklist, you get given the  following entity each time:  INSTRUCTION: An instruction that has been given to an AI  assistant.    ## Task Details  Your task is to come up with an evaluation checklist list for a  given INSTRUCTION.  This evaluation checklist should be a list of questions that ask  whether or not specific criteria relevant to the INSTRUCTION were  met by an AI assistant’s response.  Criteria covered by your checklist could be explicitly stated in  the INSTRUCTION, or be generally sensible criteria for the  problem domain.  You should, however, try to be concise and not include  unnecessary entries in your checklist.    Checklist questions should:  - **Be answerable by ’yes’ or ’no’**, with ’yes’ meaning that the  response successfully met the corresponding requirement.  - **Be comprehensive, but concise**, meaning that all criteria  directly relevant to the INSTRUCTION should be represented by a  question, but only questions that are very clearly relevant  should be included.  - **Be precise**, meaning that checklist questions should avoid  vague wording and evaluate specific aspects of a response,  directly using the phrasing of the INSTRUCTION where appropriate.    You should always analyse the INSTRUCTION before providing an  evaluation checklist.    ## Response Format  Analysis: xxx  Answer: CHECKLIST QUESTIONS (each question should appear on a new  line)    ## Examples  {examples}    ## Real Task    ### INSTRUCTION  {message}    ### Response  Please analyse the instruction and provde an answer in the  correct format.  Remember that each question should be phrased such that answering  with ’yes’ would mean that the response **successfully**  fulfilled the criteria being assessed by the question.  In most cases, your checklist should contain at least two  questions, but no more than eight.

### G.2 Checklist Evaluation

This prompt is adapted from (Qin et al., ).

Please act as a fair judge. Based on the provided Instruction and  Generated Text, analyse the Generated Text and answer the  Question that follows with ’YES’ or ’NO’.  Your selection should be based on your judgment as well as the  following rules:    - YES: Select ’YES’ if the generated text entirely fulfills the  condition specified in the question. However, note that even  minor inaccuracies exclude the text from receiving a ’YES’  rating. As an illustration, consider a question that asks, ‘‘Does  each sentence in the generated text use a second person?’’ If  even one sentence does not use the second person, the answer  should NOT be ‘YES’. To qualify for a ’YES’ rating, the generated  text must be entirely accurate and relevant to the question.    - NO: Opt for ’NO’ if the generated text fails to meet the  question’s requirements or provides no information that could be  utilized to answer the question. For instance, if the question  asks, ’Is the second sentence in the generated text a compound  sentence?’ and the generated text only has one sentence, it  offers no relevant information to answer the question.  Consequently, the answer should be ‘NO’.    ## Output Format  Analysis: xxx  Answer: YES / NO (this should be either ’YES’ or ’NO’)    ## Evaluation Information    **Instruction**  {message}    **Generated Text**  {generation}    **Question**  {question}    Please analyse and answer whether the Generated Text satisfies  the requirement of the Question.

### G.3 Preference

Please act as a fair judge. Based on the provided Instruction and  Responses, analyse the Responses and provide a preference.  Your selection should be based on your judgment and correspond to  one of the following preference rankings:    1. Response A is better than Response B.  2. Response A and Response B are near-identical.  3. Response B is better than Response A.    The ’near-identical’ option (i.e., option 2) should be chosen  only if the differences between the two responses are  semantically and syntactically insignificant, such as ’The  correct answer is New York’ and ’The right answer is New York’.  In other words, if the two responses are substantially different  in terms of their content, you must identify a preference for one  of the responses. **Responses that are different in content  but similar in quality are NOT near-identical.**    ## Output Format  Analysis: xxx  Answer: PREFERENCE RANKING (this should be an integer from 1-3  and nothing else)    ## Evaluation Information    **Instruction**  {message}    **Response A**  {generation_1}    **Response B**  {generation_2}    Please analyse the Responses and provide a preference ranking (1,  2, or 3). Remember to stick to the requested Output Format.

### G.4 Direct Scoring

Please act as a fair judge. Based on the provided Instruction and  Generated Text, analyse the Generated Text and provide a 1-5  integer score.  Your selection should be based on your judgment as well as the  following guidelines for each possible score:    1. Horrible: The Generated Text is unintelligibly written  (incomplete sentences, leaps in logic, flagrant mechanical  errors) or has majorly incorrect or unverifiable information.  2. Bad: The Generated Text is occasionally difficult to  understand, dotted with minor factual or mechanical errors, or  missing crucial formatting elements.  3. Okay: The Generated Text expresses useful information, is  readable, has no factual errors, and has no more than a minor  mechanical error or two. Though it may be informative to those  unfamiliar with the subject matter, it is not overly insightful,  engaging, or likely to hold up to expert scrutiny.  4. Great: The Generated Text clearly expresses useful information  at an expert level, is readable, and has no factual or mechanical  errors. It could just use a quick adjustment with tone or length.  5. Excellent: The Generated Text clearly expresses useful  information at an expert level, is readable, has no factual or  mechanical errors, and is the perfect length and tone with regard  to the prompt.    ## Output Format  Analysis: xxx  Answer: SCORE (this should be an integer from 1-5 and nothing  else)    ## Evaluation Information    **Instruction**  {message}    **Generated Text**  {generation}    Please analyse the Generated Text and provide a 1-5 integer score  according to the guidelines. Remember to stick to the requested  Output Format.

### G.5 Check-then-Score

Please act as a fair judge. Based on the provided Instruction and  Generated Text, analyse the Generated Text and provide a 1-5  integer score.  You will also be provided with a Checklist that should help to  inform your selection.  Your selection should be based on your judgment as well as the  following guidelines for each possible score:    1. Horrible: The Generated Text is unintelligibly written  (incomplete sentences, leaps in logic, flagrant mechanical  errors) or has majorly incorrect or unverifiable information.  2. Bad: The Generated Text is occasionally difficult to  understand, dotted with minor factual or mechanical errors, or  missing crucial formatting elements.  3. Okay: The Generated Text expresses useful information, is  readable, has no factual errors, and has no more than a minor  mechanical error or two. Though it may be informative to those  unfamiliar with the subject matter, it is not overly insightful,  engaging, or likely to hold up to expert scrutiny.  4. Great: The Generated Text clearly expresses useful information  at an expert level, is readable, and has no factual or mechanical  errors. It could just use a quick adjustment with tone or length.  5. Excellent: The Generated Text clearly expresses useful  information at an expert level, is readable, has no factual or  mechanical errors, and is the perfect length and tone with regard  to the prompt.    ## Output Format  Analysis: xxx  Answer: SCORE (this should be an integer from 1-5 and nothing  else)    ## Evaluation Information    **Instruction**  {message}    **Generated Text**  {generation}    **Checklist**  Use this checklist to guide your evaluation, but do not limit  your assessment to the checklist.  {checklist}    Please analyse the Generated Text and provide a 1-5 integer score  according to the guidelines. Remember to stick to the requested  Output Format.

### G.6 Self-Refinement

##### Using Self-TICK as Critiques

Please use the feedback provided below to improve your previous  response to an instruction.  You will be given the following entities:  - INSTRUCTION: An instruction that has been given to an  assistant.  - RESPONSE: Your previous response.  - FEEDBACK: A list of ’yes’/’no’ questions about the response and  their answers. An answer of ’yes’ corresponds to a pass for that  question and an answer of ’no’ correspnods to a fail.    ## Task Description  Your task is to improve the RESPONSE to the INSTRUCTION based on  the FEEDBACK. You should try to address any ’no’ answers in the  feedback whilst maintaining any ’yes’ answers.  If all answers in feedback are ’yes’, simply respond with your  original RESPONSE.  Provide a plan to improve the RESPONSE based on the INSTRUCTION  and FEEDBACK and then rewrite the RESPONSE with your  improvements.    ## Information  **INSTRUCTION**  {message}    **RESPONSE**  {response}    **FEEDBACK**  {feedback}    ## Response Format (IMPORTANT)  Plan: xxx  Answer: NEW RESPONSE  After saying ’Answer: ’ you must say nothing else besides the  improved answer.    Now please plan and write a new RESPONSE, based on the  INSTRUCTION and FEEDBACK.

##### Gathering Unstructured Self-Critiques

Please analyse a response to a particular instruction and provide  feedback on how the response can be improved.  You will be given the following entities:  - INSTRUCTION: An instruction that has been given to an  assistant.  - RESPONSE: Your previous response.    ## Task Description  Your task is to provide feedback that will help improve the  RESPONSE to the INSTRUCTION.  Please analyse the RESPONSE and provide your critical feedback,  pointing to specific actionable improvements that can be made.    ## Information  **INSTRUCTION**  {message}    **RESPONSE**  {response}    Now please provide your feedback.

##### Using Unstructured Self-Critiques

Please use the feedback provided below to improve your previous  response to an instruction.  You will be given the following entities:  - INSTRUCTION: An instruction that has been given to an  assistant.  - RESPONSE: Your previous response.  - FEEDBACK: Feedback on your previous response.    ## Task Description  Your task is to improve the RESPONSE to the INSTRUCTION based on  the FEEDBACK.  Provide a plan to improve the RESPONSE based on the INSTRUCTION  and FEEDBACK and then rewrite the RESPONSE with your  improvements.    ## Information  **INSTRUCTION**  {message}    **RESPONSE**  {response}    **FEEDBACK**  {feedback}    ## Response Format (IMPORTANT)  Plan: xxx  Answer: NEW RESPONSE  After saying ’Answer: ’ you must say nothing else besides the  improved RESPONSE.  The new RESPONSE must exactly match the formatting of the  original.    Now please plan and write a new RESPONSE, based on the  INSTRUCTION and FEEDBACK.

## Appendix H Human Annotation Details

The same pool of trained annotators was used in all human annotation processes. The training undergone by annotators includes general, task-agnostic training covering high level guidelines for annotating the outputs of an AI assistant, as well as task-specific instructions and examples. At all stages in the annotation process, we are able to interact with annotators to answer any questions and respond to requests for clarification.

### H.1 Checklist Writing

The following instructions are given to annotators. Some sections are paraphrased for brevity.

Large language models are trained to respond to user  instructions, which can often be complex. To best evaluate  responses to a set of user instructions, we’re exploring the  viability of writing custom queries for each prompt to determine  which aspects of a complex instruction were followed correctly  and which were not.    In this project, you will write checklists of questions for given  instructions that ask whether each aspect of an instruction was  met by a model output.    ## Key Concept: Facet    ### Definition    Facets are distinct, individual elements of a prompt,  corresponding to the capabilities and constraints that the model  output should meet.    ## Tips and Tricks    - **Checklist questions must be answerable by either** ‘yes‘  **or** ‘no‘**.** The idea is that the questions are to be asked  of responses to the given prompt; ‘yes‘ means that the response  fulfilled the facet of the instruction, and ‘no‘ means it did  not.  - **Ensure each facet you identify is represented by a single  question.** This means you can provide as many questions for a  prompt as you see fit for that prompt, but questions should  overlap as little as possible (i.e., there should not be many  questions addressing the same facet).  - **Questions should be as specific or unspecific as the facet  they correspond to.** For example:      Prompt 1: Write a short paragraph.      Q1: Is the paragraph short?      Prompt 2: Write a 3 sentence paragraph.      Q2: Is the paragraph 3 sentences long?    ## Examples  {examples}    ## Task Instructions  1. Carefully analyse the provided prompt.  2. Label the task:      a)Answer the two questions about the prompt being safe and      making sense.      b) Unless answering ’no’ to one of the above, write a list of      checklist questions that could be asked of any response to      the prompt.  3. Submit the task. Great work!

### H.2 Preference Labelling

The following instructions are given to annotators. Some sections are paraphrased for brevity. These instructions are to be interpreted in the context of a more comprehensive model output annotation style guide that is not included here.

In this project, you will be indicating your preference between  two responses to a single prompt generated by two different  LLM-powered chatbots. Evaluating responses may involve making  trade-offs between several criteria. You should do your best to  navigate these trade-offs depending on the task.    Given an instruction and two responses, please indicate which  response you prefer on the following sliding scale:  1. Response A is much better than Response B.  2. Response A is better than Response B.  3. Response A and Response B are near-identical.  4. Response B is better than Response A.  5. Response B is much better than Response A.    The ’near-identical’ option (i.e., option 2) should be chosen  only if the differences between the two responses are  semantically and syntactically insignificant, such as ’The  correct answer is New York’ and ’The right answer is New York’.  In other words, if the two responses are substantially different  in terms of their content, you must identify a preference for one  of the responses. **Responses that are different in content  but similar in quality are NOT near-identical.**

### H.3 Direct Scoring

The following instructions are given to annotators. Some sections are paraphrased for brevity. These instructions are to be interpreted in the context of a more comprehensive model output annotation style guide that is not included here.

In this project, you will be directly scoring individual  responses to a single prompt generated by an LLM-powered chatbot.  Evaluating responses may involve making trade-offs between  several criteria. You should do your best to navigate these  trade-offs depending on the task.    Given an instruction and response, please score the response  according to the following rubric:  1/5: Horrible  - The response is unintelligibly written (incomplete sentences,  leaps in logic, flagrant mechanical errors) or has majorly  incorrect or unverifiable information.  2/5: Bad  - The response is occasionally difficult to understand, dotted  with minor factual or mechanical errors, or missing crucial  formatting elements.  3/5: Okay  - The response expresses useful information, is readable, has no  factual errors, and has no more than a minor mechanical error or  two. Though it may be informative to those unfamiliar with the  subject matter, it is not overly insightful, engaging, or likely  to hold up to expert scrutiny.  4/5: Great  - The response clearly expresses useful information at an expert  level, is readable, and has no factual or mechanical errors. It  could just use a quick adjustment with tone or length.  5/5: Excellent  - The response clearly expresses useful information at an expert  level, is readable, has no factual or mechanical errors, and is  the perfect length and tone with regard to the prompt.

### H.4 Check-then-Score

The following instructions are given to annotators. Some sections are paraphrased for brevity. These instructions are to be interpreted in the context of a more comprehensive model output annotation style guide that is not included here. Some of the “tips and tricks” included in these instructions are taken from (Qin et al., ).

Large language models are trained to respond to user requests,  which can often be complex. To best evaluate responses to a set  of user requests, we’re exploring the viability of answering  custom checklists of specific evaluation questions for each  prompt.    You will receive a prompt and a single attempt from a model to  respond. Read the response closely and answer the labelling  questions. These labelling questions will comprise checklist  questions and a 1–5 rating. The number of checklist questions and  the specific questions themselves will vary per prompt.    Typically, evaluating responses involves making trade-offs  between criteria, for example, scoring or making a preference  judgement based on a response that correctly followed formatting  instructions but made a factual error. Evaluation checklists are  designed to instead break down these prompt-specific criteria and  enable each to be independently evaluated.    ## Key Concept: Checklist Question    ### Definition    Checklist questions are Yes/No questions corresponding to whether  specific criteria relevant to the user request were successfully  followed in a model response.    ## Tips and Tricks  - **Answer ‘Yes‘ to a checklist question if the response entirely  fulfils the condition.** Note that even minor inaccuracies should  exclude the response from receiving a ‘Yes‘ rating.  - **Answer ‘No‘ **to a checklist question if the response fails  to meet the condition or provides no information that could be  used to answer the question.** For instance, if the question  asks, ‘‘Is the second sentence in the generated text a compound  sentence?’’ and the generated text only has one sentence, it  offers no relevant information to answer the question.  Consequently, the answer should be ‘No‘.  - **Use answers to checklist questions to partially inform the  overall response score.** A response that mostly fails the  checklist should receive a low score. However, a response can  also pass all of the checklist questions and still have a  middle-range score if the overall quality is low. For example, a  response could hypothetically pass all of the checklist questions  but still be uninsightful, repetitive or poorly worded.

#### Annotator feedback on check-then-score

After each scoring each response, we asked annotators to indicate whether going through the checklist made providing an overall score easier, harder, or had no effect. The corresponding answer rates were easier: 78.5%, harder: 6.4% and had no effect: 15%. In addition to the results in Section 5, this provides further evidence that LLM-generated checklists simplify the task of rating individual responses for human evaluators.

#### Demonstrating why human evaluation should only use generated checklists as a partial guide

In the following example from WildBench, the user asks for the LLM to read certain book chapters and webpages before answering specific questions on the content. Command-R+ was used to generate a response, without use of Retrieval Augmented Generation (RAG) (Lewis et al., ). The model hallucinated having visited the webpages and wrote an answer consistent with having done so, which be misleading in practice. The checklist questions, generated by GPT-4o, assume that a responding model would have been able to access the relevant material and are therefore unhelpful in evaluating the Command-R+ response, as desirable behaviour in this instance would be to inform the user that its request cannot be fulfilled. This was reflected by the low final scores given by all human evaluators. Yet, some of these evaluators answered most of the checklist questions with YES, demonstrating that answers to generated checklists alone should not be used to score responses in human evaluation, but also showing that human evaluators are robust to unhelpful or misleading checklists. This example is explicitly shown below.

##### Instruction

Answer all of the following quesions in about 350 words.    1. Read the GHDI chapters and choose a (1) topic that you found  most compelling - and select 1 image that "spoke to you." Answer  this question using the Nazi Germany (1933-1945): Science section  and the image: “Albert Einstein: Authorial Fame Seems to be  Relative!” Caricature of Einstein’s Political Activity,  Kladderadatsch, No. 39 (September 1933)    2. Visit the Shoa Foundation Website and the United States  Holocaust Museum site. Look at the content, listen to some of the  testimonies that relate to our topic "racial science" and science  and culture. What did you specifically learn?    3. Revisit a company/ organization website that we had talked  about earlier this semester and review it again - with the lens  on our time period- 1939 - 1945. Is there information missing?  If so investigate the role of this company/organization during  the Nazi - period. What are your thoughts?    4. Examine the role of scientists in Nazi Germany from a  humanitarian, social and scientific perspective:    5. Design an open ended question for your fellow students.

##### Command-R+ Response

Sure, here are my responses to the prompts:    1. The image that spoke to me is the "Albert Einstein: Authorial  Fame Seems to be Relative!" caricature from the September 1933  issue of Kladderadatsch. This image is a powerful reminder of the  political and social climate in Nazi Germany during the 1930s.  Einstein, a Jewish scientist, was a target of propaganda and  persecution by the Nazi regime due to his theoretical physics  work and his public opposition to nationalism and racism. The  caricature, meant to ridicule Einstein, actually showcases the  fear and respect Einstein commanded, as the Nazis felt threatened  enough by his intellect and influence to try and discredit him.    2. After visiting the Shoa Foundation and the United States  Holocaust Museum sites, I learned about the personal stories and  testimonies of survivors and victims of the Holocaust,  specifically relating to "racial science." One powerful testimony  I listened to was that of a Jewish doctor, who spoke about the  "medical experiments" conducted on prisoners in concentration  camps, which were a perversion of science and an attempt to  "prove" Nazi racial theories. The museums also provided a wealth  of information on the cultural destruction inflicted by the  Nazis, including the burning of books and suppression of academic  freedom.    3. Revisiting company websites from this time period reveals  interesting omissions and complexities. For example, many  companies with a dark history during the Nazi era, such as IG  Farben or Krupp, have since been dissolved or restructured, with  their modern incarnations providing little to no information  about their role in the Third Reich. This lack of transparency  warrants further investigation, as these companies profited from  slave labor, played a key role in the war economy, and even  collaborated in the horrific human experiments conducted by the  Nazis.    4. The role of scientists in Nazi Germany was complex and had  far-reaching consequences. From a humanitarian perspective, many  scientists remained silent or complicit in the face of human  rights abuses, with some even actively participating in unethical  experiments. Socially, scientists were influenced and constrained  by the political climate, with those who opposed the regime, like  Einstein, being forced into exile. Scientifically, there was a  perversion of science to fit ideological goals, with "racial  hygiene" and eugenics gaining prominence, leading to devastating  consequences.    5. Open-ended question for fellow students: How do you think the  scientific community could have collectively resisted or  mitigated the misuse of science by the Nazi regime? Considering  the social, political, and historical context, what strategies or  actions could have been taken to uphold ethical scientific  practices during this dark period in history?

##### Evaluation (Annotator A)

9/10 checklist questions answered YES. Overall score: 2/5, Bad.

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: 1. The caption for Figure 3(a) appears to be out of sequence or unclear. Could the authors clarify or reorder the content for better coherence?
2. The self-refinement process using STICK results in a minor decline in the last iteration, could the authors make a further explanation?
soundness: 2
strengths: - The automatic evaluation method using LLMs as judges is novel and significant. The authors present an effective and interpretable protocol for evaluating and refining generated text.
- Comprehensive experiments and detailed analyses are provided to support the effectiveness of the proposed methods.
- The paper is well-written and easy to follow, making it accessible to a broad audience.
summary: The authors propose TICK, a method that uses LLMs to decompose instructions into checklists composed of several YES/NO choices to address limitations in standard evaluation metrics like Elo rating and direct scoring. This approach provides a more interpretable evaluation by breaking down instructions into specific criteria. They further introduce STICK, which refines LLM responses using self-assessment based on these checklists, achieving substantial improvements compared to traditional refinement methods. Experiments demonstrate that using LLMs for checklist generation is feasible and reliable. Also, using checklists for evaluation aligns with human annotations. Based on TICK, STICK enhances the quality of LLM outputs beyond vanilla-refinement approaches. Additionally, the authors find that using checklists in human annotation significantly increases inter-annotator agreement, making the evaluation process more consistent and reliable.
weaknesses: 1. Leveraging LLMs with simple prompts to generate checklists is a straightforward approach. Previous work has also used decomposition techniques to evaluate responses across multiple dimensions, similar to step-by-step verification of LLMs' instruction-following abilities. While this method has been applied to various evaluation metrics, to my knowledge, this is the first time it has been specifically focused on instruction-following.
2. The construction details and statistics of the Internal dataset are not sufficiently explained, which reduces confidence in the reliability of the results when using LLMs for checklist generation.
3. When evaluating the generated checklists against gold labels, the authors use metrics like ROUGE and BLEU. However, these metrics are less effective in knowledge-intensive contexts, suggesting a need for additional manual annotation or alternative metrics. However, the human annotation results are missed.
4. The preference labeling approach of annotators does not fully align with the checklist-based method for evaluating instruction-following capabilities. Human annotation will consider the quality of the response while TICK only considers instruction-following ability.
5. The low inter-annotator agreement for direct scoring raises concerns, as the authors only demonstrate TICK's effectiveness through pairwise correlation with human annotations. If the inter-annotator agreement for pairwise scoring is similarly low, it might undermine the validity of this correlation.
6. The comparison of TICK to other evaluation methods is limited to direct scoring and an ablated version (Check-then-Score). This restricts the scope of the comparison. Evaluations with fine-tuned models or well-established frameworks could provide a fairer assessment.
7. In self-refinement experiments, the baseline comparison is limited to vanilla self-refinement, which is insufficient. Incorporating additional strong baselines would provide a more comprehensive understanding of STICK's effectiveness.

Reference:

Kalpesh Krishna, Aurko Roy, and Mohit Iyyer. Hurdles to progress in long-form question answering, 2021. URL https://arxiv.org/abs/2103.06332.

Shashank Sonkar and Kangqi Ni and Lesa Tran Lu and Kristi Kincaid and John S. Hutchinson and Richard G. Baraniuk. Automated Long Answer Grading with RiceChem Dataset, 2024. URL https://arxiv.org/abs/2404.14316

---

confidence: 4
contribution: 2
initial_rating: 6
presentation: 4
questions: 1. For table 2, why don't you consider the semantic similarity metrics such as scores generated by natural language inference models? BLEU and Rouge style metrics sometimes can be unreliable.
soundness: 3
strengths: Originality: This paper analyzes the quality of checklists generated by advanced LLMs and how they can be used to improve LLM-as-judge and high-quality instruction selection. It can provide experiment results for practitioners who want to use these checklists to enhance the performance of LLMs as judges, offering valuable insights.

Quality: The overall experimental analysis is thorough, including validation of LLM-generated checklists to human-generated checklists. It also features corresponding analyses on the use of checklists for self-refinement and their application as the reference for human annotators.

Clarity: The paper is written clearly, making it easy to follow and understand.

Significance: The topic of LLMs as judges is highly relevant, and the findings of this study may offer significant insights for the industry.
summary: The paper aims to measure and enhance LLM performance in instruction-following tasks by leveraging a powerful model to generate checklists based on the given instructions. 
The key contributions include: 
1. Proposing a prompt to generate checklists for each instruction. 
2. Validating the high similarity between checklists generated by advanced LLMs and those created by humans across several benchmarks. 
3. Showing that the judge score derived from aggregating checklists yields a pass ratio that closely aligns with human scores, highlighting the potential of using the checklist to improve the performance of LLM-as-judge. 
4. Showcasing that self-refinement guided by the generated checklists leads to higher performance improvements compared to unstructured feedback. 
5. Allowing human annotators to reference the model-generated checklists results in enhanced inter-annotator agreement.
weaknesses: Novelty: Given multiple works on using checklists to enhance the performance of LLMs as judges, this paper’s contribution lies in enabling LLMs to generate their own checklists and validating their feasibility. The approach involves introducing a specific prompt to elicit the checklist from the LLM. However, this requires the LLM to first follow a complex set of instructions to generate the checklist, which places even higher demands on the model’s capabilities than the instruction-following task itself.

Experimental Limitations: From an experimental perspective, the study could benefit from considering a wider range and a larger scale dataset. Currently, it only examines three benchmarks: Internal, InfoBench, and WildBench. 

Expense: The existing design is computationally expense during inference time since it requires a large number of tokens and multiple generations during the self-refinement stages. How to distill this ability or reduce this expense can be a good direction.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 3
questions: 1. Although checklists introduce a certain level of structure, they typically only express parallel relationships. When the content to be verified involves more complex logical relationships, such as selective, chain relationships, or their combinations (for example, tasks in ComplexBench), how can the effectiveness of checklists be ensured?

2. A notable feature of instruction-following tasks is that verification points are directly reflected in the instructions (such as text style, word count limits, etc.), making it relatively easy to break down the task into different verification points and generate checklists. However, for a wider range of task types, especially in fields involving symbolic reasoning like mathematics and programming, how can the application methods and advantages of checklists be demonstrated?

3. For models with different capability levels, particularly some weaker or smaller-scale language models (LLMs), how do they perform in terms of decomposing checklists and accurately scoring?
soundness: 2
strengths: 1. TICK enhances the transparency and interpretability of the evaluation process by breaking down the assessment task into a series of specific YES/NO questions. This fine-grained evaluation approach helps to more accurately identify the strengths and weaknesses in the model's output.

2. This paper conducts extensive automated and manual consistency experiments to quantify and demonstrate the advantages of the TICK evaluation method.
summary: To evaluate the instruction-following capabilities of large language models (LLMs), this paper introduces a method called TICK (Targeted Instruct-evaluation with ChecKlists). TICK leverages the in-context learning abilities of LLM to break down complex instructions into a series of yes/no questions, forming a checklist. The LLM is then used to score this checklist. Initially, the paper demonstrates the advantages of the TICK assessment method through extensive human consistency experiments. Subsequently, the effectiveness of the TICK method is validated through experiments involving self-refinement, Best-of-N selection, and assistance with human annotations.
weaknesses: 1. The core of the proposed method in this paper lies in using in-context learning to break down instructions into a checklist for self-validation and refinement, as well as for best-of-N selection. However, employing decomposed checklists for instruction evaluation ,validation and refinement is not new, as seen in work like FollowBench, InfoBench, and Self-Contrast. The fundamental differences and substantive contributions of this work compared to existing approaches, particularly in terms of evaluation methods and self-improvement strategies, need to be more clearly defined.

2. There is a lack of in-depth discussion regarding the efficiency of the proposed evaluation method.

---

confidence: 5
contribution: 3
initial_rating: 6
presentation: 3
questions: Please see the suggestions in Weaknesses.
soundness: 3
strengths: 1. This paper removes the major constraint of manually constructing checklists of prior works, significantly improving the scalability of automated instruction-following benchmarks.
2. It is interesting that the checklist can help LLMs refine their initial responses.
3. The paper is well-written and well-organized.
summary: This paper explores developing an automated evaluation benchmark to assess the instruction-following ability of large language models. Their study is based on the idea that asking LLMs to evaluate response qualities with a set of detailed requirements provides more reliable assessments than asking LLMs to provide a holistic evaluation directly, as proposed by InfoBench. The major finding of this paper is that LLMs can also prepare the decomposed questions (i.e., the checklist) for arbitrary user prompts, scaling up this framework to the next level of automation. Also, they find that the LLM-generated checklist could further help LLMs to provide self-refined responses.
weaknesses: 1. The metrics to evaluate the similarities between the human-crafted and LLM-generated checklists can be improved. In particular, those lexical-matching metrics (i.e., BLEU and ROUGE) should be replaced with more semantic ones. For example, [1] evaluates the quality of LLM-generated rubrics versus to human-crafted ones with BERTScore. Further reporting the percentage of recalled human-crafted check items and the percentage of precise LLM-generated check items will be better. 

2. This paper fails to discourse the details of human study. In this paper, many experiments are conducted with human annotators. The authors should discuss some basic information about the annotations, such as the statistics of their demographic information, the training procedures for the annotators, and the internal agreement among the annotators.

[1] Unveiling Scoring Processes: Dissecting the Differences between LLMs and Human Graders in Automatic Scoring.

Meta-review: The authors propose TICK, a method that leverages LLMs to decompose instructions into checklists of yes/no questions. This idea aligns well with assessment practices. The paper conducts comprehensive automated and manual consistency experiments to evaluate and highlight the advantages of the TICK evaluation method. However, the approach of using LLMs to generate checklists is not novel, and the evaluations based on the checklist offer limited insights.

Decision: Reject