TheBushidoCollective.

absinthe-resolvers

Use when implementing GraphQL resolvers with Absinthe. Covers resolver patterns, dataloader integration, batching, and error handling.

absinthe-schema

Use when designing GraphQL schemas with Absinthe. Covers type definitions, interfaces, unions, enums, and schema organization patterns.

absinthe-subscriptions

Use when implementing real-time GraphQL subscriptions with Absinthe. Covers Phoenix channels, PubSub, and subscription patterns.

act-docker-setup

Use when configuring Docker environments for act, selecting runner images, managing container resources, or troubleshooting Docker-related issues with local GitHub Actions testing.

act-local-testing

Use when testing GitHub Actions workflows locally with act. Covers act CLI usage, Docker configuration, debugging workflows, and troubleshooting common issues when running workflows on your local machine.

act-workflow-syntax

Use when creating or modifying GitHub Actions workflow files. Provides guidance on workflow syntax, triggers, jobs, steps, and expressions for creating valid GitHub Actions workflows that can be tested locally with act.

ameba-configuration

Use when configuring Ameba rules and settings for Crystal projects including .ameba.yml setup, rule management, severity levels, and code quality enforcement.

ameba-custom-rules

Use when creating custom Ameba rules for Crystal code analysis including rule development, AST traversal, issue reporting, and rule testing.

ameba-integration

Use when integrating Ameba into development workflows including CI/CD pipelines, pre-commit hooks, GitHub Actions, and automated code review processes.

analyze-performance

Analyze performance metrics and identify slow transactions in Sentry

android-jetpack-compose

Use when building Android UIs with Jetpack Compose, managing state with remember/mutableStateOf, or implementing declarative UI patterns.

angular-rxjs-patterns

Use when handling async operations in Angular applications with observables, operators, and subjects.

angular-signals

Use when building Angular 16+ applications requiring fine-grained reactive state management and zone-less change detection.

ansible-inventory

Use when managing hosts and groups in Ansible inventory for organizing infrastructure and applying configurations across environments.

ansible-playbooks

Use when writing and organizing Ansible playbooks for automated configuration management and infrastructure orchestration.

ansible-roles

Use when structuring and reusing code with Ansible roles for modular, maintainable automation and configuration management.

apollo-caching-strategies

Use when implementing Apollo caching strategies including cache policies, optimistic UI, cache updates, and normalization.

apollo-client-patterns

Use when implementing Apollo Client patterns for queries, mutations, cache management, and local state in React applications.

apollo-server-patterns

Use when building GraphQL APIs with Apollo Server requiring resolvers, data sources, schema design, and federation.

atomic-design-atoms

Use when creating atomic-level UI components like buttons, inputs, labels, and icons. The smallest building blocks of a design system.

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-integration

Use when integrating Atomic Design methodology with React, Vue, Angular, or other frameworks. Framework-specific implementation patterns.

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-organisms

Use when building complex organisms from molecules and atoms like headers, footers, product cards, and sidebars. Organisms are distinct UI sections.

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-templates

Use when creating page layouts without real content. Templates define the skeletal structure of pages using organisms, molecules, and atoms.

baseline-restorer

Use when multiple fix attempts fail and you need to systematically restore to a working baseline and reimplement instead of fixing broken code.

bdd-collaboration

Use when facilitating BDD collaboration between developers, testers, and business stakeholders. Use when running discovery workshops and example mapping sessions.

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-principles

Core BDD concepts, philosophy, and the Three Amigos practice

bdd-scenarios

Use when writing effective BDD scenarios including acceptance criteria, edge cases, and scenario organization. Use when defining behavior specifications.

biome-configuration

Use when biome configuration including biome.json setup, schema versions, VCS integration, and project organization.

biome-formatting

Use when formatting JavaScript/TypeScript code with Biome's fast formatter including patterns, options, and code style management.

biome-linting

Use when applying Biome's linting capabilities, rule categories, and code quality enforcement to JavaScript/TypeScript projects.

blueprints-maintenance

Use after modifying existing systems to update blueprint documentation. Read blueprints before changes, update after. Prevents documentation drift.

