LELP-S+ Real-World Testing: Making Every AI Token Count with Up to 44% Cost Savings

An Overlooked Optimization Dimension: Information Density Per Token

In LLM applications, we habitually pursue two goals: more accurate answers and shorter responses. But the latest update to the open-source project Sir Shortoken — LELP-S+ (Less English, Less Prose) — introduces a more nuanced third dimension: information density, making every consumed token carry as much useful information as possible.

This might seem like a linguistic game, but it directly addresses the core pain point of LLM usage: token cost. Tokens are the basic units that large language models use to process text — typically one English word is split into 1-3 tokens, while each Chinese character is approximately 1.5-2 tokens. Taking GPT-4o as an example, input pricing is $2.5 per million tokens, and output is $10. For enterprise applications making millions of API calls daily, even a 30% reduction in token consumption can translate to hundreds of thousands of dollars in annualized cost savings. Additionally, while current mainstream models have expanded context windows to 128K or longer, effective attention still concentrates within a limited range — improving information density means the model can "see" more useful content within the same window.

Whether it's API call costs, context window limitations, or response latency, token count remains an unavoidable constraint. LELP-S+ doesn't take the brute-force approach of "say less" — instead, it aims for "say it more concisely."

reddit source: An Update to Sir Shortoken

Core Design Principles of LELP-S+

Preserve Grammar, Remove Redundancy

Sir Shortoken originally offered multiple output modes: Quick, Balanced, Deep, Bullets, and Aggressive Bullets. The author discovered a gap between Bullets mode and normal Prose — users wanted complete sentence expression without having their information diluted by excessive decorative English.

LELP-S+ fills exactly this gap. Its design principles can be summarized as:

Preserve complete grammatical sentences rather than fragmented phrase lists
Remove redundant English wherever possible but never remove information itself
Every sentence should introduce a new fact, avoiding tautology
Use simple symbols (like →) to replace verbose connectors, reducing word count without losing meaning

The value of this approach: it doesn't sacrifice logical coherence like Bullets, nor does it waste massive amounts of tokens on filler phrases like "as we can see" or "it is important to note that" like regular prose.

Difference from Aggressive Bullets Mode

Compared to Aggressive Bullets, which compresses content into fragmented entries, LELP-S+ is closer to a "telegraphic" technical writing style. It preserves sentence readability and reasoning chains, making it particularly suitable for technical content requiring causal explanations — such as network protocols or database principles.

Cross-Model Test Results: GPT Shows Strongest Compression

Test Design and Methodology

The author conducted comparative tests across five technical topics, covering typical computer systems knowledge:

TCP Congestion Control: TCP congestion control is a classic family of algorithms in computer networking, comprising four phases: slow start, congestion avoidance, fast retransmit, and fast recovery. From early Tahoe and Reno to Google's modern BBR algorithm, these mechanisms determine how data transmission rates dynamically adjust across networks. Technical explanations of this knowledge typically involve causal chains of window size changes — an ideal test scenario for LELP-S+'s strength in "concise expression that preserves causality."
Virtual Memory
B-Trees
Raft Consensus Algorithm: Raft is a distributed consensus algorithm proposed in 2014 by Diego Ongaro and John Ousterhout, designed as an understandable alternative to Paxos. It ensures multiple nodes in a distributed system agree on data state through decomposition into three sub-problems: leader election, log replication, and safety. Well-known systems like etcd and CockroachDB use Raft as their underlying consensus mechanism. Explaining Raft requires clear state transition descriptions and role interaction explanations — redundant expression significantly inflates content volume.
Redis Persistence

Test subjects covered four major models: GPT, Claude, Gemini, and DeepSeek. The evaluation metric was average token savings rate compared to each model's normal prose output.

Token Savings Rate Ranking

Test results revealed clear gradient differences:

