Outline-Driven Development for Claude Code

Formerly known as the ODIN Claude Plugin. The repo URL stays the same; the brand has matured.

Outline-Driven Development (nicknamed ODIN) — Advanced code agent system for Claude Code with surgical precision, diagram-first engineering, and comprehensive workflow automation.

Methodology: outline-driven-development  ·  Codex CLI: odin-codex-plugin  ·  Gemini CLI: odin-gemini-cli-extension  ·  Site: outlinedriven.github.io

Overview

ODIN is a professional-grade Claude Code plugin that transforms Claude into a sophisticated code agent with comprehensive workflow automation and rigorous engineering methodology.

Key Capabilities:

• 📐 Diagram-First Engineering - Architecture, concurrency, memory, data flow, optimization
• 🎯 Surgical Code Editing - AST-based transformations with ast-grep
• 🧠 Confidence-Driven Execution - Adaptive behavior based on complexity and risk
• 🔍 Deep Investigation - Mandatory file reading before code modifications
• 🔒 Atomic Commits - Conventional Commits protocol with incremental approvals

Installation

One repository serves every harness below. There is no build step and no converter — each tool reads skills/ directly.

Prerequisites

• Claude Code installed and running
• Git (for marketplace installation)

Full Install Script (Recommended)

wget -O ~/.claude/CLAUDE.md https://raw.githubusercontent.com/OutlineDriven/odin-claude-plugin/refs/heads/main/CLAUDE.md && claude plugin marketplace add OutlineDriven/odin-claude-plugin && claude plugin install odin@odin-marketplace

Other coding agents

Harness	Install	Extra files needed
Codex CLI	codex plugin marketplace add OutlineDriven/odin-claude-plugin then codex plugin add odin@odin-marketplace	none — Codex reads .claude-plugin/
Grok Build CLI	grok plugin install OutlineDriven/odin-claude-plugin	none — Grok reads Claude Code plugins with zero configuration
Devin CLI	devin plugins install OutlineDriven/odin-claude-plugin	.devin-plugin/
Antigravity (agy)	agy plugin install https://github.com/OutlineDriven/odin-claude-plugin	root plugin.json
Cursor	/add-plugin odin in Cursor Agent chat	.cursor-plugin/
Kimi Code CLI	/plugins install https://github.com/OutlineDriven/odin-claude-plugin then /reload	.kimi-plugin/
opencode	local checkout only — see below	.opencode/plugins/odin.js

Codex and Grok need no ODIN-specific manifest: both resolve .claude-plugin/plugin.json, and Codex additionally reads .claude-plugin/marketplace.json. .agents/plugins/marketplace.json is shipped as Codex's current (non-legacy) marketplace path.

Devin documents a .claude-plugin/ fallback from 3000.3.22, but builds before that hard-fail without .devin-plugin/plugin.json, so ODIN ships one. Devin also gates plugins behind a closed beta — request access from Cognition first. Skills surface as /odin:<skill>.

opencode documents plugin[] entries for npm packages only, so there is no one-command install from this repository. Clone it and point opencode.json at the plugin file:

{
  "plugin": ["/path/to/odin-claude-plugin/.opencode/plugins/odin.js"]
}

The plugin registers skills/ on config.skills.paths and adds one command per skill, skipping the five marked disable-model-invocation because opencode has no manual-only gate.

Verified by real installs from a clean clone of this repository at 1.17.82, on Linux. Every version below was read from the installed binary with --version, not assumed:

Harness	Installed version	Check	Result
Codex CLI	codex-cli 0.146.0	plugin marketplace add + plugin add	installed, 120 skills in plugin root
Devin CLI	devin 3000.2.17	devin plugins install	installed, skills exposed as /odin:<skill>
Antigravity	agy 1.1.9	agy plugin validate .	ok, 120 skills processed
Grok Build	grok 0.2.118 [stable]	grok plugin validate .	manifest valid, 1 skill dir + hooks
Claude Code	2.1.220	claude plugin validate	passed
opencode	not installed	module exercised directly	114 commands, 5 manual-only excluded

