Real Python (a long-running Python tutorial publisher) added a ten-lesson video course on OpenCode on August 11, 2026. OpenCode (an open-source AI coding agent that runs in your terminal and answers conversational prompts) is the kind of tool that lands awkwardly in a course catalog: it is small, it is single-purpose, and it is opinionated about the user interface. A video walk-through is overkill for the install steps and underkill for the question of whether the assistant is actually any good. The course handles the first half well and is honest about the second.
What the course actually covers
The course is ten lessons, thirty-five minutes of video, broken into eight core lessons plus a quiz and a summary. The pacing is brisk. Per the listing, lesson one is a two-and-a-half minute overview, lesson two is four-and-a-half minutes on setting up a project, lesson three is three minutes on installing OpenCode, and lesson four is three minutes on connecting to an AI provider. The middle lessons are heavier: lesson six on planning a refactor is four minutes, and lesson seven on implementing the plan is five minutes. The summary is one minute.
The author, Rodrigo Girão Serrão, is a Real Python contributor, and the course uses the same hands-on style the rest of the site does. You download the sample code as a zip, follow along with the video, and end with a quiz that checks whether you actually understood the difference between a planned refactor and a freeform conversation with the assistant.
What OpenCode is and is not
OpenCode is not an IDE plugin. It is a CLI binary that you run in a project directory. You point it at your project, type a question in plain English, and it returns an answer with full awareness of the project context. The conversational model is the same as the one Cursor (a paid AI-native IDE) and Claude Code (a similar CLI from Anthropic) use, but OpenCode is open source and works with whichever provider you want to pay for.
The course installs OpenCode using a free Google Gemini API key. That is the cheapest path for someone evaluating the tool without a paid account. If you already have an Anthropic or OpenAI account, OpenCode supports both, and the course’s lesson on connecting to an AI provider walks through the configuration file. Per the listing, OpenCode supports more than seventy-five providers, including the three big names, and the configuration is a single file in your project root.
That file is AGENTS.md, and it is the part of OpenCode that has no real equivalent in the IDE-plugin world. AGENTS.md is a markdown file you write by hand that describes how the assistant should behave in your project. The kinds of things you put in it:
- Code conventions. Whether the project uses single or double quotes, whether type hints are required, how tests are structured.
- What to refuse. Refactors that change the public API without a discussion, dependency upgrades that break the lockfile, anything that touches the migrations directory.
- What to prefer. The internal helper for date parsing over the standard library, the project’s logging module over
print, the existing test pattern over a new one. - What good output looks like. A pull request description format, a commit message style, a changelog entry template.
Per the course, this is where most of the long-term value lives, because a well-written AGENTS.md makes the assistant useful across sessions rather than just within one. Without it, every conversation starts from scratch. With it, the assistant remembers the project’s rules without being told.
What you actually learn
The course is structured around a single refactor: take an existing Python project, plan the refactor with the assistant, then implement it. Lesson six walks through the planning step (asking the assistant to identify what to refactor and why), and lesson seven walks through the implementation step (asking it to make the changes and reviewing the diff). The two lessons together are about nine minutes, which is short for what they are doing, but the pacing is honest: the instructor is not pretending that a one-line summary captures the planning.
The quiz at the end is the part most courses skip and the part Real Python keeps. It is six minutes long, which is unusually long for a video quiz, and it asks specific questions about the difference between planning and implementing, about how AGENTS.md affects the assistant’s behavior, and about the trade-offs of running a coding agent in the terminal versus an IDE. If you only do the lessons and skip the quiz, you have missed the part the instructor clearly cared about.
What it does not cover
The course does not teach you Python. The audience is developers who already know the language and want to know whether OpenCode is a useful addition to their workflow. If you are new to Python, the video will move too fast and the quiz will be opaque.
The course also does not cover the multi-agent features OpenCode supports. Per the course listing, OpenCode can spawn sub-agents for parallel work, but the ten lessons stay on the single-agent conversational path. If you are evaluating OpenCode for its multi-agent capabilities, you will need to read the project documentation separately.
Finally, the course does not compare OpenCode to Cursor or Claude Code head-to-head. The instructor acknowledges these tools exist but does not run them through the same refactor. The eight minutes of lesson time on planning and implementing is OpenCode-specific. If you want a comparison, you will have to do it yourself.
Trade-offs
The trade-off the course makes is depth versus breadth. Ten lessons is enough to install OpenCode, write an AGENTS.md, plan a refactor, and implement it. It is not enough to learn when OpenCode is the wrong tool. The course is honest about this: the closing summary lists the cases where a terminal-based agent is the wrong fit (large multi-repo refactors, code review, anything that needs a graphical diff viewer) but does not demonstrate them. You get the answer, not the proof.
Pace is the second cost. The lessons are short, which is good for attention span, but the refactor example is compressed. The instructor fits a real planning conversation into four minutes, which means the natural pauses (where you would stop and read the code, or check the project’s tests) are edited out. You will probably want to pause and replay each lesson once to get the same value out of it that the video implies.
Tool lock-in is the third cost. OpenCode is open source, but the value of the assistant depends on which AI provider you connect it to. If you choose the free Gemini tier, the assistant’s capabilities are bounded by what that tier offers. If you switch to Anthropic’s paid tier for the same project, the answers will look different. The course installs with Gemini because the API key is free, which is the right call for an introductory course, but it leaves the reader to do the provider-comparison work themselves.
Bottom line
The Real Python OpenCode course is a clean thirty-five-minute introduction to a tool that is genuinely worth knowing about, taught at the pace the rest of Real Python uses. If you have been curious about terminal-based AI coding agents but have not wanted to read the project README on your own, the course will save you the hour. If you already use Cursor or Claude Code and are looking for an open-source alternative, the course will not tell you whether OpenCode is the right switch, but it will give you enough context to make that call yourself.
If you only do one thing from this article, install OpenCode with the free Gemini key, write a three-line AGENTS.md for one of your real projects, and ask the assistant to plan a refactor. The plan is the part the course spends real time on, and it is the part you cannot get from the README.