Claude Skills by aRustyDev

Audit design components and generated code for WCAG 2.1 compliance including color contrast, touch targets, and screen reader compatibility

Optimize design assets for production deployment with format-specific compression, resolution scaling, and bundle optimization

Manage design system tokens including CRUD operations, multi-format export, version tracking, and synchronization with design files

Convert design specifications from Figma, Sketch, or Penpot to Flutter widgets with proper theming

Convert design specifications from Figma, Sketch, or Penpot to React components with CSS modules or styled-components

Convert design specifications from Figma, Sketch, or Penpot to SwiftUI view code with proper modifiers and theme integration

Convert design specifications from Figma, Sketch, or Penpot to HTML with Tailwind CSS utility classes

Extract design tokens (colors, typography, spacing, shadows) from Figma, Sketch, and Penpot design files via MCP servers and normalize to W3C format

Using DuckDB as an in-process analytical SQL engine for SwiftUI applications with CSV, Parquet, and SQLite support

Building data visualizations in SwiftUI using Apple's Swift Charts framework

Architecture patterns for SwiftUI applications including MVVM, navigation, dependency injection, and the @Observable macro

Reference for SwiftUI built-in components, layout tools, and visual styling for iOS-native interfaces

SwiftUI data flow mechanisms including @Observable, @State, @Binding, and environment values

Implementing touch interactions, gestures, and haptic feedback in SwiftUI for responsive user experiences

Testing strategies for SwiftUI applications including unit tests, UI tests, and preview-based testing

Craft targeted cover letters tailored to specific job descriptions and employer requirements

Analyze job descriptions to extract key requirements, responsibilities, and qualification signals

Analyze and categorize job requirements to identify must-have vs nice-to-have qualifications

Search and discover relevant job opportunities across platforms and networks

Develop and tailor resume content including experience descriptions, skills, and achievements

Reference for browser extension store APIs for querying extension info, checking compatibility, and tracking submission status

Browser API differences, polyfills, and feature detection for Firefox, Chrome, Safari, and Edge extensions

Common mistakes, performance pitfalls, and store rejection reasons in browser extension development

Comprehensive security guide for browser extensions covering CSP, permissions, secure messaging, sandboxing, and threat mitigation

Complete guides for submitting browser extensions to Chrome Web Store, Firefox Add-ons, Safari App Store, and Edge Add-ons

Complete reference for Manifest V3 browser extension development with cross-browser compatibility and migration guidance

Decision framework for WebAssembly usage in browser extensions including loading patterns, architecture, and performance considerations

Guide for integrating WebAssembly modules into browser extensions using wasm-pack, wasm-bindgen, and cross-browser loading

Comprehensive WXT browser extension framework patterns, security hardening rules, and cross-browser configuration

Dolt-powered issue tracker for multi-session work with dependencies and persistent memory across conversation compaction. Use when work spans sessions, has blockers, or needs context recovery after compaction. Trigger with "create task", "what's ready", "track this work", "resume after compaction". Make sure to use this skill whenever managing multi-session work, tracking dependencies, or recovering context.

Expert-level guidance for GitLab CI/CD pipeline configuration, development, optimization, debugging, and best practices.

Foundational Rust patterns covering core syntax, traits, generics, lifetimes, and common idioms. Use when writing Rust code, understanding ownership basics, working with Option/Result, or needing guidance on which specialized Rust skill to use. This is the entry point for Rust development.

Rust documentation practices for HASH codebase. Use when writing doc comments, documenting functions/types/traits/modules, creating error sections, using intra-doc links, following rustdoc conventions, or exploring crate APIs with cargo doc.

Rust crate and library development patterns covering Cargo.toml for libraries, crate structure, module organization, rustdoc, publishing to crates.io, feature flags, semantic versioning, and API design. Use when creating a Rust library or crate, publishing to crates.io, documenting APIs with rustdoc, or managing library features and versions. This is the specialized skill for Rust library/crate development.

Profile and debug Rust code using valgrind and callgrind with nextest integration. Use when debugging crashes, segfaults, memory errors, analyzing instruction counts, cache behavior, or identifying performance bottlenecks.

Foundational Scala patterns covering immutability, pattern matching, traits, case classes, for-comprehensions, and functional programming. Use when writing Scala code, understanding the type system, or needing guidance on which specialized Scala skill to use. This is the entry point for Scala development.

Scala-specific library development patterns. Use when creating Scala libraries, designing public APIs with immutability, configuring sbt/Mill build tools, managing cross-Scala version builds, publishing to Maven Central, and writing ScalaDoc. Extends lang-scala-dev with library-specific tooling and patterns.

Foundational SPARQL patterns covering RDF querying, triple patterns, graph patterns, and semantic web fundamentals. Use when querying RDF data or working with knowledge graphs. This is the entry point for SPARQL development.

Foundational SQL patterns for query writing, schema design, and dialect differences. Use when writing SQL queries, designing database schemas, understanding SQL syntax across PostgreSQL/MySQL/SQLite, or preparing SQL for conversion to other query languages. This is a meta-skill for SQL derivatives.

Foundational Swift development patterns covering modern Swift syntax, SwiftUI, protocol-oriented programming, and Cocoa Touch frameworks. Use when writing Swift code, building iOS/macOS/watchOS/tvOS applications, working with SwiftUI or UIKit, understanding Swift concurrency, or needing guidance on Swift project structure.

Swift package development with SPM. Use for Package.swift, public APIs, DocC, XCTest, XCFrameworks, and library publishing. Extends meta-library-dev.

Foundational TypeScript patterns covering types, interfaces, generics, utility types, and common idioms. Use when writing TypeScript code, understanding the type system, or needing guidance on which specialized TypeScript skill to use. This is the entry point for TypeScript development.

TypeScript-specific library/package development patterns. Use when creating npm packages, configuring package.json exports, setting up tsconfig.json for libraries, generating declaration files, publishing to npm, or configuring ESM/CJS dual packages. Extends meta-library-dev with TypeScript tooling and ecosystem patterns.

TypeScript development guidelines and patterns. Use this skill when writing TypeScript code, creating React components with TypeScript, configuring tsconfig.json, using advanced types like generics or utility types, or when the user asks about TypeScript best practices.

Discover, profile, and evaluate MCP servers for a given domain or purpose. Use when searching for MCP servers to add to a project, comparing server capabilities, enriching the local registry cache, or evaluating whether a server suite covers a stated need. Covers cache-first discovery, remote registry scanning, deep server profiling, and gap analysis.

Apply optimization techniques to extend effective context capacity. Use when context limits constrain agent performance, optimizing for cost or latency, implementing long-running agent systems, agents exhaust memory, or when designing conversation summarization strategies.

Create language conversion skills for translating code from language A to language B. Use when building 'convert-X-Y' skills, designing type mappings between languages, establishing idiom translation patterns, or defining conversion methodologies. Provides foundational patterns that specific conversion skills extend.

Guide for translating code between programming languages. Use when converting code from one language to another, planning language migrations, understanding conversion challenges, asking about type mappings, idiom translations, or referencing pattern mappings. Covers APTV workflow, type systems, error handling, concurrency, and language-specific gotchas.

Develop reusable library code across languages. Use when designing public APIs, organizing modules, managing versioning, or creating utility libraries. Provides foundational patterns that language-specific *-lib-* skills extend.

Foundational SDK development patterns that domain-specific SDK skills extend. Use when building SDKs for APIs or specifications, creating SDK development skills, or establishing SDK architecture standards across languages.