15 prompts that cut my Coding bill from $7,800 to $129

1I need to execute the following project using multiple AI agents:
2
3Project: [describe the full outcome you need]
4Scale: [number of items / files / tasks]
5Quality standard: [what good output looks like]
6Constraints: [deadline, format, restrictions]
7
8Your job is to build the execution plan, not execute it.
9
10Produce:
111. The breakdown of work into parallel streams
122. The dependencies between streams (what must happen before what)
133. The quality checkpoints where output must be reviewed before continuing
144. The exact brief for each execution stream (what each agent needs to know to do its part)
155. The final assembly instructions (how the outputs combine into the finished deliverable)
16
17Do not write any of the actual content. Only the plan.

1I have the following tasks to complete this week:
2
3[list your tasks]
4
5Sort them into two groups:
6
7Group A — Opus handles (reasoning-heavy, judgment calls, ambiguous, high-stakes):
8[Opus-level criteria: architecture decisions, quality reviews, strategic analysis, anything where being wrong has downstream consequences]
9
10Group B — Kimi Agent Swarm handles (execution-heavy, batch processing, repetitive at scale, clear output spec):
11[Kimi-level criteria: researching N sources, producing N files, transforming N inputs, any task where the output spec is clear and the work is parallel]
12
13For each Group B task, write the exact project brief that Kimi Agent Swarm will receive.
14For each Group A task, work through it directly.

1Kimi Agent Swarm is about to execute the following project:
2
3[describe the project]
4
5Before it runs, I need a quality rubric.
6
7Define:
81. What a passing output looks like for each deliverable type
92. What a failing output looks like (be specific — not "low quality" but "missing citations," "under 500 words," "wrong format")
103. The 3 most common failure modes for this type of task
114. How to catch each failure mode in the output before it reaches the final assembly stage
12
13This rubric will be used to review Agent Swarm outputs before they are accepted.

1Kimi Agent Swarm completed the following project:
2
3Project brief: [what was asked]
4Output: [paste or summarize the output]
5
6Review against the quality rubric:
7[paste the rubric from Prompt 3]
8
9For each deliverable:
10- Pass or fail against each rubric criterion
11- Specific issues that need to be fixed (quote the exact problem)
12- Whether the issue requires a full re-run or a targeted fix
13
14Produce a revision brief: exactly what Kimi needs to fix, in the same project brief format, so it can be sent directly without re-explanation.

1Kimi Agent Swarm produced the following outputs:
2
3[list or paste the outputs]
4
5These are the components of: [describe the final deliverable]
6
7Your job is to assemble them into a coherent final output.
8
9Rules:
10- Do not rewrite what works. Connect and integrate.
11- Identify and fix inconsistencies between sections
12- Ensure the final output reads as one unified piece, not a compilation
13- Flag anything that requires my review before finalizing
14
15Final format: [describe exactly what the assembled output should look like]

1Take the following execution plan produced by Claude Opus:
2
3[paste Opus plan from Prompt 1]
4
5Rewrite it as a Kimi Agent Swarm project brief.
6
7Format:
8Project: [one line summary]
9Input: [files, URLs, data attached]
10Output: [file type / count / naming convention / format]
11Phase 1: [first execution stream — what agents do, what they produce]
12Phase 2: [second stream — dependencies noted]
13Phase 3: [assembly — how outputs combine]
14Quality note: [the minimum standard each output must meet]
15
16The brief should be complete enough that Agent Swarm can execute without clarification.

1Project: [describe the batch task]
2Input: [N items — attach files or list them]
3Output spec: [exact format, file type, naming convention, one output per input]
4
5For each input:
6- [step 1 of what to do]
7- [step 2]
8- [step 3]
9- Output: [exact format of the deliverable]
10
11Quality standard: [minimum requirement — word count, citation format, structure, etc.]
12
13Run all [N] inputs in parallel. Deliver as [file format] named [convention].

1Research phase:
2Search for [topic / competitor / subject] across [N] sources.
3For each source extract: [list of specific data points]
4Output: structured dataset with one row per source.
5
6Analysis phase:
7Using the research dataset, identify: [patterns / gaps / opportunities / rankings]
8Flag any source where the data is unclear or contradictory.
9
10Deliverable phase:
11Produce [final output format] using the research and analysis.
12Format: [exact specification]
13Length: [word count or page count]
14Citations: [style]
15
16Total output: one [file type], one supporting dataset.

