AI curriculum
Course outline for OpenCode and Open Agentic Coding Tools
Use and customize OpenCode for repository engineering. Configure models, instructions, commands, skills, tools, and MCP integrations. Manage context, permissions, and delegated work, then automate a repeatable task. Inspect the client/server boundary through CLI queries and extend a small local plugin. Apply the same engineering concepts as C13 and C14 through OpenCode-specific steps.
OpenCode and Open Agentic Coding Tools Course Objectives
- Configure a scoped session and complete a checked repository change.
- Use session commands, project instructions, skills, and explicit context records.
- Connect an MCP tool and customize behavior through configuration and a plugin.
- Delegate independent work and execute a bounded adaptive workflow.
- Query OpenCode through its CLI and explain client/server responsibilities.
- Automate and diagnose tasks using independent correctness and permission checks.
Pre-requisites
- AI-Assisted Software Development or equivalent AI-assisted development, independent testing, and review competence.
- Programming, Git, terminal use, and repository build/test commands.
- No prior MCP knowledge is required; the course introduces it before integration.
- Read basic JavaScript or TypeScript for the scaffolded plugin exercise.
- Harness Engineering helps with harness concepts; Claude Code Engineering and Codex and OpenAI Coding Agents are not prerequisites.
Before this course
Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.
Required preparation
Recommended preparation
Readiness checks
- AI-Assisted Software Development or equivalent AI-assisted development, independent testing, and review competence.
- Programming, Git, terminal use, and repository build/test commands.
- No prior MCP knowledge is required; the course introduces it before integration.
- Read basic JavaScript or TypeScript for the scaffolded plugin exercise.
- Harness Engineering helps with harness concepts; Claude Code Engineering and Codex and OpenAI Coding Agents are not prerequisites.
AI-Assisted Software Development or equivalent AI-assisted development, independent testing, and review competence.
Find your place in the learning mapLab Setup
Delivery requirements: this environment, access, and the exercise materials must be prepared and verified before delivery. This outline does not certify that a lab package is ready.
A verified stable OpenCode V2 release, two compatible model configurations, authorized inference access, runtime/tests, Git, a disposable repository, controlled MCP service, and prepared plugin and orchestration scaffolds. Use official V2 documentation and a release-compatible plugin package. Inspect the installed API contract before selecting read-only queries. Query only synthetic lab sessions; do not export private conversations or credentials. Prepare local inference in advance if used; two supported hosted configurations also satisfy the comparison.
Detailed Course Outline
Module 1: Establish a controlled repository session (2 hours)
- Stable V2 setup: Stable V2 setup, authentication, model/provider choice, and terminal operation.
- Client and service roles: Client, background service, provider, model, and tool responsibilities.
- Project configuration: AGENTS.md guidance and project/global opencode.jsonc configuration.
- Terminal preferences: Terminal-only cli.json preferences versus server/project behavior.
- Scoped repository change: Permissions, scoped exploration, planning, edits, independent tests, and diffs.
- Model comparison: Two supported model configurations against the same task checks.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Produce a checked patch and compare observed model-backed task results.
Module 2: Commands, skills, context, and memory (2 hours)
- Session command discovery: Command discovery and session controls in the installed V2 client.
- Custom prompt commands: Built-in actions versus custom slash-command prompt templates.
- Reusable skills: Reusable skills with SKILL.md, arguments, references, and deterministic helpers.
- Fresh-session invocation: Progressive disclosure and fresh-session skill invocation.
- Context and handoffs: Context selection, compaction, persistent instructions, and task handoff records.
- Continuity and costs: Session continuity, model choice, usage evidence, and context costs.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Configure a custom command and invoke a skill in a genuinely fresh session.
Module 3: Tools, MCP, hooks, and customization (2 hours)
- MCP participants: MCP basics: host, client, server, tools, resources, and prompts.
- Tool integration routes: Built-in tools, direct APIs, MCP, and custom plugin tools.
- Actual MCP connection: MCP server setup, connection status, authentication, and actual invocation.
- Configuration precedence: Configuration precedence, agents, permissions, interface preferences, and reload behavior.
- Plugin compatibility: Plugin installation, compatibility, trust, scope, and disabling changes.
- Small server plugin: A local V2 server plugin scaffold and one observable customization.
- Hooks and cleanup: Plugin hooks versus model instructions; harmless behavior tests and cleanup.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Invoke an MCP tool and test a small local plugin customization.
Module 4: Delegation and adaptive workflows (2 hours)
- Primary and delegated agents: Primary agents, custom subagents, narrow roles, and separate contexts.
- Background work and conflicts: Background work, worktrees, shared-file conflicts, and coordination costs.
- Task decomposition: Divide a task into independent investigations and dependent changes.
- Explicit branching wrapper: Branch on checked artifacts using a small explicit orchestration wrapper.
- Worker limits and resume: Monitor workers, bound retries and concurrency, stop, and resume safely.
- Single-worker comparison: Review worker output and compare a simpler single-worker approach.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Run a delegated workflow and verify its branch and returned artifacts.
Module 5: CLI queries, internals, and repeatable automation (2 hours)
- Non-interactive execution: opencode run for bounded non-interactive repository tasks.
- Client/server request flow: Client/server request flow and the installed API contract.
- Read-only CLI queries: opencode api for read-only server and session queries.
- Service diagnosis: Service status, effective configuration, session results, and privacy-safe diagnosis.
- CLI and database boundaries: CLI evidence versus direct database inspection; avoid persistent-state mutation.
- Checks and merge decisions: Fixed checks, bounded repair, rerun safety, and explicit merge decisions.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Query actual service/session state and diagnose a repeatable task from its execution evidence.
Practical exercise
- Improve a small repository with a configurable export option. Configure project guidance, permissions, a custom command, and a reusable skill. Compare two supported model configurations using the same acceptance checks. Connect a provided MCP tool and verify its output. Change one terminal preference without putting it in the server configuration.
- Extend a prepared local V2 plugin to add a small review command or harmless tool. Test its observable behavior, inspect a provided hook example, then verify that disabling the customization removes it. Do not build a full plugin platform. Delegate an independent investigation and run a small adaptive workflow using a prepared wrapper with an explicit branch on checked artifacts.
- Run a bounded non-interactive task and query the service through the CLI. Inspect server information and the disposable session's results. Explain the request path from client to service, model, and tool. Diagnose one failure and rerun the skill in a fresh session. Independently verify the final diff and tests.
Delivery and timing
- Guided hours include explanations, demonstrations, learner practice, checks, feedback, questions, and contingency as allocated above. Breaks, bulk downloads, and prerequisite account/environment setup are additional. These allocations require a timed pilot before delivery; they are not measured completion times.
What you will produce
Customize OpenCode, test a small plugin, query session state, and verify a delegated repository task.
How the work is checked
- Actual product execution produces a patch that meets independent acceptance criteria.
- Commands and skills run with relevant inputs and inspectable results.
- MCP and the local plugin customization are exercised and can be disabled.
- Configuration separates terminal preferences from project/server behavior.
- CLI queries return actual state and support a correct client/server explanation.
- Delegated output receives independent review; orchestration branches use checked artifacts.
- Fresh-session and rerun evidence expose required context and completed effects.
- The final automation retains permission, test, and merge boundaries.
10 guided hours. A standalone OpenCode V2 specialization with core customization, CLI inspection, and a small plugin. Learners query synthetic sessions through supported read-only interfaces. A prepared wrapper supplies adaptive orchestration. Full SDK embedding, custom providers, GUI plugins, and database reverse engineering are excluded.
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
Contact us for full course details, including duration, delivery options and lab requirements.
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