Development skills

Clarify a development request through structured questions and choose a practical next step: update an existing specification, create new ones, or implement directly. For new specifications, record scope, approach, and dependencies in planning files.

• Clarify a development idea before defining requirements
• Choose between updating a specification and implementing directly
• Split a large request into features with explicit dependencies

Document a project's purpose, technical choices, and organization patterns as persistent reference files for agents. Compare existing guidance with the codebase, identify mismatches, and propose additions while preserving user-written content.

• Create project reference documents from an existing codebase
• Check whether project guidance matches current code
• Document technical and organizational conventions

Create project guidance documents for topics such as API conventions, testing, security, and deployment. The skill examines existing code patterns and relevant templates, then writes focused documents that agents can use as ongoing project memory.

• Documenting project-specific API conventions
• Recording test organization and mocking practices
• Summarizing authentication and security patterns

Create requirements, designs, and implementation tasks for multiple roadmap features in dependency order. Use parallel workers when available and permitted, or process sequentially, then check consistency across specifications.

• Prepare specifications for multiple roadmap features
• Sequence specification work around feature dependencies
• Check shared data models and interfaces across specifications

Investigate blocked implementation work and recurring failures using error output, code changes, configuration, and dependency evidence. Get a root cause report with a focused repair plan, verification steps, and a recommendation to retry, block, or seek human input.

• Investigating an implementation blocker
• Finding why repeated fixes keep failing
• Checking runtime and dependency conflicts

Create topic-specific project guidance that agents can use as project memory. Examine existing code and available templates to document conventions for areas such as APIs, testing, authentication, or deployment, with concrete examples.

• Documenting project-specific API conventions
• Recording test organization and mocking practices
• Sharing authentication and permission patterns

Turn a feature description and project guidance into a requirements document with testable acceptance criteria. Review coverage, ambiguity, and scope before saving, using EARS, a structured format for describing system behavior and conditions.

• Turn a feature idea into a requirements document
• Define acceptance criteria that can be tested
• Clarify what a feature includes and excludes

Create and maintain project reference documents from the codebase, covering product purpose, technology choices, and organization patterns. Detect differences between documentation and code while preserving user additions during updates.

• Creating initial project reference documents
• Updating documentation after code changes
• Checking code against documented conventions

Turn requirements into a technical design with clear component responsibilities, interfaces, file changes, and testing plans. Research existing code and external dependencies, record design decisions, and review the draft before saving the design document.

• Create a technical design from requirements
• Plan how a new feature fits into an existing system
• Define file responsibilities and component interfaces

Build an adapter that exposes API, database, or object storage data as files in Mirage. Covers Python or TypeScript implementation, mount configuration, and tests for reading, access restrictions, and supported changes.

• Connect an API or database to Mirage
• Implement file operations for a custom data source
• Package a reusable Mirage adapter

Build a custom CDF Airflow DAG, a workflow defining task order, from existing processing stages when standard workflows do not fit. Generate configuration and supporting code, or compare model, container, and prompt choices against a specification.

• Build a workflow containing only detection and captioning
• Add, remove, or reorder existing CDF stages
• Generate workflow code and execution configuration

Develop reusable external Holoscan Modules with the Holoscan CLI, from scaffolding and testing to Python bindings and package creation. Verify that applications can use installed packages in a clean environment, with checks for each requested format.

• Creating a reusable Holoscan operator module
• Adding and testing Python bindings
• Using an installed module from another application

Diagnose a specific failing, hanging, or incorrect Holoscan CLI command. The skill guides reproducible investigation, isolates the responsible layer, applies a minimal fix, and checks the same command and focused tests to verify the result.

• Diagnose a reproducible holoscan build failure
• Investigate a command that hangs
• Trace unexpected application output

Diagnose NVSHMEM launch failures, crashes, hangs, and communication problems using exact commands and complete logs. Separates observations from likely causes, checks version-specific documentation, and prepares a Markdown bug report for the user to submit.

• Investigate launch failures, crashes, and hangs
• Distinguish NVSHMEM defects from application or environment issues
• Check whether a known issue applies to the installed version

Choose the appropriate NVSHMEM performance workflow for collecting benchmark evidence, selecting communication between nodes, assigning network adapters to processing elements, or assessing TMA transfers between peer GPUs. This skill routes requests to specialists that perform the technical work.

• Choose a workflow for baseline performance measurement
• Find the specialist for inter-node transport selection
• Route network adapter assignment questions

Assess whether NVSHMEM suits communication between GPUs, then learn its core concepts and plan a first C/C++ or Python program. Guidance covers program structure, compilation, launch commands, and appropriate next steps.

• Assessing whether NVSHMEM fits a multi-GPU application
• Learning GPU communication and shared-memory concepts
• Designing, compiling, and launching a first C/C++ program

Review or prepare an NVSHMEM CUDA kernel for TMA, a GPU data-transfer mechanism. Assess hardware suitability, add shared-memory registration and launch settings, and consider direct transfers from shared memory when an intermediate copy is proven redundant.

• Assessing TMA suitability for an NVSHMEM kernel
• Preparing a selected kernel and its launch settings for TMA
• Reviewing whether an intermediate memory copy can be removed

Find official NVSHMEM and NVSHMEM4Py documentation for installation, APIs, runtime settings, and troubleshooting. Receive concise explanations with direct source links, relevant version details, and explicit uncertainty when the requested documentation or compatibility evidence cannot be verified.

• Finding installation instructions for a specific release
• Understanding APIs and runtime settings
• Checking NVSHMEM4Py compatibility

Connect Omniverse scenes to the Newton physics engine through ovnewton. The skill guides scene import, simulation stepping, synchronization of scene edits, and publication of simulation results for rendering, with setup guidance for supported solvers.

• Importing a populated ovstage into Newton
• Applying scene edits to a running simulation
• Publishing physics results for Omniverse rendering

Guide the creation and maintenance of an agent’s ethos.md, a record of its purpose, boundaries, and success criteria. Locate existing files and route requests to intent exploration or editing, carrying forward information already confirmed.

• Defining a new agent’s purpose and boundaries
• Locating an existing ethos.md and identifying gaps
• Updating specific rules or revisiting the agent’s intent

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

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

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

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