Use Cheap Models for Drafts and Strong Models for Finals

Why Split Drafting From the Final Pass

Using one powerful model for every prompt is simple, but it is rarely the most economical workflow. Early work is full of change: you discard outlines, reword paragraphs, test several approaches, and correct incomplete requirements. Those iterations need speed and low cost more than maximum reasoning depth. Reserve a stronger model for the moments when accuracy, consistency, and polish matter most: reviewing the complete result, resolving trade-offs, and producing the version another person will read or merge.

This walkthrough gives you a desk-ready process. Use Claude Haiku 4.5 or DeepSeek V4 Flash for exploratory drafts, then use Claude Sonnet 5.5 or GPT-6.1 Sol for the final pass when the work warrants it. The exact choice depends on your budget and task, but the separation of jobs is the important part.

1. Define the Deliverable Before Opening a Model

Write a short brief in your editor before sending a prompt. Include the audience, output format, constraints, source material, and definition of done. For a code task, list the files involved, expected behavior, edge cases, and test command. For writing, state the target reader, length, tone, factual boundaries, and required sections.

A clear brief prevents an expensive final model from spending tokens uncovering requirements that you could have supplied in one minute. It also gives both models the same target, making it easier to compare draft quality and identify what still needs improvement.

• Deliverable: add a pagination helper to an existing API client.
• Constraints: preserve public method signatures and support empty responses.
• Evidence: add focused tests and run the project test command.
• Done means: readable implementation, passing tests, and a concise change summary.

2. Send Broad Exploration to the Lower-Cost Model

Give the draft model the brief and ask for alternatives rather than a single perfect answer. Request an outline, implementation plan, likely risks, and questions it cannot answer from the supplied context. This is where inexpensive iteration earns its value: you can ask for three approaches, reject two, and refine the third without treating each revision as a premium review.

Keep each prompt narrow. Instead of pasting a whole repository, provide the relevant interface, a failing test, and the neighboring implementation. Ask the model to label assumptions. Assumptions are useful because they become a checklist for the final pass.

3. Turn the Best Draft Into a Review Packet

Do not immediately ask the stronger model to “make this better.” Prepare a compact packet containing the selected draft, the original brief, known assumptions, and any evidence from tests or source documents. Add explicit review questions such as: Does this meet every constraint? Which edge case is still unhandled? What would break backward compatibility? Is any claim unsupported?

This packet makes the final model a reviewer and decision-maker rather than a fresh drafter. It reduces repeated context and encourages concrete corrections. If the draft is code, include the diff and test output. If it is an article, include the outline, factual sources available to the writer, and the intended reader action.

4. Use the Stronger Model for Verification and Synthesis

Now send the review packet to the stronger model. Ask it to first list defects by severity, then produce a corrected final version only after it has checked the constraints. Require it to distinguish verified facts from assumptions and to preserve valid parts of the draft. This avoids needless rewrites that introduce new errors.

For software work, request a final response with the changed behavior, remaining risks, and tests that should pass. Run those tests yourself. For content, request a final compliance check against length, required topics, prohibited claims, and reader clarity. The stronger pass should be small in count but high in consequence.

5. Connect the Workflow Without Changing Your Tools

RelayVano is a practical option when you want pay-as-you-go access to multiple models through one relay. Its API base is https://api.relayvano.com, and it works with Claude Code, Codex, Gemini CLI, and OpenAI-compatible SDKs. Put your lower-cost draft model and stronger final model behind the same integration so changing stages does not require rebuilding your application workflow.

Start by recording three measurements for a week: draft cost, final-pass cost, and the number of revisions after final review. If a final model frequently rewrites everything, improve the brief or the draft prompt. If final reviews find little to change, reduce the final-pass frequency for low-risk tasks. Sign up for RelayVano when you are ready to test this two-stage routing with your own workload.

6. Keep a Simple Escalation Rule at Your Desk

Use a lower-cost model by default when the output is disposable, exploratory, or easy to verify. Escalate when the result affects production behavior, customer-facing communication, security-sensitive logic, or an irreversible decision. Also escalate when the draft model identifies uncertainty it cannot resolve from the context.

The goal is not to prove that one model is always better. It is to spend attention and budget where they reduce real risk. Draft quickly, collect evidence, review deliberately, and make the strongest model responsible for the final decision rather than every first attempt.