Yonatan

Automate test generation and coverage analysis for your applications.

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

Automate GitHub releases with semantic versioning and changelog generation.

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

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

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

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

Create named HTTPS .localhost URLs for seamless local development.

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

Streamline your code review process with structured guidelines and templates.

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

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

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

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

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.

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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.

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.

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

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

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

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.

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.

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

Specializes in observability and monitoring using Prometheus and Grafana.

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

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.

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

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

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.

Integration and contract testing patterns for APIs and components.

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

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

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

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

Streamline GitHub issue tracking with automated workflows using gh CLI.

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

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

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

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

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

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

Document significant architectural decisions with structured ADR templates.

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

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.

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.

Database design and migration patterns for Alembic and schema management.

Transform plain JSON responses into interactive dashboards for MCP tools.

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

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

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

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.

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

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

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

Expert agent for auditing and implementing WCAG 2.2 accessibility standards.

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

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

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

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

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

Audits OrchestKit skills for quality and compliance with authoring standards.

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.

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

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

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

Integrate LLM APIs with optimized prompt templates and function calling.

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

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.

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

Generate and run comprehensive test suites with automated failure healing.

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.

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

Analyze and troubleshoot error patterns in Claude Code sessions.

Strategically evaluate product opportunities and validate value propositions.

Standardize your technical documentation with proven patterns for various formats.

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

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

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.

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

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

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

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

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

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

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

UI interaction design patterns that enhance user experience and accessibility.

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

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

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

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

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

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

Sequential release gate ensuring build success and compliance before deployment.

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

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

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

Stateful API emulation for reliable testing across multiple services.

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

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.

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

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.

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

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.

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

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

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

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.

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

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

Manage complex tasks with dependency tracking and orchestration patterns.

Implement Retrieval-Augmented Generation patterns for grounded LLM responses.

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

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

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

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

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

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.

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.

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

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

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

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

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

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.

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

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

Advanced patterns and security hardening for Model Context Protocol servers.

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