dykyi-roman/awesome-claude-code

525 skills2.0K total installs Github

Github

Github

Skill

Installs

psr-overview-knowledge

clean-arch-knowledge

codeigniter-knowledge

detect-code-smells

ddd-knowledge

bug-root-cause-finder

testing-knowledge

api-design-knowledge

solid-knowledge

architecture-doc-template

outbox-pattern-knowledge

detect-n-plus-one

adr-knowledge

claude-code-knowledge

hexagonal-knowledge

yii-knowledge

check-access-control-model

laravel-knowledge

cqrs-knowledge

check-context-communication

check-dependency-injection

check-bounded-contexts

event-sourcing-knowledge

estimate-complexity

task-progress-knowledge

check-immutability

analyze-solid-violations

check-command-injection

adr-template

analyze-php-logs

check-dependency-vulnerabilities

check-caching-strategy

check-test-quality

create-value-object

check-cascading-failures

create-integration-test

diagram-knowledge

access-control-knowledge

create-access-control

check-async-patterns

check-consistency

check-sql-injection

create-feature-flags

create-factory

create-entity

api-doc-template

grasp-knowledge

create-dto

check-naming

create-facade

check-code-style

mermaid-template

trace-data-transformation

caching-strategies-knowledge

detect-architecture-pattern

docker-networking-knowledge

suggest-testability-improvements

check-singleton-antipattern

optimize-docker-image-size

consistency-patterns-knowledge

check-12-factor-compliance

analyze-coupling-cohesion

check-aggregate-consistency

create-dockerfile-production

extract-business-rules

analyze-test-coverage

code-examples-template

check-serialization

create-rector-config

create-psr13-link

detect-memory-issues

layer-arch-knowledge

explain-business-process

bug-fix-knowledge

create-object-pool

check-sensitive-data

create-health-check

ci-tools-knowledge

create-psr3-logger

check-idempotency

check-method-length

check-authorization

create-di-container

find-infinite-loops

documentation-knowledge

bug-regression-preventer

detect-unnecessary-loops

check-database-scaling

create-repository

message-queue-knowledge

check-batch-processing

check-abstract-factory

check-insecure-design

create-test-double

extract-domain-concepts

create-psr20-clock

check-query-efficiency

create-domain-service

check-class-length

create-null-object

check-input-validation

check-lazy-loading

suggest-simplification

create-unit-of-work

create-domain-event

estimate-pipeline-time

check-cqrs-alignment

find-logic-errors

explain-output-template

check-csrf-protection

create-specification

bug-impact-analyzer

changelog-template

create-decorator

create-builder

create-unit-test

create-prototype

check-comments

check-ssrf

create-bridge

create-aggregate

create-proxy

docker-knowledge

create-mediator

create-flyweight

create-docker-supervisor-config

docker-security-knowledge

create-psr14-event-dispatcher

check-scalability-readiness

create-psr16-simple-cache

psr-coding-style-knowledge

docker-troubleshooting-knowledge

check-observability-coverage

check-docker-layer-efficiency

stability-patterns-knowledge

create-docker-nginx-config

psr-autoloading-knowledge

create-docker-compose-dev

check-docker-production-readiness

create-message-broker-adapter

create-anti-corruption-layer

analyze-docker-build-errors

check-version-consistency

create-chain-of-responsibility

optimize-docker-build-time

docker-orchestration-knowledge

analyze-docker-runtime-errors

optimize-docker-compose-resources

create-idempotent-consumer

docker-base-images-knowledge

create-psr17-http-factory

detect-docker-antipatterns

documentation-qa-knowledge

create-docker-compose-production

analyze-docker-image-size

docker-scanning-knowledge

docker-php-extensions-knowledge

replication-sharding-knowledge

docker-multistage-knowledge

docker-buildkit-knowledge

create-idempotency-handler

create-docker-env-template

docker-production-knowledge

create-correlation-context

check-docker-compose-config

check-docker-user-permissions

create-docker-healthcheck

cloud-native-knowledge

check-leaky-abstractions

check-type-juggling

analyze-ci-config

create-test-builder

find-boundary-issues

create-template-method

create-mock-repository

discover-project-logs

extract-state-machine

check-timeout-strategy

create-docker-entrypoint

optimize-docker-php-fpm

microservices-knowledge

deployment-knowledge

check-docker-secrets

create-dockerignore

create-psr6-cache

optimize-docker-opcache

create-event-store

create-psalm-config

create-metrics-collector

check-cors-security

check-side-effects

scalability-knowledge

create-read-model

