thelobbi

Enhanced plan-authoring skill with Pre-Writing context gathering, task metadata, non-TDD templates, Red Flags, telemetry, and an automated plan linter. Use when you have a spec or requirements for a multi-step task, before touching code.

Expertise in CI/CD pipeline creation, process automation, and team workflow optimization. Activates when working with "automate", "pipeline", "workflow", "CI/CD", "process", or automation tools.

Background tasks and worker services with IHostedService, BackgroundService, and .NET hosted service patterns

Use when starting, tracking, or closing a discrete unit of work. Enforces ULTRA §13 reporting contract — what/why/tests/deps/reuse/risks/follow-ups/completion table. Invoke when user says "start work unit", "close work unit", "work unit report", or when a multi-step implementation task begins.

This skill should be used when designing the visual and interaction layer of an agent-rendered widget — choosing among inline card, carousel, fullscreen, and picture-in-picture, action budgets, layout and typography rules, host theming, accessibility requirements, and the vendor dos and donts.

MUI multi-theme and white-label systems — nested ThemeProvider, dynamic theme switching, tenant-specific branding, and theme composition

Deep web research using Perplexity and Firecrawl MCP servers. Use when researching technologies, APIs, best practices, or current information.

Vision and multimodal capabilities for Claude including image analysis, PDF processing, and document understanding. Activate for image input, base64 encoding, multiple images, and visual analysis.

MUI list virtualization with react-window, react-virtuoso, virtualized Autocomplete, and large dataset rendering patterns

Vector database operations for embeddings and semantic search. Activate for Pinecone, Weaviate, Chroma, pgvector, RAG, and similarity search.

Core analysis patterns, detection heuristics, and scoring algorithms for the upgrade intelligence system

Master all templating formats - Handlebars, Cookiecutter, Copier, Maven, and Harness - with format selection matrix, generation workflows, and best practices

This skill should be used when testing or debugging an agent UI locally — the basic-host loop, MCP Inspector, cloudflared tunnels into Claude or ChatGPT, sendLog, the bridge-level assertions worth writing, and a triage table mapping every common symptom to its cause.

This skill should be used when deciding where state lives in an agent UI — the three ownership tiers (authoritative business data, ephemeral UI state, durable cross-session state), the write-through loop, updateModelContext vs setWidgetState, remount survival, and AG-UI shared-state reconciliation.

This skill should be used when hardening an agent UI — authoring the narrowest _meta.ui.csp allowlists, the iframe sandbox and proxy-origin model, treating structuredContent as untrusted input, prompt-injection through rendered data, host-mediated navigation, secrets handling, and the pre-ship security checklist.

