Cheap Prompt Optimization in 2026: 5 Free Tricks That Beat Paid Tools

I burned roughly €400 of Claude credits in three weeks before I noticed something stupid. The system prompt I was reusing on 90 calls a day was not cacheable. A stray comma in the wrong place was breaking the cache fingerprint, and every call paid full token price.

That single fix cut the bill on that workload by 78%. None of the paid prompt optimization tools I had tried would have caught it. Not PromptPerfect. Not AI Test Kitchen. Not Vellum's optimizer. They all rewrite the text of your prompt. The thing that was draining my wallet was the architecture around the prompt.

This article is the consolidated playbook: 5 free tricks I now apply to every new prompt I ship, in order of effort. Combined, on a typical solo-dev workload, they cut 60-75% of the bill. Tested on 47 of my own prompts over the last two weeks, scored before and after on Keep My Prompts (KMP), with the actual deltas per trick.

If you are an indie hacker or you ship from a 1-5 person team, this is calibrated for you. If you are a CTO with 50 engineers and a procurement contract, this is not your article.

Why the cost problem just got worse in 2026

Three things happened in Q2 2026 that make this the right moment to optimize aggressively.

First, Anthropic quietly cut the Claude prompt cache TTL from 60 minutes to 5 minutes by default in March. If you were relying on long cache windows without auditing your call frequency, your bill went up by 17-30% without any change on your side.

Second, DeepSeek V4 hit Opus 4.6 quality at one tenth of the price. The economics of "use the best model for everything" stopped making sense, and the cost-conscious developer suddenly had a credible cheap alternative.

Third, the prompt optimization SaaS market kept inflating subscription pricing while the actual value gap closed. A €30/month tool that promised to "rewrite your prompts" was already weak in 2024. In 2026, with KMP scoring available free at 5 runs a day, the value is gone for indie use.

The opportunity is real, but it is not where the paid tools want you to look. The waste is structural. Cache misses, redundant few-shot examples, parse failures forcing retries, premium models running on trivial tasks. Lexical rewrites do not fix any of that.

For context on the size of the problem: on KMP, across the 39 prompts that early users scored, the average overall score is 3.60 out of 5. The median is 3.50. Even the 75th percentile sits at 4.40. The "top quartile" prompt in the field still has documentable structural issues. The waste is not a rare outlier. It is the default.

Trick 1: Score the prompt, do not rewrite it

The common mistake, and what paid optimizers encourage, is to ask an LLM "rewrite my prompt to be better". You spend 10 tokens of input, get back 1500 tokens of output, repeat three or four times until something "sounds better", and ship. Total token cost per optimization pass: 4500-6000 tokens of output. Total useful information gained: usually nothing structural.

The cheap and correct move is to score the prompt first. A scorer tells you why the prompt is weak: weak context, missing output format, ambiguous role, no few-shot examples, no chain-of-thought scaffolding. With that diagnostic, you make one targeted edit and ship. Total token cost: roughly 600 tokens for the scoring call, zero for the edit (you do it yourself in your editor).

On the 47 prompts I scored last week, the targeted edit after scoring matched or beat the blind rewrite in 39 cases, or 83%. The 8 cases where blind rewrite was comparable were all prompts that were already structurally fine and just needed a tone tweak. For everything with a real structural problem, scoring won.

The KMP Free tier gives you 5 Quick Optimize runs per day, and that is enough for one focused refactor session. The scoring is the diagnostic, not the optimization. Treat it like a profiler: you read the output, you fix one thing, you move on.

Trick 2: Re-extract your system prompt

This is the trick that paid me back the €400 in the first paragraph.

The anatomy of the waste: I had a 200-token preamble starting with "You are a helpful assistant that responds in JSON…" that was being prepended to the user message on every single call. 90 calls a day. The role boundary said user, not system. The cache fingerprint never matched. I was paying 200 tokens of input cost out of cache on every call, 18,000 tokens a day, when I should have been paying it once an hour at most.

The fix is mechanical. Move the preamble into the system role. Add cache_control: {"type": "ephemeral"} to the system block on Anthropic, or use the equivalent caching primitive on OpenAI (prompt prefix caching kicks in automatically above 1024 tokens). Cache hit rate on the first deploy went from 0% to 92%. That stable 92% drove the workload cost from €130 a week to €28 a week.

One warning, and this ties to the cache TTL change: the new 5-minute default TTL means you also need to think about call frequency. If your traffic is bursty, with quiet hours in between, the cache will expire before the next burst and you will see no benefit. The fix is to add a heartbeat call every 4 minutes during active periods, or to opt into the 1-hour TTL flag where available. The cache TTL article walks through the heartbeat pattern in detail.

This trick alone moves 60-80% of the bill on any workload with a stable system prompt and 30+ calls per hour. There is no paid tool that will identify this for you. They look at the text of the prompt, not at the role boundary.

Trick 3: Few-shot pruning A/B

Here is a fact that should surprise you. On KMP, the lowest-scoring criterion across all 39 scored prompts is few-shot, with an average of 1.63 out of 5. The worst criterion by far. The next worst is chain-of-thought at 2.83. Few-shot is in a different category.

This breaks in two directions, and both cost money.

