odin

Map codebase health with complexity metrics, dependency graphs, coupling analysis, and anti-pattern detection. Produces quantified assessments with actionable insights. Use PROACTIVELY before major refactoring, when onboarding to unfamiliar codebases, or when refactoring agent needs baseline data.

Designs scalable system architectures and makes critical technical decisions. Creates blueprints for complex systems and ensures architectural consistency. Use PROACTIVELY when planning system design or making architectural choices. Pair with devil-advocate for adversarial challenge pipeline before committing to decisions.

Creates beautiful, intuitive user interfaces and experiences. Focuses on visual design, UX patterns, and aesthetic excellence. Use PROACTIVELY for UI/UX design, visual improvements, or design system creation. For wireframes and interaction design, also consider ui-ux-designer.

Design scalable backend systems, APIs, database schemas, and service architectures. Covers load balancing, caching strategies, message queues, and microservice decomposition. Use PROACTIVELY when building new backend features, designing APIs, or solving performance problems. For adversarial design review, invoke devil-advocate.

Designs compelling brand identities including names, logos, corporate identity systems (CIS), brand identity systems (BIS), and complete visual languages. Creates artistic yet strategic branding that resonates with audiences and elevates businesses. Use for any naming, branding, or visual identity needs.

Master-level C programmer who pushes hardware to its limits. Expert in kernel programming, lock-free algorithms, and extreme optimizations. Use when you need to squeeze every drop of performance or work at the hardware level.

Write fast, reliable C code with correct memory management close to the hardware. Expert in system programming, embedded devices, and performance-critical code. Use PROACTIVELY for C development, memory management, or performance-critical systems. For extreme kernel-level and lock-free work, use c-pro-ultimate.

Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying code. For systemic quality critique, use criticizer. For pre-decision adversarial challenge, use devil-advocate.

Analyze and optimize concurrent systems with focus on thread safety, synchronization primitives, and parallel programming patterns. Masters race condition detection, deadlock prevention, and lock-free algorithms. Use PROACTIVELY for multi-threaded code, async patterns, or concurrency bugs. For holistic system performance, also invoke performance agent.

Grandmaster-level Modern C++ with template metaprogramming, coroutines, lock-free algorithms, and extreme optimizations. Expert in C++17/20 features, compile-time programming, SIMD, memory models, and zero-overhead abstractions. Strategic use of boost and abseil for advanced functionality. Use for COMPLEX C++ challenges requiring deep template wizardry, advanced concurrency, or extreme optimization.

Write modern C++ code that's fast, safe, and maintainable. Expert in managing memory automatically, handling multiple threads safely, and making programs efficient. Use for C++ development, performance work, or concurrent programming.

Unflinching systemic critique of code, designs, and architectures AFTER implementation. Severity-driven analysis demanding evidence for quality claims. Identifies architectural rot, hidden coupling, performance time-bombs, and security gaps at the system level. Use PROACTIVELY after major implementation milestones. For pre-decision challenge, use devil-advocate. For line-by-line code review, use code-reviewer.

Write modern C# with async/await, LINQ, and .NET 6+ features. Masters ASP.NET Core, Entity Framework, and Azure integration. Use PROACTIVELY for C# development, .NET microservices, or enterprise application architecture.

Build ETL pipelines, data warehouses, and streaming architectures. Implements Spark jobs, Airflow DAGs, and Kafka streams. Use PROACTIVELY for data pipeline design or analytics infrastructure.

Unified database expert covering SQL queries, schema design, query optimization, BigQuery analytics, and migration safety. Masters CTEs, window functions, execution plans, indexing strategies, N+1 detection, caching, and data analysis. Use PROACTIVELY for query optimization, schema design, database performance issues, or data analysis. For memory-layer caching, also consider performance agent.

Systematic debugging from compiler errors to production incidents. Covers error analysis, root cause investigation, log correlation, binary search debugging, performance profiling, memory leak detection, and incident reports. Use PROACTIVELY for compiler errors, runtime failures, test failures, or production incidents. For performance profiling, also invoke performance agent. For memory-specific deep dives, also invoke memory-expert.