create-github-actions

create-circuit-breaker

create-psr18-http-client

create-phpstan-config

check-index-usage

check-docker-php-config

check-path-traversal

check-mass-assignment

check-fallback-strategy

check-deserialization

create-saga-pattern

check-docker-healthcheck

detect-test-smells

check-doc-examples

detect-ci-antipatterns

create-cache-aside

find-race-conditions

create-deptrac-config

docker-compose-knowledge

create-distributed-lock

create-deploy-strategy

check-secure-headers

symfony-knowledge

identify-entry-points

ci-pipeline-knowledge

check-magic-values

check-nesting-depth

resolve-entry-point

create-dead-letter-queue

check-crypto-usage

check-connection-pool

create-read-write-proxy

create-dockerfile-ci

check-docker-security

find-resource-leaks

create-retry-pattern

create-api-versioning

check-pure-functions

create-psr11-container

no-framework-knowledge

create-psr7-http-message

optimize-docker-startup

check-encapsulation

saga-pattern-knowledge

check-distributed-locks

create-dockerfile-dev

create-docker-php-config

create-structured-logger

check-authentication

find-exception-issues

observability-knowledge

create-psr15-middleware

optimize-docker-layers

trace-request-lifecycle

check-logging-failures

getting-started-template

scan-codebase-structure

find-null-pointer-issues

troubleshooting-template

create-docker-makefile

check-output-encoding

create-outbox-pattern

create-rate-limiter

create-responder

check-file-io

create-state

create-strategy

check-doc-links

create-timeout

create-adapter

find-type-issues

create-visitor

create-iterator

readme-template

create-bulkhead

create-memento

create-gitlab-ci

generate-ci-fix

analyze-ci-logs

map-async-flows

eda-knowledge

create-command

create-use-case

check-xxe

create-action

create-policy

create-composite

generate-bug-fix

create-snapshot

create-query

acc-optimize-docker-php-fpm

acc-create-phpstan-config

acc-create-docker-healthcheck

acc-psr-coding-style-knowledge

acc-analyze-coupling-cohesion

acc-check-singleton-antipattern

acc-optimize-docker-layers

acc-docker-scanning-knowledge

acc-check-fallback-strategy

acc-create-mock-repository

acc-create-deploy-strategy

acc-create-psr18-http-client

acc-create-psr11-container

acc-create-circuit-breaker

acc-ci-pipeline-knowledge

acc-check-deserialization

acc-detect-ci-antipatterns

acc-check-abstract-factory

acc-bug-root-cause-finder

acc-create-docker-compose-dev

acc-check-batch-processing

acc-detect-architecture-pattern

acc-stability-patterns-knowledge

acc-check-timeout-strategy

acc-detect-unnecessary-loops

acc-detect-docker-antipatterns

acc-check-output-encoding

acc-check-query-efficiency

acc-create-chain-of-responsibility

acc-create-docker-nginx-config

acc-getting-started-template

acc-check-dependency-vulnerabilities

acc-create-domain-service

acc-documentation-knowledge

acc-suggest-testability-improvements

acc-identify-entry-points

acc-check-csrf-protection

acc-create-docker-entrypoint

acc-analyze-solid-violations

acc-bug-regression-preventer

acc-create-psr7-http-message

acc-docker-multistage-knowledge

acc-check-docker-security

acc-create-docker-makefile

acc-docker-networking-knowledge

acc-create-docker-supervisor-config

acc-trace-data-transformation

acc-analyze-docker-image-size

acc-optimize-docker-image-size

acc-create-github-actions

acc-check-docker-layer-efficiency

acc-check-docker-production-readiness

acc-check-cascading-failures

acc-create-integration-test

acc-extract-domain-concepts

acc-explain-output-template

acc-check-command-injection

acc-outbox-pattern-knowledge

acc-check-version-consistency

acc-task-progress-knowledge

acc-check-mass-assignment

acc-check-context-communication

acc-scan-codebase-structure

acc-check-aggregate-consistency

acc-troubleshooting-template

acc-check-caching-strategy

acc-optimize-docker-build-time

acc-analyze-docker-runtime-errors

acc-docker-base-images-knowledge

acc-check-leaky-abstractions

acc-check-dependency-injection

acc-docker-php-extensions-knowledge

acc-check-bounded-contexts

acc-explain-business-process

acc-docker-orchestration-knowledge

acc-create-docker-compose-production

acc-documentation-qa-knowledge

acc-optimize-docker-startup

acc-optimize-docker-compose-resources

acc-create-outbox-pattern

