agent-skills

Apply Clean Code principles (meaningful names, small functions, error handling, TDD, SRP, smells & heuristics) when authoring, refactoring, or reviewing code—especially TypeScript. Use when the user asks for clean code, refactoring, extract function or class, code smell or maintainability review, readable tests, or Robert C. Martin's Clean Code rules.

Detect, name, and remediate code smells using the classic taxonomy (Bloaters, Object-Orientation Abusers, Change Preventers, Dispensables, Couplers) when reviewing, refactoring, or authoring code. Use when the user asks to find code smells, review code for maintainability, identify long methods/large classes/duplicate code/feature envy, or wants refactoring guidance tied to a named smell.

Create and maintain custom Skills with correct SKILL.md metadata, strong trigger-aware descriptions, concise instructions, progressive disclosure, and validation loops. Use when the user asks to write, improve, review, or organize a Skill.

Create and maintain custom subagent definition files for any AI agent platform, with strong descriptions, tight tool scope, and explicit handoff contracts. Use when the user asks to create, improve, or standardize a subagent.

Teach and apply the Chain of Responsibility (CoR) pattern to pass requests along a dynamic chain of handlers where each can process or forward the request. Use when users ask about CoR, Chain of Command, middleware pipelines, sequential validation, request bubbling, or comparing CoR to Decorator, Command, or Mediator.

Teach and apply the Command pattern to encapsulate requests as objects for decoupled invocation, queuing, scheduling, logging, and undo/redo workflows. Use when users ask about Command, Action, Transaction, invoker-receiver decoupling, reversible operations, or comparing Command with Strategy, Chain of Responsibility, or Memento.

Teach and apply the Iterator pattern to traverse collections without exposing their internal structure. Use when users ask about Iterator, custom traversal algorithms, decoupling traversal from collections, parallel iteration, lazy iteration, or comparing Iterator to for-each loops and language-native iterables.

Teach and apply the Mediator pattern to centralize collaboration rules among tightly coupled components and eliminate direct component-to-component dependencies. Use when users ask about Mediator, Intermediary, Controller, UI dialog coordination, reusable components, or comparing Mediator with Observer, Facade, or Chain of Responsibility.

Teach and apply the Memento (Snapshot) pattern to save and restore object state without breaking encapsulation. Use when users ask about Memento, Snapshot, undo/redo, state history, transaction rollback, or comparing Memento to Prototype or Command.

Teach and apply the Observer pattern to implement event-driven one-to-many notifications with dynamic subscription and loose coupling between publishers and subscribers. Use when users ask about Observer, Event-Subscriber, Listener, pub/sub style updates, runtime subscriptions, or comparing Observer with Mediator, Command, or Chain of Responsibility.

Teach and apply the State pattern to replace state-based conditional branches with polymorphic state objects. Use when users ask about State, finite-state machines, eliminating state conditionals, behavior that changes per state, or comparing State to Strategy.

Teach and apply the Strategy pattern to isolate interchangeable algorithms behind a common interface and swap them at runtime without changing context logic. Use when users ask about Strategy, algorithm selection, replacing large conditionals, runtime behavior switching, or comparing Strategy with State, Command, or Template Method.

Teach and apply the Template Method pattern to define an algorithm skeleton in a base class while allowing subclasses to override selected steps without changing overall flow. Use when users ask about Template Method, extracting duplicate algorithm structure, superclass hooks, final template flows, or comparing Template Method with Strategy or Factory Method.

Teach and apply the Visitor pattern to add new operations to a stable element hierarchy without modifying element classes, using double dispatch. Use when users ask about Visitor, double dispatch, adding behavior to sealed/frozen class hierarchies, separating algorithms from object structures, or combining Visitor with Composite or Iterator.

Teach and apply the Abstract Factory pattern to create families of related products through abstract interfaces while keeping variants compatible. Use when users ask about Abstract Factory, replacing concrete constructors for multiple product types, ensuring variant consistency, or comparing Abstract Factory with Factory Method or Builder.

Teach and apply the Builder pattern to construct complex objects step by step, separating construction from representation. Use when users ask about Builder, telescoping constructors, step-by-step object assembly, Director/Builder roles, or comparing Builder to Factory patterns.