Aggressively challenges architecture decisions, technology choices, implementation plans, and API designs BEFORE commitment. Runs pre-mortem analysis, dismantles hidden assumptions, red-teams designs, and stress-tests claims. Use PROACTIVELY before significant technical decisions. Pair with architect for challenge pipeline. For post-implementation review, use code-reviewer or criticizer instead.

Creates comprehensive technical documentation — from architecture guides and API references to technical manuals and searchable specifications. Combines narrative storytelling with exhaustive reference coverage. Use PROACTIVELY for system documentation, architecture guides, API references, or configuration documentation. For codebase analysis before documenting, invoke analyzer first.

Flutter expert for high-performance cross-platform applications. Masters widget composition, state management, platform channels, and native integrations. Use PROACTIVELY for Flutter development, custom widgets, animations, or platform-specific features.

Write idiomatic Go code with goroutines, channels, and interfaces. Optimizes concurrency, implements Go patterns, and ensures proper error handling. Use PROACTIVELY for Go refactoring, concurrency issues, or performance optimization.

Design GraphQL schemas, resolvers, and federation. Optimizes queries, solves N+1 problems, and implements subscriptions. Use PROACTIVELY for GraphQL API design or performance issues.

Develop native iOS applications with Swift/SwiftUI. Masters UIKit/SwiftUI, Core Data, networking, and app lifecycle. Use PROACTIVELY for iOS-specific features, App Store optimization, or native iOS development.

Master modern Java with streams, concurrency, and JVM optimization. Handles Spring Boot, reactive programming, and enterprise patterns. Use PROACTIVELY for Java performance tuning, concurrent programming, or complex enterprise solutions.

Master modern JavaScript with ES6+, async patterns, and Node.js APIs. Handles promises, event loops, and browser/Node compatibility. Use PROACTIVELY for JavaScript optimization, async debugging, or complex JS patterns.

Write idiomatic Kotlin with coroutines, null safety, and functional patterns. Masters Android development, Spring Boot backends, and Kotlin Multiplatform. Use PROACTIVELY for Kotlin development, coroutine-based concurrency, or cross-platform applications.

Analyze and optimize memory usage patterns, layouts, and resource management. Masters heap/stack analysis, memory leak detection, and allocation optimization. Use PROACTIVELY for memory-intensive code, leak detection, or resource management. For holistic system performance, also invoke performance agent.

System migration and cross-platform porting specialist. Covers database schema migrations, data transformations, version upgrades, language transitions, platform porting, and framework migration with zero data loss and minimal downtime. Use PROACTIVELY for migration planning, database upgrades, language/platform porting, or framework transitions. For architecture-level migration decisions, pair with architect.

Implement ML pipelines, model serving, and feature engineering. Handles TensorFlow/PyTorch deployment, A/B testing, and monitoring. Use PROACTIVELY for ML model integration or production deployment. For ML infrastructure and experiment tracking, also invoke mlops-engineer.

Build ML pipelines, experiment tracking, and model registries. Implements MLflow, Kubeflow, and automated retraining. Handles data versioning and reproducibility. Use PROACTIVELY for ML infrastructure, experiment management, or pipeline automation. For model development and deployment, also invoke ml-engineer.

Develop React Native or Flutter apps with native integrations. Handles offline sync, push notifications, and app store deployments. Use PROACTIVELY for mobile features, cross-platform code, or app optimization.

Advanced holistic performance optimization across all system layers — from algorithms to infrastructure. Expert in profiling, benchmarking, and implementing data-driven optimizations. Use PROACTIVELY for any performance concerns or when building high-performance systems. For memory-specific deep dives, use memory-expert. For concurrency optimization, use concurrency-expert.

Write idiomatic PHP code with generators, iterators, SPL data structures, and modern OOP features. Use PROACTIVELY for high-performance PHP applications.

Optimizes prompts for LLMs and AI systems. Expert in crafting effective prompts for Claude 4.5, Gemini 3.0, GPT 5.1, and other frontier models. Use when building AI features, improving agent performance, or crafting system prompts.

Write clean, fast Python code using advanced features. Expert in performance optimization, async/concurrent programming, and thorough testing. Use PROACTIVELY for Python development, performance tuning, or complex Python patterns.

Build React components, implement responsive layouts, and handle client-side state management. Optimizes frontend performance and ensures accessibility. Use PROACTIVELY when creating UI components or fixing frontend issues.

