Nicholas Ferguson

Extract insights from multi-agent interactions, identify patterns, and build collective intelligence through cross-agent learning and knowledge management. Use when synthesizing findings, building knowledge bases, or improving system-wide practices.

Test and validate skills under pressure using a structured TDD approach.

Conduct comprehensive security assessments and remediation for your applications.

Design effective data dashboards by selecting KPIs, structuring layouts, and applying visual hierarchy.

Systematically audit and maintain project documentation to ensure accuracy and organization.

Facilitates a feedback loop for AI skill recommendations based on context changes and task completions.

Use when facing 3+ independent failures that can be investigated without shared state or dependencies - dispatches multiple Claude agents to investigate and fix independent problems concurrently

Build scalable design systems using design tokens, component APIs, and documentation strategies.

Optimize build systems to reduce compilation times and enhance developer productivity.

Structured protocols for challenging proposals and assumptions to enhance decision-making.

Implement API Gateway patterns for routing, authentication, and service composition in microservices.

Analyze competitors effectively using structured frameworks for strategic insights.

Create and evaluate accessible color palettes for brands and design systems.

Implement multi-layer validation to prevent bugs caused by invalid data.

Curate and prepare datasets for machine learning model training and evaluation.

Validate documentation claims against the codebase to ensure accuracy.

Systematic workflow for refining code, documentation, or designs to production-grade quality.

Automate code review remediation loops using the codex CLI for structured code quality management.

Helm chart development patterns for Kubernetes applications.

Master TypeScript with advanced types, generics, and strict type safety. Handles complex type systems, decorators, and enterprise-grade patterns. Use proactively for TypeScript architecture, type inference optimization, or advanced typing patterns.

Create comprehensive technical references and API documentation effortlessly.

Design and optimize GitHub Actions CI/CD pipelines with proven workflow patterns.

Implement robust security policies in Kubernetes clusters for hardened deployments.

Fast, high-signal accessibility triage for pages, components, or PRs targeting WCAG 2.2 AA compliance.

Use when implementing any feature or bugfix, before writing implementation code - write the test first, watch it fail, write minimal code to pass; ensures tests actually verify behavior by requiring failure first

Best practices for Terraform infrastructure-as-code to ensure scalability and maintainability.

A specialized agent that implements the Orchestrator-Workers pattern. It analyzes complex requests, breaks them down into atomic tasks, delegates them to the most appropriate specialist agents or tools, and synthesizes the results. Use this agent for "vague" or multi-step requests. For durable team design and capacity planning, use `agent-organizer` instead.

Optimize prompts for LLMs and AI systems with structured techniques, evaluation patterns, and synthetic test data generation. Use when building AI features, improving agent performance, or crafting system prompts.

Debugging specialist for errors, test failures, and unexpected behavior. Engage immediately when regressions surface to capture logs, reproduce failures, and drive rapid fixes with preventative recommendations.

Manages context across multiple agents and long-running tasks. Use when coordinating complex multi-agent workflows or when context needs to be preserved across multiple sessions. Must be used for projects exceeding 10k tokens.

Use when executing implementation plans with independent tasks in the current session - dispatches fresh subagent for each task with code review between tasks, enabling fast iteration with quality gates

Use when tests have race conditions, timing dependencies, or inconsistent pass/fail behavior - replaces arbitrary timeouts with condition polling to wait for actual state changes, eliminating flaky tests from timing guesses

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes - four-phase framework (root cause investigation, pattern analysis, hypothesis testing, implementation) that ensures understanding before attempting solutions

Use when writing or changing tests, adding mocks, or tempted to add test-only methods to production code - prevents testing mock behavior, production pollution with test-only methods, and mocking without understanding dependencies

Operational workflow for implementer agents to manage code changes and testing efficiently.

Audit documentation completeness by identifying gaps between what should be documented and what exists.

Create effective data visualizations by selecting the right chart type and generating code for implementation.

Master Kubernetes deployment strategies and workload patterns for production applications.

Systematic approach for identifying and fixing bugs effectively.

Streamline your project estimations with structured workflows for time, effort, and complexity.

Establish a safe workflow for cleaning up repositories by removing dead code, unused dependencies, and outdated documentation.

Comprehensive patterns for designing and implementing microservices architectures.

Contribute your developed skills back to the upstream repository via pull requests.

Master advanced TypeScript patterns for type-safe and maintainable code.

A set of resources to help write all kinds of internal communications, using company-specific formats. Use when asked to write internal communications (status reports, leadership updates, 3P updates, company newsletters, FAQs, incident reports, project updates, etc.).

Modernize legacy systems using proven migration patterns for safe and incremental transitions.

Structured research methodology for thorough analysis and synthesis of information.

Comprehensive guide for designing REST and GraphQL APIs with industry-standard patterns.

Streamline the creation and organization of documentation across various formats.

Transform PRDs and feature specs into actionable implementation workflows with structured task decomposition.

