DOCA Programming Guide
Guides developers through building, testing, and debugging library-agnostic DOCA applications from shipped samples.
The skill defines scope boundaries, validation-before-commit, staged execution, smallest-scope operation, install-tree protection, and routing between environment and program failures. This supports a strong but incomplete trust score. Points were deducted because hardware-affecting commands, containers, file copying, and runtime actions lack a consistent user-confirmation gate, rollback procedure, and explicit external-effect confirmation; license metadata is also inconsistent across files.
SKILL.md, CAPABILITIES.md, and TASKS.md provide structured loading order, prerequisites, lifecycle guidance, error taxonomy, and diagnostic routing, with frequent stop-and-route behavior on failure. Points were deducted because key paths were not executed during this static review, many API and cross-library claims lack committed tests, and the benchmark dataset is unavailable, so the reported benchmark cannot establish full reproduction.
The audience, trigger phrases, use cases, and non-fit boundaries are unusually explicit, and the skill addresses both C/C++ and FFI consumers. Points were deducted because it depends on an installed DOCA environment, Linux or a container, and often real hardware; Chinese-language interaction is not addressed, nor is reachability of public documentation, forums, or NGC from mainland-China networks.
The documentation is layered into a loader, capability reference, and task workflows, with dependency notes, related-skill routing, examples, version rules, and stated limitations. Points were deducted for the missing author field, missing recommended Instructions/Examples sections, lack of a clear maintenance owner and update path, no formal changelog, and inconsistent licensing: Apache-2.0 in SKILL.md versus Apache 2.0 AND CC-BY-4.0 in skill-card.md.
The skill covers first-app derivation, pkg-config/Meson builds, lifecycle management, error interpretation, testing, and debugging with concrete workflows; BENCHMARK.md reports a pass and strong assisted metrics. Points were deducted because it ships no directly buildable sample or template, depends on the user's installation, version, hardware, and library-specific overlays, and the unavailable evaluation dataset plus lack of execution prevents confirming directly usable results.
Most documented workflows, commands, paths, and symbols are auditable from the supplied files, with references to public documentation, samples, and repositories; BENCHMARK.md adds limited evaluation-summary evidence. Points were deducted because this review performed no execution, the benchmark dataset and raw trial records are missing, and independent corroboration is thin.
- Running or modifying DOCA programs may affect real NICs, DPUs, representors, queues, or network traffic; obtain explicit user confirmation and define a recoverable rollback before execution.
- The skill depends on a version-compatible DOCA installation, Linux or container access, and sometimes real hardware; it provides no Chinese-language or mainland-China network reachability guarantee.
- Do not treat the BENCHMARK.md summary as independent test proof; the raw dataset is unavailable and this review executed nothing.
- Before publication, reconcile the license, author, and maintenance metadata between SKILL.md and skill-card.md.
What does this skill do, and when should you use it?
This skill is for external developers who consume DOCA libraries in applications. It covers first-application derivation, the canonical pkg-config and Meson build pattern, the common DOCA object lifecycle, cross-library error handling, observability, validation, and debugging. C and C++ are the canonical paths, while Rust, Go, and Python are addressed through FFI or bindings against the public C ABI. It assumes the DOCA environment is already prepared and routes installation, version lookup, and library-internal API questions elsewhere.
Reads the skill guidance and its CAPABILITIES.md and TASKS.md companion materials; directs users to C samples installed under /opt/mellanox/doca for minimal-diff customization; describes the pkg-config doca-{library} plus Meson build pattern and non-C FFI against the public C ABI; explains the cfg-create→init→start→use→stop→destroy lifecycle; and guides users through doca_error_get_descr() for DOCA_ERROR_* values, validation, testing, and the program-class debugging ladder.
- A developer writing a first application against any DOCA library and looking for a shipped sample to modify.
- A C or C++ developer choosing the standard pkg-config and Meson build line for APIs such as doca_rdma_*.
- A Rust, Go, or Python developer calling DOCA through the public C ABI without authoring a C wrapper.
- A developer diagnosing DOCA_ERROR_BAD_STATE or an application that starts successfully but produces no traffic.
- A developer classifying sample and application build failures, including missing optional GPU, RMAX, or MPI stacks.
What are this skill's strengths and limitations?
- Covers the library-agnostic DOCA workflow from first sample through build, lifecycle, errors, observability, testing, and debugging.
- Provides both direct C/C++ guidance and language-neutral FFI guidance for Rust, Go, Python, and similar consumers.
- Clearly separates programming questions from setup, public-knowledge routing, and library-internal API questions.
- Uses shipped, installed samples as the source for verified application code instead of supplying unverified implementations.
- The SKILL.md is a thin loader; substantive workflows are delegated to CAPABILITIES.md and TASKS.md.
- It does not include application source, bindings, standalone build manifests, or samples/reference subtrees.
- It does not handle DOCA installation, hugepages, device preparation, version lookup, or library-specific API construction.
- Validation steps require a live DOCA installation at /opt/mellanox/doca.
How do you install this skill?
Use the installation flow documented in the repository README: npx skills add nvidia/skills --skill doca-programming-guide --yes. The CLI prompts for the installation destination; cloning the repository or manually copying the folder is not required. The source does not specify a fixed local installation path.
How do you use this skill?
After installation, prompt the agent with a programming request such as “I want to write my first DOCA Flow application” or “How do I call DOCA Comch from Rust without writing C?”. The DOCA environment should already be ready and pkg-config doca-{library} should resolve. Route installation, hugepages, device visibility, version lookup, and library-specific API construction to the related skills.