acc-optimize-docker-opcache

acc-claude-code-knowledge

acc-extract-state-machine

acc-create-psr14-event-dispatcher

acc-create-dockerfile-production

acc-docker-troubleshooting-knowledge

acc-docker-compose-knowledge

acc-extract-business-rules

acc-event-sourcing-knowledge

acc-code-examples-template

acc-check-logging-failures

acc-analyze-docker-build-errors

acc-analyze-test-coverage

acc-saga-pattern-knowledge

acc-create-psr17-http-factory

acc-create-dockerfile-dev

acc-create-psr16-simple-cache

acc-docker-security-knowledge

acc-check-input-validation

acc-check-insecure-design

acc-create-anti-corruption-layer

acc-psr-autoloading-knowledge

acc-trace-request-lifecycle

acc-check-docker-user-permissions

acc-check-docker-php-config

acc-docker-production-knowledge

acc-create-template-method

acc-estimate-pipeline-time

acc-find-null-pointer-issues

acc-check-docker-healthcheck

acc-check-docker-compose-config

acc-create-deptrac-config

acc-create-docker-php-config

acc-check-connection-pool

acc-architecture-doc-template

acc-create-psr15-middleware

acc-docker-buildkit-knowledge

acc-suggest-simplification

acc-find-exception-issues

acc-psr-overview-knowledge

acc-create-docker-env-template

acc-check-consistency

acc-ddd-knowledge

acc-check-path-traversal

acc-check-authorization

acc-detect-n-plus-one

acc-create-mediator

acc-layer-arch-knowledge

acc-check-docker-secrets

acc-detect-memory-issues

acc-create-dockerignore

acc-create-feature-flags

acc-create-visitor

acc-check-encapsulation

acc-detect-code-smells

acc-diagram-knowledge

acc-bug-fix-knowledge

acc-map-async-flows

acc-deployment-knowledge

acc-check-method-length

acc-find-type-issues

acc-find-race-conditions

acc-check-doc-links

acc-check-crypto-usage

acc-create-action

acc-check-sql-injection

acc-analyze-ci-logs

acc-check-secure-headers

acc-cqrs-knowledge

acc-create-read-model

acc-check-magic-values

acc-check-comments

acc-create-psr20-clock

acc-check-class-length

acc-grasp-knowledge

acc-create-aggregate

acc-create-value-object

acc-eda-knowledge

acc-bug-impact-analyzer

acc-create-repository

acc-estimate-complexity

acc-create-iterator

acc-docker-knowledge

acc-find-logic-errors

acc-create-specification

acc-create-di-container

acc-check-sensitive-data

acc-create-strategy

acc-check-side-effects

acc-create-rector-config

acc-create-builder

acc-create-memento

acc-solid-knowledge

acc-check-lazy-loading

acc-create-composite

acc-create-bridge

acc-create-use-case

acc-create-domain-event

acc-check-code-style

acc-find-boundary-issues

acc-analyze-ci-config

acc-create-saga-pattern

acc-create-responder

acc-resolve-entry-point

acc-create-unit-test

acc-clean-arch-knowledge

acc-create-gitlab-ci

acc-create-psr13-link

acc-create-psalm-config

acc-check-cqrs-alignment

acc-create-bulkhead

acc-create-test-builder

acc-api-doc-template

acc-create-test-double

acc-hexagonal-knowledge

acc-create-command

acc-generate-ci-fix

acc-create-facade

acc-check-cors-security

acc-check-pure-functions

acc-create-null-object

acc-testing-knowledge

acc-check-nesting-depth

acc-create-policy

acc-check-doc-examples

acc-create-entity

acc-adr-knowledge

acc-check-index-usage

acc-find-resource-leaks

acc-generate-bug-fix

acc-check-file-io

acc-check-type-juggling

acc-readme-template

acc-check-test-quality

acc-check-async-patterns

acc-create-dockerfile-ci

acc-create-factory

acc-create-decorator

acc-detect-test-smells

acc-create-object-pool

acc-changelog-template

acc-create-prototype

acc-create-flyweight

acc-check-immutability

acc-create-rate-limiter

acc-create-adapter

acc-find-infinite-loops

acc-check-authentication

acc-mermaid-template

acc-check-serialization

acc-ci-tools-knowledge

acc-create-retry-pattern

acc-create-psr3-logger

acc-create-psr6-cache

acc-check-ssrf

acc-create-proxy

acc-adr-template

acc-check-naming

acc-check-xxe

acc-create-state

acc-create-dto

acc-create-query