Messy folder structures slow down development and make codebases hard to navigate. This skill provides proven patterns from Next.js, Bulletproof React, and Feature-Sliced Design to help you organize projects that scale.

Developers spend hours manually converting git commits into readable release notes. This skill automatically analyzes commit history, groups changes by type, and formats them into user-friendly release documentation.

Technical teams forget why decisions were made. This skill helps create Architecture Decision Records that capture context, alternatives, and trade-offs for future team members and your future self.

Understanding framework architecture helps you choose the right tool for your project. This skill evaluates how frameworks handle extensibility, dependency injection, and configuration to identify the best fit for your needs.

Agent frameworks often contain hidden architectural problems that cause bugs and technical debt. This skill provides a catalog of anti-patterns to identify, categorize, and remediate issues across structural, behavioral, observability, and performance categories.

Writing formal Software Requirements Specifications can be time consuming and error prone. This skill provides IEEE 830 compliant templates and checklists to help generate structured, professional SRS documents quickly and consistently.

Claude Code skills provide intelligent, context-aware guidance that activates automatically based on your work. This guide teaches you to build skills with triggers, hooks, and memory patterns for specialized assistance.

Complex documents fail when context and structure are weak. This workflow guides you through context gathering, drafting, and reader testing stages to create documents that work for readers.

Manual documentation is time-consuming and often outdated. This skill automatically generates comprehensive API documentation, README files, inline comments, and architecture diagrams by analyzing code structure.

Developers often struggle with when and how to request effective code reviews. This skill provides templates, workflows, and guidance for requesting and processing code reviews that catch issues before they compound.

This skill generates RBS type signatures for Ruby code from scratch. It analyzes Ruby source files and creates corresponding .rbs signature files with proper type definitions.

Writing clear, comprehensive PR descriptions takes significant time and effort. This skill automates the creation of reviewer-friendly descriptions using structured formatting, visual diagrams, and organized sections.

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 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.

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.

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.

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.

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.

Inconsistent file headers make codebases hard to navigate and maintain. This skill provides standardized @input/@output/@pos comment templates for TypeScript, Python, and Shell files to document dependencies and purpose.