Claude Skills

This skill provides persistent memory patterns for AI agents using AgentDB, enabling session memory, long-term storage, and context management across interactions. It's designed for building stateful agents, chat systems, or intelligent assistants that need to remember conversations and learn from patterns. The solution offers significant performance improvements while maintaining full backward compatibility.

AgentDB Learning Plugins provide a suite of 9 reinforcement learning algorithms, including Decision Transformer and Q-Learning, for creating self-learning agents. It enables developers to build, train, and deploy AI plugins that optimize agent behavior through experience. The skill offers accelerated performance with WASM-accelerated neural inference for faster model training.

This skill teaches advanced AgentDB features for building distributed AI systems and multi-agent coordination. It covers QUIC synchronization for sub-millisecond cross-node communication, multi-database management, and hybrid search with custom distance metrics. Use it when developing applications requiring sophisticated vector search or distributed system integration.

The agent-creator skill provides a framework for building specialized, production-ready AI agents using a proven 4-phase SOP methodology. It combines evidence-based prompting techniques with the Claude Agent SDK to create agents with deeply embedded domain knowledge. Use it when developing agents for specific domains or workflows that require consistent, high-quality performance.

This skill applies Test-Driven Development principles to creating and refining Claude skills by first testing them with subagents. It ensures skills are validated through iterative testing before documentation is finalized, making them robust against rationalization. Use it when developing new skills, editing existing ones, or verifying skill functionality prior to deployment.

The writing-plans skill creates detailed implementation plans for engineers after design completion, particularly when they lack codebase context. It generates comprehensive tasks with exact file paths, complete code examples, and verification steps. This skill assumes minimal domain knowledge and emphasizes TDD, frequent commits, and bite-sized implementation tasks.

This Claude Skill enforces verification before claiming work is complete by requiring developers to run specific verification commands and confirm their output. It mandates fresh evidence through a strict process of identifying, executing, and reading command results before making any success assertions. Use this skill when preparing to commit code or create PRs to ensure all claims of completion are substantiated.

The using-ring skill establishes mandatory workflows that must be applied at the start of every conversation. It requires developers to check for applicable skills before responding, use the Skill tool to read relevant skills, and announce which skill is being implemented. Key features include mandatory brainstorming before coding and creating TodoWrite todos for checklist management.

This Claude Skill creates isolated Git worktrees for feature development or implementation plans that need separation from your current workspace. It automatically selects optimal directories using a priority system and performs safety verification before creating worktrees. Use it when you need to work on multiple branches simultaneously while maintaining clean, isolated environments.

This skill applies TDD methodology to skill development by using the RED-GREEN-REFACTOR cycle. It validates skills before deployment by testing scenarios without the skill, then iteratively improving documentation to address failures and close loopholes. Developers use it to ensure skills perform under pressure and resist rationalization attempts.

This Claude Skill helps developers avoid common testing anti-patterns when writing or modifying tests. It prevents testing mock behavior, adding test-only methods to production code, and mocking without understanding dependencies. Use it to ensure tests verify real behavior rather than mock implementations and maintain clean production code.

This Claude Skill enforces test-driven development by requiring developers to write failing tests before implementation code. It automatically verifies that test files exist and that tests actually fail during the initial RED phase. The skill works across multiple languages and testing frameworks to ensure tests properly validate behavior.

The systematic-debugging skill provides a four-phase framework for developers to methodically debug issues before proposing fixes. It enforces root cause investigation, pattern analysis, hypothesis testing, and implementation to ensure understanding of bugs, test failures, or unexpected behavior first. Use this skill when encountering any technical issue to avoid premature solutions and implement correct fixes.

This skill executes implementation plans by dispatching a fresh subagent for each independent task, followed by comprehensive code reviews between tasks. It enables rapid iteration within the same session while maintaining quality gates for code, security, and business logic. Use it when you want continuous automated progress on parallelizable tasks without manual intervention.

This Claude Skill guides developers through contributing broadly useful skills back to the upstream repository via pull request. It provides the complete workflow from branching and committing to creating PRs, along with criteria for determining when a skill is appropriate to share. The skill requires proper testing and documentation before contribution.

This skill systematically traces bugs backward through the call stack to identify the original source of invalid data or incorrect behavior. It is used when errors manifest deep in execution and adds instrumentation when needed to follow the problem to its root cause. This approach helps developers fix issues at the source rather than just treating symptoms.

This skill dispatches three specialized subagents (code, security, and business logic reviewers) in parallel to verify implementations against requirements. Use it when completing major features or before merging to ensure work meets quality standards. The parallel execution provides comprehensive feedback 3x faster than sequential reviews.

This skill helps developers process code review feedback by promoting technical verification over immediate agreement. It provides a structured response pattern for evaluating suggestions, particularly when feedback seems unclear or questionable. The approach emphasizes understanding requirements, verifying against codebase reality, and providing reasoned technical responses rather than performative acceptance.

This Claude Skill helps developers create technology-agnostic architecture designs before selecting specific tools or frameworks. It is used when translating business requirements into technical designs, particularly after Feature Map Gate 2 passes. The skill prevents premature technology specification by focusing on architectural patterns rather than concrete implementation choices.

This skill breaks down features into implementation tasks that each deliver measurable user value, preventing oversized or technical-only work. Use it after dependency mapping and design validation when preparing sprint work. It ensures every task produces working software that can be validated independently.

This Claude Skill breaks down development tasks into 2-5 minute, zero-context subtasks after initial planning is complete. It generates TDD-based implementation steps following a RED-GREEN-REFACTOR cycle, providing complete code and explicit commands. Use it when you are tempted to write TODOs or need to create small, independent work units for implementation.

This Claude Skill helps developers create Product Requirements Documents (PRDs) that separate business needs from technical implementation. It ensures WHAT and WHY are fully defined before addressing HOW, preventing technical constraints from limiting product vision. Use it when starting new features, planning development, or whenever business and technical concerns risk being mixed.

This skill creates feature relationship maps after PRD approval but before technical design. It visualizes how features interact and group together at a business level to define scope and dependencies. This helps developers establish proper module boundaries and avoid missing integration points before architectural planning.

This skill helps developers create explicit, versioned technology choices after key design gates have passed. It ensures all dependencies are validated and justified to prevent unreliable builds and compatibility issues. Use it when finalizing technology selections before breaking down implementation tasks.