iceflower
- 62 skills
- 0 followers
- 6 hours ago last updated
- ▌ Ddd · iceflower bundleDomain-Driven Design patterns including entities, value objects, aggregates, repositories, domain services, domain events, and bounded contexts. Use when designing domain models or implementing business logic.
- ▌ A11Y · iceflower bundleWeb accessibility (a11y) guidelines based on WCAG 2.2 and WAI-ARIA 1.2. Covers semantic HTML, ARIA patterns, keyboard accessibility, color contrast, form accessibility, media alternatives, and automated testing with axe-core. Use when building accessible web interfaces, reviewing UI components for accessibility compliance, or implementing ARIA widget patterns.
- ▌ Grpc · iceflower bundlegRPC and Protocol Buffers conventions for service-to-service communication including proto3 schema design, service definition patterns, streaming (unary, server, client, bidirectional), error handling with Status codes, interceptor patterns, deadline/timeout management, load balancing strategies, and service mesh integration (Istio, Envoy). Covers gRPC-Java, gRPC-Kotlin, and Spring Boot integration via grpc-spring. Use when designing or implementing gRPC services, writing proto files, configuring gRPC clients/servers, or integrating gRPC with microservices and service mesh environments.
- ▌ CI CD · iceflower bundleCI/CD pipeline patterns with GitHub Actions. Use when writing or reviewing workflow files, deployment pipelines, or branch protection rules.
- ▌ Index · iceflower bundleMeta-skill for routing to appropriate domain-specific skills. Provides a categorized routing map to help agents discover relevant skills by keyword, technology, or task type. Use when you need to discover which skill to use for a given task or context.
- ▌ Caching · iceflower bundleFramework-agnostic caching strategies including cache selection, TTL design, invalidation patterns, stampede prevention, and anti-patterns. Use when designing or reviewing cache logic.
- ▌ Exposed · iceflower bundleJetbrains Exposed ORM rules including DSL vs DAO, table definition, query patterns, transaction management, and schema migration. Use when writing Exposed ORM code.
- ▌ GRAPHQL · iceflower bundleGraphQL API design and implementation patterns including schema design principles, type system (Object, Input, Interface, Union, Enum), resolver patterns, N+1 problem prevention with DataLoader, pagination (Cursor-based, Relay Connection), error handling, query complexity and depth limiting, authentication/authorization at field level, and Federation (Apollo). Covers Spring for GraphQL, Netflix DGS Framework, and GraphQL security (OWASP GraphQL Cheat Sheet). Use when designing GraphQL schemas, implementing resolvers, optimizing query performance, setting up GraphQL Federation, or reviewing GraphQL API security.
- ▌ Logging · iceflower bundleLogging standards, structured logging, and sensitive data handling. Covers log levels (DEBUG, INFO, WARN, ERROR, TRACE), MDC (Mapped Diagnostic Context), correlation ID propagation, log format standardization, sensitive data masking, and log aggregation best practices. Use when writing logging code, configuring log frameworks (Logback, Log4j2), reviewing log output, or implementing request tracing with correlation IDs.
- ▌ Testing · iceflower bundleBDD-style test writing rules including unit testing patterns, integration testing with Testcontainers, contract testing for microservices (Pact, Spring Cloud Contract), E2E testing (Playwright, Cypress, visual regression), and performance testing strategies (k6, Gatling). Use when writing or modifying test code.
- ▌ Weather · iceflower bundleWeather and air quality information lookup using KMA (기상청), AirKorea, and AccuWeather. Use when users ask for current weather, weather forecasts, hourly forecasts, weather conditions, sunrise/sunset times, UV index, air quality (미세먼지/초미세먼지), or past/historical weather observations.
- ▌ Database · iceflower bundleFramework-agnostic database rules including migration conventions, query performance, transaction management, concurrency control (optimistic/pessimistic locking), backup strategies, replication patterns, connection pool tuning, and CDC. Includes MySQL and PostgreSQL specific guides. Use when writing SQL or designing database access.
- ▌ Security · iceflower bundleFramework-agnostic security rules including input validation, auth principles, CORS, API headers, rate limiting, secret management, authentication patterns (JWT, OAuth2, session, MFA), web protection (CSRF, XSS, injection defense, TLS), container security, and software supply chain security (SBOM, Cosign, Sigstore, SLSA). Use when implementing security-related code.
- ▌ Messaging · iceflower bundleAsync messaging patterns including broker selection, message design, producer/consumer patterns, schema evolution, and monitoring. Use when implementing Kafka, RabbitMQ, or event-driven architecture.
- ▌ Spring AI · iceflower bundleSpring AI conventions and patterns for building AI-powered applications including ChatClient configuration, tool/function calling, prompt template management, vector store integration, RAG (Retrieval Augmented Generation), Advisors API, MCP (Model Context Protocol) integration, multi-model routing patterns, advanced RAG (query rewriting, hybrid search, reranking, agentic RAG), agent frameworks (Router Agent, Human-in-the-Loop, memory patterns), and model evaluation/token monitoring. Use when building or reviewing Spring AI applications, integrating LLMs with Spring Boot, implementing ChatClient, configuring tool calling, designing prompt templates, working with vector databases in Spring, or building advanced RAG pipelines and autonomous agent workflows.
- ▌ API Design · iceflower bundleREST API design principles including URL design, HTTP methods, status codes, pagination, versioning, security, and OpenAPI documentation. Use when designing or implementing REST APIs.
- ▌ Dockerfile · iceflower bundleDockerfile best practices including multi-stage builds, layer caching, security, JVM/Spring Boot containerization patterns, BuildKit features (cache/secret mounts), multi-architecture builds, signal handling, and image provenance (cosign, SBOM). Use when writing or reviewing Dockerfiles.
- ▌ Code Review · iceflower bundleCode review checklist, comment guidelines, and PR review best practices. Covers PR review workflows, code suggestions, nitpick vs blocking review classification, LGTM criteria, review checklist (correctness, security, performance, readability), and constructive feedback patterns. Use when reviewing pull requests, providing code suggestions, or establishing a team code review process and review comment conventions.
- ▌ Code Search · iceflower bundleEfficient code search strategies for large codebases including ripgrep advanced patterns, AST-based search with ast-grep, git history search (pickaxe, git grep, bisect), LSP navigation, GitHub code search, and codebase exploration strategies (top-down, bottom-up, call chain, data flow tracing). Use when searching large codebases, tracing code history, navigating unfamiliar projects, or finding specific patterns across files.
- ▌ Concurrency · iceflower bundleJVM concurrency rules including thread safety, synchronization tools, Executor framework, CompletableFuture, Kotlin coroutines, and virtual threads. Use when writing concurrent or parallel code.
- ▌ HTTP Client · iceflower bundleFramework-agnostic external API integration patterns including timeouts, error handling, retry strategy, circuit breaker, and response mapping. Use when writing or reviewing HTTP client code.
- ▌ Cloud Native · iceflower bundleCloud native application design principles based on the Twelve-Factor App methodology and CNCF patterns including codebase management, dependency isolation, config externalization, backing services, build-release-run separation, stateless processes, port binding, concurrency via process model, disposability, dev/prod parity, log streaming, and admin processes. Extends to 15-Factor with API-first design, telemetry, and security. Covers AWS/GCP/Azure Well-Architected frameworks. Use when designing cloud native applications, reviewing application architecture for cloud readiness, or applying twelve-factor principles to existing applications.
- ▌ Code Quality · iceflower bundleCode quality and design principles. Includes refactoring techniques, code smell identification, and safe refactoring workflows. Use when writing, reviewing, or refactoring code.
- ▌ Devcontainer · iceflower bundleDev Container configuration patterns including devcontainer.json structure, image selection, Features, Docker Compose integration, lifecycle commands, port forwarding, VS Code customizations, and GitHub Codespaces integration. Use when setting up reproducible development environments with Dev Containers, configuring Codespaces, or writing devcontainer.json files.
- ▌ Feature Flag · iceflower bundleFeature flag and progressive delivery patterns including toggle classification (release, experiment, ops, permission), flag lifecycle management, targeting rules, percentage rollouts, A/B testing integration, trunk-based development with feature flags, and progressive delivery strategies (canary, blue-green). Covers OpenFeature standard, LaunchDarkly, Unleash, Flipt, and Flagsmith. Use when implementing feature flags, designing toggle strategies, planning progressive delivery, or integrating feature management with CI/CD pipelines and trunk-based development workflows.
- ▌ Git Workflow · iceflower bundleGit commit conventions, branch strategy, and collaboration workflow rules. Covers conventional commits, commit message formatting, squash merge, rebase, interactive rebase, branch naming conventions, merge conflict resolution, cherry-pick, git bisect, and pull request workflows. Use when committing code, managing branches, resolving merge conflicts, or defining a team Git branching strategy.
- ▌ K8S Workflow · iceflower bundleKubernetes core workflow rules, manifest conventions, security best practices, and version considerations. Includes managed K8s providers (EKS, AKS, GKE), autoscaling (KEDA, Knative, event-driven scaling), networking (Ingress, Gateway API, NetworkPolicy, Service Mesh), storage (PV/PVC, StatefulSet), RBAC, and deployment strategies (Rolling, Blue-Green, Canary). Use for Kubernetes operations and manifest authoring.
- ▌ Load Testing · iceflowerLoad and performance testing best practices with k6 and Gatling including test design, metrics, thresholds, CI integration, and result analysis. Use when designing or implementing performance tests.
- ▌ Localization · iceflower bundleInternationalization (i18n) and localization (l10n) patterns including ICU Message Format, i18n library integration (react-intl, i18next, vue-i18n), RTL language support, Intl API formatting, translation file management, and Unicode/CLDR considerations. Use when building multilingual applications, implementing i18n libraries, handling RTL layouts, or managing translation workflows.
- ▌ Openapi Spec · iceflower bundleOpenAPI specification writing best practices including schema design, documentation generation, validation, versioning, and code generation patterns. Use when writing, reviewing, or maintaining OpenAPI specifications.
- ▌ PDF Handling · iceflower bundlePDF file reading and processing rules. Use when analyzing PDF files or extracting content from them.
- ▌ Gitops Argocd · iceflower bundleGitOps workflow with Argo CD including application management, sync strategies, secret management, multi-cluster deployment, rollback, notifications, and CI/CD integration. Covers ApplicationSet patterns and progressive delivery. Use when implementing GitOps workflows or managing Argo CD configurations.
- ▌ Helm Workflow · iceflower bundleHelm chart development and release management including chart structure, values design, template best practices, hooks, dependency management, testing, and repository management. Covers Helm v3/v4 and Kustomize selection. Use when creating, reviewing, or managing Helm charts.
- ▌ Microservices · iceflower bundleMicroservices architecture patterns including service decomposition, communication (sync/async, gRPC), API gateway, Saga, CQRS, event sourcing, transactional outbox, data management, and fault isolation (Circuit Breaker, Bulkhead). Use when designing or reviewing microservice architectures, or implementing distributed transactions, service discovery, or strangler fig migration.
- ▌ Observability · iceflower bundleModern observability and monitoring patterns centered on OpenTelemetry (OTel). Covers the three pillars (traces, metrics, logs) with context propagation, OTel SDK architecture, OTLP protocol, distributed tracing with W3C Trace Context, metric instrument types (Counter, Histogram, Gauge, Timer, Exemplars), key metrics to monitor (application, business, infrastructure), metric naming conventions, log correlation, OTel Collector pipelines, Semantic Conventions, backend integration (Jaeger, Grafana Tempo, Loki, Prometheus), alerting rules, health check patterns (liveness, readiness, startup), SLO/SLI design, error budget management, and business metrics modeling. Use when implementing distributed tracing, setting up OTel instrumentation, configuring Collector pipelines, designing alerting strategies, implementing health checks, defining SLO/SLI targets, or integrating observability backends.
- ▌ System Design · iceflower bundleLarge-scale system design patterns including database architecture, caching, CDN, stateless design, message queues, consistent hashing, and rate limiting. Covers CAP theorem, eventual consistency, sharding strategies, replication factor, read replica configuration, and system stability patterns (circuit breaker, bulkhead, backpressure). Includes distributed systems patterns: data replication, partitioning, consensus, distributed time (Lamport clock, hybrid clock), cluster management (lease, gossip, state watch), and network communication patterns. Use when designing scalable system architectures, evaluating consistency vs availability trade-offs, planning data partitioning and replication strategies, or implementing distributed systems patterns.
- ▌ API Versioning · iceflower bundleAPI versioning strategies and lifecycle management including URL path, header, and content negotiation versioning, breaking change classification, deprecation policies (RFC 9745, RFC 8594), API lifecycle stages, evolution patterns (expand-and-contract, tolerant reader), and API gateway version routing. Use when designing API versioning strategies, managing breaking changes, planning deprecation timelines, or implementing version routing.
- ▌ Data Migration · iceflower bundleData migration and ETL patterns including zero-downtime migration strategies (dual-write, shadow table, expand-and-contract), online schema migration tools (gh-ost, pt-online-schema-change, pgroll), large-scale data migration planning, ETL/ELT pipeline design, CDC (Change Data Capture), backward compatible schema changes, data validation and reconciliation, and rollback strategies. Use when planning database migrations, implementing zero-downtime schema changes, designing ETL/ELT pipelines, or performing large-scale data movement between systems.
- ▌ Error Handling · iceflower bundleFramework-agnostic error handling patterns including exception hierarchy, error classification, response format, and handling principles. Use when designing error handling strategies.
- ▌ Event Storming · iceflower bundleEvent Storming workshop facilitation guide including sticky note color conventions, workshop levels (Big Picture, Process Modeling, Design Level), facilitation techniques, DDD transition patterns (Bounded Context and Aggregate identification), remote Event Storming, and common pitfalls. Use when planning or facilitating Event Storming workshops, transitioning workshop results into domain models, or guiding teams through collaborative domain exploration.
- ▌ Resume Writing · iceflower bundleDeveloper resume writing guide including structure, experience description with STAR method, technical skills organization, and project description. Use when writing or reviewing a developer resume.
- ▌ Java Convention · iceflower bundleJava coding conventions and modern idioms. Includes version migration guide (8 → 11 → 17 → 21 → 25). Use when writing or reviewing Java code.
- ▌ Jvm Performance · iceflower bundleJVM performance tuning including garbage collection algorithms, GC selection, heap analysis, profiling tools, and cloud-native considerations. Use when diagnosing performance issues or tuning JVM parameters.
- ▌ Tekton Workflow · iceflower bundleKubernetes-native CI/CD pipeline system including Task, Pipeline, Trigger CRDs, workspace sharing, Artifact Hub reuse, and CI/CD integration patterns. Use when building or reviewing Tekton pipelines on Kubernetes.
- ▌ Troubleshooting · iceflower bundleGeneral debugging and troubleshooting patterns for slow APIs, deployment rollback, connection issues, OOMKilled pods, CrashLoopBackOff, and debugging principles. Covers root cause analysis, incident triage workflows, error stack trace analysis, pod logs inspection, metrics anomaly detection, alert investigation, and systematic debugging methodologies. Use when diagnosing errors, performing root cause analysis on production incidents, investigating alert anomalies, or triaging deployment failures.
- ▌ React Convention · iceflowerReact and Next.js coding conventions including component patterns, hooks, state management, performance optimization, and project structure. Use when writing, reviewing, or refactoring React/Next.js code.
- ▌ Spring Framework · iceflower bundleSpring Framework core conventions including IoC/DI, AOP, transaction management, event system, bean lifecycle, WebMVC, WebFlux, validation, scheduling, configuration management, and JPA/data access patterns. Includes Spring Boot implementation patterns for caching, error handling, HTTP client, monitoring (Actuator, Micrometer), security (SecurityFilterChain), troubleshooting (HikariCP, connection pool, OOM), and integration with Exposed ORM and Kotlin interop. Includes migration guides for Framework (5.x → 7.0) and Boot (2.7 → 4.0). Use when working with Spring Framework or Spring Boot features, Actuator health probes, Bean Validation, @Transactional, RestClient, WebClient, or Spring Security.
- ▌ Chaos Engineering · iceflower bundleChaos engineering principles and practices for building resilient systems. Covers tools such as Chaos Monkey, Gremlin, and Litmus for fault injection, blast radius analysis, steady state hypothesis definition, experiment design, failure mode validation, and game day planning. Use when designing reliability testing, running fault injection experiments, defining steady state hypotheses, or planning chaos game days to verify system resilience.
- ▌ Gradle Convention · iceflower bundleGradle build conventions for Kotlin/JVM multi-module projects. Covers multi-module project structure, convention plugins, buildSrc setup, dependency management with version catalogs, Gradle wrapper configuration, build cache configuration, task optimization, and plugin publishing. Use when writing or reviewing build.gradle.kts, settings.gradle.kts, version catalog files, or configuring convention plugins for shared build logic.
- ▌ Incident Response · iceflower bundleIncident response workflow including severity classification, communication protocols, triage, mitigation strategies, runbook authoring, postmortem process, and on-call best practices. Covers MTTD, MTTA, MTTR metrics and SLO/SLI/SLA relationships. Use when handling production incidents, writing runbooks, or establishing incident response procedures.
- ▌ Kotlin Convention · iceflower bundleKotlin coding conventions, idioms, and language-specific best practices. Covers null safety, data class, sealed class, enum class, extension functions, coroutines, Flow, when expression, scope functions (let, run, apply, also), collection operations, and Kotlin DSL patterns. Use when writing or reviewing Kotlin code, designing domain models with sealed hierarchies, or implementing asynchronous logic with coroutines and Flow.
- ▌ Nestjs Convention · iceflowerNestJS framework conventions and Node.js backend patterns including module structure, dependency injection, controllers, services, guards, interceptors, pipes, exception filters, Prisma/TypeORM integration, and testing patterns. Use when writing or reviewing NestJS applications or Node.js backend code.
- ▌ Clean Architecture · iceflower bundleClean Architecture and Hexagonal Architecture (Ports & Adapters) patterns. Covers the dependency rule, domain layer isolation, use case (application service) design, repository pattern, input/output port definitions, adapter implementation, and onion architecture layering. Use when designing layered architecture, defining port/adapter boundaries, structuring domain-centric applications, or enforcing the dependency rule between infrastructure and domain layers.
- ▌ Karpenter Workflow · iceflower bundleKarpenter core workflow, NodePool configuration, autoscaling patterns, and troubleshooting. Includes cloud provider configurations (AWS EC2NodeClass, Azure AKSNodeClass, GCP GKENodeClass). Use for Karpenter operations.
- ▌ Prompt Engineering · iceflowerPrompt engineering best practices for LLM-powered applications including prompt design patterns, structured output, evaluation, safety, and cost optimization. Use when building or reviewing AI-powered features that interact with LLMs.
- ▌ Secrets Management · iceflower bundleSecret lifecycle management including storage solutions, rotation policies, Kubernetes patterns (ESO, Sealed Secrets, CSI), CI/CD pipeline secrets, certificate management, and secret detection/prevention. Use when managing secrets, credentials, or certificates in any environment.
- ▌ Terraform Workflow · iceflower bundleTerraform core workflow rules, state management, module design patterns, and version considerations. Includes provider-specific guides for AWS (v6.x), Azure (v4.x), and GCP (v6.x). Use for Terraform operations and best practices.
- ▌ Java Kotlin Interop · iceflower bundleJava-Kotlin interoperability guide covering platform types, null safety with JSpecify, JVM annotations (@JvmStatic, @JvmOverloads, @JvmExposeBoxed, @Throws), collection interop, coroutine-Java bridging, SAM conversion, and build configuration for mixed projects.
- ▌ Typescript Convention · iceflowerTypeScript coding conventions including type system best practices, strict mode configuration, utility types, error handling, and project organization patterns. Use when writing, reviewing, or refactoring TypeScript code.
- ▌ Object Oriented Design · iceflower bundleObject-oriented design principles with practical examples covering all five SOLID principles: Single Responsibility (SRP), Open/Closed (OCP), Liskov Substitution (LSP), Interface Segregation (ISP), and Dependency Inversion (DIP). Includes design patterns, class hierarchy design, and refactoring guidance. Use when designing class hierarchies, applying SOLID principles, refactoring toward better abstractions, or reviewing object-oriented design for violations.
- ▌ Technical Documentation · iceflower bundleTechnical documentation guide covering writing principles, user research, deployment process, and quality measurement. Use when writing or reviewing technical documentation.
- ▌ Performance Optimization · iceflower bundlePerformance optimization patterns for frontend and backend applications. Covers Core Web Vitals (LCP, INP, CLS), bundle optimization, image optimization, rendering performance, DB query tuning, connection pooling, HTTP caching, CDN strategies, compression, performance budgets, and CI integration. Use when optimizing application performance, diagnosing slow pages or APIs, or setting up performance monitoring and budgets.