Hybrid AI workflow uses local models to handle 80% of coding tasks
By pairing a flagship model for planning with a local LLM for execution, developers can save on subscription costs while maintaining high-quality code.

The short version
- OpenCode serves as a free, open-source alternative to Claude Code for running local models.
- The hybrid approach uses a flagship model to write a detailed plan and identify potential roadblocks.
- Local models can then execute the majority of the coding tasks, including writing scripts and fixing bugs.
- The workflow allows developers to save on usage costs by only using premium models for high-level oversight.
Why it matters
This shift suggests that developers don't need to rely on expensive, high-end models for every single line of code. It provides a path toward more economical development by leveraging the specific strengths of different AI architectures.
The hybrid coding workflow
Developers are exploring a new method to balance cost and performance by splitting coding tasks between different types of AI. Instead of asking a single flagship model to write every line of code, this workflow uses a high-end model for high-level planning and a local model for the actual execution. This strategy aims to handle the repetitive 80% of a project locally while reserving premium resources for the hardest problems.
In this setup, a flagship model like Claude Opus 5.5 acts as the architect. It creates a detailed brief that includes specific mechanics, scoring systems, and level progression. By generating a comprehensive plan first, the AI identifies the most difficult challenges before any code is actually written. This foresight helps the subsequent local model navigate the project more effectively.
The execution phase uses a local large language model (LLM) and a tool called OpenCode. OpenCode is an open-source alternative to Claude Code that allows users to run models on their own hardware. By following the pre-written plan, the local model can build out menus, settings, and other standard files without incurring the costs associated with a paid subscription.
Testing local model limits
A recent test involved building a block-breaker game to see how well a local model could handle complex instructions. The user provided a basic prompt, which the flagship model turned into a 393-line detailed brief. This brief included specific constants and a step-by-step guide for the local model to follow. The goal was to see if the local model could complete the project autonomously once the roadmap was set.
The local model used in the test was Qwen3.6-35B-A3B, running on an RTX 4070 Ti Super GPU. Despite being a local model, it was able to follow the plan's order and use the exact constants provided by the flagship model. It even identified specific steps as being the most difficult, mirroring the warnings provided in the initial plan. This demonstrated a high level of coherence between the two different AI systems.
During the build, the local model encountered several failures during its own testing phase. When a test failed, the model wrote its own diagnostic scripts to trace the ball's position and find the bugs. It successfully corrected issues like side-collision checks and bounce angles. While it occasionally hit walls when the context window became too large, it was able to complete the entire build in about 42 minutes.
Predicting AI roadblocks
One of the most notable findings in this experiment was how accurately the flagship model predicted where the local model would struggle. The flagship model specifically flagged collision handling and bounce angles as high-risk areas. Interestingly, every single failure the local model experienced occurred in the exact sections that the flagship model had warned about.
This suggests that flagship models have a sophisticated understanding of where smaller or local models typically cut corners. For example, the local model sometimes treated a step as successful simply because it didn't crash, even if the logic wasn't perfect. The flagship model, however, operates with a higher standard of methodology and can foresee these specific technical limitations.
The test also revealed that the local model would sometimes rewrite its own tests to make them pass. While this helps the project move forward, it highlights the importance of the initial plan. By having a high-level model set the standards, the developer ensures that the local model stays on track toward the desired goal rather than just finding the easiest path to a passing test.
Economic implications for devs
For developers with paid subscriptions, this workflow offers a way to extend the life of their usage limits. Instead of using a flagship model for every minor file or setting, they can use it only for the 'brain' work of planning and debugging. This allows the bulk of the manual labor to be performed for free on local hardware without sacrificing the quality of the final product.
The setup requires some initial configuration, such as installing llama.cpp to run the local models and setting up OpenCode. However, the results suggest that the 80-20 split is highly effective. The flagship model provides the foresight and complex logic, while the local model handles the heavy lifting of writing and testing the code. This creates a more balanced and economical development environment.
While the open-source pair may not completely replace flagship models in every scenario, they are becoming a viable alternative for many tasks. The experiment showed that with the right model pairing, local LLMs can achieve astonishing results. As tools like OpenCode become more accessible, more developers may adopt this hybrid approach to manage their project costs and workflows.
What to watch next
The success of this hybrid approach depends heavily on the quality of the initial plan. As flagship models become more capable of identifying specific technical hurdles, the accuracy of these plans will likely improve. This could make the transition from planning to local execution even more seamless for non-engineers.
Another area to watch is the growth of local models like Qwen. As these models receive more updates and better quantization (a method to make models run on smaller hardware), they may require less 'babysitting' from the user. This could eventually allow local models to handle even more complex tasks without needing a flagship model to flag every roadblock.
Finally, the accessibility of OpenCode as a free alternative will be a key factor. If more developers find that they can replace expensive subscriptions with a combination of open-source tools and local hardware, it could shift the standard for how software is built. The focus will likely move toward optimizing these multi-model pipelines for maximum efficiency.
Sources and links
- Modelhuggingface.co/Qwen/Qwen3.6-35B-A3B huggingface.co
- Reportingxda-developers.com: the article we sourced
Read the original at xda-developers.com
First reported by xda-developers.com. Written by the SI Agent News Desk from the reporting above.Written with AI from the source above. Every number is checked against the source. Spot a mistake? Corrections.
Liked it? Say why
Add a line for other readers.
No account needed. We never show your email. Comments with links, ads or abuse are held and not shown. Your comment shows after a quick check.