Direction one: most prompts have no few-shot examples at all when they would benefit from them. Two or three concrete examples can replace a paragraph of abstract instructions, and the token cost is usually lower. If your prompt is failing on consistency, this is your fix.

Direction two, and this is the cost waste: when developers do use few-shot, they often pile in five, six, eight examples. The marginal value of example 4 onwards is near zero for most non-classification tasks. You are paying full token price on every call for examples that are not changing the output.

The test takes ten minutes. Take a prompt with N=3 or more few-shot examples. Score it on KMP. Drop to N=1 (the strongest example only). Score again. If the overall score delta is under 5%, you can ship the N=1 version and save 30-50% of input tokens per call.

I ran this on 12 of my own few-shot prompts. The average score delta from N=3 to N=1 was 0.18 points on a 5-point scale. On 7 of the 12, the delta was under 0.10 and statistically a wash. Those 7 prompts now run at the smaller token footprint, with no observable quality loss.

When not to prune: strict classification tasks where the examples are establishing the label boundary, and structured-output tasks where examples are demonstrating the schema. Everything else, prune aggressively.

Trick 4: Output contracts kill retry loops

If your prompt returns free-form text and your downstream code tries to parse it, you are in a retry loop you may not be measuring.

On my customer-support classifier, before output contracts, the retry rate was 22%. Two calls out of ten returned malformed JSON, the parse failed, the code retried, and the retry sometimes worked. That 22% was pure waste: every retry was a full second call at full token cost.

The fix is structured output. OpenAI exposes response_format: {type: "json_schema", json_schema: ...} since GPT-5.4. Anthropic does it through tool use with a forced tool choice. Mistral has a JSON mode. Pick the primitive native to your provider and define the exact schema you want.

After deploying structured output on the same workload, the retry rate dropped to 3%, and those 3% were caused by genuine ambiguity in the input (not by the model failing the schema). Net token savings on the workload: 38%, because every retry was a full call.

There is a caveat. Structured output adds 5-10% latency overhead on the constrained call. If you are doing one-shot interactive prompts where latency matters and parse failure is benign, it is not worth it. If you are in a loop, it pays for itself in the first hour.

Trick 5: Cheap model triage

The principle: roughly 70% of your calls are extraction, classification, summarization, or simple paraphrase. None of those needs Opus or GPT-5.4. Haiku 4.5 and Mistral Small 4 do the job at one fifteenth of the cost. DeepSeek V4-Pro does it at one fortieth.

The pattern that pays off consistently is two-tier triage. First pass with a cheap model. Capture the confidence signal (either a model-emitted score, an output logprob threshold, or a downstream validator). If confidence is high, ship the cheap answer. If confidence is low, escalate to a premium model only on that case.

I ran this on the customer-support classifier mentioned above. Pre-triage, every call went to Opus. Cost per 1000 messages: €4.80. After triage, Haiku handled 91% of messages, Opus handled 9%. Cost per 1000 messages: €0.61. The classifier quality, measured against the same labeled test set, dropped by 0.4 percentage points. Acceptable trade for an 87% cost reduction.

The two-tier pattern only works if you can detect low confidence. The cheapest way to do this is to ask the cheap model to also output a confidence score in the structured output (trick 4 pairs naturally here). Models are not perfect at self-rating, but they are good enough that the 9% escalation rate is a usable signal.

For the decision matrix on which model goes with which task, the Choosing the Right AI Model in 2026 article has the full mapping. For the DeepSeek V4 specific migration path, the DeepSeek migration recipe lays out the prompt-level breaks.

The combined savings stack

The five tricks do not stack additively. They share waste. Trick 2 (caching) and trick 5 (cheap model triage) both reduce the same bill, and once you have applied one the other has less to bite into.

In practice, on three of my own production workloads, the realistic combined savings landed in this range:

The marginal value of tricks 1 and 3 is in the quality of the prompt, not the size of the bill. They make sure you are not paying for tokens that produce nothing.

If you have one hour to spend on cost reduction, do trick 2. If you have a day, do tricks 2 + 4 + 5.

Why paid tools do not help here

Paid prompt optimization tools optimize the lexical surface of the prompt. They rewrite "Please respond in JSON" to "Respond in valid JSON format" and call it a savings. The savings does not exist. The bill is not driven by word choice.

The bill is driven by where the prompt lives (role boundary, cache region), when it is sent (frequency, TTL), how often the output fails to parse (retry loops), and which model runs it (triage). None of those four are visible to a paid optimizer that sees only the prompt text.

The verdict, plain: pay for a prompt optimization tool only if you are managing 500+ distinct prompts across a team and need workflow automation. For solo dev and small team work, KMP Free for scoring plus a methodical hour of refactoring around the 5 tricks above will out-perform any subscription at any tier.

Where to start

Pick your single highest-volume workload. Score the prompt on KMP. Open the trace and check the role boundaries. If your system prompt is sitting in the user role, you have found your trick 2. If you have more than three few-shot examples, you have found your trick 3. If you are not running structured output, you have found your trick 4. If everything is going through Opus, you have found your trick 5.

You probably have at least three of the five waiting for you on your first workload. Start with whichever is cheapest to implement, not biggest in expected savings: momentum matters more than optimization on the first pass.

The scoring is free. The refactoring is yours. The €400 I burned learning trick 2 is the tuition for this article.