Gary Sims demonstrates that Open Code, when paired with local large language models of varying sizes and quantization levels, can successfully generate functional code—unlike proprietary agents like Codex—though the process is significantly slower and produces code requiring substantial debugging. While promising as a cost-effective and experimental alternative, Open Code with local LLMs currently lacks the speed and polish needed for professional development.
In this video, Gary Sims explores whether it is possible to replace proprietary coding agents like Claude Code or Codex with an open-source alternative called Open Code, combined with a local large language model (LLM) running on a personal computer. His previous tests showed that using Codex or Claude Code with local LLMs was unsuccessful, but Open Code is designed specifically to work with local models, making it a promising alternative. The goal was to see if Open Code could successfully generate a program—in this case, an interpreter for a simple, custom scripting language called New Scrippy.
Gary tested Open Code with three different local LLM setups: a 3.6 billion parameter model on a Jetson Thor, a 27 billion parameter model on an RTX 5090, and a quantized 27 billion parameter model (Q8). Unlike his earlier attempts with Codex, all three configurations produced working interpreters that could run the example scripts from his GitHub repository. Open Code’s design, which is more conservative about the capabilities of local models, allowed it to function effectively where Codex failed, demonstrating that Open Code is better optimized for local LLM use.
Despite the success in generating functional code, the quality of the output varied. Gary used ChatGPT to review the generated code and found several issues, including memory leaks, incomplete implementations (such as missing division operations), and runtime errors. The quantized Q8 model produced higher quality code with fewer critical bugs compared to the Q4 versions, and it also engaged more interactively by asking clarifying questions during the coding process. This indicated that quantization level and model size both significantly impact the effectiveness of local LLMs in coding tasks.
However, the process was extremely slow, with token generation rates as low as seven tokens per second, causing the coding tasks to take hours or even overnight to complete. This is in stark contrast to the six minutes it took ChatGPT 5.5 with Codex to build a fully functional interpreter. Additionally, the generated code, while functional, was not production-ready and would require significant debugging and refinement. This makes Open Code with local LLMs more suitable for experimentation and prototyping rather than professional development.
In conclusion, Gary finds that while Open Code combined with local LLMs can produce working code and offers a cost-effective alternative to subscription-based AI coding agents, it comes with notable drawbacks such as slow performance and imperfect code quality. The choice of model size and quantization level plays a crucial role in the results. He invites viewers to share their experiences with Open Code and local LLMs, emphasizing that this approach is promising but still has limitations that need to be addressed for broader practical use.