Rank	Model	Token Savings Rate
🥇	GPT	44%
🥈	Gemini	36%
🥉	Claude	32%
4️⃣	DeepSeek	30%

GPT led by a wide margin at 44% compression, meaning it could eliminate nearly half of redundant expression when handling identical technical explanations. For high-frequency API call scenarios, this represents considerable cost savings.

Compression Discipline: The True Differentiator

All Four Models Maintained Factual Accuracy

The most interesting finding from this test: accuracy was not the differentiator. Throughout the evaluation, all four models maintained technical factual correctness — not a single model sacrificed content reliability due to compression. This demonstrates that LELP-S+'s instruction design is robust enough to avoid inducing models to fabricate information for the sake of brevity.

"Compression Discipline" Differences Between Models

What truly created the gap was what the author calls "compression discipline" — the model's instruction compliance and self-restraint capability.

Instruction Following is one of the core evaluation dimensions for LLMs. Benchmarks like Stanford's IFEval and Tsinghua's FollowBench specifically evaluate model adherence to format, content, and style constraints. Research shows that models trained with RLHF (Reinforcement Learning from Human Feedback) perform better at instruction following, but alignment strategies differ significantly across vendors — OpenAI tends to train models to strictly obey user instructions, while some models are tuned to "proactively provide more help." This difference in training strategy is precisely the root cause of the phenomena observed in LELP-S+ testing.

GPT led because it could consistently and stably remove prose redundancy while fully preserving the core of technical explanations. This reflects its high compliance with system prompts.

In contrast, DeepSeek's lower score is representative: it tends to add extra sections the user didn't request, making answers longer than actually needed. This isn't a capability issue but rather "over-enthusiasm" — the model's habit of proactively supplementing information becomes a burden in scenarios requiring conciseness.

This observation has practical implications for prompt engineering: tension exists between a model's "compliance boundary" and "autonomous elaboration," and different models vary enormously along this boundary.

Practical Implications for Developers

The Goal Isn't Shorter — It's Higher Information Density

The author repeatedly emphasizes: LELP-S+'s goal isn't "shorter answers" but "more information per token." This positioning distinguishes it from crude output truncation. In scenarios like long document processing, RAG context injection, and multi-turn conversations, improved information density directly translates to:

Lower API call costs
More effective utilization of limited context windows
Faster response times

RAG (Retrieval-Augmented Generation) is the mainstream architecture for enterprise LLM applications today. It enhances answer quality by first retrieving relevant document fragments from a knowledge base, then injecting those fragments into the model's context window. In this architecture, every token in the context window is extremely precious — the more concise the injected reference documents, the more relevant information can be packed in, and the higher the model's answer quality. LELP-S+'s information density optimization philosophy naturally aligns with RAG scenarios, as it not only optimizes the model's output side but its design philosophy can equally guide input-side document preprocessing strategies.

The Reverse-Constraint Approach to Prompt Engineering

This project also reminds us that prompt engineering isn't just about "telling the model what to do" — it also includes "telling the model what not to do." Removing redundancy, constraining divergence, enforcing information increment — these reverse constraints often improve actual user experience more than positive instructions.

From a broader perspective, this "reverse constraint" approach shares similarities with Constraint Programming in software engineering: by defining boundary conditions and prohibited behaviors, you indirectly guide the system to produce desired results. In prompt engineering practice, negative instructions like "don't add unrequested content" and "don't use transitional phrases" are often more effective than vague positive instructions like "please answer concisely" because they provide specific constraints the model can clearly execute.

LELP-S+ is now integrated into the Sir Shortoken open-source project (github.com/shouvik12/sir-shortoken). Interested developers can directly try integrating it into their workflows.

Summary

LELP-S+ is a clearly-conceived token optimization tool that makes the often-overlooked dimension of "information density per token" explicit, and reveals real differences in "compression discipline" across major LLMs through cross-model testing. For cost-sensitive production environments, optimizations like these can accumulate into tangible benefits.