This is my experiment to see how far you can get using free models that are currently available in the OpenCode Zen. As they are (mostly) open weights, I could also run them locally if I felt like it, someday.

What was available today:

  • GLM-5 (with some rate limiting, unfortunately)
  • MiniMax M2.5
  • Big Pickle (?)
  • Trinity Large Preview (?)

Scaffolding

I copy pasta’d some configuration files (e.g. Makefile, .golangci-lint.yml) from another project, wrote README.md (which is bit inconsistent with the prompt by design, to see which model honors or if it asks questions), and also left one error in place in the Makefile (lint target doesn’t work due to depending on another target which is no longer in the file).

Then I ran /init in the OpenCode to get skeleton of AGENTS.md, removed things I did not like, and added the libraries I want to use in Go. And then we’re off to the races.

Prompt (plan mode)

Make a plan for implementing the tool and its tests. Update @AGENTS.md and @README.md as needed, and then implement it.

The first argument (target) should be ssh target (e.g. user@host, user@host:relativepath, user@host:/absolutepath), or local directory (e.g. relativepath, /absolutepath).

Please also ensure that the file modification times match, as otherwise subsequent run will cause problems.

Questions and subsequent implementation in build mode

GLM-5

  • How to set the mtime
  • It brought up parallelism (nice)
  • R: traversal - recursive or not

(follow-up)

  • Should tool read ssh/config for host configuration?

( it hit hardish rate-limit, aborted mid-implementation - the plan looked reasonable, although bit slow to produce )

Trinity Large Preview

It did not use OpenCode prompt for questions.

  1. SSH Authentication: Should I use SSH keys (default), passwords, or both?
  2. Dry-run mode: Should I add a –dry-run flag to show what would be copied without actually copying?
  3. Verbose logging: Should I add a –verbose flag for detailed operation logging?
  4. Remote-only mode: Should I add a –remote-only flag to only check remote files without copying?

(2nd batch)

  1. SSH Authentication Preference: Should SSH agent be the default, or should we require explicit -i flag?
  2. Dry-run Verbosity: Should –dry-run show detailed file operations or just a summary?
  3. Confirmation Prompt: Should –confirm prompt for each file or just once per operation?
  4. Recursive Default: Should recursive be default for directories, or require -r flag?
  5. Error Handling: Should we continue on errors or stop immediately?

(3rd batch)

  1. SSH Agent Fallback: If SSH agent is unavailable and no -i flag is provided, should we:
    • Fail immediately with error message
    • Prompt user to set up SSH agent
    • Show helpful setup instructions
  2. Dry-run Output: Should –dry-run show:
    • Just file names (concise)
    • Detailed operations (verbose)
    • Both with different verbosity levels
  3. Error Recovery: For non-fatal errors (like permission denied on single file), should we:
    • Continue with other files
    • Stop immediately
    • Skip and continue with warning

.. I gave up. Too much micromanagement. I rather fix bad choices after review than answer too many questions.

Big Pickle

  • source path for files to be mirrored (pretty legit q)
  • SSH method (SCP, SFTP)
  • support magic paths?

▣ Build · big-pickle · 13m 52s

The result looks surprisingly good, but it misunderstood what I actually wanted. The examples contained only one pattern, so it supported only really 0-1 patterns, copying content from the current directory.

Minimax M2.5

  • Asked if same CLI arg usage should be retained
  • Should sync be uni- or bidirectional
  • Should remote target also set mtime ▣ Build · minimax-m2.5-free · 10m 52s

The resulting implementation looked bit scary - it was mostly running shell commands on the remote host, and I’m pretty sure the arguments it gave do not work universally, and e.g. Go %q (Go quoted string) was used for handling filenames, which may or may not what shells use for quoting.

Prompting to fix (GLM-5 plan, MiniMax M2.5 implementation):

  • Use golang.org/x/crypto/ssh/agent by default if available, and fall back to known key files only if it is not.
  • Use sftp for remote access instead of shell commands; fall back to shell commands if sftp is not available

.. then I got roughly what I wanted, but eventually on subsequent iteration hit ‘free usage exceeded’, so building this took over an hour.

Conclusion

I’m not sure if this is (substantially) worse than Claude Code (at least with the cheaper models); the code looks reasonable, and the model hit its head against linter+test wall until the code looked mostly reasonable and it did not take that long either.

Today the best choice, based on this experiment, is to use GLM-5 for planning and Minimax M2.5 for coding. Who knows what is the best tomorrow, or for what you are doing?