1. Software Development

Provides property-based testing utilities for Rust, enabling automatic generation of arbitrary inputs and verification of properties across edge cases.

Provides deep code review standards for WordPress plugin development, ensuring adherence to security guidelines and proper hook implementation.

Reviews code and systems to eliminate unnecessary complexity while maintaining functionality and quality, promoting sustainable development practices.

Verifies Rust code for memory safety, undefined behavior, and correctness properties using the Kani model checker.

Enables structured debugging with DebugScope patterns, providers, and conditional logging via Effect.Console.

Enables TMNL embedded testing via Renode with tmux, UART, telemetry, and guardrails.

Generates high-quality, distinctive frontend code for web components and pages, avoiding generic AI aesthetics.

CLI tool for seeding IIoT databases, built with @gbg/ctl to automate data population during development workflows.

Guides idiomatic patterns for Laminar and Airstream in Scala.js reactive UI development, covering component structure, signals, and state management.

Removes redundant, obvious, or AI-generated comments from code to enhance readability and maintainability.

Assists in formal verification of Rust code using Creusot and Pearlite, enabling contract specification, correctness proofs, and loop invariant writing.

Provides architecture guidance for Industrial IoT (IIoT) data flow using Unified Namespace (UNS) with topic hierarchy and NATS subject patterns.

Provides multi-dimensional code reviews for security, readability, testing, and documentation using parallel agent analysis.

Translates Effect-TS functional patterns to Rust, covering Result/Option handling, error propagation, and effectful computation for idiomatic code.

Reviews Next.js App Router and TypeScript code for correctness, maintainability, and performance in PRs and feature changes.

Provides structured patterns for writing BDD specifications using Given/When/Then, feature files, and scenario outlines to define requirements as executable tests.

Enforces Effect.log over console.log for structured logging with dynamic levels, annotations, and observability integration in codebases.

Provides stream processing utilities for Effect-TS, including creation, transformation, and consumption patterns with Stream.async and Stream.runForEach.

Provides patterns for Rust macro development including procedural, derive, attribute, and declarative macros for code generation and compile-time metaprogramming.

Provides Rust-based patterns for Tauri application development, covering command handling, state management, IPC, and cross-platform window management.

Provides structured error messaging and output formatting for Effect CLI, including Data.TaggedError patterns and recovery suggestions.

Generates or refines Makefiles for consistent build, format, lint, test, and check workflows across Go, Node, and mixed project stacks.

Enforces Python code organization conventions including method ordering, datetime handling, circular import avoidance, and type annotations for service classes and modules.

Organizes frontend components into a three-tier hierarchy (primitives, composites, testbeds, pages) for consistent code structure and scalability.