Cursor and Kimi are not tested. Both install through an in-editor slash command rather than a shell, so there is no headless path to exercise them. Their manifests match the vendors' published schemas; treat first install as unproven.

claude plugin validate --strict fails on this repo, and did so before any harness work: metadata.maintainer, .website and .support in .claude-plugin/marketplace.json are unknown to Claude Code, which ignores them at load time. Non-strict validation passes.

Verify Installation

# List available agents
/agents

# View all commands
/help

# See the installed plugins
/plugin

Core Philosophy

ODIN follows strict engineering principles:

1. Investigate Before Acting - Never speculate about code you haven't read
2. Diagram-First Design - Five mandatory diagrams before any implementation
3. Surgical Precision - Minimal, targeted changes using AST-based tools
4. Atomic Commits - One logical change per commit, properly typed
5. Confidence-Driven - Adapt behavior based on familiarity and risk
6. Tool Selection - ast-grep > native-patch > ripgrep (never sed for edits)

Five Required Diagrams

Before any non-trivial implementation:

1. Architecture - Components, interfaces, contracts, dependencies
2. Data Flow - Sources, transformations, sinks, state transitions
3. Concurrency - Threads, synchronization, happens-before relationships
4. Memory - Ownership, lifetimes, allocation patterns, safety guarantees
5. Optimization - Bottlenecks, targets, complexity bounds, resource budgets

Skills (119 total)

Skills are invokable workflows that extend ODIN with process- and domain-specific protocols. Invoke with /<skill-name>; many also trigger on natural language cues described in their frontmatter.

Planning & Exploration (21 skills)

• askme - Verbalized Sampling protocol for deep intent exploration before planning
• batch-ask-me - Walk a dependency-aware design tree in batched question rounds until shared understanding
• wayfinder - Chart a multi-session effort into a destination, mapped fog, and decision tickets on the frontier
• mutual-sync - Three-way grounding: verify user, agent, and codebase share one picture of current state before proceeding
• loop-me - Design recurring workflows through a stateful askme session and cwd specs
• to-questionnaire - Turn a knowledge gap into an async questionnaire for the person who can answer it
• clarify - Scan a request, document, or conversation for ambiguities and unstated assumptions; certainty-tiered findings with defaults
• exhaustive - Prove a decision, state, or requirement space is fully covered by enumerating every cell as covered, gap, or deferred
• shape - Shape Up shaping: appetite, breadboard, rabbit holes, no-gos for a bet on work
• to-tickets - Break a plan into tracer-bullet tickets with blocking edges, on GitHub or in .outline/
• contexts - Coordinate context sweep before coding
• domain-modeling - Build and sharpen a project's ubiquitous language, glossary, and domain decisions as you design
• init - Analyze a codebase and create or improve AGENTS.md
• brainstorm - Explore vague or ambitious ideas into a right-sized requirements-only plan
• explore - Read-only codebase exploration to map structure, symbols, and dependencies
• strategy - Sharp interview to write or maintain STRATEGY.md as the product anchor
• ideate - Generate grounded, divergent ideas from the codebase into docs/ideation
• design - Set visual and interaction direction for UI surfaces before writing code
• prototype-logic - Throwaway single-file HTML demo that answers one question about a state model
• pov - Decisive, project-grounded verdict on adopting or switching technology
• research - Gather external knowledge from authoritative sources with verified citations

Writing & Learning (5 skills)

• teach - Run a persistent cwd teaching workspace across missions, lessons, resources, and learning records
• writing-fragments - Mine heterogeneous raw material into an append-only pile before shaping
• writing-shape - Shape a raw pile into an article paragraph by paragraph with argued formats
• writing-beats - Build a grounded article journey one candidate beat at a time
• writing-skills - Reference for writing agent-consumed documents so they run predictably: context load, hierarchy, leading words, and pruning

Working Posture (5 skills)

