A look back across the week

A week ago feedmill was a thing you’d inherited and didn’t fully trust: dozens of differently-shaped feeds stitched into one queue, a parser package full of someone else’s assumptions, a sync server you weren’t sure you could leave running. It’s not that anymore. The timestamp bug is fixed and committed, the parsers have tests pinning the cases that used to break, the rules that kept biting you are written down, and the nightly check runs without you watching. That’s the visible result. The part worth looking back at on the last day is how you got there — because you didn’t just use a terminal agent. You used OpenCode specifically, in three ways that no closed tool would have let you, and those three are the spine of everything you’ll keep doing.

The model was always yours to choose

The first thing OpenCode asked that Claude Code and Codex never did was which provider’s model runs the loop — and that question turned out to be a tool, not a tax. You connected a key you already had and you were agentic from the first keystroke, but the leverage showed up later, once the work got uneven. Parsing one feed’s gnarly Atom edge cases is a different job from drafting feedmill’s README, and you stopped pretending one model was right for both. A cheap model for the throwaway question:

$ opencode run -m anthropic/claude-haiku-4-5 "what does the dedupe step key on?"

A heavier one, set per-agent, for the parser refactor that actually had to land. The provider/model string is the whole mechanism — anthropic/claude-sonnet-4-5, openai/gpt-5.2, ollama/llama3.1 — and the slash is what lets OpenCode hold several providers at once and never guess which you meant. By Friday “pick the model that fits this task” had stopped being a decision you made and become a reflex, the way you’d reach for a different wrench. The closed tools made that choice for you on install. OpenCode handed it back, and on a repo this varied, that mattered.

The TUI made the keyboard the fast path

The second differentiator you stopped noticing because it became muscle memory. OpenCode’s TUI is built to be driven from the keyboard, and the week trained your hands on it: ctrl+p to find any command when you didn’t know its name, the ctrl+x leader for the chords you ran constantly, Tab to swap the primary agent, /undo to reach back over a bad exchange before reaching for git.

  ctrl+p           →  find any command, learn its chord
  ctrl+x  then l   →  jump to the session where you were stuck
  Tab              →  swap the agent driving this turn
  /undo            →  revert the last bad exchange

The point was never keyboard-purism. It was that feedmill work is constant context-switching — jump to the JSON-parser session, swap a cheaper model onto a throwaway, flip a theme when you move from desk to couch — and a TUI that makes each of those a chord instead of a hunt is the difference between fighting the tool and forgetting it’s there. You bent the keymap to your hands in tui.json once, early, and then stopped thinking about it.

The architecture was open, so you could open it up

The third thing is the one that genuinely has no equivalent in the closed tools, and it’s a single fact wearing two hats: OpenCode is a client/server engine, not a sealed app — one engine drives both the TUI and headless runs, opencode serve exposes it, and opencode run --attach connects back to it. You felt that fact twice.

Once as a share link. Stuck for forty minutes on one source’s almost-parsing Atom export, you didn’t paste a wall of terminal output into a chat and hope a colleague could follow it — you ran /share and handed over the whole session as a URL at opncd.ai/s/<id>: prompts, reasoning, diffs, dead ends, all readable with no OpenCode install on the other end. No closed agent gives you that. And because it’s a real capability with a real blast radius, you also learned to govern it — manual mode by default, so a feedmill session full of internal feed URLs never lands on the open web by accident.

Once as headless. The same engine behind the TUI ran with no TUI at all — opencode run for a one-shot fix, --format json when a script needed to consume the run as a stream of JSON events, opencode serve to stand the engine up as something automation points at. That’s why feedmill, already built to run unattended on a cron, ended the week with an agent that runs unattended too: a nightly check, a CI gate against its own server. The share link and the headless run were never two features. They were one open architecture seen from two sides — opened up for a human to read, or handed to a machine to execute.

What carries past this repo

Here’s the part that makes the week worth more than one fixed repo. Almost none of what you set up is locked to OpenCode. The rules you wrote live in AGENTS.md — the same file Codex reads, committed to feedmill’s git root, so the next person (or the next tool) inherits your hard-won context instead of relearning it. The skills you packaged are portable procedures, not OpenCode-flavored macros. The permission posture, the agents-as-policy split, the headless invocation — those are primitives, and primitives travel. The same handful that tamed one inherited repo this week is exactly what scales to a team workflow: agents to isolate work, permissions to bound it, AGENTS.md to encode the shared rules, a headless run to put it in CI. You didn’t learn a tool. You learned a setup that mostly comes with you.

One honest caveat before you go further

OpenCode drifts fast — it’s young and shipping hard. Some of what you ran this week will have moved by the time you reach for it again: a config key renamed, a TUI command or keybind relabeled, a flag that grew or lost an option. That’s not a reason to distrust it; it’s a reason to keep one habit. When something doesn’t behave the way this course described, check the current docs at opencode.ai/docs before assuming you’re holding it wrong — the concepts here are stable, but the exact names underneath them are not. Treat the in-house fact sheets and this course as a strong starting point, and the live docs as the tiebreaker.

Where to point it next

The arc is complete: a model you chose, a TUI you drive blind, an open engine you can share and automate, and a setup that travels. The natural next move isn’t a new feature — it’s compounding the one habit that pays every day. You’ve fixed the same kind of feedmill chore by hand more than once this week; the next lesson turns those repeated keystrokes into commands you invoke instead of retype. Next: codify your repeated chores.