Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/lnardev/opencode-config-agent/llms.txt

Use this file to discover all available pages before exploring further.

OpenCode Config Agent is a shareable, drop-in configuration for OpenCode that transforms a standard AI coding session into a structured, professional development environment. Out of the box, OpenCode is a powerful AI terminal — this config layers four carefully designed systems on top of it: a senior architect mentor persona, a spec-driven workflow engine, a persistent memory layer, and a context-aware skills registry. The result is an AI collaborator that doesn’t just write code on demand, but teaches, plans, remembers, and enforces real software engineering discipline across every session.
OpenCode Config Agent is a configuration layer, not a standalone tool. It requires OpenCode to be installed and running on your machine. All features are activated by placing this config in your ~/.config/opencode/ directory.

​
The Four Pillars

OpenCode Config Agent is built around four interconnected systems that work together to elevate the quality and consistency of AI-assisted development.

Tony Stark Agent

A senior architect mentor with 15+ years of experience, GDE & MVP credentials, and a philosophy that puts concepts above code. Pushes back on shortcuts, explains the why behind every decision, and uses construction analogies to make architecture intuitive.

Spec-Driven Development

A coordinated pipeline of 10 specialized sub-agents that guide every change from exploration through proposal, design, spec, tasks, implementation, verification, and archival — no more ad-hoc coding sessions.

Engram Persistent Memory

A persistent memory system that survives across sessions and context compactions. Decisions, bug fixes, architecture choices, and team conventions are saved automatically so the agent never starts a new session blind.

Auto-Loading Skills

A context-aware registry of reusable skills that activate automatically based on what you’re working on — Go testing patterns, PR creation, adversarial code review, and more — injected into the agent’s context before it writes a single line.

​
Tony Stark: Your Senior Architect Mentor

The tony stark agent is the primary persona you interact with day-to-day. Configured via AGENTS.md, it embodies a specific engineering philosophy: CONCEPTS > CODE. Before writing anything, it validates that you understand the why. It pushes back when you reach for a framework before understanding the fundamentals, corrects mistakes ruthlessly but with technical evidence, and uses building and architecture analogies to make abstract concepts concrete. The agent also integrates directly with Engram, running a mandatory memory protocol: every architecture decision, bug fix, convention, and non-obvious discovery is saved to persistent memory automatically — not when you ask, but immediately after it happens.

​
Spec-Driven Development Workflow

SDD is the structured planning layer for substantial changes. Instead of jumping straight to code, every change goes through a dependency-ordered pipeline managed by the sdd-orchestrator agent:
AgentRole
sdd-orchestratorCoordinate the pipeline — delegates phases to sub-agents, never executes inline
sdd-initBootstrap SDD context and detect project stack
sdd-exploreInvestigate the codebase and research ideas
sdd-proposeCreate a structured change proposal
sdd-designProduce technical design with architecture decisions
sdd-specWrite detailed specifications with test scenarios
sdd-tasksBreak specs into implementation tasks
sdd-applyExecute code changes from task definitions
sdd-verifyValidate implementation against specifications
sdd-archiveArchive completed artifacts to persistent memory
sdd-onboardGuided end-to-end walkthrough using your real codebase
The orchestrator coordinates these agents, choosing the right model for each phase (Opus for architecture decisions, Sonnet for implementation, Haiku for archival), and supports both Interactive mode (review each phase before continuing) and Automatic mode (run all phases back-to-back).

​
Skills: Context-Aware Standards

Skills are compact rule sets that are resolved from a registry and injected into the agent’s context automatically — before any code is written. The orchestrator reads the skill registry once per session, matches skills to the current task context (file types, actions being performed), and pre-digests the rules into every sub-agent prompt.
Context DetectedSkill Activated
Go tests, Bubbletea TUIgo-testing
Creating new AI skillsskill-creator
SDD workflow phasessdd-*
Creating pull requestsbranch-pr
Creating GitHub issuesissue-creation
Adversarial code reviewjudgment-day

​
Project Structure

The entire configuration lives in your ~/.config/opencode/ directory. Here’s what each part does: 
.config/opencode/
├── AGENTS.md           # Personality and rules for the "tony stark" agent
├── opencode.json       # Main agent and MCP configuration
├── package.json        # Plugin dependencies
├── commands/           # SDD slash commands
├── plugins/            # TypeScript custom plugins
├── prompts/            # SDD agent prompts
└── skills/             # Reusable skills loaded by context

​
Where to Go Next

Quickstart

Clone the config, install dependencies, and run your first SDD workflow in under 10 minutes.

Installation

Detailed setup guide including Engram configuration, MCP server setup, and verification steps.

Tony Stark Agent

Learn how the mentor persona works, how to invoke it, and how Engram memory is managed.

SDD Workflow

Deep dive into the Spec-Driven Development pipeline, commands, and execution modes.

Build docs developers (and LLMs) love

Get started for freeTalk to us