You're paying five times too much for most of your LLM calls. Not because you picked the wrong provider. Because you're sending every task to your most expensive model in a single massive prompt.

Here's what happens instead when you break that one complex prompt into a chain of five focused ones: quality goes up, cost drops 70%, and debugging gets easier. That's not theory. That's production data from teams running this pattern at scale.

The Math That Should Bother You

Claude Opus 4.6 costs $5 per million input tokens and $25 per million output tokens. Claude Haiku 4.5 costs $1 and $5 respectively. That's a 5x spread on both sides.

Run the numbers on a typical content generation task. One Opus call processing 2,000 input tokens and generating 1,000 output tokens costs about $0.035. Five Haiku calls at 500 input and 300 output tokens each cost about $0.010 total. That's roughly 70% cheaper for the chain.

Stack prompt caching on top (which knocks another 90% off repeated prefixes), and the gap gets absurd. A workflow that costs you $100/month on all-Opus calls drops to under $10/month with a well-designed Haiku chain plus caching.

Stanford's FrugalGPT research found that enterprises overspend 50-90% on LLM inference by routing everything through frontier models. A 70/20/10 split across Haiku, Sonnet, and Opus instead of all-Sonnet cuts costs roughly 60% with negligible quality loss on most workloads.

Why Decomposition Fixes Quality Problems Too

Cost savings are the obvious win. The less obvious one: decomposition often produces better results than a single complex prompt.

Zalando learned this the hard way. Their postmortem analysis system had a "Surface Attribution Error" where the LLM blamed a technology just because it appeared near the failure description. One big prompt couldn't separate correlation from causation. They decomposed into a multi-stage pipeline with a dedicated classification step solely responsible for determining causality. The decomposition didn't just save money. It fixed a quality problem that no amount of prompt tweaking on a single call could solve.

Researchers at the Natural Legal Language Processing Workshop (Kwak et al., 2024) found the same thing. Their classify-first-then-extract chain on legal documents beat every single-prompt baseline on F1 score across both in-domain and out-of-domain data. And it used fewer tokens.

The reason is straightforward. A 2,000-token prompt asking a model to research, analyze, structure, write, and format all at once forces the model to juggle competing objectives in a single pass. Five focused prompts each get a clean context window and a single clear job.

A Real Decomposition: Blog Post Generation

Stop thinking about this abstractly. Here's what a monolithic blog prompt looks like versus a decomposed chain.

The monolithic approach (one Opus call):

You are a content strategist and expert writer. Research the topic
"kubernetes cost optimization," identify the target audience, 
determine the best angle, create an outline, write a 1200-word blog
post with SEO keywords naturally integrated, include a compelling 
introduction and conclusion, and format it in markdown with 
appropriate headers.

That prompt asks the model to do six different cognitive tasks simultaneously. It works, but the model compromises on each one because it's trying to satisfy all constraints at once.

The decomposed chain (five Haiku calls):

Step 1 -- Audience and Angle:

Given the topic "kubernetes cost optimization," identify:
1. The primary audience (role, experience level)
2. Their specific pain point this topic addresses
3. One concrete angle that makes this post different from generic coverage

Output as three labeled lines, nothing else.

Step 2 -- Outline:

Create a blog post outline for this angle:
Topic: kubernetes cost optimization
Audience: {step_1_audience}
Angle: {step_1_angle}

Output: 4-6 section headers with 1-sentence description of each section's content. No intro/conclusion headers -- those are implied.

Step 3 -- Draft each section:

Write section "{section_header}" of a blog post.
Context: {step_1_audience_and_angle}
This section should: {section_description}
Target: 200-250 words. Markdown format. Be specific and use examples.

Step 4 -- Assemble and edit:

Here is a blog post assembled from individually written sections:

{combined_sections}

Edit for flow between sections. Fix any redundancy. Add a 2-sentence
introduction and a 1-sentence closing. Do not rewrite sections -- 
only smooth transitions and trim repetition.

Step 5 -- SEO and metadata:

Given this blog post:

{edited_post}

Generate: title (under 60 chars), meta description (under 155 chars),
5 SEO keywords, and 3 internal linking suggestions based on common
related topics. Output as labeled fields.

Why This Works:

Each step has one job. Step 1 makes a strategic decision. Step 2 structures content around that decision. Step 3 writes with full focus on a single section. Step 4 handles editorial polish. Step 5 handles SEO. No step is asked to juggle competing concerns, so each step does its job better than a model trying to do all five at once.

Expected Output (Step 1):

Audience: Platform engineers and DevOps leads at mid-size companies (50-500 employees) running 10-50 node clusters, typically spending $15-40k/month on cloud Kubernetes.

Pain point: They know they're overspending but can't identify which workloads are wasting resources without disrupting production stability.

Angle: The "right-sizing audit" -- a 4-step process to cut 30-50% of cluster costs in one sprint by targeting the three resources that are almost always overprovisioned.

Notice how specific that output is. A monolithic prompt rarely produces targeting this precise because the model is already thinking about writing the actual post.

The Trap: When Chaining Costs More

Naive chaining is worse than a good single prompt. This matters.

If you dump the full output of every previous step into the next step's input, your token count balloons. A five-step chain where each step receives all prior context can actually cost more than one well-crafted monolithic prompt.

The discipline is passing minimal context between steps. Step 3 doesn't need Step 1's raw output. It needs three fields extracted from it. Step 4 doesn't need the outline. It needs the assembled sections. Trim aggressively at each handoff.

The other cost is cascading failures. A bad output in Step 1 poisons every downstream step. With a single prompt, a mediocre response is self-contained. With a chain, you need validation between steps. That means either automated checks (does the output match the expected format?) or a quick classifier call that catches garbage before it propagates.

Both of these problems are solvable. But they're the difference between a chain that saves 70% and a chain that costs 20% more while being harder to debug.

The RouteLLM Evidence

UC Berkeley, Anyscale, and Canva published RouteLLM at ICLR 2025. They trained routing models that achieve 95% of GPT-4's performance while only using GPT-4 for 14% of queries. On MT-Bench, they hit 85% cost reduction.

The implication for prompt decomposition: most of your chain steps don't need a frontier model. A well-decomposed chain naturally creates a routing opportunity. Step 1 (strategic decisions) might warrant Sonnet. Steps 2-5 (structured generation, editing, metadata) run fine on Haiku.

ZenML's database of 1,200+ production deployments confirms the pattern. Intent classification, entity extraction, and summarization run on small models at 88-92% accuracy. Only the final response generation step needs a larger model.

Your Move

Pick one workflow you're currently running as a single expensive prompt. Break it into its component cognitive tasks. Run each task on the cheapest model that handles it well. Measure cost and quality against your baseline.

For most content, analysis, and data processing workflows, you'll find what the research consistently shows: focused prompts on cheap models beat unfocused prompts on expensive ones. The $20/month Haiku budget outperforms the $100/month Opus budget when you decompose well.

Start with the pattern above. Five steps: decide, structure, generate, edit, metadata. Adapt it to your specific workflow. The technique transfers to everything from code generation to customer support to data extraction.

Want hands-on training on prompt decomposition and chaining for your team? Connect with Kief Studio on Discord or schedule a session.

prompt decomposition

Prompt Decomposition: Break One Complex Prompt Into Five Simple Ones and Get Better Results for Less Money