Engineers struggle to break complex features into manageable steps. This skill creates granular implementation plans with test-driven development built into every task.

Writing tests after code proves nothing about correctness. This skill enforces the RED-GREEN-REFACTOR cycle to ensure every feature has a failing test first. Write minimal tests, verify they fail, implement the simplest code to pass, then refactor with confidence.

Debugging without a systematic approach leads to wasted time and new bugs. This skill provides a four-phase methodology to find root causes before attempting fixes, dramatically improving first-time fix success rates.

Complex development plans often fail due to accumulated context errors and missing quality checks. This methodology ensures each task gets a fresh subagent with clean context, followed by mandatory code review before proceeding.

Ruby projects need type safety for reliable code. This skill adds Sorbet inline type signatures to methods using sig blocks. It analyzes Ruby source files, generates proper type annotations, and validates signatures with the Sorbet type checker.

Ruby lacks built-in type annotations, making code harder to understand and maintain. This skill adds RBS-inline type comments directly to your Ruby files, improving code clarity without requiring separate .rbs signature files.

Building applications with Prisma ORM v7 requires understanding new ESM requirements, driver adapters, and configuration changes. This skill provides expert guidance on schema design, migrations, client queries, and migrating from v6 to v7.

Code reviews generate long lists of issues that are tedious to fix manually. This skill processes review documents systematically, letting you fix or skip each issue while tracking progress and running quality checks.

Code reviews often miss subtle correctness issues, especially around multi-tenant safety and data integrity. This skill provides a structured, hyper-pedantic review framework that catches correctness bugs, SOLID violations, and security risks before they reach production.

This skill creates structured implementation plans with quality gates for Django projects. Use it to break down complex backend features into Ralph Loop-compatible tasks with built-in verification steps.

Backend pull requests often miss critical workflow steps like proper ClickUp ticket linkage, migration safety checks, or downtime-safe schema changes. This skill provides a pedantic checklist to catch these issues before merge and deployment.

Backend code often fails CI quality gates and contains non-atomic commits. This skill runs Ruff, ty, Django checks, and security scripts to fix issues and enforce commit standards without AI signatures.

Stop switching between Unity Editor and terminal when developing games. This skill lets AI agents control Unity directly from the command line to compile scripts, enter play mode, capture screenshots, and execute debug code.

Writing React/TypeScript frontend code without consistent patterns leads to maintenance issues and bugs. This skill provides comprehensive development guidelines with code examples for components, data fetching, routing, styling, and performance optimization using modern React patterns.

AI coding workflows often skip tests or write them after code, leading to untested functionality and hidden bugs. This skill enforces the TDD Iron Law: no production code until a failing test exists. It provides enforcement checkpoints, error recording protocols, and rationalization prevention to ensure every feature has proper test coverage.

Teams often mark implementation tasks complete before tests, breaking Test-First Development principles. This guardrail blocks real-time violations by detecting when implementation tasks are checked off before corresponding test tasks.

CC-DevFlow provides structured development workflows but users often struggle to know which command to use next. This orchestrator skill routes users to the correct workflow command and specialized agent based on their current project phase and task type.

Backend code becomes inconsistent and hard to maintain without clear patterns. This skill provides comprehensive guidelines for layered architecture, error handling, validation, and testing for Node.js/Express/TypeScript microservices.

SwiftUI views often become disorganized with inconsistent property ordering and mixed responsibilities. This skill applies a consistent structure to views by enforcing proper ordering, favoring MV patterns over view models, and ensuring correct Observation usage.

SwiftUI apps can suffer from slow rendering, janky scrolling, and excessive CPU usage. This skill guides you through code review, Instruments profiling, and targeted fixes to optimize your app performance.