Results for “modules”

Guides development across the Kilo JetBrains plugin’s shared, frontend, and backend modules. Explains remote calls between modules, UI thread rules, dependency packaging, and testing practices, including serialization failures that require checks in a running IDE.

• Placing new code in the appropriate plugin module
• Defining frontend and backend communication
• Reviewing UI threading and coroutine usage

Guides Node.js scripts and shared modules in the Handsontable monorepo using .mjs files, native APIs, and asynchronous file operations. It covers task registration, error handling, and compatibility across Linux, macOS, and Windows.

• Create build scripts and shared Node.js modules
• Replace shell commands with cross-platform Node.js code
• Register tasks and dependencies in tasks.json

Write and manage infrastructure as code with Terraform and OpenTofu. Design reusable modules, review planned changes before applying them, bring existing resources under management, and organize shared state so teams can track infrastructure across environments.

• Designing reusable infrastructure modules
• Bringing existing resources under Terraform management
• Separating development, staging, and production state

Configure a repository for Superset so new isolated Git workspaces have dependencies, environment files, and service access ready. Create lifecycle scripts in .superset/config.json and verify the setup by starting a real test workspace.

• Prepare a repository for use with Superset
• Install dependencies automatically in new workspaces
• Provide environment files when creating workspaces

Builds CARLA's ue4-dev branch on Linux, producing the Unreal Engine 4.26 editor, server modules, and an installed Python client package. Fetches required content, optionally compiles native ROS 2 support, and verifies the build against a source-built server.

• Building CARLA ue4-dev from source
• Compiling CARLA with native ROS 2 support
• Building the Python client for an existing environment

Build infrastructure as code with Terraform across AWS, Azure, and GCP. Create reusable modules, manage state records that track resources, configure environments and providers, and validate proposed changes before applying an explicitly approved plan.

• Creating reusable Terraform modules
• Migrating state storage or importing existing resources
• Managing settings across development and production

Build and debug mobile apps for iOS and Android with React Native and Expo. Implement navigation, adapt screens to each platform, integrate native modules that access platform features, and improve list rendering, keyboard behavior, and memory use.

• Building an app for both iOS and Android
• Adding tabs, navigation stacks, and deep links
• Improving scrolling performance in long lists

Adjust an existing corporate legal practice profile through guided questions. Change risk preferences, contacts, review thresholds, active modules, or workspace paths, with an explanation of how each change affects related workflows.

• Change thresholds used to flag important contracts
• Update team contacts and escalation paths
• Enable or disable corporate legal modules

Guides Java SDK development in Apache Beam, from finding relevant modules to building code, running focused tests, and trying examples. Also explains how to publish modified modules locally and build SDK containers.

• Finding the Java SDK module to modify
• Running a specific test class or method
• Checking setup with the WordCount example

Design and review how a system is divided into modules, cohesive parts with clear responsibilities. Evaluate data ownership, communication rules, dependencies, and failure handling, and decide when to split or merge parts without assuming a particular technology.

• Define responsibilities and boundaries for a new module
• Review dependencies between system modules
• Clarify data ownership and communication rules

Analyze a monolithic codebase before splitting it into modules or services. The skill inventories components, examines duplication, hierarchy, and dependencies, then proposes groupings aligned with business domains, with optional checks against business terminology and boundaries.

• Assessing component sizes before splitting a monolith
• Finding duplicated business logic across modules
• Reviewing module hierarchy and dependencies

Build ice and frost visual effects in Three.js using reusable modules. Combine branching frost growth, refractive ice spikes, cracks and settling fragments, freezing mist, and swirling snow into a coordinated sequence demonstrated on a snowy ground.

• Animate frost spreading across the ground
• Create erupting ice spikes that crack and shatter
• Combine freezing mist with a swirling blizzard

Build AI agents in Unity with PuerTsAgent by organizing role instructions, skills loaded when needed, and executable helper modules. The guide covers resource folders, module design, and TypeScript or JavaScript implementation.

• Build an AI assistant for the Unity Editor
• Define a maze exploration agent's behavior
• Separate occasional knowledge into skills

Validate and fix Pinot pre-commit checks for modules affected by a change. Use it before a commit or pull request to address check failures in the relevant parts of the project.

• Checking affected modules before a commit
• Validating changes before a pull request
• Fixing pre-commit check failures

Guides the refactoring of large JavaScript files into smaller CommonJS modules within gh-aw. It covers source placement, function exports, tests, and action builds so extracted code remains testable and is included in generated actions.

• Splitting a large JavaScript file by responsibility
• Extracting utilities shared across workflows
• Adding tests for extracted modules

Design modules that expose simple interfaces while hiding substantial behavior. Use shared terms and principles to assess interface complexity, decide where behavior can be swapped, and organize code so callers and tests use the same interface.

• Simplify a module interface
• Review module structure during refactoring
• Decide where behavior should be swappable

Fix Node.js CLI tools crashing inside Docker containers when host-installed node_modules require a newer Node version than the container provides. Use when: (1) "SyntaxError: Invalid regular expression flags" with /v flag in string-width or similar packages, (2) node_modules installed on host with Node 20+ but container has Node 18, (3) `npm install` with file: protocol creates symlinks that break inside Docker, (4) pnpm workspace packages become broken symlinks in containers. Covers version detection, Node binary mounting, and npm install strategies for cross-version compatibility.

The English summary is being prepared. Showing the original description.

Use when surfacing architectural friction and proposing deepening refactors (shallow modules → deep modules) for testability and AI-navigability. Triggers on "improve architecture", "find deepening opportunities", "where is this codebase shallow", "architecture review". Emits structured candidates + precise patches; delegates ALL rendering to mk:preview. NOT for diagram/HTML rendering (see mk:preview); NOT for trade-off deliberation (see mk:party); NOT for plan critique (see mk:plan-ceo-review).

The English summary is being prepared. Showing the original description.

Guide for creating and writing Expo native modules and views using the Expo Modules API (Swift, Kotlin, TypeScript). Covers module definition DSL, native views, shared objects, config plugins, lifecycle hooks, autolinking, and type system. Use when building or modifying native modules for Expo.

The English summary is being prepared. Showing the original description.

Investigate memory growth and out-of-memory failures in OpenClaw tests. Compare memory measurements and heap snapshots, records of objects held in memory, to distinguish cleanup leaks from retained test modules and verify targeted fixes.

• Investigating Vitest out-of-memory failures
• Comparing heap snapshots from the same process
• Distinguishing cleanup leaks from retained test modules

Write, review, and modernize Perl 5.36+ applications using clear function parameters, focused error handling, and organized modules. Includes examples for classes, regular expressions, file operations, formatting, code checks, and dependency management.

• Write new Perl code and modules
• Review code against modern Perl conventions
• Update legacy code for Perl 5.36+

Write, review, and refactor Rust code using established conventions for ownership, error handling, type design, and concurrency. It guides safer implementations, avoids unnecessary copying, and organizes modules with a limited public interface.

• Review ownership and borrowing in Rust code
• Replace panic-prone error handling
• Design types and modules for a Rust application

Build or review NestJS backends with clear module boundaries, request validation, access controls, and consistent error handling. The skill guides TypeScript service structure, environment configuration, database integration, and testing for production use.

• Structuring a new NestJS API
• Adding request validation and access controls
• Reviewing error handling and environment settings

Design APIs and interfaces between modules with clear inputs, outputs, naming, and errors. The skill guides compatible extensions, input validation, and retry handling so callers can use interfaces consistently without accidentally repeating state-changing operations.

• Designing new REST endpoints
• Defining frontend and backend data contracts
• Extending an API while preserving compatibility