Yonatan

Systematic debug agent for root cause analysis and execution path tracing.

Streamline your design handoff process with automated PR creation from Claude Design URLs.

Implement internationalization in React applications with locale-aware formatting for strings, dates, and currencies.

NotebookLM integration patterns for external RAG, research synthesis, studio content generation (audio, cinematic video, slides, infographics, mind maps), and knowledge management. Use when creating notebooks, adding sources, generating audio/video, or querying NotebookLM via MCP.

Integrate vision, audio, and video generation capabilities using multimodal LLMs.

Design and implement multi-agent workflows using LangGraph with state management and RAG orchestration.

OrchestKit doctor for health diagnostics across manifest integrity, hook configuration, skill validation, agent frontmatter, MCP server connectivity, CC version compatibility, and permission rules. Reports issues with severity levels and auto-remediation suggestions. Validates component counts, detects orphaned entries, and checks CC version matrix compliance. Use when diagnosing plugin health, troubleshooting configuration issues, or running pre-release checks.

Redirect to five focused sub-skills for various testing patterns and automation.

Agent orchestration patterns for agentic loops, multi-agent coordination, alternative frameworks, and multi-scenario workflows. Use when building autonomous agent loops, coordinating multiple agents, evaluating CrewAI/AutoGen/Swarm, or orchestrating complex multi-step scenarios.

Automates GitHub issue resolution through root cause analysis and bug fixing.

Integrate Storybook 10 testing patterns with Vitest for robust component testing.

Design and implement scalable backend architectures with REST/GraphQL APIs and microservices.

Evaluates code and designs with a structured scoring system and actionable insights.

Streamline your code review process with structured guidelines and templates.

Security auditor: vulnerability scanning, dependency audits, OWASP Top 10 compliance, secrets detection, remediation.

Manage complex tasks with dependency tracking and orchestration patterns.

Generate seed configurations for stateful API emulation using Vercel's emulate tool.

Generate and run comprehensive test suites with automated failure healing.

Nightly memory consolidation — prunes stale entries, merges duplicates, resolves contradictions, rebuilds MEMORY.md index. Use when memory files have accumulated over many sessions and need cleanup. Do NOT use for storing new decisions (use remember) or searching memory (use memory).

Automate CI/CD processes with GitHub Actions and GitLab CI for efficient deployments.

LLM integration patterns for function calling, streaming responses, local inference with Ollama, and fine-tuning customization. Use when implementing tool use, SSE streaming, local model deployment, LoRA/QLoRA fine-tuning, or multi-provider LLM APIs.

Creates GitHub pull requests with pre-flight validation, conventional title formatting, and structured summary generation. Runs parallel checks (tests, lint, type-check, security) before opening. Supports feature, bugfix, refactor, and hotfix PR types with milestone assignment via gh CLI. Use when opening PRs or submitting code for review.

Implement domain-driven design patterns for complex business modeling in Python and TypeScript.

Transform plain JSON responses into interactive dashboards for MCP tools.

Monitoring and observability patterns for Prometheus metrics, Grafana dashboards, Langfuse v4 LLM tracing (as_type, score_current_span, should_export_span, LangfuseMedia), and drift detection. Use when adding logging, metrics, distributed tracing, LLM cost tracking, or quality drift monitoring.

Design scalable event-driven architectures using event sourcing, message queues, and CQRS patterns.

OrchestKit help directory with categorized skill listings. Use when discovering skills for a task, finding the right workflow, or browsing capabilities.

Build production-ready React 19/TypeScript components with advanced features and validation.

Manage design tokens efficiently with W3C specifications and a three-tier hierarchy.

Sequential release gate ensuring build success and compliance before deployment.

OrchestKit security wrapper for browser automation. Adds URL blocklisting, rate limiting, robots.txt enforcement, and ethical scraping guardrails on top of the upstream agent-browser skill. Use when automating browser workflows that need safety guardrails.

Integration and contract testing patterns for APIs and components.

Database design and migration patterns for Alembic and schema management.

PostgreSQL specialist for schema design, migrations, and query optimization.

Audits security layers to ensure comprehensive defense-in-depth implementation.

Evaluates platform upgrade readiness across Claude models and OrchestKit updates with a structured migration plan.

Enforce clean architecture and project structure with validation patterns for backend systems.

Create polished marketing demo videos for any content type using VHS recording and Remotion.

Analyze local analytics data across OrchestKit projects for insights on usage and performance.

Implement robust background job processing with async-jobs patterns for Celery and task scheduling.

Automated code quality reviewer for bug detection, security vulnerabilities, and performance issues.

Streamline design-to-code workflows with Figma handoff patterns.

User personas, customer journey maps, interview guides, usability testing, and card sorting. Use when building user understanding, mapping customer experiences, planning user research sessions, or defining Jobs-to-Be-Done.

Validates consistency of hook, skill, and agent counts across multiple sources in OrchestKit.