This skill should be used when migrating an agent UI between protocols or SDKs — OpenAI Apps SDK to portable MCP Apps, mcp-ui legacy actions to the ui/* bridge, MCP Apps to A2UI, adding AG-UI to an existing app, the adapter layer that makes ports cheap, and the field-by-field mapping tables.

This skill should be used when an agent UI is slow, heavy, or janky — bundle size and single-file inlining, skeletons from tool-input, ontoolinputpartial streaming, avoiding remount via decoupled tools, polling and chunked transfer through app-only tools, offscreen pausing with IntersectionObserver, and size-change churn.

Deploy and manage Home Assistant on Ubuntu servers with Docker, security hardening, and complementary services.

MUI X Tree View — SimpleTreeView, RichTreeView, lazy loading, custom icons, multiselect, drag-and-drop, and virtualization

Tool use patterns for Claude including schema design, tool_choice modes, result handling, parallel execution, error recovery, and extended thinking integration.

This skill should be used when designing the tool surface behind an agent UI — action-oriented naming, descriptions that drive correct model selection, input and output schemas, structuredContent vs content vs _meta, safety annotations, tool visibility, and the discovery metadata that decides whether the app ever gets invoked.

Expert knowledge for creative text animations - typewriter effects, character-by-character reveals, kinetic typography, split text animations, and expressive text motion.

Testing MUI components with React Testing Library — theme mocking, portal components, DataGrid, DatePicker, and accessibility testing

Terraform infrastructure as code including modules, state management, and cloud provisioning. Activate for tf files, IaC, infrastructure provisioning, and cloud resource management.

This skill should be used when the user asks to "enrich a task", "add task details", "analyze requirements", "add context to an issue", "expand a ticket", or "estimate complexity" — enriching Jira issues with requirements, dependencies, and technical context.

Syncfusion Blazor component library with DataGrid, Charts, Scheduler, PDF, and 80+ components

MUI sx prop and styled() API for component styling

This skill should be used when running many parallel coding agents against a Linear backlog — conductor/worker dispatch, exclusive claims, workspace isolation, retry and stall handling. Activates on "swarm", "parallel agents", "conductor", "fan out issues", "symphony", "worktree isolation", "delegation ledger".

Expert knowledge for SVG path animations, morphing shapes, and vector graphics effects that create stunning visual experiences with resolution-independent graphics.

Supply chain security model for the marketplace plugin ecosystem

Server-Sent Events (SSE) streaming for Claude API with support for text, tool use, and extended thinking. Activate for real-time responses, stream handling, and progressive output.

This skill should be used when working with stacked or dependent pull requests — resolving topology, retargeting and rebasing after a parent lands, splitting an oversized branch, and force-push safety.

MUI server-side rendering with Next.js — App Router, Pages Router, RSC compatibility, Emotion cache, and Pigment CSS

Expert knowledge for physics-based spring animations - natural, organic motion that follows real-world physics principles for delightful user experiences.

MUI slots and slotProps API for deep component customization — replacing internal elements, custom renderers, and composition patterns

SignalR for real-time communication in Blazor apps including hubs, groups, streaming, and scaling

Comprehensive knowledge for interactive setup and validation of the AWS EKS + Helm + Keycloak + Harness ecosystem.

Home Assistant sensor configuration and analytics patterns.

Scrum methodology including sprints, ceremonies, backlog management, and agile practices. Activate for sprint planning, standups, retrospectives, and agile workflows.

Expert knowledge for scroll-triggered animations, parallax effects, and scroll-linked interactions that create immersive storytelling experiences.

Scrape and extract documentation from a URL using Firecrawl. Use when you need to read external documentation.

This skill should be used when running or designing a code review process — adversarial verification, lens separation, evidence standards, severity mapping, and blackboard synthesis.

REST API design, implementation, and best practices. Activate for API endpoints, HTTP methods, status codes, authentication, and API documentation.

This skill should be used when computing or interpreting repository delivery metrics — DORA four keys, lead time decomposition, change-failure hotspots, ownership drift, bus factor, and flake cost.

This skill should be used when cutting a release — computing a semver bump from conventional commits, writing changelogs and release notes, sequencing breaking changes, and planning rollbacks.

Redis caching, pub/sub, and data structures. Activate for Redis operations, caching strategies, session management, and message queuing.

This skill should be used when the user asks to "reason through", "think step by step", "analyze systematically", "debug with hypotheses", "root cause analysis", "chain of thought", "tree of thought", "documentation lookup", or needs structured reasoning frameworks with mandatory documentation retrieval before analysis.

React 18+ patterns with Vite bundler, TypeScript, hooks, component design, and state management. Activate for React apps, Vite configuration, TypeScript, frontend development, and modern React patterns.

React development including hooks, components, state management, and modern patterns. Activate for React components, JSX, hooks, context, and frontend development.

This skill should be used when choosing between MCP Apps, mcp-ui, the OpenAI Apps SDK, A2UI, and AG-UI for a given requirement — the decision tree, the axes that actually discriminate, valid combinations, anti-patterns, and how to keep a migration path open.

Prompt caching for Claude API to reduce latency by up to 85% and costs by up to 90%. Activate for cache_control, ephemeral caching, cache breakpoints, and performance optimization.

Project type detection matrix, template recommendations per project type, post-scaffolding checklist, Harness integration patterns, and testing recommendations

Gantt charts, Kanban boards, scheduling, and resource management libraries that integrate with MUI — SVAR, DHTMLX, Bryntum, Syncfusion, FullCalendar, dnd-kit, and architecture patterns

Deep project fingerprinting for tech stack detection, architecture analysis, and quality assessment

This skill should be used when the user asks to "create a PR", "open a pull request", "merge changes", "set up a git/PR workflow", or "request review" — creating, managing, and merging pull requests linked to Jira issues.

This skill should be used when writing or reviewing a pull request title, description, or size — covering template resolution, PR size budgets, conventional titles, and what must never appear in a PR body.

Knowledge for exporting marketplace items as Cowork-compatible plugin ZIPs for distribution via Claude Desktop private marketplaces

Domain knowledge for the cowork marketplace seed catalog, including all 17 items mapped to 16 installed plugins with their agents, skills, and commands

MUI performance optimization — tree-shaking, bundle size, rendering, SSR

This skill should be used when building ChatGPT apps with the OpenAI Apps SDK — the window.openai bridge, openai/* _meta fields and their MCP Apps equivalents, widget state, display modes, the decoupled data/render tool pattern, checkout, file handling, and the esbuild component bundle.

Next.js development including App Router, Server Components, API routes, and deployment. Activate for Next.js apps, SSR, SSG, and React Server Components.

Multi-tenant architecture patterns including org_id claim management, JWT token structure with organization context, database isolation strategies for MongoDB and PostgreSQL, theme switching per organization, tenant provisioning workflows, data isolation patterns, and cross-tenant security. Activate for multi-tenancy implementation, tenant isolation, and organization-scoped data access.

MUI theming system — createTheme, palette, typography, dark mode, component overrides, TypeScript augmentation, and design tokens

MongoDB Atlas cloud database management including clusters, schemas, aggregation pipelines, and Prisma ORM integration. Activate for MongoDB queries, schema design, indexing, and Atlas administration.

MUI version migration guides — v4→v5 and v5→v6 with codemods and patterns

.NET microservices patterns including service decomposition, communication, CQRS, saga, and resilience

MERN stack patterns including React with Vite, Express middleware, MongoDB schemas, API Gateway architecture, session management, error handling, and testing strategies. Activate for MERN development, microservices architecture, and full-stack JavaScript applications.

This skill should be used when working with GitHub merge queues and branch protection — queue semantics, required checks, strict status checks, auto-merge, and why a merge is blocked.

This skill should be used when working with mcp-ui — createUIResource and its rawHtml/externalUrl/remoteDom content types, the five UI action types (tool, prompt, link, intent, notify), the messageId async response flow, iframe lifecycle events, and the client-side UIResourceRenderer/AppRenderer components.

This skill should be used when writing code against @modelcontextprotocol/ext-apps — registerAppTool, registerAppResource, RESOURCE_MIME_TYPE, the App class and its handlers, the React useApp hook, the app-bridge entry point, and the Vite single-file build that MCP Apps expect.

This skill should be used when implementing or debugging the MCP Apps extension — ui:// resource URIs, the text/html;profile=mcp-app mimeType, every _meta.ui field, the full ui/* JSON-RPC bridge over postMessage, tool visibility, host context, display modes, and the five lifecycle phases.

This skill should be used when shipping an MCP app into Microsoft 365 Copilot as a declarative agent — prerequisites, the widget host CORS URL, OAuth 2.1 and Entra SSO redirect URIs, Agents Toolkit sideloading, dynamic tool discovery, and the Copilot-specific capability gaps to design around.

Advanced Lovelace dashboard patterns for Home Assistant.

Deploy and integrate local LLMs with Ollama, LocalAI, and Home Assistant for privacy-focused voice assistants and automation.

Local Kubernetes development with EKS parity using Kind, LocalStack for AWS services, and local Keycloak for authentication testing

LLM integration patterns for Claude, GPT, Gemini, and Ollama. Activate for AI API integration, prompt engineering, token management, extended thinking, and multi-model orchestration.

This skill should be used when registering, verifying, or processing Linear webhooks — HMAC signatures, replay protection, idempotency, dead-letter queues. Activates on "linear webhook", "webhook signature", "Linear-Signature", "webhook secret".

This skill should be used when implementing or debugging two-way sync between Linear issues and a git host — branches, pull requests, reviews, deploys — across GitHub and Harness Code. Activates on "linear github sync", "harness sync", "harness bridge", "linear vcs", "issue to pr sync", "magic words", "closing keywords".

This skill should be used when implementing Linear integrations using the official @linear/sdk — creating issues programmatically, advanced fetch/modify patterns, error handling, and type safety. Activates on "linear sdk", "@linear/sdk", "linear client", "linear typescript".

This skill should be used when designing bulk operations against Linear — complexity budgets, exponential backoff, request pacing, and avoiding 429s. Activates on "linear rate limit", "linear 429", "linear throttle", "complexity budget".

This skill should be used when fetching large result sets from Linear — cursor pagination, filter DSL, sorting, and complexity budgeting. Activates on "linear pagination", "linear filter", "linear cursor", "linear filtering".

This skill should be used when implementing Linear OAuth 2.0, OAuth actor authorization, or file-storage authentication. Activates on "linear oauth", "linear auth", "actor token", "linear-actor-token", "file storage".

This skill should be used when writing or reviewing GraphQL queries against the Linear API — selecting fragments, navigating connection types, batching, and avoiding deprecated fields. Activates on "linear graphql", "linear query", "linear api", "linear schema".

This skill should be used when uploading files to Linear, linking external URLs as attachments, or downloading existing attachments with auth. Activates on "linear attachment", "linear file upload", "fileUpload mutation", "attachmentLinkCreate".

This skill should be used when building, registering, or operating an agent inside Linear — agent sessions, agent activities, delegation, Agent Skills, Loops, and Linear's built-in coding sessions. Activates on "linear agent", "agent session", "agent activity", "delegate issue", "linear aig", "agents in linear", "coding session", "linear loops".

MUI layout components and responsive design patterns

Kubernetes deployment, management, and troubleshooting. Activate for k8s, kubectl, pods, deployments, services, ingress, namespaces, and container orchestration tasks.

This skill should be used when the user asks to "add Keycloak authentication", "implement OIDC", "configure SSO", "validate JWT token", "add role-based access", "protect API endpoint", or mentions Keycloak, OAuth2, OpenID Connect, identity provider, or authentication in FastAPI. Provides Keycloak/OIDC integration patterns.

Keycloak administration including realm management, client configuration, OAuth 2.0 setup, user management with custom attributes, role and group management, theme deployment, and token configuration. Activate for Keycloak Admin API operations, authentication setup, and identity provider configuration.

Keycloak identity and access management including realms, clients, authentication flows, themes, and user federation. Activate for OAuth2, OIDC, SAML, SSO, identity providers, and authentication configuration.

Kanban methodology including boards, WIP limits, flow metrics, and continuous delivery. Activate for Kanban boards, workflow visualization, and lean project management.

Audit K8s deployments for stale images, wrong pull policies, and volume issues. Use when debugging Helm deploy or image caching problems.

Joy UI — MUI's alternative design system with CSS variables, modern aesthetics, and simpler API

Start working on a Jira issue with optimized tiered orchestration. Begins with intelligent question-gathering to ensure complete understanding before implementation.

Triage and analyze Jira issues. Use when the user wants to "triage issues", "analyze backlog", "assess tickets", or "jira triage".

Sync local changes with Jira issue. Use when the user wants to "sync to jira", "update jira", "push progress", or "sync status".

Check status of current Jira work session. Use when the user asks "what's the status", "show progress", "current work", or "jira status".

Review code changes for Jira issue. Use when the user wants to "review code", "code review", "jira review", or "check implementation".

Prepare a Jira task with enrichment and subtask creation. Use when the user wants to "prepare task", "enrich issue", "create subtasks", or "prepare for development".

Create pull request linked to Jira issue. Use when the user wants to "create PR", "open pull request", "submit for review", or "jira pr".

This skill should be used when the user asks to "orchestrate jira", "work on issue", "complete jira ticket", "development workflow", "jira automation", "issue lifecycle", "work on story", "fix bug ticket", or needs guidance on coordinating development work through Jira with multi-agent orchestration patterns.

This skill should be used when the user asks to "triage issue", "classify ticket", "route jira", "analyze priority", "categorize issue", "determine complexity", "route to agents", or needs guidance on classifying, prioritizing, and routing Jira issues to appropriate agents and workflows.

Create smart commit linked to Jira issue. Use when the user wants to "commit", "smart commit", "jira commit", or "commit changes".

Create git branch linked to Jira issue. Use when the user wants to "create branch", "new branch for issue", "jira branch", or "feature branch".

Jira project management including issues, sprints, boards, and workflows. Activate for Jira tickets, sprint planning, backlog management, and Atlassian integration.

Resolve high-level intents into ordered plugin composition plans using greedy set cover for capability matching and Kahn's topological sort for dependency ordering. Activates when working with "compose", "plugin composition", "capability matching", "dependency resolution", or "intent specification".

Expertise in API design, database integration, and service connectivity. Activates when working with "API", "database", "webhook", "service", "integrate", "connect", or system architecture.

Identifies cutting-edge, innovative upgrade opportunities based on tech stack and industry trends

MUI internationalization, RTL support, locale customization, and bidirectional text

This skill should be used when deciding which MCP Apps or window.openai APIs are safe to depend on for a given host — the verified M365 Copilot support matrix for the component bridge, tool descriptor _meta, annotations, resource _meta, CSP properties, and client _meta, plus the feature-detection patterns that keep a widget portable.

Helm chart development workflow including chart structure, values management, testing, linting, and publishing for EKS deployments with Keycloak integration

Safe Helm deployment with image verification, cache busting, and rollback safety. Prevents deploying stale images.

Detect and replace a hung session in a multi-session fleet without killing a working one. Use when a lane looks silent, stalled, unresponsive or hung, when deciding whether to replace or ping a session, when taking a fleet census, or when a heartbeat file has gone stale. Enforces the hard-won rule that message-absence is not work-absence - read the lane's own artifact (heartbeat file, branch, open PR, worktree) and quote what it showed before calling anything silent - plus the staleness thresholds, the three silence classes and their different remedies, and the replacement handover that lets a successor resume rather than restart.

This skill should be used when the user asks to "configure Harness delegates", "set up Harness RBAC", "manage connectors/secrets/templates", "apply OPA policy as code", or "review audit logs" — Harness platform administration and governance.

This skill should be used when the user asks to "run a Harness pipeline", "trigger a deployment pipeline", "monitor a Harness execution", or "check pipeline status" — executing and watching Harness pipelines with Jira integration.

This skill should be used when the user asks to "use the Harness MCP", "connect Harness to Jira", "manage Harness pipelines/repos/PRs from AI", or "sync Jira to Harness" — AI-driven Harness CD operations and Git/PR automation.

Keycloak OIDC integration with Harness pipelines, EKS IRSA, service account authentication, and realm-as-code patterns

Expert-level Harness template types, runtime inputs, expression language, pipeline patterns (CI/CD, GitOps, Canary, Blue-Green), versioning, and step configurations

AWS EKS deployment patterns via Harness CD - Native Helm, Kubernetes manifests, and GitOps strategies with rolling, canary, and blue-green deployments

Harness Code repository workflows, triggers, PR pipelines, branch protection, and GitOps integration for AWS EKS deployments

This skill should be used when the user asks to "set up Harness CI", "build a CI pipeline", "configure test intelligence", or "cache/parallelize builds" — container-native build infrastructure on Harness.

This skill should be used when the user asks to "deploy with Harness", "set up Harness CD", "configure a canary/blue-green/rolling deployment", "add approval gates", or "roll back a deployment" — Kubernetes, Helm, Terraform, ECS, and serverless delivery via Harness.

Universal Harness Code + CI/CD + Pipeline automation patterns. Uses mcp__harness__* tools when available; falls back to hc CLI. Invoke for pipeline ops, PR workflow, deployment, feature flags, GitOps, IaCM, or when user says "harness", "pipeline", "run ci", "deploy".

Core Home Assistant API integration patterns, authentication, and entity management.

Automation YAML patterns, triggers, conditions, actions, and best practices for Home Assistant.

Expert knowledge for GSAP (GreenSock Animation Platform) - the industry-standard JavaScript animation library for professional-grade animations with precise timeline control.

gRPC service development in .NET for high-performance inter-service communication

GraphQL API development including schemas, resolvers, queries, mutations, and subscriptions. Activate for GraphQL servers, clients, and API design.

Git workflows including branching strategies, commits, merging, rebasing, and GitHub collaboration. Activate for git commands, version control, PRs, and repository management.

This skill should be used when reading or writing GitHub Projects (v2) — the REST and GraphQL surfaces, field types and their IDs, item lifecycle, built-in workflows, and the token types each endpoint accepts.

This skill should be used when coordinating multi-agent GitHub delivery work — dispatching teams, holding a blackboard, enforcing merge gates, and deciding what to run in parallel versus in sequence.

This skill should be used when working with GitHub's issue data model — issue types, sub-issues, dependencies, labels, milestones, issue forms and templates, and the community health files that configure them.

This skill should be used when choosing, diagnosing, or configuring how something authenticates to GitHub — personal access tokens, GitHub Apps, OAuth, SSH and deploy keys, GITHUB_TOKEN in Actions, OIDC, and the permission model each one carries.

This skill should be used when delegating work to agents that run inside GitHub — Copilot cloud agent, custom agents, Copilot code review, and GitHub Agentic Workflows — including when delegation beats doing the work directly.

This skill should be used when calling GitHub MCP tools — which tool does what, the method discriminators several of them require, oversized payload handling, and the pitfalls that produce confusing errors.

Google Cloud Platform services including GKE, Cloud Run, Cloud Storage, BigQuery, and Pub/Sub. Activate for GCP infrastructure, Google Cloud deployment, and GCP integration.

Expert knowledge for Framer Motion - the production-ready motion library for React. This skill enables declarative animations, gesture recognition, and layout animations with optimal performance.

MUI form patterns with validation and library integration

The role catalogue and the descending-model rule for a multi-session fleet - which roles exist at each tier, what each owns, which model tier each runs on, and when a role should be its own session versus a subagent. Use when standing up a fleet, deciding who owns an activity, choosing a model for a spawned agent, writing a role brief, adding a second lane to one repository, or building the RACI for a run. Enforces that every spawned agent names its model - the orchestrator reasons, mid-tier executes, cheap models verify mechanically - and that a role which must heartbeat cannot be a subagent.

The contract every session in a multi-session Claude Code fleet reads first. Use when starting, joining, or running a fleet of parallel sessions on one codebase - heartbeats and standby, addressing other sessions through a dispatch router, ASSERTED vs DELIVERED claim states, git discipline (one repo per lane, push-and-open-PR as one action, never rewrite shared history), and merge-readiness discipline (re-read the checks as the literal last action before a merge). Triggers on "start a fleet", "orchestration protocol", "lane", "heartbeat", "dispatch", "PR ready", "merge gate", "who owns this repo", or any question about how parallel sessions coordinate.

Flask API development including blueprints, extensions, and REST patterns. Activate for Flask apps, Python web APIs, and lightweight API development.

Federated registry protocol for multi-source plugin resolution with policy enforcement, lockfile management, and conflict detection across local, team, org, and public registries.

This skill should be used when the user asks to "add WebSocket", "implement real-time", "create file upload", "add S3 upload", "send email", "implement notifications", "broadcast events", or mentions WebSockets, file storage, email service, push notifications, or real-time communication. Provides WebSocket, file upload, and notification patterns.

FastAPI best practices, Pydantic models, SQLAlchemy ORM, async patterns, dependency injection, and JWT authentication. Activate for FastAPI apps, async Python APIs, API design, and modern Python web services.

This skill should be used when the user asks to "add logging", "implement metrics", "add tracing", "configure Prometheus", "setup OpenTelemetry", "add health checks", "monitor API", or mentions observability, APM, monitoring, structured logging, distributed tracing, or Grafana. Provides comprehensive observability patterns.

This skill should be used when the user asks to "deploy FastAPI to Kubernetes", "create Dockerfile", "build Docker image", "write Helm chart", "configure K8s deployment", "add health checks", "scale FastAPI", or mentions Docker, Kubernetes, K8s, containers, Helm, or deployment. Provides containerization and orchestration patterns.

This skill should be used when the user asks to "add caching", "implement Redis cache", "cache API response", "invalidate cache", "add cache layer", "optimize with caching", or mentions Redis, caching strategies, cache invalidation, or performance optimization. Provides Redis caching patterns for FastAPI.

This skill should be used when the user asks to "create background task", "add async job", "implement task queue", "schedule periodic task", "use Celery", "use ARQ", "process async", or mentions background processing, task queues, job scheduling, workers, or async jobs. Provides multiple task queue framework patterns.

FastAPI development including async endpoints, Pydantic models, dependency injection, and OpenAPI documentation. Activate for FastAPI apps, async Python APIs, and modern Python web services.

Extended thinking (ultrathink) configuration for Claude API. Activate for complex reasoning tasks, deep analysis, multi-step problem solving, and tasks requiring careful deliberation. Enables Claude's internal reasoning with configurable thinking budgets.

One claim with ten sightings - a wrong predicate and a missing notification both produce a plausible, quiet, checkable-looking state, neither raises an error, and the only defence in both is a second reading through a different mechanism. In tooling that is the raw print through a different field; in coordination it is measuring the thing you wait on rather than waiting for news of it. Covers - ask what an artifact SITS ON and whether that moved, print the RAW STATE beside any predicate that decides whether to stop, a gate must name an input that turns it red, a destructive predicate needs its spare case proven by mutation, an absence needs the size of the space searched, a search-space cap manufactures false negatives while a result-set cap does not, check the exit code before reading the output, a true measurement stated as a durable property never expires and never stops being wrong, a count is only evidence when the thing counted is named, and a correction is itself a claim that names the set it ranges over. Use when writing a gate, guard, scanner, retention or delete rule; when reporting that something was not found, does not exist, or is not used; when writing a PR body, review verdict, status report or handover; when quoting a number to someone else; when relaying someone else's finding; and when correcting anything you or anyone else said earlier.

Entity Framework Core patterns for data access, migrations, relationships, performance, and best practices

Metadata-driven CRUD with MUI X DataGrid + FormEngine — entity metadata model, server-driven UI, column/form generation, shared validation, access control, wizard flows

Home Assistant energy monitoring and optimization patterns.

MUI ecosystem — FormEngine, react-jsonschema-form, Uniforms, schema-driven forms, Tailwind interop, Framer Motion, and third-party component libraries

.NET Aspire for cloud-native app orchestration, service discovery, telemetry, and component integrations

.NET AI integration with Microsoft.Extensions.AI, Semantic Kernel, MCP servers, embeddings, vector search, and agent frameworks

Multi-container .NET applications with Docker Compose, container orchestration, and development environments

Build Docker images with proper tagging, cache busting, and build tracking. Prevents stale image issues.

Plugin Dev Studio workflow for hot-reload development, interactive testing, dependency visualization, and validation of Claude Code plugins. Covers the full plugin development lifecycle from scaffold to publish.

Expertise in deployment automation, container orchestration, and infrastructure as code. Activates when working with "deploy", "kubernetes", "docker", "terraform", "helm", "k8s", "container", or cloud infrastructure.

Apply and manage the AI-powered design system with 50+ curated styles

Comprehensive research on a topic using multiple sources and approaches. Spawns parallel research threads.

Analytical thinking patterns for comprehensive evaluation, code audits, security analysis, and performance reviews. Provides structured templates for thorough investigation with extended thinking support.

Debugging techniques for Python, JavaScript, and distributed systems. Activate for troubleshooting, error analysis, log investigation, and performance debugging. Includes extended thinking integration for complex debugging scenarios.

Domain-Driven Design and CQRS patterns for .NET microservices including aggregates, value objects, domain events, repositories, and application layer design

MUI X Date/Time Pickers setup, configuration, and form integration

Database design, SQL queries, migrations, and optimization. Activate for PostgreSQL, MySQL, SQLite, schema design, queries, indexes, and data modeling.

MUI X DataGrid configuration, server-side integration, and optimization

MUI CSS Variables mode (CssVarsProvider), Pigment CSS zero-runtime engine, and CSS custom properties theming

Expert knowledge for pure CSS animations - lightweight, performant animations using CSS keyframes, transitions, and modern CSS features without JavaScript dependencies.

Modern C# 13/15 patterns, LINQ mastery, async/await, records, pattern matching, .NET 10/11 features, and .NET AI integration

Expert knowledge for artistic and creative animation effects - morphing shapes, liquid animations, glitch effects, distortion, and experimental visual techniques that push creative boundaries.

Knowledge for launching, managing, and monitoring cowork sessions that orchestrate multiple plugin agents in parallel

Project fingerprinting, association rule mining (Apriori), and cosine-similarity plugin recommendations

This skill should be used when the user asks to "create a Confluence page", "write documentation", "write a TDD", "create an ADR", "write a runbook", or "publish to Confluence" — authoring and linking technical documentation in Confluence from Jira work.

Confluence documentation including pages, spaces, templates, and Atlassian integration. Activate for wiki pages, documentation, knowledge bases, and team collaboration.

MUI core component patterns and best practices

Multi-step reasoning patterns and frameworks for systematic problem solving. Activate for Chain-of-Thought, Tree-of-Thought, hypothesis-driven debugging, and structured analytical approaches that leverage extended thinking.

This skill should be used when the user asks to "review code", "check changes", "analyze a PR", "do a security review", or "assess code quality" — providing comprehensive review across correctness, security, performance, accessibility, and testing.

Expertise in automated testing, code review practices, and quality standards enforcement. Activates when working with "lint", "test", "review", "coverage", "quality", "standards", or test automation.

Deploying .NET apps to Azure Container Apps, App Service, Docker, and Kubernetes with CI/CD

This skill should be used when the user asks to "apply clean architecture", "follow SOLID principles", "add dependency injection", "separate layers", "use hexagonal/onion architecture", "domain-driven design", or needs guidance on structuring code into clean, testable, decoupled layers.

Universal reference for Claude Code automation surface — hooks, skills, plugins, sub-agents, agent teams, MCP, scheduled tasks, channels, routines, headless/SDK, checkpointing, permissions. Invoke when designing automations that leverage Claude Code features or when user asks "how do I automate X with Claude Code".

Document citations and RAG (Retrieval-Augmented Generation) patterns for Claude. Activate for source attribution, document grounding, citation extraction, and contextual retrieval.

This skill should be used when reading CI logs and diagnosing failures — fetching Actions logs through the GitHub MCP, classifying failures by cause, and distinguishing flaky tests from real regressions.

MUI X Charts — BarChart, LineChart, PieChart, ScatterChart, composition API, custom axes, tooltips, and responsive patterns

Git worktree creation, agent isolation, parallel task execution with EnterWorktree/ExitWorktree, branch-per-worktree patterns, and cleanup lifecycle for Claude Code

Checkpoint-between-waves cadence for multi-file refactors. After each logical batch (wave) of edits, run typecheck + tests; commit only on green; roll back the wave (not the whole branch) on red. Use for any refactor touching more than three files or three distinct concerns.

Ultraplan cloud planning — kick off a plan in the cloud from your terminal, review and revise in the browser, then execute remotely or send back to CLI

Idempotent update of an existing Claude Code setup — re-fingerprint the repo, propagate updates to sub-repos, refresh docs/context, section-merge CLAUDE.md/README.md, fix configuration drift. Use this skill whenever the user runs /cc-sync, asks to "update the claude setup", "propagate to sub-repos", "fix drift", "resync", or reports that the .claude/ directory has gone stale.

Deploy or audit the full 5-layer Claude Code stack (CLAUDE.md + skills + hooks + agents + memory) in a repository. Use this skill whenever the user runs /cc-setup, asks to "set up Claude Code on this repo", "configure a new repo for Claude", "audit my Claude Code setup", "generate CLAUDE.md", "install hooks", "wire up the 4-layer stack", or starts work in a repo that lacks .claude/. Also triggers on "bootstrap Claude Code", "add claude setup", or whenever a fresh repo needs Claude Code configuration.

Claude Code security and compliance — permissions model, settings.json allowlists/denylists, enterprise managed settings, audit logging, secrets handling, SOC2/HIPAA/GDPR patterns. Use this skill whenever configuring permissions, auditing a setup for security, handling secrets, preparing for compliance, or tightening access. Triggers on: "permissions", "allowlist", "security audit", "compliance", "SOC2", "HIPAA", "GDPR", "secrets", "enterprise settings", "managed settings", "deny list".

Manage the three-tier memory system (engram + Obsidian vault + plugin rules) for Claude Code setups. Use this skill whenever saving CC-setup findings, consolidating engram into durable knowledge, writing repo docs to the Obsidian vault, or running /cc-memory subcommands. Triggers on phrases like "save this pattern", "promote to memory", "update the vault", "consolidate memory", "write an ADR", and whenever work on CC plugins, hooks, agents, skills, or autonomy profiles concludes.

Craft effective CLAUDE.md routing, agent system prompts, skill descriptions, rule files, and task framings. Use this skill whenever writing a CLAUDE.md, authoring a subagent, writing a skill description, crafting a /command prompt, framing an ambiguous task for Claude, or debugging why Claude isn't picking up guidance. Triggers on: "write a CLAUDE.md", "agent prompt", "skill description", "pushy description", "task framing", "claude isn't following", "make claude do X", "rules not loading".

Pre-flight check to run before any Agent-tool spawn. Prevents the "Prompt is too long" rejection class by enforcing a 5-section minimum-viable-prompt template and estimating forwarded context cost. Use whenever you are about to call the Agent tool with more than a one-paragraph prompt.

Build, validate, and publish Claude Code plugins — manifest schema, skill/command/agent/hook authoring, MCP server integration, marketplace publishing, version management. Use this skill whenever creating a new plugin, adding a skill/command/agent to an existing plugin, validating plugin.json, debugging plugin load failures, or publishing to a marketplace. Triggers on: "create plugin", "plugin.json", "add skill to plugin", "publish plugin", "plugin validation", "marketplace", "plugin manifest", "my plugin isn't loading".

Shared filesystem-backed blackboard for multi-agent runs. Parallel subagents append findings for a given run-id; subsequent-round subagents read them via MCP tools without the orchestrator having to paste everything into their prompts. Use for any fan-out pattern with more than one round of deliberation.

Monitor tool for streaming background process events into conversations — tail logs, watch CI, auto-fix dev server crashes, and /loop self-pacing without Bash sleep loops

Pick the right Claude model (Fable, Opus, Sonnet, Haiku) for a task and manage cost — decision matrix, cost tables, budget planning, cascading strategy. Use this skill whenever choosing a model, setting a token budget, optimizing session cost, or deciding whether to upgrade/downgrade mid-task. Triggers on: "which model", "cost", "budget", "haiku vs sonnet", "opus for this", "fable for this", "save tokens", "model cascading", "/cc-budget".

Configure MCP servers for Claude Code — stdio vs HTTP, authentication, Tools/Resources/Prompts distinction, channels (CI webhook, mobile relay, Discord bridge, fakechat), and cost of always-loaded tools. Use this skill whenever adding an MCP server, debugging connection issues, choosing between MCP Tools vs Prompts vs Resources, installing channel servers, or managing .mcp.json. Triggers on: "MCP server", "mcp config", "add Obsidian MCP", "install context7", "channels", "webhook receiver", "mobile approval", "Discord bridge", "mcp not connecting".

Design, install, and debug Claude Code hooks across the full lifecycle (PreToolUse, PostToolUse, PostToolUseFailure, UserPromptSubmit, Notification, Stop, SessionStart, SessionEnd, PreCompact, SubagentStart, SubagentStop, TeammateIdle, PermissionRequest, Setup). Use this skill whenever a user asks to "install hooks", "add a pre-tool hook", "format on save", "block dangerous commands", "protect sensitive files", "restore context after compact", "enforce tests before stop", capture subagent telemetry, or runs /cc-hooks. Also triggers on "hooks not firing", "hook keeps blocking", or any configuration of .claude/settings.json hook sections.

Evidence-driven deep analysis for hard coding problems — architecture decisions, root-cause investigation, high-stakes refactor planning, performance bottleneck isolation. Use this skill whenever the user asks for "the best approach", a "deep analysis", "root cause", "principal engineer review", or runs /cc-intel. Also triggers on hard debugging questions, major architectural choices, tricky performance problems, or any task where a hypothesis tree and evidence table matter more than a fast answer.

Manage Claude Code's context window — token arithmetic, /compact strategy, anchor preservation, progressive loading, session analytics. Use this skill whenever a session gets long, context approaches limits, after /compact, when deciding what to load into CLAUDE.md vs leave in references, or when analyzing session cost/token usage. Triggers on: "context full", "compact", "too many tokens", "budget", "session analytics", "save tokens", "context window", "/compact strategy".

Configure Claude Code's autonomous operating mode — profile selection (conservative, balanced, aggressive, unattended-review), permission blocks, and the three gate agents (planner, verifier, reviewer). Use this skill whenever enabling autonomous mode, switching profiles, tightening permissions for production branches, or setting up unattended execution. Triggers on: "autonomy", "unattended mode", "auto-approve", "permission mode", "autonomy profile", "gates", "/cc-autonomy", "planner verifier reviewer", "let claude run on its own".

Auto mode permission handling — classifier-based approvals, PermissionDenied hook, defer permissionDecision, and autonomy profiles for hands-off Claude Code usage

Select and wire an agentic design pattern (reflection, prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer, ReAct, blackboard) into the 5-layer Claude Code stack. Use this skill whenever deciding how to structure a multi-step task, whether to spawn subagents, how to run parallel review, or when to use which pattern. Triggers on: "which pattern", "orchestrate", "parallel review", "self-review", "chain of thought", "eval-optimizer loop", "blackboard", "ReAct", "how to decompose this task".

Select and coordinate multi-agent teams (topology kits, role-based squads, lifecycle, worktree isolation). Use this skill whenever launching parallel agents, designing a review board, running a debug council, scheduling an orchestrator-workers team, configuring agent tool restrictions, or deciding between solo and team execution. Triggers on: "launch a team", "parallel agents", "review board", "debug council", "architect-implementer-reviewer", "swarm", "multi-agent", "subagents for X", "team topology", "agent lifecycle".

Home Assistant camera integration and Frigate NVR patterns.

Testing Blazor apps with bUnit, xUnit, WebApplicationFactory, and integration testing patterns

Blazor rendering optimization, virtualization, lazy loading, caching, and memory management

JavaScript interop in Blazor for calling JS from .NET and .NET from JS

Blazor forms, EditForm, input components, DataAnnotations, FluentValidation, and custom validation

Blazor component model including render modes, lifecycle, parameters, event handling, and component communication

Authentication and authorization in Blazor with ASP.NET Core Identity, Entra ID, JWT, and policy-based auth

This skill should be used when the user asks to "create MongoDB model", "define Beanie document", "write MongoDB query", "create aggregation pipeline", "run database migration", "index MongoDB collection", or mentions Beanie, Motor, MongoDB documents, or async database operations. Provides MongoDB/Beanie ODM patterns for FastAPI.

Message Batches API for Claude with 50% cost savings on bulk processing. Activate for batch jobs, JSONL processing, bulk analysis, and cost optimization.

MUI Base (unstyled/headless) components and hooks — useButton, useInput, useMenu, useSlider for building custom UI

Expert knowledge for creating stunning animated backgrounds - gradient flows, particle systems, mesh gradients, aurora effects, wave patterns, and dynamic textures that bring depth and life to your interfaces.

AWS cloud services including EC2, EKS, S3, Lambda, RDS, and IAM. Activate for AWS infrastructure, cloud deployment, and Amazon Web Services integration.

Authentication and authorization including JWT, OAuth2, OIDC, sessions, RBAC, and security analysis. Activate for login, auth flows, security audits, threat modeling, access control, and identity management.

Atlassian API integration for Jira and Confluence automation. Activate for Atlassian REST APIs, webhooks, and platform integration.

ASP.NET Core API development with minimal APIs, controllers, middleware, OpenAPI, and best practices

MUI transition components (Fade, Grow, Slide, Collapse, Zoom), custom transitions, TransitionGroup, and Framer Motion integration

Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to full-stack development and infrastructure-as-code automation

This skill should be used when integrating AG-UI — the full event taxonomy (lifecycle, text message, tool call, state, activity, reasoning, custom), RunAgentInput, SSE and binary transports, AbstractAgent/HttpAgent, STATE_DELTA JSON Patch, generative UI, human-in-the-loop interrupts, and CopilotKit frontends.

Top 0.01% MUI patterns — sparkline grid cells, heatmap DataGrids, real-time WebSocket grids, AI assistant, save/restore grid state, bi-directional chart+grid, pivot tables, clipboard paste, progress cells

Advanced MUI component patterns — Autocomplete (async, virtualized, grouped, createFilterOptions), Stepper (non-linear, vertical, mobile), Popover, Popper, Portal, ClickAwayListener, and complex composition

This skill should be used when building automation on GitHub Actions beyond CI — manual and external triggers, scheduled jobs, reusable workflows, composite actions, issue and PR bots, auto-merge, and Dependabot.

This skill should be used when writing, hardening, or optimizing GitHub Actions workflows — permissions, action pinning, script injection, caching, matrices, concurrency, and cost.

MUI accessibility patterns, ARIA attributes, and WCAG compliance

Expert knowledge for decorative accent animations - floating shapes, glowing orbs, animated borders, sparkle effects, and embellishments that add visual polish and delight to interfaces.

This skill should be used when building A2UI (Agent to UI) interfaces — the six streamed message types, surfaces, the flat adjacency-list component model, component catalogs, JSON Pointer data binding and two-way input binding, actions vs functionCalls, CheckRule validation, and progressive streaming.

Expert knowledge for CSS/JS-based 3D animations - perspective transforms, depth effects, card flips, cube rotations, and parallax depth without WebGL.