My Opencode Workflow As A Senior Engineer

Overview / thesis of the video

• The speaker argues that, despite predictions that AI will soon write most software code, they personally do not allow AI to write their code directly (beyond small, controllable pieces).
• Instead, they describe using Open Code as an orchestrator for a structured “agent team” approach:
  • Plan first
  • Build in constrained ways
  • Use supporting agents (e.g., code review, QA/test, security) to reduce errors and improve traceability.
• They claim Open Code has matured significantly since an earlier “basics” video, citing major upgrades such as:
  • sub-agent control
  • skills
  • GitHub integration
  • image input
  • GUI/Web options

Key product features and capabilities (Open Code)

Multi-environment interface

• Open Code works beyond terminal-only:
  • GUI
  • Web
  • IDE integration
  • Terminal / TUI

Agent architecture

• Primary agents
  • plan and build
  • plan is described as read-only / non-executing (permissions restricted).
  • build handles implementation/execution.
• Sub-agents
  • Specialized background agents invoked via @ (or via prompt instructions).
  • Example: a code reviewer focused on security and performance that “cannot write,” but returns review output.

Session management

• Sessions store:
  • full history
  • context
  • the active model
• A recent change moved session storage from JSON to a SQLite DB, improving speed (snappier filtering/search).
• A CLI-style session lookup is referenced via /sessions.

Configuration

• Uses Open Code JSON configuration.
• Supports:
  • project-specific settings
  • global settings
  • overrides via environment variables

Model support

• Can integrate with any model; the speaker demonstrates:
  • Claude via Zen (and other models)
  • Big Pickle (described as Open Code’s free option at the time, with training on user data mentioned)
  • MiniMax (described as a “Claude-derived” Chinese LLM)
• Zen is described as an Open Code router that provides access to tested/verified models after adding a credit card once.
• Open Code charges only credit-card fees at cost.

Skills system

• skills let agents locate and install tools/behaviors autonomously.
• Skills are described as:
  • on-demand prompt injections (not permanently loaded into every context window)
  • able to include code/scripts and references to specific tooling (e.g., GitHub Actions, Kubernetes)
• There’s an installation path and a large community pool of skills, with warnings about junk.

Agent creation tool

• Open Code Agent Create offers a wizard to generate an agent definition:
  • sets role/purpose
  • interactively configures permissions
  • outputs a standalone instruction file with guidelines, examples, edge cases, and output preferences
• Caution noted by the speaker:
  • it’s essentially prompting + permission constraints
  • agents can still potentially break constraints without strong safeguards

Security improvement: just-in-time tokens

• Concern highlighted: agents often get permanent API keys via environment variables/config files.
• They integrate Disco to issue short-lived JIT tokens:
  1. agent requests access
  2. Disco verifies identity
  3. token expires after minutes (reduces “forever key” risk)
• Recommendation: grant sensitive capabilities to the security-focused sub-agent with Disco rather than distributing permanent credentials.

Guides / workflows described (how the speaker uses Open Code)

Local coding workflow via keybindings

• Uses Neovim workflow:
  • a leader key binding opens an Open Code prompt in Neovim
  • the speaker edits with “human dignity” before returning saved text to the agent

Building an autonomous “engineering team”

• For larger feature work, they describe a setup with:
  • a team lead/orchestrator agent that delegates tasks
  • a product manager (read/explore/user-story understanding)
  • a backend dev
  • a tester/QA
  • a code reviewer
• Emphasis:
  • structured request flow helps for large tasks
  • performance is “95% okay” over a couple weeks, but not perfect
  • they continuously refine each sub-agent’s instructions/context (markdown files) to match preferences

Pros/cons of sub-agent teams

• Pros
  • better performance “per component”
  • clearer separation of concerns
  • improved tracking of what each agent did
• Cons
  • more tokens/instructions
  • harder to skim outputs
  • sometimes unnecessary complexity for smaller tasks

Other runtime modes / integrations

Open Code in Neovim

• Mentioned as a popular plugin, though the speaker says they no longer find it comfortable.

Web interface + remote access

• Runs locally and can be exposed via ngrok.
• Supports browsing prior sessions and continuing work from a remote device (they mention an iPad setup).

GitHub integration

• Uses commands like open code GitHub install to add a GitHub action.
• Trigger via /oc or /opencode in comments.
• Bot behavior:
  • provides an emoji indicator
  • then returns:
    • review thoughts/issues
    • optionally a link / session dive

Native GUI app (beta)

• “Fully native” app with OS notifications and sounds.
• Includes an integrated terminal-like interface.

Image input

• Accepts images by dragging into the terminal.
• Can interpret images as:
  • requirements/themes/visual styles
  • enabling “visual” agent tasks

Project/company / ecosystem background (relevant analysis)

Origins and “drama”

• Open Code started as TermAI, a terminal agent built by one developer.
• Mentions community/dev contributions and a naming/ownership conflict:
  • a company CEO responded
  • the project was renamed/positioned
  • references “Crush” as an agent/company competitor or variant tied to commits

Corporate umbrella

• Open Code is described as moving from a side project under SST to being under an umbrella called Anomaly, supported by Y Combinator and investors (including a PayPal founder mentioned).
• The speaker suggests this brings VC money but potentially less direct control (balanced view).

Main speakers / sources (as referenced)

• Dario — Anthropic’s boss (quoted prediction about AI writing most code)
• The speaker / narrator — senior engineer describing their personal workflow with Open Code (main voice; no name provided in subtitles)
• Dax and Adam — early contributors tied to Open Code’s origin/drama
• Charm CEO — involved in the naming/ownership conflict (no name provided)