Stores decisions, patterns, and outcomes in the MCP memory knowledge graph as entities with typed observations and relations. Supports recording architectural decisions, anti-patterns, tool preferences, workflow outcomes, and project conventions that persist across sessions. Use when saving patterns, remembering outcomes, recording decisions, or building institutional knowledge.

Comprehensive reference for Zustand 5.x state management patterns with TypeScript examples.

Extract design DNA from app screenshots or live URLs to create design tokens.

LangGraph 1.x provides robust workflow patterns for state management and AI pipelines.

Implement accessibility patterns for WCAG 2.2 compliance and keyboard navigation in web applications.

Diff-aware AI browser testing that analyzes git changes and generates targeted test plans.

Assess task complexity and enforce quality gates to prevent wasted work on poorly-defined tasks.

Knowledge graph orchestration layer for enhanced entity extraction and query optimization.

Implement Retrieval-Augmented Generation patterns for grounded LLM responses.

Implement production-ready Python backends using async patterns with FastAPI and SQLAlchemy.

Quickly search for production-ready React components from 21st.dev's registry using natural language.

Analyze and troubleshoot error patterns in Claude Code sessions.

Implement robust security patterns for authentication, input validation, and LLM safety.

Optimize web performance with comprehensive patterns for frontend, backend, and LLM inference.

Curate and audit project component libraries for design consistency and upgrade opportunities.

Render multi-surface outputs from a single JSON spec for various platforms.

Audits OrchestKit skills for quality and compliance with authoring standards.

Manage production releases with zero-downtime deployments and rollback procedures.

Stateful API emulation for reliable testing across multiple services.

Import and scaffold components from a Claude Design handoff bundle into your project.

Automate GitHub releases with semantic versioning and changelog generation.

Market research: competitive landscapes, market trends, TAM/SAM/SOM sizing, threat/opportunity analysis.

Streamline GitHub project management with CLI operations for issues, PRs, and milestones.

Design effective OKRs and KPIs to drive team performance and measure success.

Interactive configuration wizard for OrchestKit plugin settings including MCP server enablement, hook permissions, keybindings, and installation presets (Complete/Standard/Lite). Supports preset shortcuts, per-category skill customization, and webhook configuration. Use when customizing plugin behavior or managing settings.

Implement distributed systems patterns for locking, resilience, idempotency, and rate limiting.

Architect and implement scalable design systems with token hierarchies and Figma-to-code workflows.

Streamline Git operations with branch management, rebases, and merges.

Unit testing patterns for isolated business logic tests, optimizing speed and maintainability.

Right-sizes architecture to project scope, preventing over-engineering by classifying projects into 6 tiers.

PR review using parallel specialized agents for code quality, security, testing, architecture, and performance analysis. Synthesizes findings into a review report with conventional comments (praise/issue/suggestion/nitpick) and approve or request-changes verdict. Use when reviewing pull requests, conducting security audits, or validating changes before merge.

Personalized 8-phase onboarding wizard that scans the codebase, detects tech stack, recommends skills and MCP servers, and generates an improvement plan with readiness score. Includes safety checks, project-scoped configuration, and release channel detection. Use when setting up OrchestKit for a new project or rescanning after major changes.

Create engaging demo videos for skills, agents, and tutorials effortlessly.

Design exploration using parallel agents through a 7-phase process: topic analysis, memory context, divergent ideation (10+ ideas), feasibility filtering, evaluation with devil's advocate scoring (0-10 across 7 dimensions), synthesis of top approaches, and trade-off comparison. Supports open exploration, constrained design, comparison, quick ideation, and iterative optimization modes. Use when brainstorming ideas, exploring solutions, or comparing alternatives.

Extract design context from visual sources to create structured design tokens.

Master advanced Vite 8 patterns for optimized builds and plugin development.

Utilize prioritization frameworks like RICE, WSJF, and MoSCoW to effectively rank and justify backlog decisions.

Automates UI feedback processing by mapping annotations to source code and implementing fixes.

Unified read-side memory operations for knowledge graph search and context loading.

Syncs latest release content to NotebookLM and HQ Knowledge Base after version tagging.

Automate web research tasks with browser automation and competitive intelligence gathering.

Estimate market size using TAM/SAM/SOM frameworks with top-down and bottom-up methods.

Streamline GitHub issue tracking with automated workflows using gh CLI.

Standardize your technical documentation with proven patterns for various formats.

Implement responsive design patterns in React using Container Queries and fluid typography.

Manage and validate golden datasets for AI/ML evaluation with structured lifecycle patterns.

Create AI-safe generative UIs with json-render component catalogs.

API design patterns for REST/GraphQL framework design, versioning strategies, and RFC 9457 error handling. Use when designing API endpoints, choosing versioning schemes, implementing Problem Details errors, or building OpenAPI specifications.

Automate test generation and coverage analysis for your applications.

Strategically evaluate product opportunities and validate value propositions.

UI interaction design patterns that enhance user experience and accessibility.

Implement end-to-end testing patterns using Playwright, including accessibility and visual regression testing.

Advanced patterns and security hardening for Model Context Protocol servers.

Integrate Storybook with MCP for component-aware AI development, enabling component discovery, testing, and previews.

