Count the words in your last big system prompt. Now count again — this time, skip every article, filler phrase, and polite transitional sentence.
What’s left? That’s the actual logic. The rest is context-window noise you’re paying tokens for.
This week, u/Glass-War-2768 over at r/PromptEngineering shared a technique called Semantic Compression, and once you try it, you’ll start questioning every verbose instruction set you’ve ever written.
The claim: you can pack 1,000 words of logic into roughly 100 tokens. Same output quality. Fraction of the cost. And before you assume your prompts are already tight, most engineers who run this test are surprised to find they’re carrying 60 to 70 percent dead weight in even their leanest-feeling instructions.
The Challenge
Take a prompt you use regularly, one that runs 300 words or more. Your goal is to compress it down to 20% of its original size without losing a single logical step.
Sounds brutal. It’s surprisingly doable. The reason it works is that most prompts are written to communicate with humans, not models. We add context, soften commands, explain our reasoning, and cushion transitions. Models don’t need any of that. They parse structure and intent. The conversational wrapping is noise to them. Here’s how to strip it.
🔧 How to Build a Dense Logic Seed
Step 1. Choose a prompt you use frequently, a system prompt, a classification instruction, a transformation workflow. Longer is better for this test. A good candidate is any prompt where you’ve written things like “Please make sure to…” or “It’s important that you remember…” Those phrases signal filler.
Step 2. Paste it into your AI with this compression wrapper:
“Take the following instructions: [Instructions]. Rewrite them into a Dense Logic Seed. Use imperative verbs, omit all articles (the, a, an), and utilize technical abbreviations. The goal is 100% logic retention with 80% fewer tokens.”
Step 3. Review what comes back. The model strips out all conversational scaffolding and leaves behind only the functional logic, imperative verbs, no filler, no hand-holding. A 400-word classification prompt might come back as 12 crisp lines. Read through it carefully and verify every rule you care about is still represented, even if the phrasing is unrecognizable.
Step 4. Run both versions against the same task. Use at least five to ten representative inputs, not just one clean example. Compare outputs side by side. That comparison is where the real learning happens.
📊 What Your Results Tell You
If the compressed version performs just as well: you’ve been wasting tokens. The model didn’t need the padding. You just assumed it did because that’s how humans communicate. This is the most common outcome.
If something breaks: those failure points are valuable data. They show you exactly which parts of your instructions need natural-language framing to land correctly. Maybe a nuanced classification rule loses meaning when reduced to a single imperative. Maybe a tone instruction requires descriptive language to carry weight. Now you know what to protect in future prompts, and everything else is fair game to compress.
If performance actually improves, and this does happen, it’s because compressed prompts remove ambiguity. Less for the model to navigate means less drift from the original intent. Cleaner logic, cleaner output. When you remove redundant phrasing that says the same thing twice in different ways, the model stops hedging between two interpretations and commits to one.
The original poster’s framing here is sharp: this isn’t about making prompts shorter for the sake of it. It’s about keeping your context window clear for the actual data, the inputs, the content, the task at hand, rather than filling it with instructional fluff. In a production pipeline that processes thousands of calls a day, that’s not just a token cost issue. It’s a latency issue too.
💡 Extra Tips
- Semantic compression works best for procedural prompts, classification tasks, step-by-step workflows, transformation instructions. For creative briefs, keep some natural language to preserve tone signals
- Apply this to system prompts first, not one-off queries. That’s where savings compound across every single call in a production pipeline. One compressed system prompt across 10,000 daily calls adds up fast
- Save your Dense Logic Seeds in a reusable prompt library. They’re model-agnostic and stay readable months later, unlike verbose prompts that feel stale and bloated when you revisit them. A seed from today will still run cleanly on next year’s models
- Test compressed prompts on edge cases, not just clean inputs. That’s where compressed logic sometimes misses nuance you didn’t realize was load-bearing in the original. Weird inputs expose hidden assumptions your verbose version was quietly handling
- If you work with long-running agents or multi-step chains, this technique compounds hard. Each node in the chain gets cleaner, and the whole pipeline benefits. The reduction in accumulated context drift across a five-step chain can meaningfully improve final output coherence
🎯 Prompt of the Day
Grab your longest active prompt right now and run it through this:
“Rewrite this as a Dense Logic Seed: imperative verbs only, no articles, abbreviate where unambiguous. Preserve 100% of the logic.”
Compare the two versions on the same task. Try it on outputs you’d normally accept without question. If the compressed version holds up, and it probably will, you just found dead weight that’s been riding along in every single run.
Cut it. Then cut it from every prompt you build going forward!
The ‘Recursive Chain of Thought’ (R-CoT) Protocol: Eliminating Logical Drift
by u/Glass-War-2768 in PromptEngineering