Coding standards, frameworks, refactoring, and code review (18K skills)
Apply common patterns when building Java Spring Boot backends, from REST controllers and layered services to repositories, validation, caching, asynchronous work, and logging. The examples also cover error handling, pagination, rate limiting, and resilient external calls.
Apply practical coding guidelines to TypeScript, JavaScript, React, and Node.js projects. The examples cover readable naming, immutability, type safety, component structure, API validation, performance, tests, and common code smells to help keep code easier to maintain.
Use practical PostgreSQL patterns for schema design, SQL queries, indexing, row-level security, connection pooling, and performance troubleshooting. The quick reference includes data type guidance, query examples, anti-pattern checks, and configuration snippets based on Supabase practices.
Use this skill when writing, reviewing, or refactoring Go code. It offers practical guidance on idiomatic patterns for error handling, concurrency, interfaces, package and type design, performance, and Go’s formatting and analysis tools.
Use this skill as a Java 17+ coding reference for Spring Boot services. It explains naming, immutable data, Optional and Stream usage, meaningful exceptions, type-safe generics, project layout, logging, null handling, and testing expectations.
Guide Spring Boot data modeling and persistence with JPA/Hibernate. Get practical patterns for entity relationships, repository queries, transaction boundaries, pagination, indexes, auditing, caching, and connection pools, with advice for reducing N+1 queries and validating data access.
Observe Claude Code prompts and tool activity through hooks, then record repeated behaviors as small learned rules called instincts, each with confidence and evidence. Group related instincts into reusable skills, commands, or agents, and import or export them.
Select and install skills and rules from Everything Claude Code at the user or project level. The guided workflow checks installed files and path references, reports missing dependencies, and can tailor the installed materials to a project's stack.
Use this skill for React and Next.js interface work. It provides code examples for reusable components, custom hooks, shared state, data fetching, validated forms, rendering performance, lazy loading, animations, error handling, and accessible keyboard and focus behavior.
Use this skill to adopt Swift 6.2 concurrency in apps and scripts. It explains actor isolation, MainActor protocol conformances, and how to move CPU-heavy work off an actor with @concurrent, including incremental migration guidance.
Apply backend patterns to Node.js, Express, and Next.js API routes. The guidance covers REST design, separating business logic from data access, database query efficiency, caching, authentication, rate limits, error handling, background jobs, and structured logs.
Use this skill when writing, reviewing, or refactoring Python. It covers readable idioms, type hints, error handling, resource management, generators, concurrency, package layout, performance, and common tools for formatting and static checks.
Design testable Swift code by placing file, network, and external API dependencies behind small protocols. Inject mock implementations to test expected behavior and error paths with Swift Testing, without relying on real I/O.
Build SwiftUI interfaces with practical patterns for state management, reusable views, navigation, and rendering performance. It explains when to use Observation property wrappers, how to structure view models, and how to avoid costly work during view updates.
Use this skill when writing, reviewing, or refactoring modern C++ code. It applies C++ Core Guidelines to choices such as resource ownership, type safety, interfaces, errors, concurrency, templates, and standard library use, with concrete rules and examples.
Create a thread-safe local persistence layer in Swift using actors, an in-memory cache, and file storage. The skill explains a reusable repository pattern for Codable and Identifiable models, atomic writes, async access, and integration with an observable view model.
Add a file cache for costly work such as PDF parsing, text extraction, or image analysis. It uses SHA-256 content hashes, so moving a file can still reuse its result, while changed content triggers fresh processing.
Use this skill to guide TypeScript, JavaScript, React, and Node.js work with shared coding conventions. It covers readable naming, types, error handling, API design, project structure, performance, testing, and common code smells to review or refactor.
Explore ways to run Claude Code through repeatable development loops, from simple command pipelines to persistent sessions, parallel agents, CI-backed pull requests, and RFC-driven task graphs. The skill explains when each pattern fits and how to manage context, reviews, and stopping conditions.
Help multi-agent workflows find the codebase context a subagent needs. Start with a broad search, judge which files are relevant, identify missing information, and refine the search for up to three cycles to keep the returned context focused.
Use this skill to make practical PostgreSQL choices for queries, schema design, indexes, row-level security, and connection settings. It provides quick reference patterns and SQL checks for slow queries, missing foreign-key indexes, and table bloat.
Learn patterns for adding Apple’s FoundationModels to iOS 26+ apps. Generate text, return typed data with `@Generable`, let the model call custom tools, and stream partial results to the UI, while checking model availability and respecting the stated context limit.
Use this example as a template for a project-specific skill that helps an agent work within a particular application. It demonstrates how to document architecture, file layout, coding patterns, testing expectations, and deployment steps for consistent project work.
Use this skill to write, review, or refactor modern C++ code with guidance based on the C++ Core Guidelines. It covers safer types, resource ownership, errors, concurrency, templates, and standard library choices, helping keep code consistent and clear.