OpenCode + GSD: The Free AI Coding Workflow to Build Real Projects 10X Better

So, if you have used any AI coding agent

for more than 15 minutes on a real

project, you already know the pain. The

agent starts strong. The first few

responses are clean, the code makes

sense, and then somewhere around turn 10

or 12, things fall apart. It forgets

what it already built. It starts

duplicating logic. It changes files it

should not touch. And before you know

it, you are spending more time fixing

the agent's mistakes than actually

building your feature. GSD, or Get

Done, is an open-source workflow system

that fixes this problem. It currently

sits at over 48,000 stars on GitHub, and

it is growing fast. So, what GSD

actually does is it sits on top of your

existing coding agent. It is not a new

IDE, it is not a new model. It is a

context engineering layer. You install

it, and it gives your agent a structured

process to follow, instead of just

dumping everything into one giant prompt

and hoping for the best. And the tool

now supports a bunch of different

runtimes: Claude Code, Codex, Gemini

CLI, Copilot, Cursor, WinSurf,

Anti-Gravity, and OpenCode, which is the

one we are focusing on today. Okay, so

OpenCode is an open-source AI coding

agent built primarily for the terminal.

It is written in Go, which means it

starts up fast and runs efficiently. You

can use it as a terminal TUI, a desktop

app, or an IDE extension. The main thing

that separates OpenCode from tools like

Cursor or Copilot is that it is

completely model agnostic. It supports

over 75 different LLM providers. So, you

can use Claude, GPT, Gemini, DeepSeek,

Mistral, local models through Ollama,

basically whatever you want. You can

even log in with your GitHub Copilot

account or your ChatGPT Plus

subscription and use those models

directly. And it is free. You only pay

for the API calls to whichever provider

you choose. OpenCode has some nice

built-in features. Plan mode, where the

agent analyzes code without modifying

anything. Build mode, where it writes

code and makes real changes. You switch

between them with the tab key. It

supports multi-session workflows, so you

can run multiple agents in parallel. And

it has LSP integration, so the model

gets better context about your code. But

even with all that, OpenCode still

suffers from the same context rot

problem every other agent has. The

longer the session, the worse the

output. And that is where GSD comes in.

Before I continue, let me tell you about

KeysOff. So, if you are setting up a new

PC, or maybe reinstalling your system,

you probably need a Windows key or an

Office license. And paying full retail

price for those is honestly just

throwing money away at this point.

KeysOff sells genuine OEM software keys

for different softwares, including

Windows and Microsoft Office, at way

lower prices. Everything activates

online. It is 100% legit, and they have

24/7 customer support if anything goes

wrong. You can see they have Windows 11

Pro, Office 2021 Pro, Office 2021 and

2024 bundles that include both Windows

and Office together. I have two

exclusive coupon codes for you. The

first one is AI50, that gets you 50% off

any Windows product. The second one is

AI62, that gets you 62% off on Office

and bundle deals. So, for example,

Windows 11 Pro drops to around $14.35

after the coupon. Office 2021 Pro Plus

comes down to about $34.37.

And if you grab the bundle with Windows

11 Pro Plus Office 2021 Pro together,

that is around $45 total. That is both

for less than what most people pay for

just Windows alone. You can pay with

PayPal or credit card, whatever works

for you. Takes about 30 seconds, and you

get your key right away by email. Link

is in the description below. All right,

back to the video. GSD adds a rigid,

repeatable structure on top of OpenCode.

It breaks your project into small

phases, and each phase gets its own

discuss, plan, execute, verify cycle.

Every task runs in a fresh context

window with clean state. So, the model

never has to hold your entire project

conversation in memory while also trying

to implement task 12 out of 20. The

context stays fresh. The quality stays

consistent. All right, so to install GSD

for OpenCode, run this NPX command in

your terminal. The installer will ask

you two things. First, which runtime you

want. You pick OpenCode from the list.

And second, whether you want a global

install or a local install. Global means

it applies to all your projects, and for

OpenCode, that installs to your home

directory under .config/opencod.

Local means just the current folder.

Once it is done, you can verify the

installation by typing /gsd-help

inside OpenCode, and it should show you

all available commands. If you want to

do it non-interactively, say for a

script or Docker setup, you can run NPX

command, and it will skip all the

prompts. GSD also works with Claude

Code, Gemini CLI, Codex, Copilot,

Cursor, WinSurf, and Anti-Gravity. So,

if you switch between tools, you can

install GSD for multiple runtimes in a

single session. Now, let me run the two

commands that are the foundation of any

GSD project. The /gsd-map-codebase

command. If you already have an existing

project with code in it, this is always

where you should start. What it does is

it spawns multiple agents in parallel to

analyze your entire codebase. It looks

at your architecture, your tech stack,

your naming conventions, and your folder

structure. The output becomes a

reference that GSD loads into every

future step. So, when you later ask GSD

to plan a new feature, it already knows

how your project is organized. This

prevents that really common problem

where the AI agent starts writing code

that clashes with what already exists.

When you run this command, it takes a

little bit because it is running

parallel analysis agents. When it

finishes, it stores the analysis files

in a .planning folder. And from now on,

every GSD command has context about how

this project works.

And the /gsd-new-project

command. This is how you kick off a

brand new project or a new milestone for

an existing one. When you run it, GSD

starts asking you questions about what

you want to build: goals, constraints,

tech preferences, edge cases. It keeps

asking until it has a complete picture.

Then it optionally spawns research

agents to investigate the domain. After

that, it separates your requirements

into version one, version two, and out

of scope. And finally, it generates a

roadmap with phases mapped to those

requirements. The files it creates are

project, requirements, roadmap, and

state.md.

These are all stored in the .planning

folder. And this is your project memory.

Every step from here reads from these

files, so the agent always has the right

context loaded. After new project, the

next step for each phase is

/gsd-discuss-phase.

You pass it the phase number. So, for

phase one, it would be

/gsd-discuss-phase-one.

This step is about surfacing all the

gray areas before any planning or coding

happens. If you are building a user

interface, it asks about layout,

spacing, interactions, empty states. The

output goes into a context.md

file that feeds directly into planning

and research. Next, you run

/gsd-plan-phase.

Again, with the phase number. This is

where GSD does domain research, creates

small atomic task plans, and then

verifies those plans against your

requirements. The plans are formatted in

XML, and they are deliberately small,

small enough to fit inside a fresh

context window. And that is the entire