It's Time to Optimize Your LLM Prompts
to Reduce Environmental Impact — and Cut Costs

This article benchmarks the off-the-shelf prompt generators from OpenAI and Anthropic against EigenPrompt — the dedicated prompt-optimization tool we developed. Shameless plug: please try it and give us your unfiltered feedback (eigenprompt.ai).

Summary

"What a surprise - we spent months on this, and when you focus on a problem, you get better results!"

Here are our detailed findings and how we got these results

Both OpenAI and Anthropic ship slick prompt generators in their developer consoles. You describe your task, and they write the prompt for you. The results look brilliant: clean markdown, numbered rules, meticulously anticipated edge cases, and a tasteful flourish of XML tags. It reads like a senior engineer spent all afternoon on it.

It also costs a small fortune to run, and worse, it hogs a massive amount of data centre energy. The very instinct that makes a generated prompt look thorough is the same one that runs up your electricity bill, drives up carbon emissions, and burns through your budget. It's a quiet love story between the world's best AI labs and prompt bloat—and both your wallet and the planet are paying for it.

To find out exactly what this romance costs in dollars and resources, we pointed OpenAI's prompt generator and Anthropic's Workbench generator at the same real-world job: turning messy bank descriptors like KLARNA* HMSVERIGE SE SEK into clean merchant names. We fed each the training examples, ran the generated prompts on a held-out evaluation set using a heavy reasoning model (gpt-oss-120b), and tallied up the damage.

Both prompts worked. But both also used about ten times more compute resources per call than the task needed, buying zero extra accuracy for the massive carbon and financial footprint.

The receipt isn't pretty. OpenAI's unoptimized prompt scored 60% accuracy and cost about $0.24 per 1,000 calls. Anthropic's scored 67% and cost about $0.33 per 1,000 calls.

Then we handed those exact prompts to EigenPrompt and let it optimize.

Starting from OpenAI's draft, it found a leaner variant that was actually more accurate (64%) for just $0.018 per 1,000 calls - thirteen times cheaper.

Starting from Anthropic's draft, it maintained the exact same 67% accuracy but slashed the rate to $0.034, nearly ten times cheaper.

The answers came out the same. The computational strain and the price tag did not. That massive gap between a prompt that looks finished and one that has been systematically trimmed down is what we call prompt bloat. It quietly bills you - and taxes the environment - on every single API call.

The Environmental Elephant in the Server Room

When we talk about AI efficiency, we usually focus on the monthly invoice. But every token an LLM processes or generates requires physical servers, cooling infrastructure, and electricity.

On complex reasoning models, the real resource hog isn't the prompt text you send; it's the output and reasoning tokens the model generates. When a prompt is bloated with over-engineered instructions, it forces the model to deliberate, double-check, and generate internal "thought" chains. For a simple task like "is this descriptor DoorDash or Chipotle?", those extra GPU cycles are an absolute waste of energy.

By trimming a prompt down to its absolute essentials, you aren't just saving pennies - you're directly reducing the number of computational operations the model has to perform. A 10x reduction in token usage means a massive drop in the energy required to serve your application. Multiply that across millions of production calls, and you are taking a meaningful bite out of your company's digital carbon footprint.

Where the Bloat Hides (and How We Cut It)

How is there a 10× gap on a classification task this small? The winning, optimized prompts give the secret away. Take a look at the lean version EigenPrompt found when starting from OpenAI's draft, which managed to climb to 81% accuracy while still costing a third as much as the original draft:

Extract the primary merchant name from the transaction description.

- Transaction: {{INPUT}}
- Return only the canonical merchant name (e.g., Amazon, Starbucks) or **Unknown** if it cannot be identified.

Rules:
* Ignore numbers, locations, and payment-platform codes unless essential.
* Convert known abbreviations to standard names (e.g., "AMZN MKTP" → "Amazon Marketplace", "GOOG" → "Google").
* When a payment facilitator (PayPal, Square, Stripe) appears, name the underlying merchant; if none is present, output the facilitator.
* If the description refers to a person or generic hold, output **Unknown**.

Process:
* Perform all extraction and reasoning internally before answering.
* Output a single line containing only the merchant name or **Unknown**, with no additional text.

Notice those last two lines. They strictly cap the model's output behavior: "output a single line... with no additional text."

By aggressively stopping the model from writing lengthy internal monologues or regurgitating the question, we put a hard ceiling on token generation. It keeps the model focused, hyper-efficient, and fast. The search to find this perfect balance tried 44 variants and finished in about 35 minutes, using a negligible couple of dollars in API spend to lock in long-term efficiency.

Green Compute is Just Better Engineering

None of this means OpenAI or Anthropic's prompt generators are bad tools. They do the heavy lifting of solving the "blank page" problem, turning a basic idea into a functional prompt in seconds.

But a generated prompt is just a first draft. It's an untested guess about what the model needs, optimized for thoroughness rather than efficiency. If you ship that first draft straight to production, you are unknowingly signing up to overpay—and over-consume power—by an order of magnitude.

True sustainability in AI doesn't mean using AI less; it means engineering it better. There is no single "perfect" prompt, but there is a frontier of trade-offs between accuracy, cost, and environmental impact.

EigenPrompt maps that entire curve for you, testing variations against your data until it finds the leanest possible instructions that still clear your quality bar.

Don't ship the first draft. Measure it, trim the bloat, and run your AI on the clean, cost-effective end of the frontier.