• duet - Two-party posture: user as director, agent as executor. Surfaces every fork via AskUserQuestion with structural framing and a recommended default. Eliminates the review-bottleneck and prevents codebase-understanding debt. Pair with the Duet output style.
• axiom-mode - Compact formal-logic English register using predicate claims and ASCII keywords
• ai-collab-protocols - Surface in-task AI collaboration protocols one tactic at a time
• taste - Apply distinctive judgment to prose, code, design, or decisions instead of AI mediocrity
• do-it-now - Single-pass posture: ship the whole ask now, with no phases, stubs, or follow-up remainders

Engineering Methodologies (16 skills)

• test-driven - TDD with 10-language support
• type-driven - Type-driven development (Idris 2, with 10-language support)
• proof-driven - Proof-driven development (Lean 4, with property-based testing fallback and 10-language support)
• contract-driven - Design-by-Contract (DbC): pre/post/invariants at API boundaries, state invariants, and trust boundaries
• validation-first-driven - State machines, invariants, and temporal properties (Quint spec) before implementation
• tests-purge-unneeded - Delete tests that don't catch real bugs (the inverse of TDD); load-bearing principles, static-vs-dynamic carve-out, language-specific examples
• spec-driven - Write a structured spec before writing code
• source-driven - Ground implementation decisions in official documentation with version-aware citations
• ground-latest - Pin versions, stacks, and practices from today's release channels instead of from recall
• doubt-driven - Subject non-trivial decisions to adversarial review before they stand
• minimalism-driven - Minimalism as enforced doctrine: null-solution start, need-gated additions, delete > edit > add as authoring-time gates
• verification-before-completion - Require fresh, fully-read run evidence before any completion claim
• lighter-checks - Size verification to the change: one proving action, scoped, no repeat runs, gate intact
• codebase-design - Shared vocabulary for deep modules: module, interface, depth, seam, adapter, leverage, locality
• security-hardening - Harden code against vulnerabilities as you build it
• observability - Instrument code with logging, metrics, traces, and alerts

Tooling (9 skills)

• ast-grep - Structural code search, analysis, and refactoring
• browser-testing - Test and debug browser code with Chrome DevTools MCP
• git-branchless - Idiomatic git-branchless workflows for stack edits, rebases, and stacked-PR publishing
• setup-gitignore - Compose or revise .gitignore from templates, editor patterns, and confirmed untracked noise
• setup-pre-commit - Install ecosystem-appropriate pre-commit hooks for formatting, linting, and test gates
• setup-git-guardrails - Install a PreToolUse hook that blocks irreversible git operations before they run
• setup-ts-deep-modules - Enforce TypeScript package boundaries through entry points with dependency-cruiser
• strict-validation-setup - Bootstrap strict-mode tooling and per-task GOALS.md scaffolding for self-verifying agent loops
• wizard - Generate an interactive bash wizard that walks a human through a manual setup or migration

Execution (16 skills)

• parallel-launch - Decompose a task into independent concerns and execute via agents
• tests-adversarial - Adversarial tests that stress failure paths
• work - Execute a plan or concrete work prompt end-to-end
• subagent-driven - Delegate a multi-task plan to fresh subagents, auditing results before proceeding
• workflows-driven - Deterministic phased fan-out with per-task contracts and adversarial verification; materializes on Claude Code Dynamic Workflows or omp eval orchestration
• fix - Iterative repair loop that fixes one thing at a time and keeps changes on green
• resolving-merge-conflicts - Resolve an in-progress merge or rebase conflict from both sides' primary sources, then finish the integration
• autopilot - Hands-off plan-to-ship pipeline chaining existing skills
• llm-self-loop - Restructure human-gated workflows into autonomous LLM loops with file-based outputs
• incremental - Deliver changes in small, testable slices
• update-todos - Re-sync a stale task list against what actually landed, with proof required per completion
• sophisticate-todos - Split compound tasks into atomic ones, order by dependency, pin an acceptance criterion to each
• debug - Hypothesis-driven debugging with minimal reproduction
• frontend-ui - Build production-quality user-facing interfaces
• optimize - Locate a hot path, benchmark transformations, and commit the proven winner
• shipping - Prepare a production launch with checklists, monitoring, and rollback planning

