OpenCode Engineer James Long Shares his AI Workflows

Summary

OpenCode engineer James Long describes how improving AI models have changed his software-development workflow. Rather than treating agents as simple code generators, he uses them to explore ideas, build tools, coordinate parallel work, and evaluate results through visual feedback.

OpenCode architecture and workflows

• Server-first design: OpenCode sessions run in a separate server process from the TUI or desktop client. Sessions can keep running after a client closes, and multiple clients—including a terminal interface, GUI, or mobile app—can connect to the same server. Long also runs sessions on remote virtual machines to avoid overloading his local machine.
• Remote sessions and synchronization: Remote-session support was an early experiment and is still being reconsidered. Long mentions SQLite synchronization as part of the related work.
• SDK and custom integrations: Long uses OpenCode’s SDK for a personal iMessage bot. A separate, persistent Mac acts as the iMessage bridge; messages are queued and passed into OpenCode sessions. He says the SDK handles complicated session behavior such as compaction and model switching. It can also support custom servers that remain compatible with OpenCode clients. Long identifies Ramp as a user of this approach, while warning that custom implementations can introduce pitfalls involving tokens, caching, and other internal behaviors.

Multi-agent development

Long’s preferred pattern is to work out a plan and then divide implementation among several subagents. He commonly limits how many agents run at once and avoids deeply nested agents, which can lead to poorly coordinated work, unpredictable results, and runaway costs.

He describes a team workflow in which colleagues send requirements to a shared Slack-style session, a practice he calls “gang prompting.” Agents can implement changes in subagents, deploy them, record videos of the results, and post those videos for the team to review. Long sees visual collaboration—reviewing and annotating an application together—as a promising alternative to everyone sending prompts into one session.

Parallel agents can generate large amounts of work quickly, but also increase compute, CI, and infrastructure demands. Long prefers a straightforward, larger VM for many tasks rather than adding a complex sandboxing system for every session. He also discusses a more advanced setup using Durable Objects and persisted (“freeze-dried”) agent context to distribute parallel work, but considers it complex and not a default recommendation.

Canvas, testing, and visual feedback

Long demonstrates a custom infinite canvas that represents OpenCode sessions as movable blocks. Agents can use the blocks’ positions and annotations as context, while the canvas collects images, screenshots, videos, and session outputs. It connects through the browser to a local OpenCode server, with explicit CORS permission and a server password.

OpenCode Drive provides a mock backend for testing the OpenCode interface. It can script application states, interact with the front end, and record videos. Long describes it as a way for agents to inspect and iterate on the UI through screenshots and recordings.

His broader principle is to give agents a feedback loop: make a change, capture the result, inspect it—either personally or with another agent—and revise until it meets a defined standard.

Creative tools and product design

Long shows a workflow for generating multiple design alternatives, comparing them on a contact sheet, and refining the promising options. He also uses adjustable parameters and controls so a person can make the final visual choices rather than accepting a single AI-generated result.

Other examples include:

• An experimental audio interface that can record audio, display notes and waveforms, and support AI-generated material that can be adjusted and mixed.
• Analyzing espresso-making footage to graph extraction flow over time.
• Combining webcam and audio input to explore a Eurorack synthesizer setup.

OpenCode’s low-verbosity TUI mode hides tool calls and terminal output, letting users focus on results once they have confidence in the model and suitable verification checks.

Analysis and cautions

Long argues that AI makes personal software and prototypes much quicker to build, but turning them into secure, reliable products for large numbers of users remains difficult. He supports moving quickly where problems are reversible while retaining strong engineering standards for security and critical infrastructure.

He also emphasizes that technical knowledge still matters: understanding concepts and having the right vocabulary can help guide agents toward better solutions. At the same time, agents can help users learn those concepts.

Adoption is uneven. Some companies struggle to get developers to use even modest AI budgets, while Long’s own Opus usage would amount to about $1,800 per day at retail pricing.

Demonstrations and practical guides

The interview and workflow demonstration covers:

• Using the OpenCode SDK to route messages from an iMessage bot into sessions.
• Running persistent sessions through a server and connecting different clients.
• Planning work, delegating implementation to subagents, and reviewing recorded results.
• Using an infinite canvas to organize sessions and annotate visual output.
• Automating UI testing with OpenCode Drive and video capture.
• Generating design variants and refining them with human-controlled parameters.
• Building experimental audio and other creative tools.

This is an interview and workflow demonstration, rather than a formal product review.

Main speakers/source: James Long (OpenCode engineer) and Joel Hooks (host).