Two models on a billing refactor before Friday

It is Thursday afternoon, and the payments team wants one change ready for Friday: move invoice calculations out of HTTP handlers without changing a single customer total. The arithmetic is straightforward. The danger sits in the surrounding behavior: rounding, retries, discounts, and the order in which credits apply.

That is a useful setting for testing GPT-6 Astra on a long refactor and GPT-6.1 Sol on quick passes. The exercise below is an illustrative field test you can reproduce in your repository, not a claim of measured model performance. Its purpose is to turn a plausible division of work into a decision you can verify.

The billing change and its acceptance checks

Use a service where invoice logic spans a route handler, a calculation module, a database adapter, and tests. The assignment is to extract a calculation function, keep persistence in the adapter, and preserve the existing API response. Freeze the scope there; dependency upgrades and naming cleanups can wait.

Before either model edits anything, capture representative outputs from the current implementation. Include an ordinary invoice, a percentage discount, a partial credit, a zero balance, and a rounding boundary. Add a retry case if the endpoint can receive the same payment event twice.

• Require identical totals and response fields for the captured cases.
• Check that retries preserve the existing behavior for duplicate events.
• Record elapsed time, review effort, and repair attempts separately.
• Inspect the final diff for changes outside the assigned boundary.

These checks make the exercise useful even without a formal benchmark. A fast response matters less if a reviewer spends the next hour finding an altered rounding rule.

GPT-6 Astra gets the extraction

Give GPT-6 Astra the connected part of the job. Ask it to inspect the request path, identify the calculation boundary, and describe the behavior that must survive the move. Require a short plan before edits, including which files it expects to touch and which tests protect the extraction.

A practical instruction is: extract invoice calculation into a function with explicit inputs; preserve rounding order, credit application, and response serialization; run the relevant tests; report any behavior the tests do not cover.

Keep this work in one session while the model builds its understanding of the code. Splitting the extraction across fresh conversations creates extra handoffs: each session needs to rediscover where amounts originate and which layer owns side effects.

The review should follow the money. Trace one invoice from request parsing through calculation to persistence. Passing tests provide evidence, but reviewers still need to check whether the new boundary accidentally reads the database or changes when rounding happens.

GPT-6.1 Sol gets three bounded passes

After the extraction is reviewed, give GPT-6.1 Sol small tasks against that stable diff. Suitable passes include adding a missing rounding fixture, correcting a misleading parameter name, or drafting the pull request description from the actual changes.

Assign each pass an explicit stopping point. For example: add a regression test for a credit that reduces the payable amount to zero; follow the current test style; run the relevant test file; stop after reporting the result.

For an independent check, ask it to inspect the diff and list possible behavior changes with file references. Keep that pass read-only. Review the findings before authorizing repairs, so a speculative concern does not become an unnecessary rewrite.

The Friday routing decision

The recommendation is to start with GPT-6 Astra for the connected refactor, then use GPT-6.1 Sol for bounded verification and finishing work. Treat that as a routing hypothesis to validate with your own elapsed time, usage charges, and review notes. This exercise does not establish that either model is universally faster, cheaper, or more accurate.

RelayVano is a practical choice for trying this workflow: its pay-as-you-go relay lets you access both models through Codex or an OpenAI-compatible SDK, using https://api.relayvano.com as the API base. Sign up for RelayVano and repeat the exercise on a small, well-tested change before assigning a release-critical migration.

For Friday’s billing release, keep the decision concrete: GPT-6 Astra owns the extraction; GPT-6.1 Sol handles short, explicit passes after the boundary is stable. Ship only when the behavior checks and human review agree.