User flow design, micro-interactions, and interface behavior patterns with state management for all interaction conditions. Use when designing natural interactions, feedback systems, or handling error states.

Implement CQRS and Event Sourcing patterns for scalable, auditable systems.

Implement robust testing strategies in Python with pytest and mocking techniques.

Conduct a thorough documentation health audit across five critical dimensions.

RESTful API specialist for designing and implementing HTTP contracts.

Systematically generate tests to improve code coverage and validate quality.

Conduct user research effectively with this skill, from planning to reporting.

Design system and component library specialist for reusable UI architectures.

Safely execute git operations and generate conventional commit messages.

Verify factual claims and assess the credibility of information with this skill.

Streamline your production release process with a comprehensive checklist-driven workflow.

Event-driven architecture patterns with event sourcing, CQRS, and message-driven communication. Use when designing distributed systems, microservices communication, or systems requiring eventual consistency and scalability.

Create engaging hands-on tutorials with structured exercises and troubleshooting guidance.

Use when designing system architecture, APIs, components, or data models - provides a structured design workflow with validation and documentation outputs.

Achieve maximum visual excellence for any UI platform with this skill.

Manage reasoning depth, budgets, and metrics visibility with precise controls.

Task tracking system for agents using Backlog.md CLI, optimized for structured issue filing and task management.

Frontend performance specialist focused on Core Web Vitals and bundle optimization.

Streamline feature implementation with structured guidance for multi-file changes.

Consult multiple external LLMs for diverse perspectives and task delegation.

Systematic performance analysis and optimization for applications.

Expert code review specialist. Proactively reviews code for quality, security, and maintainability with heightened attention on configuration drift that could impact production reliability. Invoke immediately after code or config changes to prevent regressions.

Compressed communication using symbols and abbreviations. Use when context is limited or brevity is needed.

Use this skill when writing product requirements documents, prioritizing features, creating user stories, defining acceptance criteria, or setting product metrics. Trigger phrases: 'write a PRD for', 'prioritize this feature backlog', 'write user stories for', 'help me define acceptance criteria', 'what metrics should we track for'. Not for writing code, designing UI mockups, or conducting user research interviews.

Activate visual showcase modes for impactful UI design with specific enhancement checklists.

Writes, optimizes, and debugs complex SQL queries for Postgres, MySQL, and SQLite.

Senior JavaScript engineer mastering ES2024+, async orchestration, and cross-runtime debugging. Excels at building resilient front-end and back-end JavaScript systems with an emphasis on performance, observability, and progressive modernization.

Create detailed user journey maps to identify pain points and opportunities across user experiences.

Design, validate, and maintain OpenAPI 3.x specifications for REST APIs.

Create high-quality, distinctive UI designs focused on performance and user experience.

Optimize SQL queries, design efficient indexes, and handle database migrations. Solves N+1 problems, slow queries, and implements caching. Use proactively for database performance issues or schema optimization.

Vitest specialist for fast unit tests in Vite-based projects.

Designs and scales real-time WebSocket architectures with low latency and resilience.

Coordinate complex tasks with structured workflows for orchestration and delegation.

Establishes mandatory workflows for skill usage in conversations.

Use when creating new skills, editing existing skills, or verifying skills work before deployment - applies TDD to process documentation by testing with subagents before writing, iterating until bulletproof against rationalization

Review code for vulnerabilities, implement secure authentication, and ensure OWASP compliance. Handles JWT, OAuth2, CORS, CSP, and encryption. Use proactively for security reviews, auth flows, or vulnerability fixes.

Select the best MCP tool based on task complexity and requirements.

Use this skill when specifying, designing, or documenting UI components, layouts, and design systems for frontend implementation. Trigger phrases: 'design this UI component', 'create a responsive layout', 'spec the CSS for', 'design system for'. Do NOT use for backend development, server-side logic, data engineering, or writing server code.

Manage session lifecycles with structured workflows for loading, saving, and reflecting on context.

Analyze complex problems by adopting multiple expert personas sequentially for diverse insights.

Implement secure coding practices to build security-first applications and mitigate risks.

Proofread written content for grammar, spelling, and style consistency before publishing.

Identify and remediate the top 10 web application security vulnerabilities.

Guide for creating effective skills. Use when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.

Automates browser interactions for web testing, form filling, screenshots, and data extraction. Use when the user needs to navigate websites, interact with web pages, fill forms, take screenshots, test web applications, or extract information from web pages.

Optimize Python code performance with profiling and algorithmic improvements.

Meta-skill for auditing and validating skill quality across multiple dimensions.

Standardize code quality assessments and improvements with structured workflows.

Craft clear and effective UI text for in-product writing, including microcopy and error messages.

Draft professional and personal emails with clarity and effectiveness.

Structured decision-making framework for complex choices and trade-offs.