blueprints-organization

Use when managing blueprints directory structure and avoiding duplication. Always search existing blueprints before creating to prevent duplicate documentation. Handles naming conventions and cross-references.

blueprints-writing

Use when creating or updating technical blueprint documentation for new features, API changes, or architectural modifications. Always search existing blueprints first to avoid duplication, then write with proper structure.

boy-scout-rule

Use when modifying existing files, refactoring, improving code quality, or touching legacy code by applying the Boy Scout Rule to leave code better than you found it.

bun-bundler

Use when bundling JavaScript/TypeScript code with Bun's fast bundler. Covers building for different targets, tree-shaking, code splitting, and optimization strategies.

bun-package-manager

Use when managing dependencies with Bun's package manager. Covers installing packages, workspaces, lockfiles, and migrating from npm/yarn/pnpm to Bun.

bun-sqlite

Use when working with SQLite databases in Bun. Covers Bun's built-in SQLite driver, database operations, prepared statements, and transactions with high performance.

bun-testing

Use when writing tests with Bun's built-in test runner. Covers test organization, assertions, mocking, and snapshot testing using Bun's fast test infrastructure.

c-data-structures

Use when fundamental C data structures including arrays, structs, linked lists, trees, and hash tables with memory-efficient implementations.

c-memory-management

Use when managing memory in C programs with malloc/free, pointers, and avoiding common memory safety pitfalls.

c-systems-programming

Use when c systems programming including file I/O, processes, signals, and system calls for low-level system interaction.

check-releases

Check release health and compare error rates across deployments

checkstyle-configuration

Use when configuring Checkstyle for Java projects with XML config, custom checks, properties, and module setup.

checkstyle-custom

Use when developing custom Checkstyle checks, filters, and plugin integrations for project-specific Java code standards.

checkstyle-rules

Use when applying Checkstyle built-in checks for Java code including naming conventions, code metrics, and suppressions.

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.

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-tool-integration

Use when integrating tools, permissions, and MCP servers with Claude AI agents using the Agent SDK.

clippy-configuration

Use when configuring Clippy for Rust projects with TOML config, lint groups, attributes, and workspace setup.

clippy-custom

Use when developing custom Clippy lints, implementing lint passes, and contributing to Clippy for Rust code standards.

clippy-lints

Use when applying Clippy lint categories for Rust code including correctness, performance, style, and custom lint configuration.

cocoapods-podspec-fundamentals

Use when creating or modifying CocoaPods podspec files. Covers required attributes, file patterns, dependencies, and platform specifications for iOS, macOS, tvOS, watchOS, and visionOS projects.

cocoapods-privacy-manifests

Use when implementing iOS 17+ privacy manifests for CocoaPods libraries. Covers PrivacyInfo.xcprivacy file creation, required reasons API declarations, and proper resource bundle integration for App Store compliance.

cocoapods-publishing-workflow

Use when publishing CocoaPods libraries to CocoaPods Trunk. Covers pod trunk registration, podspec validation, version management, and publishing best practices for successful library distribution.

cocoapods-subspecs-organization

Use when organizing complex CocoaPods libraries into subspecs. Covers modular architecture, dependency management between subspecs, and default subspecs patterns for better code organization and optional features.

cocoapods-test-specs

Use when adding automated tests to CocoaPods libraries using test specs. Covers test spec configuration, app host requirements, and testing patterns that integrate with pod lib lint validation.

code-annotation-patterns

Use when annotating code with structured metadata, tags, and markers for AI-assisted development workflows. Covers annotation formats, semantic tags, and integration with development tools.

comment

Add a comment to a ClickUp task

complete

Mark a ClickUp task as complete after validating checklist

cpp-modern-features

Use when modern C++ features from C++11/14/17/20 including auto, lambdas, range-based loops, structured bindings, and concepts.

cpp-smart-pointers

Use when C++ smart pointers including unique_ptr, shared_ptr, and weak_ptr for automatic memory management following RAII principles.

cpp-templates-metaprogramming

Use when C++ templates and metaprogramming including template specialization, SFINAE, type traits, and C++20 concepts.

