opencode Tool Review

A Versatile Open-Source Terminal Coding Agent

I recently spent time testing opencode (yes, all lowercase), an open-source terminal coding agent that is quickly becoming one of my favorite development tools. Starting with a simple test to create a to-do list application gave me an opportunity to showcase of opencode's sophisticated features and exceptional UI design.

First Impressions: Beauty Meets Functionality

opencode immediately stands out with what is quite possibly the best terminal-based user interface I've encountered in an open-source coding agent, competing well with Claude Code. The interface presents information beautifully:

• Tool calls are clearly formatted and easy to follow

• File generation displays with syntax highlighting

• Diffs display side-by-side

• Each action is presented with excellent visual hierarchy

But opencode is far more than just a pretty face. Its feature set includes:

• Universal model support — works with all models from all providers

• Multiple operational modes including separate planning and execution modes

• Full MCP (Model Context Protocol) server support

• Custom instructions and agents for personalized workflows

• IDE integration with Visual Studio Code

• Web-based conversation sharing for easy collaboration

Setting Up the Test Project

To properly evaluate opencode, I decided to create a simple web-based to-do list application. I configured my environment using my standard setup through Ruler, which includes several MCP servers:

• Playwright for browser automation

• Context7 for reading library documentation

• Additional servers for various development tasks

• Basic coding rules I apply across all projects

See the opencode config I used in this gist

For the tech stack, I chose:

• FastHTML as the web framework

• FastLite for SQLite-based persistence

• Monster UI for creating UI elements

(notice a pattern? all excellent libraries with major contributions by the one and only Isaac Flath 😉)

The Planning Phase

I started by switching opencode to the plan agent — a primary agent that can research and strategize without making any file system changes. This separation is becoming standard in modern coding agents, and opencode implements it well.

Wtih the plan agent, opencode:

1. Researched the specified libraries using Context7

2. Analyzed how the components would work together

3. Created a comprehensive plan for building the application

4. Presented the strategy for my review

Once I was satisfied with the plan, I switched to the build agent (since the plan agent intentionally lacks file writing capabilities) and asked opencode to write the plan to a markdown file for future reference. After reviewing the written plan, I gave the go-ahead to proceed.

Building the Application

I selected Claude Sonnet 4 for this task, since it's become the gold standard for agentic coding. opencode began executing the plan methodically:

1. Created the project structure with all necessary files

2. Set up the development environment using standard Python virtual environments and pip

3. Implemented features incrementally, updating the task list after each step

4. Wrote comprehensive documentation including a README file

The process was smooth and transparent, with opencode showing each file creation, every code change, and all modifications in real-time through its beautiful interface.

Hitting a Snag: Rate Limits and Recovery

While deep in the development process, I encountered a common frustration — rate limiting from the Anthropic API. This is where opencode's flexibility truly shined. Without missing a beat, I switched to my GitHub Copilot subscription, which also provides access to Claude Sonnet, and continued working using the same model without further disruption.

This seamless provider switching is a killer feature that sets opencode apart from many competitors locked into single providers.

Adapting on the Fly

After opencode completed the initial implementation, I noticed it had used standard Python virtual environments and pip for package management. Since I prefer using uv, I asked opencode to update the configuration. It quickly refactored the project to use my preferred tooling. In hindsight, I should have included this in my plan, even though my rules file indicates my preference for uv.

Debugging

When I first ran the application, it didn't work. Rather than dive into manual debugging, I decided to delegate the debugging session to opencode. I instructed it to:

1. Run the server itself

2. Use the Playwright browser automation to test the application

3. Fix any issues it encountered

What followed was fun to watch:

• opencode launched the server in the background

• Opened a browser using Playwright

• Navigated to the application

• Encountered the initial errors

• Made targeted fixes based on what it observed

• Retested the application after each fix

• Interacted with the UI by clicking buttons and adding test data

• Continued iterating until everything worked perfectly

Only after confirming full functionality did opencode report back, suggesting I try the application myself. When I did, the to-do list worked flawlessly — it wasn't particularly pretty since I hadn't requested any aesthetic improvements, but it was completely functional.

What Makes opencode Special

Through this testing experience, several aspects of opencode particularly impressed me:

1. Provider Flexibility
The ability to switch between API providers mid-session without losing context or momentum is invaluable. This feature alone saved my work session when I hit rate limits.

2. Intelligent Autonomy
With minimal instructions, opencode filled in gaps intelligently. I provided high-level requirements, and it handled the implementation details expertly.

3. Exceptional Presentation
The terminal UI makes long coding sessions more pleasant and productive. Every element from tool calls to file diffs is presented clearly and beautifully.

4. Active Development
The opencode team releases improvements at least once daily, sometimes several times per day. This rapid development cycle gives me confidence in the tool's long-term viability.

Open Source Advantage

As someone who values open-source software, particularly for critical developer tools, opencode's open nature is a significant advantage. It provides:

• Transparency in how the tool works

• Community-driven improvements

• No vendor lock-in

• The ability to customize and extend functionality

The combination of being open source while matching or exceeding the capabilities of the best closed tools makes opencode a compelling alternative to tools like Claude Code.

Sharing and Collaboration

opencode includes a cool feature for sharing sessions through a web browser interface. After completing my to-do list project, I exported the entire conversation for future reference. This capability is invaluable for:

• Team collaboration

• Creating documentation

• Seeking help from the community

• Building a knowledge base of successful patterns

See the full conversation transcript here

Final Thoughts

opencode successfully combines versatility, sophistication, and user experience in a way that few coding agents achieve. It's not just about having all the features — it's about implementing them thoughtfully and presenting them beautifully.

The tool excels at:

• Providing flexibility when you need it most

• Maintaining context across modes, models, and even provider switches

• Offering powerful agentic operation

• Making the development process visually engaging and intuitive

• Building on a strong open-source foundation

For developers seeking a coding agent that doesn't lock them into a single ecosystem while providing a premium experience, opencode deserves serious consideration. It's quickly becoming a permanent part of my development toolkit, and with its rapid pace of improvement, I'm excited to see where it goes next.