Use this skill when gathering and documenting business requirements, mapping processes, performing gap analysis, writing business requirements documents (BRDs), or modeling stakeholder impact. Trigger phrases: 'write a business requirements document', 'map this process', 'gather requirements for', 'gap analysis for', 'AS-IS TO-BE process'. Not for writing user stories (use product-manager skill), conducting user research (use ux-researcher), or financial modeling.

Designs secure, scalable, and cost-aware cloud architectures across AWS, Azure, and GCP.

Builds reliable automated test suites across unit, integration, and end-to-end layers with CI integration.

Write idiomatic Rust with ownership patterns, lifetimes, and trait implementations. Masters async/await, safe concurrency, and zero-cost abstractions. Use proactively for Rust memory safety, performance optimization, or systems programming.

Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always

A template for creating new skills. Use when initializing a new skill to ensure proper structure and metadata.

Comprehensive security testing patterns for SAST, DAST, and penetration testing.

Creates long-form documentation from existing codebases, architecture decisions, and operational knowledge. Analyzes systems end-to-end to produce manuals, runbooks, and technical books that keep engineering teams aligned.

Create persuasive, conversion-focused copy for marketing materials like landing pages and ads.

Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation

PostgreSQL specialist for schema design, indexing, and query tuning.

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup

Streamline feature development from design to deployment with a structured workflow.

Streamline feature development from design to deployment with a structured workflow.

Automate regulatory compliance auditing across major frameworks like GDPR and HIPAA.

Create interface designs, wireframes, and design systems. Masters user research, prototyping, and accessibility standards. Use proactively for design systems, user flows, or interface optimization.

Python asyncio and concurrent programming patterns for high-performance applications. Use when building async APIs, concurrent systems, or I/O-bound applications requiring non-blocking operations.

Evaluate documentation quality for readability, consistency, and clarity with actionable insights.

Optimize React application performance with proven patterns and strategies.

Request code reviews to ensure quality and adherence to requirements before merging changes.

Review test quality and audit coverage gaps for any module with a structured pipeline.

Conduct comprehensive UX reviews combining usability, accessibility, and interaction design insights.

Comprehensive guide for secure coding practices to prevent web vulnerabilities.

Conduct thorough online research and evaluate source credibility with this skill.

Build GitOps-driven Kubernetes platforms with service mesh and observability for cloud-native environments.

Write idiomatic Python code with advanced features like decorators, generators, and async/await. Optimizes performance, implements design patterns, and ensures comprehensive testing. Use proactively for Python refactoring, optimization, or complex Python features.

Provides observability and anomaly detection for multi-agent systems, driving continuous improvements.

Senior React engineer mastering concurrent features, server components, and production-grade front-end systems. Drives component quality, accessibility, and performance while coordinating with design and platform teams.

Proactive threat modeling techniques using STRIDE, attack trees, and risk assessment for secure system design.

Maintains persistent project knowledge and session summaries to prevent loss of insights.

Toolkit for interacting with and testing local web applications using Playwright. Use when verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.

Incident triage, cascade prevention, and postmortem methodology. Use when handling production incidents, designing resilience patterns, or conducting chaos engineering exercises.

State management specialist for React applications and complex frontend architectures.

Create professional Mermaid diagrams for technical documentation, covering various types like flowcharts and ERDs.

Implement GitOps workflows for Kubernetes using ArgoCD and Flux to streamline CI/CD processes.

Compare AI and LLM models on benchmarks, cost, and performance to select the best fit for your needs.

Tailwind CSS specialist for utility-first design systems and styling.

Ensures database reliability through proactive management of operations, backups, and security.

Craft engaging narratives for fiction, brand stories, and emotional content.

Design evaluation frameworks for LLM quality, safety, and alignment.

Get structured feedback on UI designs, wireframes, and mockups to enhance usability and clarity.

Evaluate documentation architecture for better navigation and discoverability.

Enhance your codebase exploration with semantic search and impact analysis tools.

Streamline requirements gathering and project scope definition with structured techniques.

Enhanced skill template for creating complex skills with structured tiers and quality rubrics.

Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification

Streamline your build, test, and developer experience workflows with structured guidance.

Guide discovery through questioning techniques for Clean Code and design patterns.

Create beautiful visual art in .png and .pdf documents using design philosophy. Use when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.

Build, explain, and debug regular expressions for text processing tasks.

Draft comprehensive legal documents like Terms of Service and Privacy Policies for web applications and SaaS products.

Provide structured explanations of code and concepts tailored to specific audience levels.

Use when errors occur deep in execution and you need to trace back to find the original trigger - systematically traces bugs backward through call stack, adding instrumentation when needed, to identify source of invalid data or incorrect behavior

Conduct structured market research to size markets, analyze competitors, and design customer surveys.

Expert strategies for designing and optimizing database schemas across relational and NoSQL databases.

Product vision, roadmap development, and go-to-market execution with structured prioritization frameworks. Use when evaluating features, planning product direction, or assessing market fit.