Claude Skills by aRustyDev

Extract IR from source code for cross-language conversion

Synthesize target language code from IR

**Pragmatic Institute Framework** (High relevance) distinguishes MRD (problem space: personas, their problems, market opportunity) from PRD (solution space: features, user stories, acceptance criteria). Its key insight: requirements should be written as **problems to be solved for specific personas**, not feature lists. This prevents over-engineering and keeps focus on product-market fit. **ISO 9001:2015** (Medium-High relevance) requires "documented information" but doesn't prescribe formats...

QMS documentation, engineering handbooks, or SOPs

Guidelines for writing effective code examples in technical blog posts

Blog structure patterns for tutorials, deep-dives, research summaries, and development journals

Astro/AstroPaper platform configuration for the blog-workflow plugin

SEO fundamentals for technical blog posts — meta tags, structured data, keyword placement, and readability optimization

Style guide for technical blog posts covering voice, tone, clarity, and consistency standards

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.