create

Create a new ClickUp task interactively

create-blueprint

Research a specific system and create or update its blueprints/ documentation

create-mr

Create a new merge request in a GitLab project

create-sop

Create a new Standard Operating Procedure (SOP) file with proper structure

credo-checks

Use when understanding and fixing common Credo check issues for Elixir code quality and consistency.

credo-configuration

Use when configuring Credo static analysis for Elixir projects requiring customized code quality rules and settings.

credo-custom-checks

Use when creating custom Credo checks for project-specific code quality rules and standards in Elixir.

crystal-concurrency

Use when implementing concurrent programming in Crystal using fibers, channels, and parallel execution patterns for high-performance, non-blocking applications.

crystal-engineer

Use when working with Crystal language development including WebSocket communication, TLS/SSL configuration, HTTP frameworks, ORM operations, and high-performance concurrent systems.

crystal-macros

Use when implementing compile-time metaprogramming in Crystal using macros for code generation, DSLs, compile-time computation, and abstract syntax tree manipulation.

csharp-async-patterns

Use when C# asynchronous programming with async/await, Task, ValueTask, ConfigureAwait, and async streams for responsive applications.

csharp-linq

Use when lINQ (Language Integrated Query) with query and method syntax, deferred execution, expression trees, and performance optimization.

csharp-nullable-types

Use when C# nullable reference types and value types for null safety, nullable annotations, and patterns for handling null values.

cucumber-best-practices

Cucumber best practices, patterns, and anti-patterns

cucumber-fundamentals

Core Cucumber concepts, Gherkin syntax, and feature file structure

cucumber-step-definitions

Writing effective step definitions and organizing test code

cypress-advanced

Use when advanced Cypress features including custom commands, plugins, and network stubbing.

cypress-ci-cd

Use when cypress CI/CD integration including parallelization, test recording, and media capture.

cypress-fundamentals

Use when cypress fundamentals including commands, assertions, fixtures, and E2E testing patterns.

dialyzer-analysis

Use when analyzing and fixing Dialyzer warnings and type discrepancies in Erlang/Elixir code.

dialyzer-configuration

Use when configuring Dialyzer for Erlang/Elixir type checking and static analysis.

dialyzer-integration

Use when integrating Dialyzer into development workflows and CI/CD pipelines for Erlang/Elixir projects.

django-cbv-patterns

Use when Django Class-Based Views for building modular, reusable views. Use when creating CRUD operations and complex view logic.

django-orm-patterns

Use when Django ORM patterns with models, queries, and relationships. Use when building database-driven Django applications.

django-rest-framework

Use when Django REST Framework for building APIs with serializers, viewsets, and authentication. Use when creating RESTful APIs.

docker-compose-basics

Use when defining and running multi-container Docker applications with Docker Compose YAML configuration.

docker-compose-networking

Use when configuring networks and service communication in Docker Compose including bridge networks, overlay networks, service discovery, and inter-service communication.

docker-compose-production

Use when deploying Docker Compose applications to production including security hardening, resource management, health checks, logging, monitoring, and high-availability patterns.

documentation-linking

Use when creating bidirectional links between code and documentation. Covers link patterns, documentation references, context preservation across artifacts, and maintaining synchronization between code and docs.

ecto-changesets

Use when validating and casting data with Ecto changesets including field validation, constraints, nested changesets, and data transformation. Use for ensuring data integrity before database operations.

ecto-query-patterns

Use when querying data with Ecto.Query DSL including where clauses, joins, aggregates, preloading, and query composition. Use for building flexible database queries in Elixir applications.

ecto-schema-patterns

Use when defining data structures using Ecto schemas including fields, associations, embedded schemas, and schema metadata. Use for modeling domain data in Elixir applications.

ecto-schemas

Use when defining and working with Ecto schemas including field types, associations, and embedded schemas. Use when modeling database entities in Elixir.

effect-concurrency

Use when Effect concurrency patterns including fibers, fork, join, parallel execution, and race conditions. Use for concurrent operations in Effect applications.

effect-core-patterns

