Revision Prompting Enables Cost Reduction for Industrial LLM Processing

According to reporting by roberthoenig on Lobsters via revisionprompting.info, a technique called “Revision Prompting” has been proposed to address re-execution costs and output consistency issues in industrial LLM processes. Instead of reprocessing the entire input data, this method passes only the diff information to the LLM and generates a patch for the output, significantly reducing token consumption and processing time.

Two Ways to Use LLMs

The article notes that LLM usage can be broadly classified into two forms. The first is called “ad-hoc prompting,” a manual approach in which different instructions are given for each call—such as asking a coding agent to implement a new feature or asking a chatbot to draft an email.

The second is “industrial prompting.” This refers to a method that uses the same instructions repeatedly within automated processes—such as extracting structured information from invoices as part of an accounting pipeline, or translating document pages into other languages as part of a release process.

Two Problems Caused by Re-execution

In industrial prompting, outputs are generated from input data and instructions. When the input is updated, the conventional simple approach re-executes the same instructions against the updated input and regenerates the updated output. The article points out that this approach has two drawbacks.

First, there is a lack of consistency. Because LLMs are non-deterministic, the updated output can differ from the original output in ways that go beyond what the input change requires. Second, there is the overall burden of processing time and token costs. Even if only part of the input has changed, the entire output is generated from scratch, incurring costs equivalent to the original output generation.

Avoiding Reprocessing with Diffs and Patches

Revision Prompting solves both problems by operating on “revision diffs” of the input and output, rather than on the full input and output. The mechanism is as follows.

First, for a given input, the LLM is called with a prompt combining the instructions and the input, and an output is generated. Later, if the input is updated, instead of reprocessing the entire updated input, the following prompt is constructed:

1. The original instructions and input
2. The output generated from the original input
3. The diff between the original input and the updated input
4. An instruction to generate a patch that updates the output

The LLM returns an output patch in response to this prompt. By applying the patch to the original output, the updated output is obtained.

Effectiveness Demonstrated in a Translation Task

The article presents a concrete example of translating an electric bicycle product page into German. The initial English input was “Vela 3 e-bike has a range of 80 km. Its battery recharges in three hours. The frame is made from recycled aluminium. Every Vela 3 includes a two-year warranty.” The LLM generated the corresponding German translation.

Subsequently, suppose a battery upgrade changes the range from 80 km to 100 km. In the conventional approach, the entire page would need to be re-translated. With Revision Prompting, however, the original output and the diff information are included in the prompt. The diff indicates that the line “The Vela 3 e-bike has a range of 80 km.” was changed to “The Vela 3 e-bike has a range of 100 km.” The LLM is then asked to generate a patch to update the output. With this technique, regenerating the entire translation is unnecessary, and token costs are incurred only for the changed part.

Technical Considerations for Practical Use

This technique is particularly effective in industrial processes where part of the input data is updated frequently. In pipelines that repeatedly execute the same process—such as data extraction from invoices or document translation—partial input updates occur often. Compared to full re-execution, the token savings depend on the proportion of the input that changes.

On the other hand, it is important to note that the quality of the patch generation affects the quality of the original output. In cases of substantial input changes involving additions or removals of items, patch generation accuracy may decline. Additionally, in situations where output consistency is critical, combining the diff detection and patch application process with a version control system is a possible approach.

Editorial Opinion

In the short term, this technique is worth considering as a cost-reduction measure for companies that operate business pipelines incorporating LLMs. In areas where routine processing is repeated, such as invoice processing and translation work, reducing token consumption leads directly to cost savings. The ease of implementation is also appealing; because it can be tried simply by adding diff information to existing prompts, adoption cases are likely to increase over the coming months.

From a long-term perspective, diff-based processing brings LLM output management closer to the concept of version control. This method of applying patches while tracking output change history is highly compatible with the direction of improving reproducibility and auditability in LLM pipelines. At the same time, there is a risk that repeatedly overlaying patches on non-deterministic LLM outputs will degrade output quality, so combining this approach with periodic full regeneration appears to be a realistic operational policy.

From the editorial desk’s perspective, the key issues for putting this technique into practical operation will be how to evaluate the quality of patch generation and what criteria to use for deciding between full regeneration and partial updates. Systematic evaluation data on how the scale and type of input diffs affect patch quality is still lacking, and further verification is awaited.

References

• “Revision Prompting improves industrial LLM processes”, by revisionprompting.info by roberthoenig — Lobsters, 2026-08-08T20:20:42.000Z (ARR)
• Source URL: https://revisionprompting.info/