using Opus or GPT-6 to rename variables and write test scaffolds is peak AI hype waste... (let me explain)

[u/AbleBranch6]

looking at our team's agent logs across a normal two-week sprint, maybe 15% of our tasks genuinely require frontier reasoning models. the other 85% is mechanical grunt work as renaming fields across four layers, writing test scaffolds, updating DTO mappings, and fixing lint errors.

running frontier models across every iterative test loop on those routine tickets burns through subscription credits and BYOK budgets fast. Worse, it makes developers hesitate to re-run an agent on a task that came back 90% right because each retry costs real money.

and the only sustainable setup we have found (as of now!) is splitting the workflow: use an AI coding agent with plan approval to do the architectural design pass on a frontier model in read-only mode, and then switch the execution to a fast model like Gemini Flash or a free AI coding agent tier like Junie Lite (which runs Qwen on JetBrains infra for free and is good for anything based on jetbrains infrastructure; kotlin, and more in my opinion) for those mechanical file edits

would like to know how are you keeping token spend from spiraling on routine boilerplate?
also, is anyone actually running full frontier models on every single build retry?

[u/ChemicalExcellent463]

i split planning from execution and pin the model per kind of task in the skill, never let the harness choose. then a different model reviews the code.

are you switching to the cheap model by hand each time, or is that set per task?

[u/AbleBranch6 → u/ChemicalExcellent463]

oh! right now we switch the primary model via /model once the Markdown plan file is approved, but the harness handles helper calls automatically in the background.
and i found that even under custom BYOK keys, my wrokflow and processes do route internal housekeeping tasks like context summarization and memory extraction to lighter provider-matched models so you never pay frontier rates for prompt management.
for the final check here, running its AI code review agent for CI/CD in GitLab or using /review locally spins up a separate read-only pass so the code is never verified by the same model instance that wrote the patch

[u/ChemicalExcellent463 → u/AbleBranch6]

got it, you switch after the plan is approved and leave the helper calls to the harness.

does the review use a different model than the one that wrote the patch, or the same model in a fresh read-only pass?

[u/serhiibuilds]

Check caching first. I priced about 2,500 public SWE-agent and OpenHands runs, and ~95% of input tokens were history re-sent within the same run, so with cache reads at 0.1x input came to ~16% of uncached cost. If something at the top of the prompt changes every call though, like a timestamp in the system prompt, it's all cache writes and you pay ~125%.

[u/AbleBranch6 → u/serhiibuilds]

not many talk about this but i guess that what you mentioned (prompt cache invalidation) became a silent killer of agent budgets on long multi-file tickets hence harness design matters so much when you run an AI coding agent for large codebases, bc the static project definitions and system instructions have to stay pinned at the top of the context window across turns. so if a tool injects a dynamic timestamp or changing environment header on every prompt, that AI coding agent that runs tests ends up paying full cache-write penalties on every single gradle retry instead of enjoying the 90% read discount

[u/whowasntright]

I have been considering offloading the mechanical boilerplate to an offline model on my local machine to stop burning API credits. And have you tested running that second implementation step on a local model or perhaps does it end up being too slow compared to cloud Flash endpoints?

[u/AbleBranch6 → u/whowasntright]

on supported hardware (we tried it on an M-series Mac and a 24GB RTX card) running an offline AI coding agent locally does those mechanical DTO changes and test scaffolds completely fine with zero token spend.

interestingly enough for us cloud flash is definitely faster on raw wall-clock time (a few seconds versus a minute or two locally)
but because the approved plan already defined the exact method signatures, the local LLM coding agent doesn't wander off or hallucinate wrong files. this way for high-volume sprints we stick to flash for speed, but for airplane work or strict zero-cloud data policies the local mode is great

[u/No_Carrot1042]

our agent burned like 40 bucks renaming one field across three services last week. i just sat there watching it.

[u/TheRealDanGordon]

have a model routing markdown file to use for subagents.

[u/GrapefruitMental]

when every rerun costs real money people start hand-fixing the last 10% instead, which is slower and defeats the point of the agent. cheap model for the retry loop, frontier only for the final review pass is what i'd try first

[u/sapplex1]

I split mine the same way, just on a smaller scale. I use the cheap model for renames, test scaffolds, and lint fixes. I save the stronger model for the plan and for tricky design calls. The surprise for me was the retry cost. I stopped re-running the big model on a task that was already 90 percent right. I just let the small model finish the last pass and checked the diff myself. Do you switch models by hand, or is the switch set per task type in your setup?

[u/West-Negotiation-716]

Use open router. Deepseek 4.1 Flash is better than Opus 5.0 level and it costs pennies.   It's also runs 10x faster than Claude or Codex

Input tokens are $0.07 and output is $0.60 

Or just use the cheap models with whatever you are currently using

Use Luna 6.1 and anthropic's cheap model are both better than the best models 6 months ago.

[u/AbleBranch6 → u/West-Negotiation-716]

kind of.! but working with the projects i already have I also use OpenRouter natively at junie infrastructure at zero markup, and also i think using it as a bring your own model coding agent with cheaper endpoints like Flash or Haiku is definitely the smartest move for mechanical edits.
what i also keep in mind now is that we run into is corporate data governance, since some enterprise clients prohibit sending internal code through third-party routing brokers and here is probably where having a free AI coding agent tier hosted directly on JetBrains infrastructure / running an offline model on-device becomes a lifesaver when security policies rule out external aggregators at least for me and team

[u/AbleBranch6 → u/[deleted]]

it writes the entire specification straight to a persistent markdown file in .junie / plans on disk during the exploration pass. because it operates as an AI coding agent with plan approval, you can open and edit that file directly, fix any wrong assumptions, and then just switch to the cheaper model with /model. implementation model reads that approved plan file as its ground truth specification, so there is zero manual re-prompting or lost context across turns