1. Software Development

Builds reusable ViewComponents in Rails with Hotwire (Turbo/Stimulus) and tests them using Lookbook.

Enables building modern SPAs with Inertia.js, React/Vue/Svelte, and Rails, handling client-side routing, forms, and shared data.

Enforces multi-layer data validation across software components to prevent bugs at every stage of data processing.

Provides a four-phase debugging framework to identify root causes before implementing fixes, preventing premature solutions.

Validates all external inputs for correctness, ensuring only valid data is processed and preventing invalid data from propagating.

Automates software development by assigning dedicated subagents to each task and integrating code reviews between steps for quality assurance.

Enforces code naming based on domain semantics rather than implementation, improving readability and maintainability.

Creates isolated Git worktrees with intelligent directory selection and safety verification to prevent conflicts during development.

A safe refactoring methodology prioritizing test coverage before changes, with incremental adjustments isolated from bug fixes or new features.

Encourages evaluating 2-3 design alternatives prior to implementation to improve solution quality and avoid premature decisions.

Refactors code to flatten nested conditionals using early returns or table-driven approaches, ensuring control flow clarity with ≤3 nesting levels.

Enforces minimal variable scope and early initialization to enhance code clarity and reduce bugs.

Dispatches a code-review subagent to validate implementation against project requirements and plans before proceeding.

Handles code review feedback with technical precision, ensuring thoughtful implementation rather than superficial agreement or blind execution.

Focuses on reducing software complexity through core engineering practices to enhance maintainability and scalability.

Guides developers in selecting descriptive, accurate variable names to improve code clarity and maintainability.

Systematically traces bugs backward through the call stack to identify the original trigger point in software applications.

Hides implementation complexity behind clean interfaces, allowing developers to work with domain concepts rather than technical details.

Enforces clean class design by ensuring interfaces maintain a single cohesive abstraction without mixing domain logic, serialization, or persistence concerns.

Identifies and extracts multi-responsibility routines to ensure each routine has a single responsibility.

Guides developers to create pseudocode designs, iterate on approaches, and translate them into functional code for structured development.

Guides developers to avoid common testing anti-patterns, such as testing mock behavior and adding test-only methods to production code.

Automates completion of a development branch with options for merge, pull request, or cleanup.

Applies the RED-GREEN-REFACTOR TDD cycle to document testing processes, address failures, and iteratively close code loopholes.