copyleftdev/sk1llz

This skill helps you design ultra-minimal, high-performance systems in the Bellard mold, emphasizing deep domain mastery and single-file pragmatism.

This skill teaches Rust-style clear, idiomatic coding by writing examples and docs that illuminate concepts and teach as they run.

This skill helps you implement Google Material Design principles to create accessible, delightful interfaces across platforms with consistent elevation,

This skill helps you build robust, correct-by-construction market systems inspired by Jane Street, using functional patterns, strong types, and explicit error

This skill helps you design Python APIs in the Kenneth Reitz style, emphasizing simplicity, human-friendly interfaces, and meaningful defaults.

This skill guides you to write portable, clean C-style systems code in the Dennis Ritchie tradition, emphasizing abstractions, safety, and minimal interfaces.

This skill helps you write Python with Wadler-inspired monadic patterns, guiding type-driven design and clean composable abstractions.

This skill helps you write cleaner C++ by applying Sean Parent's no raw loops philosophy, replacing loops with expressive algorithms for clarity and

This skill helps you write high-performance Go code with mechanical sympathy and data-oriented design, improving execution understanding and readability.

This skill helps you write high-performance systems and kernel-level code with pragmatic design, data-structure focus, and rigorous code review.

This skill helps you write idiomatic Python in the Hettinger style, using generators, iterators, and built-ins for clean, efficient code.

This skill helps you write C++ in Stroustrup style, emphasizing type safety, RAII, and zero-overhead abstractions for clear, efficient systems.

This skill analyzes PCAPs from the OSI outward, delivering expert forensics insights with native Linux tools and precise attribution.

This skill helps you write practical, compiler-friendly Haskell and Python alike by teaching laziness, purity, and profiling-driven optimization for real-world

This skill helps you implement ultra-low-latency trading systems with deterministic execution, kernel bypass networking, and lock-free structures inspired by

This skill helps you design resilient cloud-native systems using Vogels principles, emphasizing failure handling, eventual consistency, and API-driven

This skill maps threats to MITRE ATT&CK tactics and techniques to improve detection coverage and threat intelligence.

This skill helps you build transparent, academically grounded factor investing models in Python, guiding portfolio construction and risk-aware implementation.

This skill helps you write correct, efficient concurrent Rust code by applying Mara Bos-inspired memory-ordering guidance and safe patterns.

This skill helps you build modular compiler infrastructure and progressive lowering, enabling reusable libraries and clearer diagnostics for language tooling.

This skill helps you apply Addy Osmani's performance-first patterns to build fast, well-structured Python apps with thoughtful design.

This skill guides you to optimize network performance using Jacobson-inspired congestion control, RTT-based adaptation, and robust traceroute diagnostics.

This skill helps you design and optimize high-performance JIT compilers and interpreters by applying trace-based, microarchitecture-aware techniques.

This skill helps you build threat hunting programs by applying Roberto Rodriguez's playbook with reproducible notebooks, data-driven tests, and open-source

This skill helps you craft portable detection rules with Sigma and YARA, enabling cross-platform sharing and quality through community-driven patterns.

This skill helps you write Rust-style ownership and lifetime guidance in Python, applying Matsakis-inspired patterns to APIs for safer borrows.

This skill helps you design ultra-low-latency trading systems using FPGA, network optimization, and hardware-software co-design principles.

This skill helps you design game engines and languages inspired by Jonathan Blow, prioritizing programmer productivity and compile-time efficiency.

This skill helps you write idiomatic Python in the Ramalho Fluent Python style, focusing on the data model and advanced idioms.

This skill guides platform engineering by embracing the Tao of HashiCorp, focusing on workflows, immutability, and codified, composable infrastructure.

This skill helps you write Python code that emphasizes readability and simplicity following Guido van Rossum's Pythonic principles.

This skill helps you write predictable, composable React state, colocate data, and use custom hooks to improve developer experience.

This skill helps you design threat detection using the Pyramid of Pain and Threat Hunting Maturity Model to maximize adversary pain.

This skill helps you write practical Zig code in the style of Loris Cro, emphasizing build system mastery and real-world patterns.

This skill guides you through exploratory testing in the James Bach style, blending learning, design, and execution to uncover hidden risks.

This skill helps you design distributed systems at planet scale with Jeff Dean principles, optimizing tail latency and scalability.

This skill helps you write robust C++ following Herb Sutter's exceptional principles, emphasizing exception safety, const correctness, and defensive

This skill helps you design data-intensive systems by applying Kleppmann-style trade-offs, ensuring reliability, observability, and scalable data architectures.

This skill helps you adopt Kent Beck's test-driven development discipline, guiding red-green-refactor, small steps, and emergent design for reliable Python

This skill helps you write practical, safe, and maintainable Rust code in the spirit of Carol Nichols, with clear explanations and real-world patterns.

This skill helps you design reusable algorithms following Stepanov's generic programming, focusing on minimal requirements, concepts, and iterator-based

This skill helps you design declarative, GPU-accelerated native UIs with synchronized trees and Rust patterns inspired by Raph Levien.

This skill guides database architecture design inspired by Stonebraker, emphasizing workload-specific, shared-nothing, and durable, extensible storage and

This skill helps you build geospatial services with S2 by indexing and querying spherical data using Hilbert-based cell IDs for efficient proximity and

This skill helps you design durable REST APIs by applying Fielding's constraints to ensure statelessness, hypermedia, caching, and uniform interfaces.

This skill helps design scalable distributed data systems inspired by Pat Helland, emphasizing idempotency, entity-based design, and messaging over distributed

This skill helps you make architectural decisions and design evolving APIs using Butler Lampson's abstraction, interfaces, and security principles.

This skill helps you write advanced Python in the Beazley style, emphasizing generators, coroutines, metaprogramming, and deep interpreter understanding.

This skill helps you design and test Renaissance-style statistical arbitrage systems using rigorous backtesting, signal integration, and robust risk management.

This skill helps you design user-friendly public APIs and async Rust interfaces with Turon-inspired patterns for safe, ergonomic usage.

This skill helps you identify Minervini-style swing setups by applying SEPA principles, VCP patterns, and strict risk controls for stock momentum trades.

This skill helps you design simple, immutable data oriented Python code inspired by Rich Hickey, making state explicit and maintainable.

This skill helps you design Go packages and tooling with Russ Cox's correctness and compatibility principles, emphasizing reproducible builds and stable APIs.

This skill helps you write robust C++ code by applying Meyers Effective C++ guidelines for safer, clearer, and more maintainable interfaces.

This skill helps you implement Google's continuous fuzzing framework with OSS-Fuzz and ClusterFuzz to automate bug discovery and CI/CD integration.

This skill helps you apply Andrei Alexandrescu's Modern C++ Design, promoting policy-based templates and compile-time abstractions for zero-runtime overhead.

This skill helps you design safe, memory-efficient Rust code inspired by Graydon Hoare's vision, emphasizing ownership, zero-cost abstractions, and practical

This skill helps you apply John Hughes property-based testing concepts to Python code, generating inputs, checking invariants, and shrinking failures.

This skill helps you design and optimize Virtu-style execution systems by modeling market microstructure, routing intelligently, and measuring execution