Development skills

Build apps for viewing USD, a 3D scene format, using guidance matched to browser streaming or local execution. The skill selects implementation references for rendering, camera controls, selection, interface layout, and validation.

• Build a browser viewer for USD scenes
• Create a local workstation viewer
• Add camera controls and object selection

Diagnose slow loading, high memory use, and low frame rates in USD 3D scenes. It coordinates measurement, scene validation, and optimization, then produces reports comparing available before-and-after evidence and an optimized scene when changes are performed.

• Investigate slow loading in USD scenes
• Diagnose low frame rates and high memory use
• Review repeated structures in large CAD scenes

Generates a standalone YOLO26 detection and tracking service scaffold for VSS Search and Alerts. Includes DeepStream configuration, Docker files, and tests, with Kafka integration guidance and clear limits on validation before model assets are available.

• Creating a standalone YOLO26 service for VSS
• Generating a scaffold before model assets are ready
• Checking Kafka integration with VSS workflows

Choose and install the right NeMo Relay option for a command-line tool, a Python, Node.js, or Rust application, or a supported framework integration. Check basic availability and report the installation result before moving to runtime setup.

• Trying NeMo Relay through a temporary CLI run
• Adding a Relay package to an existing application
• Installing Relay for a supported framework

Migrate existing NeMo Flow code and documentation to NeMo Relay by updating explicit names, imports, paths, and configuration references. A bundled helper previews changes, while language-specific checks cover dependencies, generated files, and remaining legacy identifiers.

• Migrate imports and dependencies across languages
• Preview identifier and path changes
• Update CLI examples and documentation

Tune adaptive behavior in an instrumented NeMo Relay application using runtime data. Configure tool parallelism, prompt caching, and state storage, then compare changes against a baseline to check latency, correctness, and failure rates.

• Evaluate adaptive behavior using runtime telemetry
• Tune tool parallelism against a baseline
• Evaluate prompt-cache planning

Package reusable NeMo Relay behavior as an embedded component or an independently distributed plugin. Design shared configuration, validate it before activation, and register behavior with rollback handling so failed setup does not leave partial changes active.

• Share runtime behavior across Relay applications
• Validate plugin configuration before activation
• Package a native Rust plugin or a local gRPC worker

Troubleshoot applications where NeMo Relay is installed but runtime behavior is missing or incorrect. It helps isolate loading failures, inactive execution contexts, missing events, and plugin or export configuration issues before changing application settings.

• Diagnose native extension or shared-library loading failures
• Investigate missing lifecycle events
• Separate execution contexts across concurrent requests

Wrap existing tool functions and language model calls with NeMo Relay to record execution events, process requests through middleware, and apply guardrails. Guides integration while preserving the original functions’ arguments, results, and business logic.

• Adding execution events to existing tool calls
• Wrapping model provider calls with NeMo Relay
• Integrating request processing and execution guardrails

Build, migrate, and review adapters that connect external agent runtimes to NVIDIA NeMo Fabric. It guides configuration translation, startup and shutdown, discovery metadata, and validation against the public contract, the rules defining how adapters interact with Fabric.

• Building an adapter for an external agent runtime
• Migrating an adapter to the public contract
• Reviewing configuration mapping and runtime isolation

Integrate NVIDIA NeMo Fabric into an application or evaluation system through its Python SDK. Map application settings into typed configuration, choose an execution lifecycle, validate prerequisites, and handle standardized results, artifacts, and telemetry.

• Integrate agent execution into an application
• Build configurations for different evaluation conditions
• Manage single calls and conversations with retained state

Keep NeMo Relay event histories separate for concurrent requests, tasks, and agents. The skill guides independent scope stacks, which track nested operations, and preserves parent-child relationships when execution crosses asynchronous tasks, threads, or workers.

• Separate event histories for concurrent requests
• Preserve parent-child links across async tasks and threads
• Prevent request-specific middleware from leaking

Guides typed data integration in NeMo Relay by choosing codecs, converters between application values and JSON. Helps preserve middleware edits and caller-visible responses while distinguishing application data conversion from provider-specific LLM request and response handling.

• Connecting existing domain models to NeMo Relay
• Choosing codecs for Python or Node.js
• Making provider payloads inspectable by middleware

Understand the Isaac for Healthcare workflow architecture and discover supported workflows and run modes from the current checkout. Get directed to the appropriate stage skill for setup, data processing, training, or validation.

• Find where to start with i4h workflows
• Understand the roles of Scene, Task, and Engine
• Find the right skill for data processing or training

Split a pull request into smaller drafts based on CODEOWNERS, the file that assigns review ownership. Propose groups of changes that need fewer reviewer teams, keep tests with their code, and create the drafts after approval.

• Split a large pull request into smaller reviews
• Reduce reviewer groups required for each pull request
• Plan dependencies between split pull requests

Run a warehouse robot demo controlled by Mission Control and displayed in a local Isaac Sim window. Check startup readiness, replay a fixed route, and verify mission completion, robot movement, and system health.

• Demonstrating Mission Control with a simulated warehouse robot
• Replaying a fixed robot route
• Investigating startup or mission failures

Check Jetson video encoding and decoding capabilities by comparing live API reports, verified NVIDIA samples, and official documentation. Distinguish documented product support from observed behavior for specific formats, bit depths, dimensions, and tested operations.

• Checking support for video formats and bit depths
• Comparing API reports with official product documentation
• Verifying encoding and decoding under specific conditions

Configure USB ports on Jetson Thor or Orin custom carrier boards. Check wiring and paired USB2/USB3 ports, then create a kernel device-tree overlay, a hardware configuration layer, with consistent lane, port, and host controller settings.

• Enable or disable USB ports on a custom carrier board
• Configure USB roles and power-control wiring
• Investigate USB devices missing after flashing

Register existing Jetson and IGX reference documents in the active platform profile so downstream skills can find them by name. Suggest files based on filenames, confirm selections, and update references for guides, schematics, and pinmux spreadsheets.

• Register reference documents after setting up a target profile
• Update or remove document references in an existing profile
• Fix missing document references reported by downstream skills

Prepare a workspace for customizing Jetson board support software. Sets up Git tracking for changes, arranges kernel and related source files, and locates or extracts the NVIDIA Crosstool-NG compiler tools needed for later builds.

• Preparing a workspace after BSP image initialization
• Arranging source files from local archives for offline setup
• Using a customer Git fork as the BSP source

Investigate a failed GitHub Actions job and turn its logs into a structured bug issue for Megatron-LM. Collects failing tests, errors, and related pull requests, checks for duplicates, and identifies an assignee from test history.

• Create a bug issue from a failed GitHub Actions job
• Summarize failing tests and relevant log excerpts
• Check for an existing issue covering the same test

Rebuild Jetson hardware configuration files, kernel images, and modules after source changes. Selects a build mode from the changed repositories or an explicit request, then records the outputs in a manifest for a separate deployment step.

• Rebuilding hardware configuration after a change
• Rebuilding the kernel and modules
• Resuming an interrupted build

Check and format Python code in Megatron-LM using autoformat.sh and its linting tools. Apply project rules for imports, type hints, documentation, naming, and line length when preparing changes for a pull request.

• Check code style before opening a pull request
• Run automatic formatting fixes
• Sort imports after editing Python files

Edit an existing Isaac for Healthcare simulation scene, including object placement, cameras, and task success rules. Review changes in a running simulator, then save the confirmed scene to its source files when explicitly requested.

• Adjusting object and robot placement in an existing scene
• Adding a camera and checking its view
• Updating task instructions and success rules