1We just completed the following workflow:
2
3Opus defined: [what Opus planned]
4Kimi executed: [what Kimi ran]
5Output: [what was produced]
6
7Save this as a reusable Skill called [name].
8
9Document:
10- The trigger (what kind of request activates this skill)
11- The Opus orchestration prompt (what to send Opus to generate the brief)
12- The Kimi execution brief template (what gets sent to Agent Swarm)
13- The Opus review checklist (what Opus checks before accepting output)
14- Expected inputs and outputs
15
16Next time we run this workflow, I want to start from the Skill, not from scratch.

1This workflow just ran:
2
3Opus 4.8 tasks:
4[list each task Opus handled, estimated token count]
5
6Kimi K2.6 tasks:
7[list each task Kimi handled, estimated token count]
8
9Calculate:
10- Opus cost: [tokens] × $0.015 per 1K tokens
11- Kimi cost: [tokens] × $0.0006 per 1K tokens
12- Total actual cost
13- What this workflow would have cost running entirely on Opus
14- Savings this run
15
16Log this to WORKFLOW_COSTS.md with date, workflow name, and breakdown.

1Review the following workflows we ran this week:
2
3[list workflows]
4
5For each workflow, classify every task:
6- Opus-only: judgment-heavy, no clear rubric
7- Kimi-only: execution-heavy, clear output spec, parallel-friendly
8- Hybrid: Opus plans + Kimi executes + Opus reviews
9
10For each Hybrid workflow, write the handoff points:
11- What Opus produces before handoff (the brief)
12- What Kimi receives (the execution spec)
13- What Opus reviews after (the quality rubric)
14
15Flag any task currently on Opus that should move to Kimi.

1I need a routing framework for our recurring workflow types.
2
3For each workflow type below, define:
41. Which model handles each stage (Opus / Kimi / both)
52. The trigger that routes it to the right model
63. The handoff format between models
74. The cost estimate per run
8
9Workflow types:
10- [type 1, e.g. content research + production]
11- [type 2, e.g. competitor analysis]
12- [type 3, e.g. outreach personalization]
13- [type 4, e.g. code review + refactor]
14
15Output: a routing table I can use to classify any incoming request in 30 seconds.

1Last month we ran the following volume through our AI workflow:
2
3[describe volume — e.g. 200 research briefs, 500 outreach emails, 30 code audits]
4
5Current setup: [describe what goes to Opus vs Kimi currently]
6Current monthly cost: [amount]
7
8Analyze:
91. Which workflows are over-allocated to Opus that Kimi could handle
102. Which workflows are currently on Kimi that Opus should be handling for quality
113. What the optimal split would look like
124. Projected cost at the optimal split
13
14Produce a routing change recommendation with estimated monthly savings.

1Create a standard handoff template for the following workflow:
2
3When Opus completes [task type], it produces [output format].
4Kimi Agent Swarm receives this and executes [execution task].
5Opus then reviews [review criteria].
6
7Write:
81. The Opus output format that serves as the Kimi brief (structured, no ambiguity)
92. The Kimi execution brief template (slots for Opus to fill in)
103. The Opus review checklist (5 criteria Kimi's output is graded against)
114. The revision loop: if Kimi output fails, what gets sent back and in what format
12
13This template becomes the permanent interface between the two models for this workflow type.

1Produce a monthly ROI report for our Opus 4.8 + Kimi K2.6 workflow setup.
2
3Include:
41. Total workflows run this month: [N]
52. Volume processed: [N items / files / tasks]
63. Cost breakdown:
7   - Opus 4.8 spend: $[amount]
8   - Kimi K2.6 spend: $[amount]
9   - Total: $[amount]
104. Equivalent cost running all workflows on Opus 4.8 alone: $[calculated amount]
115. Monthly saving: $[amount]
126. Annualized saving: $[amount × 12]
137. Quality incidents (workflows that failed review and required re-run): [N]
148. Quality incident rate: [%]
15
16Format as an executive summary. One page. Numbers first.