Yonatan

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

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

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

Stateful API emulation for reliable testing across multiple services.

Sequential release gate ensuring build success and compliance before deployment.

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

Strategically evaluate product opportunities and validate value propositions.

UI interaction design patterns that enhance user experience and accessibility.

Advanced patterns and security hardening for Model Context Protocol servers.

Automate GitHub releases with semantic versioning and changelog generation.

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

Integrate LLM APIs with optimized prompt templates and function calling.

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

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

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.

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

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

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

Specializes in observability and monitoring using Prometheus and Grafana.

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

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

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.

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

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.

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

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

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

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

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

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

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.

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

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

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

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 named HTTPS .localhost URLs for seamless local development.

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

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.

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

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

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

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

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

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

Expert agent for auditing and implementing WCAG 2.2 accessibility standards.

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

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

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.

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

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

Manage complex tasks with dependency tracking and orchestration patterns.

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

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.

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

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

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

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

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

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

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

Transform plain JSON responses into interactive dashboards for MCP tools.

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

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

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

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.

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

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

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

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.

Document significant architectural decisions with structured ADR templates.

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

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

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 animation-rich HTML presentations from scratch or convert PowerPoint files effortlessly.

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

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

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.

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

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.

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.

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

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

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

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.

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.

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

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.

Audits OrchestKit skills for quality and compliance with authoring standards.

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.

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.

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.

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

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.

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

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

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

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

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.

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.

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

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

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

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

Streamline your code review process with structured guidelines and templates.

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

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

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

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.

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

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.

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

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

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.

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.

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

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

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

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

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.

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.

Generate and run comprehensive test suites with automated failure healing.