Performance engineer optimizing Core Web Vitals and bundle sizes for frontend applications.

Patterns and tools for testing LLM integrations and validating AI outputs.

Integrate LLM APIs with optimized prompt templates and function calling.

Release and versioning specialist who manages GitHub releases, milestones, changelogs, and semantic versioning. Handles release automation and project tracking.

Automate LLM evaluation by running structured datasets and computing quality metrics.

Chain patterns for building resilient CC 2.1.71 pipelines with multi-phase skills.

Streamline CI/CD processes, containerization, and Kubernetes deployments with this comprehensive DevOps skill.

Comprehensive codebase analysis for security, architecture, and dependency auditing.

Automate web research and competitive monitoring with a unified decision tree.

Specializes in observability and monitoring using Prometheus and Grafana.

Build Next.js 16+ apps using React Server Components for optimized server-first architecture.

Strategic analysis frameworks including Porter's Five Forces (industry attractiveness), SWOT (internal positioning), and competitive landscape mapping with battlecard generation. Produces competitor profiles, feature gap analysis, and positioning recommendations. Use when analyzing market position, evaluating threats, or building sales battlecards.

Full-power feature implementation using parallel subagents for backend, frontend, testing, and security. Coordinates architecture design, code generation, test coverage, and quality verification in a single workflow with worktree isolation. Chains with /ork:cover for test generation and /ork:verify for validation. Use when implementing features, building new capabilities, or creating full-stack functionality.

Optimize Python application performance through profiling, memory management, and database query enhancements.

AI safety auditor for LLM systems focusing on security assessments and compliance.

Create named HTTPS .localhost URLs for seamless local development.

Automate browser testing with diff-aware plans and ARIA selectors.

Mockup-to-component pipeline using Google Stitch, 21st.dev, and Storybook MCP. Accepts screenshots, descriptions, or URLs as input and produces production-ready React components. Checks existing Storybook components before generating, orchestrates design extraction via Stitch MCP, component matching via 21st.dev registry, adaptation to project design tokens, and self-healing verification via run-story-tests. Use when converting visual designs to code, implementing UI from mockups, or building components from screenshots.

Frameworks for product management covering business cases, market analysis, and prioritization.

UI component library patterns for building accessible components with shadcn/ui and Radix Primitives.

Creates commits with Conventional Commits format (feat/fix/docs/refactor/test/chore), automatic scope detection, co-author attribution, and pre-commit hook compliance. Validates staged changes, generates descriptive messages focusing on the 'why', and prevents secrets or generated-only files from being committed. Use when committing changes or generating commit messages.

Create consistent ASCII diagrams for architecture, workflows, and data visualizations in terminal environments.

Expert agent for auditing and implementing WCAG 2.2 accessibility standards.

Manage the OrchestKit learning system with feedback tracking and privacy controls.

OrchestKit streamlines your development process with persistent knowledge and automated workflows.

Create animation-rich HTML presentations from scratch or convert PowerPoint files effortlessly.

Orchestrates design handoff bundles from Claude AI, ensuring accurate component integration and tracking.

Manage long multi-phase tasks with a rate-limit-resilient pipeline that supports checkpointing and resuming.

Infrastructure as Code specialist for designing cloud architecture and Terraform modules.

Multimodal specialist for integrating vision, audio, and video AI capabilities.

Generative UI specialist for designing Zod-typed component catalogs and ensuring AI safety.

Visualize planned changes with ASCII diagrams, risk metrics, and execution order analysis.

Specializes in data pipelines for AI, focusing on embeddings, chunking, and vector indexing.

Create structured Product Requirements Documents (PRDs) with templates and user stories.

AI-assisted patterns for generating and reviewing UI components across multiple platforms.

Run isolated eval and grading calls using CC 2.1.81 --bare mode for efficient testing.

Document significant architectural decisions with structured ADR templates.

Tracks skill usage patterns, edit frequency, and success rates to suggest improvements and optimizations. Manages skill versioning with safe rollback capability and confidence scoring for suggestions. Use when reviewing skill performance, applying auto-suggested changes, or rolling back problematic versions.

A/B test evaluation, cohort retention analysis, funnel metrics, and experiment-driven product decisions. Use when analyzing experiments, measuring feature adoption, diagnosing conversion drop-offs, or evaluating statistical significance of product changes.

Implement advanced animations and motion design patterns using Motion and View Transitions API.

Perform comprehensive business case analysis with ROI, NPV, IRR, payback period, and TCO calculations.

Comprehensive verification tool for unit tests, integration tests, and security scanning.

Evaluate implementation plans against scale, data, security, UX, and coherence criteria.

Multi-angle codebase exploration spawning 3-5 parallel agents for code structure, data flow, architecture patterns, and health assessment. Generates ASCII visualizations, import graphs, and design pattern detection with cross-session memory storage. Use when exploring a repo, discovering architecture, onboarding to a new codebase, or analyzing design patterns.

Optimize performance and load testing with k6, Locust, and pytest patterns.