OpenCode and VS Code AI Coding Workflow: Model Costs, Permissions and Manual Review

The workflow in brief​

Shah says he tried several AI coding tools over recent months, including Cursor, Claude Code, Codex, Devin Desktop and Google Antigravity. The constant switching became a productivity drain of its own. His impressions are subjective, not controlled comparisons.

His fix is to split the job in two:

• Stage one: he launches the OpenCode desktop app, picks a model and describes the project. He says his aim is to finish roughly 85% of a project there. That figure is his own working target. It isn't a benchmark.
• Stage two: he opens the same project folder in VS Code for spacing, typography, debugging and final refinements. He says he needs no further AI prompts for this.

His test case was a fictional premium product page for high-end wireless headphones. He says he chose DeepSeek in OpenCode and wrote a detailed prompt. It covered premium typography, product visuals and smooth animations. After a few iterations he had a page close to his vision. The article doesn't name the exact DeepSeek model, the framework or the app versions. It reports no measured results. Treat it as one developer's anecdote about a made-up project, not a client deliverable or a tested result.

Why model flexibility is the real hook​

Shah's main argument is cost control. He says he doesn't need a flagship model to build a settings page, reusable UI components or documentation. He hands those jobs to cheaper or free models. He switches to a premium model for tricky business logic, architectural changes or stubborn bugs.

OpenCode's documentation supports the model-choice part. OpenCode's model docs say it uses the AI SDK and Models.dev to support more than 75 LLM providers, and that it can run local models. That claim comes from OpenCode's own documentation. You connect a provider's credentials with /connect, then pick a model with /models.

Be careful with the word "free." OpenCode being open source doesn't make every model free. OpenCode's own docs describe an optional paid subscription, called OpenCode Go, for models its team has tested. They also describe signing in with a ChatGPT Plus or Pro plan, where usage counts against that plan. Whether a given model is free, rate-limited or paid depends on the provider. Shah doesn't say which provider route he used for DeepSeek, so don't assume it cost nothing.

The extension he skips​

Shah says he deliberately avoids OpenCode's VS Code extension. He prefers OpenCode as a separate workspace with no distractions. That is a personal preference, not a limitation of the extension.

OpenCode's IDE documentation says it integrates with VS Code, Cursor or any IDE that supports a terminal, and that you run opencode in the terminal to start. According to the same docs, the integration:

• opens OpenCode in a split terminal with Ctrl+Esc on Windows and Linux;
• starts a new session with Ctrl+Shift+Esc;
• shares your current selection or tab as context;
• inserts file references such as @File#L37-42.

To install it, open the Extensions view, search for OpenCode and click Install. If it misbehaves, the docs say to run opencode in the integrated terminal and confirm the extension is installed and enabled. They also say to restart the terminal.

The trade-off is simple:

Neither is objectively better. If you work in short loops, the integration will probably suit you. If you like long, focused generation sessions followed by hands-on review, Shah's split is reasonable.

The safety point the article skips​

The handoff works because both apps point at the same project folder. That is convenient, but it needs care. OpenCode is an agent, not a chat window. Its tools documentation says it can edit files, write new ones and overwrite existing ones. It can also run shell commands such as npm install and git status. The docs also say that by default all tools are enabled and don't need permission to run.

OpenCode's permissions documentation covers how to tighten that. Each rule resolves to allow, ask or deny. The docs say most permissions default to allow, and .env file reads require approval by default. Actions outside the working directory also prompt by default. A cautious v1-style setup looks like this:

{
  "$schema": "[url]https://opencode.ai/config.json[/url]",
  "permission": {
    "*": "ask",
    "edit": "ask",
    "bash": {
      "*": "ask",
      "git status*": "allow"
    }
  }
}

OpenCode now has more than one major version, and the syntax differs between them. The v1 permissions docs and the newer v2 docs don't match. Check which version you installed before copying configuration from a guide. The install docs also warn that the v1 install script's opencode binary can conflict with or replace an OpenCode 2 installation.

A sensible way to try it​

This sequence combines Shah's account with documented features. It is not a procedure he demonstrates step by step.

1. Put the project in a Git repository and commit a clean starting point.
2. Open the folder in OpenCode and run /init. OpenCode's intro docs say this analyzes the project and creates an AGENTS.md file.
3. Use Plan mode first. The docs say it disables changes and proposes an approach. Press Tab to switch back to Build mode when you're happy.
4. Pick a model with /models. Use a cheaper one for routine work, and a stronger one when the problem gets hard.
5. If a change goes wrong, the docs describe /undo and /redo for reverting and restoring it.
6. Open the same folder in VS Code. Review the full diff, run your tests and linters, and then do the manual polish.

Verdict​

Shah's piece is a candid workflow report. It isn't a benchmark or a review. His claims about speed, the 85% figure and free-model quality are his own experience, and the article shows no data for them. The documented facts are narrower but more useful:

• OpenCode is provider-agnostic.
• Provider terms and prices vary.
• The VS Code integration exists if you want it.
• The agent can change your files and run commands unless you tell it to ask first.

The sound takeaway isn't that two windows beat one. Keep control of three things: which model you use, what the agent may touch, and what you review before shipping. Shah's split is one way to do that. The extension plus a strict permission policy is another.