AI curriculum

Course outline for OpenCode and Open Agentic Coding Tools

A reusable coding skill may work only because the current session contains hidden context, while parallel workers can produce conflicting changes. Examine a version-labeled OpenCode workflow and test a small scripted skill in a fresh session. Define isolated worker ownership, review capacity, and a merge decision based on artifacts rather than model agreement.

Technology: AI-Assisted Software Engineering
Duration: 4 hours
Modules: 2 · 2 hours each
Level: Level 3

About OpenCode and Open Agentic Coding Tools

OpenCode and Open Agentic Coding Tools Course Objectives

Separate coding-tool, provider, model, and deterministic skill responsibilities.
Inspect session state and identify information lost during compaction.
Specify an MCP integration with explicit capability and permission boundaries.
Compare local and remote response fixtures against the same skill contract.
Assign worker ownership and a bounded independent-review queue.
Verify a skill in a fresh session and justify acceptance or rejection of its patch.

Pre-requisites

AI-Assisted Software Development or equivalent scoped repository, review, and test competence.
Programming, Git, and command-line experience.
Familiarity with model-assisted coding; harness knowledge is helpful but not required.

Before this course

Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.

Required preparation

AI-Assisted Software Development

Recommended preparation

Harness Engineering

Can manage scoped repository work, tests, and Git; harness knowledge helps with sessions and integrations. This is a provisional alternative specialization.

Find your place in the learning map

Lab Setup

Computer with Git, a familiar programming runtime, test runner, and a disposable repository.
Verified-version OpenCode setup or version-labeled session/configuration fixtures, mock MCP exchanges, and supplied local/remote response sets.
Two isolated local artifact directories support simulated workers; model downloads and remote accounts are optional, and no automated shared-branch merge is required.

Detailed Course Outline

Module 1: Define a reproducible coding skill (2 hours)

OpenCode architecture: Coding tool, model provider, model, and deterministic script boundaries; identify which layer supplies instructions, executes tools, and checks results.
Sessions: Version-labeled session state, compaction, and artifact handoffs; identify information lost from conversation context and preserved in explicit records.
Skills and tools: Discoverable instructions, calculation scripts, typed inputs, and result contracts; distinguish reusable procedures from capabilities that perform effects.
Model selection: Same-task response fixtures, acceptance criteria, and resource usage; compare model suitability without assuming interchangeable tool support or output quality.

Practical outcome: Inspect version-labeled configuration and session traces, separate stack responsibilities, and extend a supplied deterministic calculation script with an explicit skill contract; compare model response fixtures on the same task.

Module 2: Verify isolated execution and review (2 hours)

MCP integration: Direct API versus protocol-mediated capability access in supplied traces; inspect schemas, execution ownership, and permissions without claiming live compatibility.
Multi-agent workflows: Isolated worker contexts, artifact ownership, and merge responsibility; reject overlapping changes and require independent verification before accepting delegated work.
Local models: Local versus remote response fixtures under the same skill contract; compare accepted results, resource constraints, and documented configuration assumptions.
Ownership and review budgets: Assigned files, approval responsibility, and finite review capacity; bound queued work and account for review time alongside supplied token usage.
Fresh-session verification: Explicit skill inputs, deterministic fixtures, and independent artifacts; verify correct results without hidden history and distinguish trace validation from actual isolation.

Practical outcome: Inspect supplied API/MCP and isolated-worker traces, compare a local-model fixture, and verify the skill from explicit artifacts in a fresh session or trace validator; reject overlap and respect reviewer capacity before a merge decision.

Practical exercise

Produce a reusable synthetic calculation/report skill by extending a supplied script, plus a two-session trace and independent review record.
Accept a contract-compliant result in a fresh session or fixture-based validator; reject invalid inputs, an overlapping worker edit, and a merge request without assigned approval.
Run at least six script fixtures and account for accepted results, tokens or supplied usage, review time, and review-queue limits across two sessions.
Record configuration/version assumptions and explain when a local model or a simple script is preferable to delegated coding.

What you will produce

Verify a scripted coding skill across fresh sessions and make a bounded, ownership-safe review decision for delegated changes.

How the work is checked

The skill has an explicit contract and deterministic checks independent of chat history.
Fresh-session fixtures pass and invalid inputs are rejected.
Worker ownership, overlap rejection, and merge approval are explicit.
The model comparison includes task acceptance and review effort rather than token usage alone.

Four-hour provisional specialization preserving the original two-module duration. The hands-on core is one scaffolded deterministic skill and its fresh-session check; MCP, model alternatives, and worker coordination use guided comparisons, not three extra implementation projects. Exercises fit within module time. The fixture route verifies explicit inputs and outputs, not actual session isolation or live product operation; current configuration needs instructor verification.

When another approach is better

Use one worker or a script when parallel work creates more merge and review effort than useful independence.
Do not select a local model solely for lower token cost when task quality, memory limits, or review effort make it unsuitable.

How we train

Ask about exercises, instructor feedback and the prior knowledge you need. Tool-specific courses marked provisional may become modules in a broader course.

Discuss your learning goals