fnox-configuration
Use when configuring Fnox secrets management with fnox.toml. Covers file structure, secrets definition, profiles, and hierarchical configurations.
claude-agent-sdk-tool-integration
Use when integrating tools, permissions, and MCP servers with Claude AI agents using the Agent SDK.
claude-agent-sdk-context-management
Use when managing agent context, memory, and conversation state in Claude AI agents using the Agent SDK.
claude-agent-sdk-agent-creation
Use when creating or configuring Claude AI agents using the Agent SDK. Covers agent initialization, configuration, and basic setup patterns.
android-kotlin-coroutines
Use when implementing async operations with Kotlin coroutines, Flow, StateFlow, or managing concurrency in Android apps.
git-storytelling-branch-strategy
Use when planning git branching strategies or managing branches for development. Helps create clear development narratives through effective branch organization and workflow patterns.
git-storytelling-commit-strategy
Use when planning commit strategies or determining when to commit changes. Helps developers commit early and often to tell the story of their development process.
bdd-scenarios
Use when writing effective BDD scenarios including acceptance criteria, edge cases, and scenario organization. Use when defining behavior specifications.
bdd-principles
Core BDD concepts, philosophy, and the Three Amigos practice
bdd-patterns
Use when applying Behavior-Driven Development patterns including Given-When-Then structure, feature files, and acceptance criteria. Use when writing BDD-style tests and specifications.
bdd-collaboration
Use when facilitating BDD collaboration between developers, testers, and business stakeholders. Use when running discovery workshops and example mapping sessions.
atomic-design-templates
Use when creating page layouts without real content. Templates define the skeletal structure of pages using organisms, molecules, and atoms.
atomic-design-quarks
Use when working with design tokens, CSS custom properties, and primitive values that form the foundation below atoms. Quarks are the sub-atomic building blocks.
atomic-design-organisms
Use when building complex organisms from molecules and atoms like headers, footers, product cards, and sidebars. Organisms are distinct UI sections.
atomic-design-molecules
Use when composing atoms into molecule components like form fields, search bars, and card headers. Molecules are functional groups of atoms.
atomic-design-integration
Use when integrating Atomic Design methodology with React, Vue, Angular, or other frameworks. Framework-specific implementation patterns.
atomic-design-fundamentals
Use when applying Atomic Design methodology to organize UI components into quarks, atoms, molecules, organisms, templates, and pages. Core principles and hierarchy.
atomic-design-atoms
Use when creating atomic-level UI components like buttons, inputs, labels, and icons. The smallest building blocks of a design system.
typescript-utility-types
Use when typeScript utility types, mapped types, and advanced type manipulation. Use when creating flexible, type-safe TypeScript code.
typescript-type-system
Use when working with TypeScript's type system including strict mode, advanced types, generics, type guards, and compiler configuration.
typescript-async-patterns
Use when typeScript async patterns including Promises, async/await, and async iterators with proper typing. Use when writing asynchronous TypeScript code.
Swift Protocol-Oriented Programming
Use when protocol-oriented programming in Swift including protocol extensions, default implementations, protocol composition, associated types, and designing flexible, reusable abstractions that favor composition over inheritance.
Swift Optionals Patterns
Use when swift's optional handling patterns including optional binding, chaining, nil coalescing, and modern approaches to safely working with optional values while avoiding common pitfalls and force unwrapping.
Swift Concurrency
Use when swift's modern concurrency model including async/await, actors, task groups, structured concurrency, and async sequences for building safe, performant concurrent code without data races or callback pyramids.
Scala Type System
Use when scala's advanced type system including generics, variance, type bounds, implicit conversions, type classes, higher-kinded types, path-dependent types, and abstract type members for building type-safe, flexible APIs.
Scala Functional Patterns
Use when functional programming patterns in Scala including higher-order functions, immutability, pattern matching, algebraic data types, monads, for-comprehensions, and functional composition for building robust, type-safe applications.
Scala Collections
Use when scala collections including immutable/mutable variants, List, Vector, Set, Map operations, collection transformations, lazy evaluation with views, parallel collections, and custom collection builders for efficient data processing.
rust-ownership-system
Use when Rust's ownership system including ownership rules, borrowing, lifetimes, and memory safety. Use when working with Rust memory management.
rust-error-handling
Use when Rust error handling with Result, Option, custom errors, thiserror, and anyhow. Use when handling errors in Rust applications.
rust-async-patterns
Use when Rust async programming with tokio, async/await, and futures. Use when writing asynchronous Rust code.
ruby-standard-library
Use when working with Ruby's standard library including Enumerable, File I/O, Time/Date, Regular Expressions, and core classes.
ruby-oop
Use when working with Ruby's object-oriented programming features including classes, modules, inheritance, mixins, and method visibility.
ruby-metaprogramming
Use when working with Ruby metaprogramming features including dynamic method definition, method_missing, class_eval, define_method, and reflection.
ruby-gems-bundler
Use when working with Ruby gems, Bundler for dependency management, creating gemspecs, and publishing gems to RubyGems.
ruby-blocks-procs-lambdas
Use when working with Ruby blocks, procs, lambdas, and functional programming patterns including closures and higher-order functions.
python-type-system
Use when Python's type system including type hints, mypy, Protocol, TypedDict, and Generics. Use when working with Python type annotations.
python-data-classes
Use when Python data modeling with dataclasses, attrs, and Pydantic. Use when creating data structures and models.
python-async-patterns
Master Python asynchronous programming with asyncio, async/await,
rails-action-controller-patterns
Use when action Controller patterns including routing, filters, strong parameters, and REST conventions.
phoenix-views-templates
Render views and templates in Phoenix using HEEx templates, function components, slots, and assigns
phoenix-routing
Define routes and URL helpers in Phoenix applications including resources, scopes, pipelines, and verified routes
phoenix-patterns
Use when applying Phoenix Framework best practices including context design, controller patterns, and application architecture. Use when building Phoenix applications.
phoenix-controllers
Handle HTTP requests with Phoenix controllers including actions, parameters, rendering, flash messages, and redirects
nextjs-server-components
Use when next.js Server Components for optimal performance. Use when building data-intensive Next.js applications.
nextjs-data-fetching
Use when next.js data fetching patterns including SSG, SSR, and ISR. Use when building data-driven Next.js applications.
nextjs-app-router
Use when next.js App Router with layouts, loading states, and streaming. Use when building modern Next.js 13+ applications.
Kotlin Null Safety
Use when kotlin's null safety system including nullable types, safe calls, Elvis operator, smart casts, and patterns for eliminating NullPointerExceptions while maintaining code expressiveness and clarity.
Lua Coroutines
Use when lua coroutines for cooperative multitasking including coroutine creation, yielding and resuming, passing values, generators, iterators, asynchronous patterns, state machines, and producer-consumer implementations.
absinthe-schema
Use when designing GraphQL schemas with Absinthe. Covers type definitions, interfaces, unions, enums, and schema organization patterns.
Kotlin DSL Patterns
Use when domain-specific language design in Kotlin using type-safe builders, infix functions, operator overloading, lambdas with receivers, and patterns for creating expressive, readable DSLs for configuration and domain modeling.
Page 596 of 1724 · 86172 results