Use when Effect core patterns including Effect<A, E, R> type, succeed, fail, sync, promise, and Effect.gen for composing effects. Use for basic Effect operations.

effect-dependency-injection

Use when Effect dependency injection patterns including Context, Layer, service definitions, and dependency composition. Use for managing dependencies in Effect applications.

effect-error-handling

Use when Effect error handling patterns including catchAll, catchTag, either, option, and typed errors. Use for handling expected errors in Effect applications.

effect-resource-management

Use when Effect resource management patterns including Scope, addFinalizer, scoped effects, and automatic cleanup. Use for managing resources in Effect applications.

effect-schema

Use when @effect/schema patterns including schema definition, validation, parsing, encoding, and transformations. Use for type-safe data validation in Effect applications.

effect-testing

Use when testing Effect code including Effect.gen in tests, test layers, mocking services, and testing error scenarios. Use for writing tests for Effect applications.

elixir-ecto-patterns

Use when Elixir Ecto patterns including schemas, changesets, queries, and transactions. Use when building database-driven Elixir applications.

elixir-otp-patterns

Use when Elixir OTP patterns including GenServer, Supervisor, Agent, and Task. Use when building concurrent, fault-tolerant Elixir applications.

elixir-pattern-matching

Use when Elixir pattern matching including function clauses, case statements, with statements, and destructuring. Use for elegant control flow.

eslint-configuration

Use when eSLint configuration including config files, extends, plugins, and environment setup.

eslint-custom

Use when custom ESLint rules and plugins including rule development, AST traversal, and publishing.

eslint-rules

Use when eSLint built-in rules including rule configuration, severity levels, and disabling strategies.

explicit-configuration

Prefer explicit configuration over framework defaults to prevent environment-dependent failures

expo-build

Use when building and deploying Expo apps with EAS Build. Covers build configuration, development builds, production builds, and app store submission.

expo-config

Use when configuring Expo apps with app.json, app.config.js, and EAS configuration. Covers app metadata, plugins, build configuration, and environment variables.

expo-modules

Use when working with Expo SDK modules for camera, location, notifications, file system, and other device APIs. Covers permissions, configurations, and best practices.

expo-router

Use when implementing file-based routing in Expo with Expo Router. Covers app directory structure, navigation, layouts, dynamic routes, and deep linking.

expo-updates

Use when implementing over-the-air (OTA) updates with Expo Updates. Covers update configuration, checking for updates, and update strategies.

fastapi-async-patterns

Use when FastAPI async patterns for building high-performance APIs. Use when handling concurrent requests and async operations.

fastapi-dependency-injection

Master FastAPI dependency injection for building modular, testable APIs.

fastapi-validation

Use when FastAPI validation with Pydantic models. Use when building type-safe APIs with robust request/response validation.

figma-analyze-frame

Analyze a Figma frame's structure, properties, and implementation considerations

figma-extract-tokens

Extract design tokens and variables from a Figma file to create or update a design system

figma-generate-component

Generate production-ready code from a Figma component or frame using the Figma MCP server

figma-sync-design-system

Sync design system components between Figma and code using Code Connect mappings

fnox-configuration

Use when configuring Fnox secrets management with fnox.toml. Covers file structure, secrets definition, profiles, and hierarchical configurations.

fnox-providers

Use when configuring Fnox providers for encryption and secret storage. Covers age encryption, cloud providers (AWS, Azure, GCP), and password managers.

fnox-security-best-practices

Use when implementing secure secrets management with Fnox. Covers encryption, key management, access control, and security hardening.

generate-blueprints

Deeply research all systems and create or update blueprints/ documentation for the entire codebase

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-messages

Use when writing commit messages that clearly communicate changes and tell the story of development. Helps create informative, well-structured commit messages that serve as documentation.

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.

git-worktrees-worktree-management

Manage git worktrees - list active worktrees, prune stale ones, and merge work back into the main branch.

gitlab-ci-artifacts-caching

Use when configuring artifacts for inter-job data passing or caching for faster builds. Covers cache strategies and artifact management.

gitlab-ci-best-practices

