Developer Tools Claude 技能

Mise Tool Management

Streamlines development environment setup by managing multi-language tool versions and project configurations with Mise.

Prettier Configuration Master

Manages and optimizes Prettier configurations to ensure consistent code formatting across diverse development environments.

Lua Table Patterns & Data Structures

Implements advanced Lua table patterns including metatables, object-oriented programming, and efficient data structures.

C++ Templates & Metaprogramming

Implements high-performance C++ abstractions using advanced template techniques, SFINAE, and C++20 concepts.

Crystal Metaprogramming & Macros

Leverages Crystal's powerful macro system to perform compile-time code generation, DSL construction, and AST manipulation.

Angular RxJS Patterns

Implements reactive programming best practices in Angular applications using RxJS observables, operators, and state management patterns.

Nim Metaprogramming

Leverages Nim's advanced macros, templates, and compile-time evaluation to create high-performance abstractions and domain-specific languages.

Nim C Interop

Streamlines bidirectional interoperability between Nim and C for building high-performance systems and type-safe library wrappers.

C Data Structures Expert

Implements memory-efficient C data structures including linked lists, trees, and hash tables with robust manual memory management.

Zustand TypeScript Integration

Implements type-safe state management patterns using Zustand and TypeScript to ensure robust, predictable application state.

Pylint Code Quality & Custom Checkers

Enforces Python code quality by providing expert guidance on configuring, optimizing, and developing custom Pylint checkers for professional workflows.

ESLint Configuration Master

Configures and optimizes ESLint environments to enforce professional code quality standards and architectural consistency across JavaScript and TypeScript projects.

Java Checkstyle Rules

Enforces professional Java code quality through standardized Checkstyle rules, naming conventions, and performance metrics.

Clippy Configuration

Optimizes Rust code quality by automating professional Clippy configurations, including TOML setup, lint groups, and workspace attributes.

Angular Dependency Injection Architect

Implements robust, modular service architectures using Angular's hierarchical dependency injection system.

Scala Collections Expert

Provides comprehensive guidance and implementation patterns for Scala's powerful immutable and mutable collections library.

Rust Clippy Lint Master

Enhances Rust code quality by applying and configuring specialized Clippy lints for correctness, performance, and idiomatic style.

Checkstyle Configuration

Configures and optimizes Checkstyle for Java projects to enforce professional coding standards and maintain high code quality.

Syncpack Version Groups

Manages and enforces complex dependency version policies across monorepos using advanced syncpack configuration patterns.

Nim Memory Management

Optimizes Nim application performance through advanced memory management strategies, including garbage collection tuning, move semantics, and manual memory control.

Markdownlint Workflow Integration

Automates Markdown style enforcement and linting across CLI, CI/CD pipelines, and local development environments.

Ink Hooks & State Management

Simplifies state management and side-effect handling in Ink-based terminal user interfaces using specialized React hooks.

Custom ESLint Developer

Builds and deploys bespoke ESLint rules and plugins using advanced AST traversal and professional development patterns.

TypeScript Async Patterns

Implements robust asynchronous programming patterns in TypeScript using Promises, async/await, and async iterators.

Zustand State Management Patterns

Implements efficient, scalable Zustand stores for React applications using industry-standard best practices and optimized performance patterns.

RuboCop CI & Integration

Streamlines Ruby code quality through advanced RuboCop configuration, CI/CD integration, and performance-optimized linting patterns.

C Systems Programming

Master low-level system interactions including file I/O, process management, and signal handling for robust C applications.

Bun Bundler

Bundles JavaScript and TypeScript applications using Bun's high-performance native bundler for web and server environments.

Lua Coroutines

Implements cooperative multitasking and complex asynchronous patterns using Lua's native coroutine library.

React Context Patterns

Implements high-performance, type-safe React Context patterns to streamline state management and eliminate prop drilling.