Yonatan

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

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

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

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

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

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

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.

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

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

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.

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

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

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

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

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

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

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

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

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

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.

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.

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

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

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

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

UI interaction design patterns that enhance user experience and accessibility.

Transform plain JSON responses into interactive dashboards for MCP tools.

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

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

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

Implement Retrieval-Augmented Generation patterns for grounded LLM responses.

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

Automate GitHub releases with semantic versioning and changelog generation.

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.

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.

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

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

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

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

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

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

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

Integrate LLM APIs with optimized prompt templates and function calling.

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.

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.

Standardize your technical documentation with proven patterns for various formats.

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).

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

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

Analyze and troubleshoot error patterns in Claude Code sessions.

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

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

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.

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

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

Document significant architectural decisions with structured ADR templates.

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

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

Audits OrchestKit skills for quality and compliance with authoring standards.

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

Streamline your code review process with structured guidelines and templates.

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.

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

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

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

Streamline GitHub issue tracking with automated workflows using gh CLI.

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.

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

Advanced patterns and security hardening for Model Context Protocol servers.

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

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.

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

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

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.

Create named HTTPS .localhost URLs for seamless local development.

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

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

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

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.

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.

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

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

Manage complex tasks with dependency tracking and orchestration patterns.

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

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

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

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

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

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

Expert agent for auditing and implementing WCAG 2.2 accessibility standards.

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

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

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

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

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

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

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

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

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

Specializes in observability and monitoring using Prometheus and Grafana.

Strategically evaluate product opportunities and validate value propositions.

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

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

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

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

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

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

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

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.

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

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

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

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

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

Generate and run comprehensive test suites with automated failure healing.

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

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

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

Sequential release gate ensuring build success and compliance before deployment.

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.

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.

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

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

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

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

Stateful API emulation for reliable testing across multiple services.

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.

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

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

Integration and contract testing patterns for APIs and components.

Database design and migration patterns for Alembic and schema management.

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

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

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

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

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

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

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

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 web performance with comprehensive patterns for frontend, backend, and LLM inference.

Automate test generation and coverage analysis for your applications.

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.