Use when optimizing GitLab CI/CD pipelines for performance, reliability, or maintainability. Covers pipeline optimization and organizational patterns.

gitlab-ci-job-configuration

Use when defining GitLab CI jobs, configuring scripts, setting up environments, or managing job dependencies. Covers job structure and execution options.

gitlab-ci-pipeline-configuration

Use when configuring GitLab CI/CD pipelines, defining stages, or setting up workflow rules. Covers pipeline structure, stage ordering, and execution flow.

gitlab-ci-variables-secrets

Use when configuring GitLab CI/CD variables, managing secrets, or integrating with external secret providers. Covers secure credential handling.

Gleam Actor Model

Use when oTP actor patterns in Gleam including processes, message passing, GenServer implementations, supervisors, fault tolerance, state management, and building concurrent, fault-tolerant applications on the Erlang VM.

Gleam Erlang Interop

Use when gleam-Erlang interoperability including calling Erlang code from Gleam, using Erlang libraries, external functions, working with Erlang types, NIFs, and leveraging the BEAM ecosystem from Gleam applications.

Gleam Type System

Use when gleam's type system including algebraic data types, custom types, pattern matching, generic types, type inference, opaque types, exhaustive checking, and functional error handling for building type-safe Erlang VM applications.

gluestack-accessibility

Use when ensuring accessible gluestack-ui implementations. Covers WAI-ARIA patterns, screen reader support, keyboard navigation, focus management, and WCAG 2.1 AA compliance.

gluestack-components

Use when building UI with gluestack-ui components. Covers component composition, variants, sizes, states, accessibility props, and platform-specific considerations for React and React Native.

gluestack-mcp-tools

Use when discovering, exploring, or retrieving gluestack-ui components via MCP tools. Provides access to component source code, variants, demos, and metadata.

gluestack-theming

Use when customizing gluestack-ui themes and design tokens. Covers theme provider setup, design tokens, dark mode, NativeWind integration, and extending themes.

graphql-inspector-audit

Use when auditing GraphQL operations for complexity metrics, depth analysis, directive usage, or query performance concerns.

graphql-inspector-ci

Use when setting up GraphQL Inspector in CI/CD pipelines, GitHub Actions, or GitLab CI for automated schema validation.

graphql-inspector-diff

Use when detecting breaking changes between GraphQL schema versions, comparing schemas across branches, or validating schema migrations.

graphql-inspector-validate

Use when validating GraphQL operations/documents against a schema, checking query depth, complexity, or fragment usage.

graphql-performance

Use when optimizing GraphQL API performance with query complexity analysis, batching, caching strategies, depth limiting, monitoring, and database optimization.

graphql-resolvers

Use when implementing GraphQL resolvers with resolver functions, context management, DataLoader batching, error handling, authentication, and testing strategies.

graphql-schema-design

Use when designing GraphQL schemas with type system, SDL patterns, field design, pagination, directives, and versioning strategies for maintainable and scalable APIs.

helm-charts

Use when understanding and creating Helm charts for packaging and deploying Kubernetes applications.

helm-templates

Use when working with Helm templates and template functions for generating Kubernetes manifests dynamically.

helm-values

Use when managing Helm values files and configuration overrides for customizing Kubernetes deployments.

ink-component-patterns

Use when building terminal UIs with Ink component patterns for React-based CLI applications.

ink-hooks-state

Use when managing state and side effects in Ink applications using React hooks for terminal UIs.

ink-layout-styling

Use when creating terminal layouts with Ink using Flexbox-based positioning and styling for CLI applications.

investigate-errors

Investigate recent errors and exceptions in your Sentry projects

ios-swiftui-patterns

Use when building SwiftUI views, managing state with @State/@Binding/@ObservableObject, or implementing declarative UI patterns in iOS apps.

ios-uikit-architecture

Use when building iOS apps with UIKit, implementing MVVM/MVC/Coordinator patterns, or integrating UIKit with SwiftUI.

issue

Get detailed information about a specific Linear issue

java-generics

Use when Java generics including type parameters, wildcards, and type bounds. Use when writing type-safe reusable code.

java-streams-api

