Managing complex projects without a structured plan leads to missed tasks and unclear progress. This skill scaffolds comprehensive project plans with numbered task files, checklists, and completion criteria that both humans and AI agents can execute.

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.

Tracking user behavior is essential for product insights, but implementing analytics incorrectly can expose sensitive user data. This skill guides you through secure Mixpanel implementation with built-in PII protection and code review processes.

Code review feedback is scattered across many PRs and hard to track over time. This skill transforms PR review comments into a structured markdown digest that captures themes, repeated issues, and actionable best practices for your team.

Manual API documentation becomes outdated quickly and rarely captures authentication, permissions, and multi-tenant filtering details. This skill generates comprehensive, accurate API documentation by parsing Bruno test files and mapping them to Django backend implementation with line-numbered code references.

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.

Creating effective skills requires systematic testing and persuasion-based design. This skill teaches RED-GREEN-REFACTOR methodology for documentation, helping you build bulletproof skills that agents follow even under pressure.

AI agents often claim success without actual verification. This skill prevents false completion claims by requiring fresh verification commands and evidence before any success assertion. It enforces discipline to run actual tests, show exit codes, and document proof.

Claude Code skills provide automated guidance and enforcement for AI assistants. This skill teaches you to create auto-activating skills with triggers, hooks, and guardrails to improve AI behavior. Build skills that activate when specific topics or files are detected.

Manual npm releases often lead to version mismatches between package.json, git tags, and changelogs. This skill provides a step-by-step workflow that keeps all version markers in perfect sync for safe, consistent publishing.

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.

Projects often lack documentation for directory structures. This skill automatically generates CLAUDE.md files with file responsibility tables when directories are created or modified, keeping documentation synchronized with code architecture.

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.

Code review feedback can be incorrect or misguided. This skill provides a systematic 3-step process to verify feedback, ask clarifying questions, and respond appropriately—ensuring technical rigor over blind compliance.

Developers often guess at bug fixes, leading to regressions and wasted time. This skill enforces a rigorous 4-phase debugging process that requires root cause investigation before any code changes.

Teams often start building before understanding the true problem. This skill transforms vague ideas into clear requirements through structured conversation. It captures original intent, explores multiple approaches, and documents decisions for traceability.

When working on long tasks with many tool calls, AI assistants often forget the original goal as it gets pushed out of the context window. This skill provides a protocol that forces reading of core documents at critical moments to keep the project goal front and center.