Review & Resolution (6 skills)

• review - Review code changes on the current branch
• resolve - Resolve code review comments with validity checks
• doc-review - Review requirements docs, plans, specs, and PRDs through persona-based lenses
• security-review - Adversarial security audit using STRIDE, OWASP, supply-chain checks, and secrets scans
• review-fix-grill-loop - Review and fix a diff in verified batches until no medium-or-higher finding remains
• simplify - Compress-op review pass on reuse, quality, and efficiency axes

Cleanup & Refactoring (8 skills)

• refactor-break-compat - Refactor by removing backward-compatibility and legacy layers (public API surface)
• breaking-driven - Bloat-triggered demolition: state the contract, derive the replacement blind, cut the residue; interior surfaces go without asking, boundary surfaces stop for a yes
• cleanup-codebase - Internal micro-hygiene: dead fields, redundant wrappers, stale config flags, identity passthrough — applied while touching nearby code, not as standalone PRs
• tidy - Dispatch compress operations to the right domain: file, diff, memory, workspace, git stack, or doc
• improve-architecture - Surface deepening refactors that turn shallow modules into deep ones
• deprecate-and-migrate - Plan and execute deprecation and migration of old systems, APIs, or features
• to-greenfield - Diagnose a degraded codebase's field state (darkfield/redfield/bluefield/brownfield) and route the recovery
• slop - Slop front door: verdict or purge for code, prose, decisions, or UI, routed to the right domain authority

GitHub Integration (14 skills)

• pr-review - Review code on a GitHub PR using gh
• pr-merge-base - Merge PRs into the base branch with queue-like sequencing
• pr-merge-temporal - Merge multiple PRs into a temporal integration branch first
• gh-fix-ci - Inspect failing CI checks, pull logs, propose fixes
• commit - Create a git commit with a clear, value-communication message
• commit-push - Commit working-tree changes and push to the remote — no PR
• commit-push-current - Commit and push to the current branch — no branch creation, no branch switch, no PR
• commit-push-pr - Commit, push, and open a PR
• atomic-issues-prs - Publish a change-set as atomic GitHub issues or PRs
• github-triage - Triage GitHub issues through a configurable label-based state machine
• github-solution-research - Find proven open-source solutions on GitHub for concrete engineering problems
• propose-issue - Turn a symptom into a source-grounded GitHub issue: evidence, analysis, self-review gate, then file
• resolve-pr-feedback - Resolve PR review feedback and fix code-review comments
• worktree - Set up isolated git worktrees for new or existing branches/PRs

Codebase Intelligence & Workflow (19 skills)

• deslop - Three-phase certainty-graded AI-slop detection with HIGH-only guarded autofix
• sync-docs - Diff-driven doc-vs-code drift detection; safe version/CHANGELOG fixes, rest flagged
• drift-detect - Plan-vs-reality reality check across GitHub, docs, and code
• audit-project - Iterative multi-agent code audit with a false-positive contract
• onboard - New-codebase orientation tour with interactive guidance
• can-i-help - Route contributors to data-backed contribution opportunities
• enhance - Certainty-graded enhancement of agent/plugin surfaces via parallel analyzers
• docs-and-adrs - Record decisions and documentation that explain why the codebase is shaped as it is
• ci-cd - Set up or modify CI/CD pipelines and deployment automation
• deps-upgrade - Run a dependency-upgrade campaign from outdated scan through lockfile audit
• memory-clean - Audit memory files for structural rot and staleness, reporting before fixing
• memory-sanitize - Produce share-safe copies of memory files with PII and credentials redacted
• memory-update - Scan session history for save-worthy signals and propose memory files
• autolearn - Compound a solved problem into a durable in-repo learning doc
• compound - Document a durable solution or project concept in the repo
• generate-my-taste - Generate a personal taste skill from local evidence and confirmation forks
• cascade-dedup - Strip duplicate and conflicting directives across the system-prompt cascade family
• dedup-skills - Ledger-first dedup of a skills/ tree: find repeated or self-conflicting rules across skill files
• handoff - Snapshot the current session into a resumable handoff artifact for a cold session, agent, or person