Teach and apply the Factory Method pattern to remove direct constructor coupling and enable extensible object creation via creator subclasses. Use when users ask about Factory Method, virtual constructor, replacing new calls, introducing creator/product hierarchies, or comparing Factory Method to Abstract Factory.

Teach and apply the Prototype pattern to copy existing objects through a cloning interface without coupling client code to concrete classes. Use when users ask about Prototype or Clone, replacing repeated initialization with preconfigured instances, handling copy semantics, or comparing Prototype with Factory Method, Builder, or Memento.

Teach and apply the Singleton pattern to ensure a class has exactly one instance with a global access point. Use when users ask about Singleton, single shared instance, thread-safe initialization, lazy vs eager instantiation, or comparing Singleton to dependency injection.

Teach and apply the Adapter pattern to let incompatible interfaces collaborate by translating calls, data formats, or call order through a wrapper. Use when users ask about Adapter or Wrapper, integrating legacy or third-party services, format conversion boundaries, or comparing Adapter with Decorator, Facade, Proxy, or Bridge.

Teach and apply the Bridge pattern to decouple abstraction from implementation across two independent class hierarchies. Use when users ask about Bridge, class hierarchy explosion, orthogonal dimensions, platform-independent abstractions, or comparing Bridge to Adapter or Strategy.

Teach and apply the Composite pattern to model tree structures where leaves and containers share a common interface and can be handled uniformly. Use when users ask about Composite or Object Tree, recursive aggregation, uniform leaf/container operations, or comparing Composite with Decorator, Visitor, or Iterator.

Teach and apply the Decorator (Wrapper) pattern to attach new behaviors to objects dynamically via composable wrapper layers. Use when users ask about Decorator, Wrapper, adding behavior at runtime, avoiding subclass explosion from optional features, or comparing Decorator to Proxy, Adapter, or Composite.

Teach and apply the Facade pattern to provide a simple, task-focused interface over complex subsystems while reducing client coupling to internal classes. Use when users ask about Facade, simplifying third-party frameworks, layered entry points, minimizing integration boilerplate, or comparing Facade with Adapter, Proxy, or Mediator.

Teach and apply the Flyweight (Cache) pattern to reduce RAM usage by sharing immutable intrinsic state across massive numbers of similar objects. Use when users ask about Flyweight, object pooling, intrinsic vs extrinsic state, RAM-constrained object creation, or comparing Flyweight to Singleton or Prototype.

Teach and apply the Proxy pattern to substitute a service with an interchangeable wrapper that controls access while preserving the same interface. Use when users ask about Proxy, lazy initialization, access control, remote service wrappers, request logging, caching, or comparing Proxy with Decorator, Adapter, or Facade.

Builds, extends, and reviews Expo native modules with the Modules API (Swift/Kotlin ModuleDefinition DSL, expo-modules-core, views, events, Records, Android Package lifecycle listeners). Use when creating a local or published Expo module, writing native code in ios/ or android/, hooking MainActivity or Application without manual MainActivity edits, deep links, ReactActivityLifecycleListener, or bridging requireNativeModule to JavaScript events.

Installs and configures NativeWind v4 (Tailwind CSS for React Native) in an Expo project, covering package installation, Tailwind config, Babel preset, Metro config, global CSS import, and app.json bundler switch. Use when the user asks to add NativeWind, set up Tailwind CSS in Expo, configure nativewind, or integrate Tailwind with a React Native / Expo project.

Apply Pragmatic Programmer principles—DRY (Don't Repeat Yourself) and Orthogonality—when authoring, reviewing, or refactoring code. Detects knowledge duplication, tight coupling, global state abuse, and similar-function sprawl, then proposes authoritative single-source fixes. Use when the user asks for DRY review, coupling analysis, orthogonality check, "make this more pragmatic", or references The Pragmatic Programmer book principles.

Apply named refactoring techniques (Extract Method, Move Method, Replace Conditional with Polymorphism, etc.) organized by the classic catalog — Composing Methods, Moving Features between Objects, Organizing Data, Simplifying Conditional Expressions, Simplifying Method Calls, and Dealing with Generalization. Use when the user wants to refactor code, restructure without changing behavior, clean up a method/class/hierarchy, or asks how to perform a specific named refactoring or treat a code smell.