Full refactoring lifecycle — assess technical debt, plan strategy, execute behavior-preserving transforms, and modernize legacy patterns. Covers debt quantification, prioritized roadmaps, code smell detection, Strangler Fig migration, and framework modernization. Use PROACTIVELY when planning debt reduction, executing refactoring, or modernizing legacy systems. Pair with analyzer for baseline metrics. For pre-decision challenge, invoke devil-advocate.

Grandmaster-level Rust programming with unsafe wizardry, async runtime internals, zero-copy optimizations, and extreme performance patterns. Expert in unsafe Rust, custom allocators, inline assembly, const generics, and bleeding-edge features. Use for COMPLEX Rust challenges requiring unsafe code, custom runtime implementation, or extreme zero-cost abstractions.

Write idiomatic Rust code with ownership, lifetimes, and zero-cost abstractions. Masters async programming with explicit concurrency diagrams and memory layout visualization. Use PROACTIVELY for Rust development requiring detailed ownership/concurrency analysis, unsafe code review, or performance-critical systems. For COMPLEX challenges requiring unsafe wizardry, custom allocators, or runtime internals, use rust-pro-ultimate.

Review code for vulnerabilities, implement secure authentication, and ensure OWASP compliance. Handles JWT, OAuth2, CORS, CSP, and encryption. Use PROACTIVELY for security reviews, auth flows, or vulnerability fixes. For adversarial security thinking, also invoke devil-advocate.

Write advanced Terraform modules, manage state files, and implement IaC best practices. Handles provider configurations, workspace management, and drift detection. Use PROACTIVELY for Terraform modules, state issues, or IaC automation.

Architects sophisticated testing strategies for edge cases, performance, security, and chaos engineering. Specializes in stress testing, fuzz testing, property-based testing, and real-world battlefield scenarios. Use PROACTIVELY for complex testing challenges requiring deep analysis and production-like simulation. For standard test suites, use test-writer instead.

Designs comprehensive test suites covering unit, integration, and functional testing. Creates maintainable test structures with proper mocking, fixtures, and assertions. Use PROACTIVELY for standard testing needs and test-driven development. For advanced testing strategies (chaos, fuzz, property-based), use test-designer-advanced.

Design ultra-low-latency trading systems, market making algorithms, and risk management infrastructure. Masters order execution, market microstructure, backtesting frameworks, and exchange connectivity. Use PROACTIVELY for HFT systems, algorithmic trading, portfolio optimization, or financial infrastructure.

Master TypeScript with advanced types, generics, and strict type safety. Handles complex type systems, decorators, and enterprise-grade patterns. Use PROACTIVELY for TypeScript architecture, type inference optimization, or advanced typing patterns.

Create interface designs, wireframes, and design systems. Masters user research, prototyping, and accessibility standards. Use PROACTIVELY for design systems, user flows, or interface optimization. For visual design and aesthetic excellence, also consider artistic-designer.

Verbalized Sampling (VS) protocol for deep intent exploration before planning. Use when starting ambiguous or complex tasks, when multiple interpretations exist, or when you need to explore diverse intent hypotheses and ask maximum clarifying questions before committing to an approach.

Effective code search, analysis, and refactoring using ast-grep (sg). Use this skill for precise AST-based code modifications, structural search, and linting.

Coordinate context sweep before coding - gather relevant files, patterns, and tooling summaries. Use when preparing to implement a feature, fix, or refactor and need comprehensive architecture, pattern, tooling, and dependency context gathered first.

Design-by-Contract (DbC) development - design contracts from requirements, then execute CREATE -> VERIFY -> TEST cycle. Use when implementing with formal preconditions, postconditions, and invariants across any language.

Two-party working posture — user as director, agent as executor. Every fork, tradeoff, and taste choice is surfaced via batched AskUserQuestion with structural framing, a recommended default, and concrete previews when comparison is visual, so the human steers direction while the agent handles implementation. Eliminates the review-bottleneck (no giant diff to approve at the end — review is distributed across picks) and prevents codebase-understanding debt (the user remembers the architecture because they picked it). Use whenever the user invokes /duet, or says "work with me", "ask before", "check with me", "I want to decide", "don't assume", "human-in-the-loop", "co-author", "pair with me", "duet", or whenever a task clearly involves aesthetic, architectural, or irreversible strategic decisions — even without those exact words. Pair with the Duet output style to minimize cognitive load between picks.

