Without evaluation, improvement will forever become a “feeling”
The wall that people who start using generative AI run into is that the output tends to be hit or miss. One day, I get surprisingly good writing, but on other days, the same request comes out thin, long, or out of place. In this case, prompt improvement tends to become a ritual of chance. I changed the wording, adjusted the ending, and carefully rewrote it, but it still didn’t fix it. The reason is simple: “what is acceptable” is not fixed.
Improvements without evaluation will almost certainly be based on impressions. “It’s different,” “It’s easier to understand,” “It doesn’t sting,” and “It’s hard.” These words can be supplemented by conversation between humans, but they are too vague to be used as material for improving prompts. Ambiguous evaluations lead to ambiguous revisions. As a result, the more you fiddle with the prompts, the less you know what’s working, and the less reproducible you become.
Ratings are important for prompts not only for scoring output. Ratings clarify what the prompt is designed for. For example, if there is an evaluation for “the main points are summarized,” you need to define what the main points are, in what order, and if some are missing, it will result in a failure. Creating evaluation criteria is also a process of breaking down objectives and putting them into conditions. In other words, creating an evaluation itself improves the quality of prompt design.
When considered in practice, the effects of evaluation are even greater. When using AI in a team, if there is no evaluation standard, discussions about “whose output is correct” will not work together. Each time the person in charge changes, the prompts change their habits and the quality of the deliverables fluctuates. Conversely, evaluation criteria turns prompts into shareable assets. Discussions about improvements can now be based on “conformity to standards” rather than “preferences,” making it less individualistic. Manipulating prompts means treating them not as sentences, but as products with quality standards.
Also, without evaluation, you will be dragged down by the “plausibility” of the model. Generative AI is good at creating natural sentences, and it produces sentences that are easy to read. However, there is a difference between being easy to read and being correct and useful. It also has the troublesome property that the better it looks, the harder it is to notice mistakes. Having an evaluation perspective is also a safety device to avoid being fooled by this “good appearance.”
How to create evaluation criteria is calculated backwards from the “scoring table”
Creating an evaluation may sound difficult, but the process is the same as creating a score sheet. A scoring sheet breaks down the elements of a good work product into a form that can be inspected. The trick here is not to start your evaluation with “abstract words.” If you use words like “easy to understand” or “persuasiveness” from the beginning, you will end up returning to ambiguity. Start by breaking it down to observable elements.
For example, when evaluating sentence production, formality comes first. Does it have the specified structure? Are the number of headings correct? Are the leads the specified length? Are bullet points used even though they are prohibited? This is a strong standard because it can be determined with “zero one.” Next is fitness for purpose. Is the target audience as expected, does the tone suit the purpose, and does it provide the desired output? This is a bit subjective, but if you clearly state the readership and purpose, it will be less confusing. Furthermore, in terms of content, candidates include comprehensiveness, specificity, accuracy, reduction of redundancy, and consistency.
The important thing here is to have “pass conditions” and “fail conditions” for each perspective. For example, in the case of specificity, a pass means “there are procedures, examples, and criteria for judgment, rather than just abstract words,” and a fail means “the test ends with generalities and does not describe what to do.” In terms of comprehensiveness, a pass means “the requested points are covered without omitting anything,” and a fail means “the central point is missing/digresses to another topic.” In terms of accuracy, a pass is “no assertions with ambiguous grounds,” and a fail is “many assertions but no evidence is provided.” By arranging the conditions in this way, the evaluation becomes a “check” rather than a “feeling.”
When creating a scoring list, it is important not to give a perfect score. Trying to meet all the high standards tends to make the prompts heavy and the output stiff. Prioritize your evaluation. For example, in the case of business documents, “accuracy > formality > conciseness > beauty of expression”. When it comes to coming up with ideas, “Novelty > Diversity > Concreteness > Compliance with formality”. Having this priority order makes it difficult for the model to get lost, and the direction of improvement remains unchanged.
And evaluation criteria do not have to be “written verbatim” in the prompt. There are several ways to embed evaluation perspectives in prompts, and you can choose which one to use depending on the purpose. For example, there are ways to put “self-check items” at the end of the output, to declare “conditions that must be met” before generation, and to incorporate steps to “correct if conditions are not met” after generation. The aim here is to give the model a “scorer’s eye”. Without a scorer, the model runs on naturalness. If there is a grader, they will try to fill in any gaps in format or conditions.
There are also some things to keep in mind when letting the model evaluate. Models’ self-evaluation is not one-size-fits-all, and they can be lenient or create convenient reasons. Therefore, it is safe to focus on objective things such as “formality”, “required items”, and “prohibited items”, rather than leaving the evaluation to the sole discretion. For evaluations that are highly subjective, it is practical to keep a distance and use them as an aid, with the assumption that humans will make the final judgment.
“Safe way” of self-checking and regeneration
The most effective way to incorporate evaluation into prompts is through self-check and regeneration designs. Even texts written by humans are better if they are elaborated rather than just written. The same goes for generation AI; the first output is treated as a “draft” and the quality improves by adding a process to adjust it according to the conditions. However, if you do it incorrectly, it will become redundant and even more difficult to use, so there are some tricks to how to turn it.
First, self-checks are not used to increase output, but to adjust output. A common mistake is to make the check results take too long. The more text there is to check, the more the final product will be obscured, and the more information it will contain, the more it will be a burden to the reader. In practice, the basic rule is to have the checks done internally and only release the final version. In other words, the prompt should be “Perform the following checks and only present the final output that satisfies the conditions.”
Second, clarify the conditions for regeneration. Simply writing “If the conditions are not met, revise it before submitting” is effective, but if you want to make it even stronger, make the correction trigger more specific, such as “Correct if there is even one formal violation,” “Correct if an essential element is missing,” or “revise the expression if there is a conclusion and lack of evidence.” This allows the model to know “what needs to be fixed” and the results are stable.
Third, have a test input set. Prompts that incorporate self-checks are powerful, but they are not a panacea. Depending on the type of request and input habits, other failures may occur. So, prepare two or three frequently used cases, preferably some of the more difficult ones, and try each prompt with that set. This prevents the game from being optimized for “one hit”. In terms of operation, it is easy to understand if you use this set every time you make improvements and see if the pass rate has increased.
Fourth, the changes are small and leave a log. Prompts may look like text, but operationally they are more like code. If you don’t know what you’ve changed, you’ll stop improving. A practical trick is to divide your prompts into blocks and try each change one at a time. For example, observe the effects of differences without making changes such as “adding prohibited items,” “refining the output template,” and “increasing the number of evaluation items” at the same time. This alone will change the speed of your progress.
Finally, it is important not to overestimate self-checking. Models cannot fully validate their output. In particular, the model alone cannot confirm the facts or guarantee the authenticity of external information. That is why the focus of self-checking is on things that the model can maintain internally, such as “observance of formality,” “presence of essential elements,” “suppression of assertions,” and “separation of speculation from fact.” Incorporating a course of action, such as “If in doubt, hold off and request additional information” when appropriate, increases safety. Incorporating evaluation into prompts is not a magic trick to make the AI smarter, but rather to clarify the “passing conditions” according to your purpose. With evaluation, improvement changes from a feeling to validation. You can start with just one task. Just write down the format, must-haves, and don’ts into a scoring sheet and incorporate it into your prompt as a self-check. The stability of the output will improve, and you will be able to see the points that need to be corrected.
Related reading