Output Styles (6 total)

Output styles shape how the agent communicates. Switch via Claude Code's /config or by setting outputStyle in settings.json.

• ODIN - Default. Skeptic register, scope discipline, systematic skepticism, no reflexive validation.
• AxiomMode - Formal-logic English with predicate-form claims, Hoare-triple framing, ASCII shortened-English keywords. Daily-driver register for coding work.
• Builder - For non-technical builders (PMs, founders, designers, no-code users). Outcome-first, plain-language, progressive disclosure.
• Duet - Companion to the duet skill. Decisions before prose, structural/taste framing first, jargon on demand, silent mechanics / loud forks. Enforces duet skill invocation.
• Linus - Torvalds review discipline. Good taste as special-case elimination, blunt about the work, show the corrected code rather than describe it.
• Eval - Benchmark harness register (output-styles/benchmark.md). Auto-generated by margin-runner; do not hand-edit above the doctrine cascade.

Configuration

Settings.json

ODIN includes comprehensive settings.json with:

• Tool Permissions - Pre-approved tools (ast-grep, fd, rg, cargo, npm, git, etc.)
• MCP Integration - Time, browser, git, context7, tavily, and more
• Security - Denied operations (sed -i, force push, destructive commands)
• Hooks - Event-driven automation
• Defaults - Bypass permissions mode, always thinking enabled

CLAUDE.md

Global instructions defining:

• ODIN methodology and principles
• Tool selection mandates (ast-grep preferred)
• Git commit strategy (Conventional Commits)
• Diagram-first engineering requirements
• Language-specific guidelines
• UI/UX design principles
• Verification and refinement patterns

Methodology

Surgical Editing Workflow

1. Find - Use ast-grep (code), ripgrep (text), fd (files)
2. Copy - Extract minimal context with precise offsets
3. Paste - Apply surgically with AST-based transformations

Confidence-Driven Execution

Confidence = (familiarity + (1-complexity) + (1-risk) + (1-scope)) / 4

• High (0.8-1.0): Direct action → Verify
• Medium (0.5-0.8): Iterative action → Expand → Verify
• Low (0.3-0.5): Research → Plan → Test → Expand
• Very Low (<0.3): Decompose → Propose → Seek guidance

Atomic Commit Protocol

Conventional Commits v1.0.0:

<type>[optional scope]: <description>

[optional body]

[optional footer(s)]

Types: feat, fix, build, chore, ci, docs, perf, refactor, style, test

Rules:

• One logical change per commit
• Never mix types or scopes
• Each commit must build and pass tests
• Independently testable and reversible

Tool Selection Mandate

Discovery → Text search → Structural search → Transform:

1. fd - File discovery (NEVER use find)
2. git grep - Primary text search within the repo (respects .gitignore, fast)
3. rg (ripgrep) - Text-search fallback when outside git or for richer flags
4. ast-grep - Structural/AST search and rewrite (metavariable patterns)
5. native-patch / Edit - Final precise edits when Find → Transform → Verify converges
6. eza - Directory listing (NEVER use ls)
7. bat -P -p -n - File display (NEVER use cat)

Tool Permission Issues

Check settings.json for tool permissions. ODIN pre-configures safe tool usage.

License

See LICENSE file for details.

Support

• Issues: https://github.com/OutlineDriven/odin-claude-plugin/issues
• Repository: https://github.com/OutlineDriven/odin-claude-plugin

Acknowledgments

Built on Claude Code's powerful plugin system with focus on professional software engineering practices, surgical precision, and comprehensive workflow automation.

---

Outline-Driven Development for Claude Code — outlinedriven.github.io