Help address review/issue comments on the open GitHub PR for the current branch using gh CLI; verify gh auth first and prompt the user to authenticate if not logged in.

Inspect GitHub PR checks with gh, pull failing GitHub Actions logs, summarize failure context, then create a fix plan and implement after user approval. Use when a user asks to debug or fix failing PR CI/CD checks on GitHub Actions and wants a plan + code changes; for external checks (e.g., Buildkite), only report the details URL and mark them out of scope.

Analyze a codebase and create or improve an AGENTS.md file for future agent instances. Use when onboarding to a repository and capturing hard-to-rediscover conventions, constraints, and rationale.

Decompose a task into independent concerns and execute them through broadly parallel, specialized agent groups. Use when a request involves multiple independent sub-tasks, research across separate domains, or work that can be parallelized across files or modules.

Software architect and planning specialist - conduct thorough read-only planning before any action. Use when exploring a codebase to design implementation plans, defining objectives, gathering relevant files, and summarizing available tools before coding begins.

Merge one or more PRs into the base branch with queue-like sequencing and conflict resolution. Use when merging PRs that may conflict with each other or the base, requiring ordered application and intelligent conflict handling.

Merge multiple PRs into a temporal integration branch before merging to base, with ordered conflict resolution. Use when you want to validate a set of PRs together on a staging branch before advancing the base branch.

Review code changes on a given GitHub PR using gh CLI. Use when the user asks to review a pull request, analyze PR diffs, or provide feedback on open PRs with structured quality, security, and testing assessments.

Execute an implementation plan with surgical precision. Use after a planning phase (plan-now or similar) has produced a step-by-step strategy and identified critical files. Focuses on precise code changes with verification at each step.

Proof-driven development - design proofs from requirements, then execute CREATE -> VERIFY -> REMEDIATE cycle. Use when implementing with formal verification using property-based testing, theorem proving, or proof tactics; zero unproven property policy enforced.

Refactor by removing backward compatibility and legacy layers. Use when modernizing APIs, cleaning up migration debt, removing compat shims, or eliminating stale feature flags.

Resolve code review comments by verifying their validity and proposing multiple solutions for confirmed issues. Use when addressing review feedback, analyzing whether review comments are valid, and generating architectural solutions (not naive fixes) for confirmed issues.

Review the code changes on the current branch. Use when the user asks to review their current work, analyze recent commits, or get a code quality assessment of the active branch against the main branch.

Practical guide for building safe, syntax-aware srgn CLI commands for source-code search and transformation. Use when users ask for srgn commands, scoped refactors (comments/docstrings/imports/functions), multi-file rewrites with --glob, custom tree-sitter query usage, or CI-style checks with --fail-any/--fail-none.

Test-Driven Development (TDD) - design tests from requirements, then execute RED -> GREEN -> REFACTOR cycle. Use when implementing features or fixes with TDD methodology, writing tests before code, or following XP-style development across any supported language.

Write adversarial tests that intentionally stress failure paths. Use when hardening error handling, stress-testing assumptions, validating boundary behavior, or hunting silent failures.

Type-driven development - design type specifications from requirements, then execute CREATE -> VERIFY -> IMPLEMENT cycle. Use when developing with refined types, state machines encoded in types, or proof-carrying types; enforces totality and exhaustive pattern matching.

Validation-first development - design state machine specifications from requirements, then execute CREATE -> VERIFY -> IMPLEMENT cycle. Use when developing with formal state machine specifications, invariants, and temporal properties before writing implementation code.

1 hook across 1 event

Outline Driven Development(ODIN)'s approach to Claude output style; Precise and effective

Output style for the duet working posture (user as director, agent as executor). Minimizes cognitive load between picks: decisions before prose, structural/taste framing first, jargon on demand, batched questions with concrete previews, short execution updates, no validation language, no recap. Goal — eliminate the review bottleneck and prevent codebase-understanding debt by distributing review across the task at pick-time.

Communication style for non-technical builders — product managers, founders, designers, and no-code/low-code users who build things without deep programming expertise. Leads with outcomes, uses plain language, maintains honesty without jargon overload.