Use when Java Streams API for functional-style data processing. Use when processing collections with streams.

jest-advanced

Use when advanced Jest features including custom matchers, parameterized tests with test.each, coverage configuration, and performance optimization.

jest-configuration

Use when jest configuration, setup files, module resolution, and project organization for optimal testing environments.

jest-testing-patterns

Use when jest testing patterns including unit tests, mocks, spies, snapshots, and assertion techniques for comprehensive test coverage.

junit-extensions

Use when jUnit extensions including custom extensions, rules, and conditional test execution.

junit-fundamentals

Use when jUnit fundamentals including annotations, assertions, and test lifecycle for Java testing.

junit-parameterized

Use when jUnit parameterized tests with various value sources and test factories.

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.

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.

kubernetes-manifests

Use when writing and deploying Kubernetes manifests for container orchestration.

kubernetes-resources

Use when managing Kubernetes resources including deployments, services, configmaps, and secrets.

kustomize-basics

Use when customizing Kubernetes configurations without templates using Kustomize overlays and patches.

kustomize-generators

Use when generating ConfigMaps and Secrets with Kustomize for Kubernetes configuration management.

kustomize-overlays

Use when managing environment-specific Kubernetes configurations with Kustomize overlays and patches.

legacy-code-safety

Use when modifying, removing, or refactoring code that lacks test coverage. Emphasizes the danger of untested changes and the RGR workflow to add characterization tests before modifications.

load-mr-context

Load MR context for the current branch using GitLab MCP tools

load-pr-context

Load PR context for the current branch using GitHub MCP tools

Lua C Integration

Use when lua C API for extending Lua with native code including stack operations, calling C from Lua, calling Lua from C, creating C modules, userdata types, metatables in C, and performance optimization techniques.

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.

Lua Tables Patterns

Use when lua tables as the universal data structure including arrays, dictionaries, objects, metatables, object-oriented patterns, data structures, and advanced table manipulation for building flexible, efficient Lua applications.

markdown-documentation

Use when writing technical documentation, READMEs, or project documentation in markdown. Covers structure, conventions, and best practices.

markdown-syntax-fundamentals

Use when writing or editing markdown files. Covers headings, text formatting, lists, links, images, code blocks, and blockquotes.

markdown-tables

Use when creating or formatting tables in markdown. Covers table syntax, alignment, escaping, and best practices.

markdownlint-configuration

Configure markdownlint rules and options including rule management, configuration files, inline comments, and style inheritance.

markdownlint-custom-rules

Create custom linting rules for markdownlint including rule structure, parser integration, error reporting, and automatic fixing.

markdownlint-integration

Integrate markdownlint into development workflows including CLI usage, programmatic API, CI/CD pipelines, and editor integration.

mise-environment-management

Use when managing environment variables and project settings with Mise. Covers env configuration, direnv replacement, and per-directory settings.

mise-task-configuration

Use when defining and configuring Mise tasks in mise.toml. Covers task definitions, dependencies, file tasks, and parallel execution.

mise-tool-management

Use when managing development tool versions with Mise. Covers installing tools, version pinning, and replacing language-specific version managers.

mocha-assertions

Use when assertion libraries for Mocha including Chai with expect, should, and assert styles.

mocha-configuration

Use when mocha configuration including reporters, config files, plugins, and CI integration.

mocha-fundamentals

Use when mocha test structure, hooks, and async testing patterns for JavaScript testing.

monitor-pipeline

Monitor a GitLab pipeline or job until completion, reporting status changes and failures in real-time

monorepo-architecture

Use when designing monorepo structure, organizing packages, or migrating to monorepo architecture with architectural patterns for managing dependencies and scalable workspace configurations.

monorepo-tooling

Use when setting up monorepo tooling, optimizing builds, or migrating between tools with Turborepo, Nx, Bazel, Lerna for efficient task running, caching, and code generation.

monorepo-workflows

Use when setting up CI/CD, implementing versioning, optimizing workflows, or managing releases with monorepo development workflows including version management, publishing, and team collaboration practices.

my-issues

Show all Linear issues assigned to you