Refactor libcudacxx-style skill by moving CCCL wide style guidelines to a specific file

.agent/skills/cccl-style/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: cccl-style
+description: Use when editing or reviewing CCCL code for style conventions; read common CCCL guidance and the path-specific references named by this skill.
+---
+
+# CCCL Style
+
+## Workflow
+
+1. Read `references/common.md` for guidance that applies across CCCL.
+2. For `libcudacxx/include/**/*`, also read `references/libcudacxx.md`.
+3. For `cudax/include/**/*`, also read `references/libcudacxx.md`.
+4. If no path-specific reference exists, follow nearby code and repository docs. Do not import rules from another subproject.
+5. Apply each reference only to its stated scope. Rules for one CCCL subproject do not automatically apply to another.

.agent/skills/cccl-style/references/common.md

@@ -0,0 +1,70 @@
+# Common CCCL Style Guidance
+
+Apply this guidance across CCCL unless a path-specific style reference says otherwise.
+
+## Naming Style
+
+- Macros: macro style, e.g. `MY_MACRO`.
+- Template parameters: PascalCase, e.g. `MyParameter`.
+- All other symbols: snake style, e.g. `my_variable`. The one exception is the CUB public API, which uses PascalCase.
+
+## Variables
+
+- All variables that are not modified must use `const`. This includes variables initialized by casts (`static_cast`, `reinterpret_cast`, `bit_cast`), function return values, and loop-invariant computations.
+- All variables that can be evaluated at compile-time must use `constexpr`.
+- All `constexpr` variables at namespace/global scope must use `inline`, including variable templates.
+- Consider using plural names for array, span, list, e.g. `int values[4]` instead of `int value[4]`.
+- Use uniform initialization for class constructors (not enforced to builtin types) and compile-time conversions, e.g. `constexpr auto x = int{sizeof(float)};`.
+
+## Headers
+
+- Files must include all headers related to the symbols that they are using.
+- Relying on transitive header inclusion is not allowed.
+- Unneeded headers must be removed.
+- All headers must have the correct license. This also applies to source files.
+- All header inclusions must use the syntax `<header>`.
+- Use forward declaration, namely `__fwd/header.h` or direct type declaration, when possible instead of including the implementation header.
+- Headers should be the most precise available, e.g. `#include <cuda/std/__type_traits/is_array.h>`.
+- Do not include headers in `cuda/std/__cccl/` directly; they are provided by `__config` or the prologue/epilogue mechanism.
+
+## Functions
+
+- Functions must be marked `_CCCL_HOST_API`, `_CCCL_DEVICE_API`, `_CCCL_HOST_DEVICE_API`, `_CCCL_TILE_API`, or `_CCCL_API`.
+- Non-template, non-`constexpr` functions must use `inline`.
+- Most functions with a non-void return type should use `[[nodiscard]]`; functions with known side effects may be exceptions.
+- Functions that do not throw exceptions must use `noexcept`.
+- Use `_CCCL_CONSTEVAL` when the function can only be evaluated at compile time.
+- Use C++20 concept macros instead of SFINAE, e.g. `_CCCL_TEMPLATE(...)` and `_CCCL_REQUIRES(...)`.
+
+## Function Calls And Types
+
+- In headers, apply global qualification where the subproject requires it:
+  - libcudacxx and cudax require free function calls to be fully qualified from the global namespace, e.g. `::cuda::ceil_div(...)`.
+  - CUB applies this rule only to calls to symbols under the `::cuda` namespace hierarchy; otherwise follow existing CUB qualification style.
+  - Thrust uses leading `::` for many symbols under the `::cuda` namespace hierarchy, but relies on ADL in many places and the blanket free-function qualification rule does not apply to those calls.
+- For covered calls, this includes calls to functions defined in the same namespace, e.g. inside `cuda::`, call `::cuda::ceil_div(...)`, not `ceil_div(...)`. This does not apply to (static) member functions of classes. The only exceptions for covered calls are functions that are supposed to be found through argument-dependent lookup (ADL), such as `::cuda::std::swap` and `::cuda::std::get`. Those functions can be called unqualified with a preceding `using ::cuda::std::get;`.
+- This global-qualification rule does not apply to source files such as tests and benchmarks.
+- In headers, apply type-name qualification where the subproject requires it:
+  - libcudacxx and cudax require type names to be fully qualified except when they are already declared in the current namespace or an enclosing one. Outside those namespaces, fully qualify `cuda::std` and standard integer type aliases such as `::cuda::std::size_t`.
+  - CUB applies this rule only to type names under the `::cuda` namespace hierarchy. Do not apply the libcudacxx/cudax blanket type-qualification rule to CUB namespaces or `detail` namespaces.
+  - Thrust does not apply the libcudacxx/cudax blanket type-qualification rule. It uses leading `::` for many `::cuda` and `::cuda::std` type names, but also uses Thrust namespace patterns; follow neighboring Thrust code.
+- A local `using` declaration, e.g. `using ::cuda::std::size_t;`, is acceptable to avoid repetition within a function body.
+- Static member functions of a class template inherit the class's namespace.
+
+## Comments
+
+- Commented code without a description is not allowed.
+
+## General Guidelines
+
+- The code must reuse `cuda/` or `cuda/std` functionalities as much as possible, including macros.
+- Try to use modern C++ as much as possible. The repository supports C++17 but many more recent functionalities have been backported with functions and macros.
+
+## Prevent Compiler Errors And Improve Compatibility
+
+- Remove unused code, variables, functions, types, template parameters, headers, etc.
+- Variables that are unsigned, or that can become unsigned after template instantiation, must not check for negative values directly. Use `cuda::std::is_unsigned_v<T> ? false : (var < 0)` instead.
+
+## Compiler Compatibility
+
+- Protect host-only code with `#if !_CCCL_COMPILER(NVRTC)`.

.agent/skills/cccl-style/references/libcudacxx.md

@@ -0,0 +1,54 @@
+# libcudacxx Style Guidance
+
+Use this reference for `libcudacxx/include/**/*` and `cudax/include/**/*`.
+
+## Naming Style
+
+All non-public symbols must be C++ reserved identifiers:
+
+- `_` for macros and template parameters, e.g. `_MY_MACRO`, `_MyParameter`.
+- `__` for all other symbols, e.g. `__my_variable`.
+- Avoid single-letter template parameter names. Wrong: `_T`; correct: `_Tp`.
+
+## Class / Struct
+
+- Data member names have postfix `_`, e.g. `class __myclass { int __data_; };`.
+- Constructor parameter names should match class/struct data member names without the postfix `_`, e.g. `class __myclass { __myclass(int __data) : __data_(__data) {} };`.
+
+## Functions
+
+- Use `constexpr` for functions that do not depend on run-time features, such as pointers.
+- If the return type is not explicit (`auto`), then a trailing return type is strongly preferred.
+
+## Headers
+
+- Use the correct license:
+  - `libcudacxx/include/cuda/std` files ported from LLVM libc++ use the LLVM license.
+  - `libcudacxx/include/cuda/` files use Apache License v2.0 with LLVM Exceptions.
+- Headers use include guards with names derived from the uppercase full path and closing `#endif` comments repeating the guard name.
+- Right after the include guard, include:
+
+```cpp
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+```
+
+- The last included header before code must be `<cuda/std/__cccl/prologue.h>`, and `<cuda/std/__cccl/epilogue.h>` must appear at the end of the file.
+
+## Comments
+
+- Use Doxygen-style `//! @brief` comments.
+- Documented functions must include `//! @brief`, `//! @param[in/out/in,out]` for every parameter, and `//! @return` for non-void functions.
+- The `@brief/@param/@return` description must accurately reflect the current functionality of the function.
+
+## Compiler Compatibility
+
+- Do not use lambda expressions in device-only or host-device code.
+- Do not rely on deduction guides for initialization; use explicit template arguments instead.

.agent/skills/cccl-test/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: cccl-test
+description: Use when writing, updating, reviewing, or validating CCCL tests; read common CCCL test guidance and the path-specific references named by this skill.
+---
+
+# CCCL Test
+
+## Workflow
+
+1. Read `references/common.md` for guidance that applies across CCCL tests.
+2. For `libcudacxx/test/**/*`, also read `references/libcudacxx.md`.
+3. If no path-specific reference exists, follow nearby tests and repository docs. Do not import test rules from another subproject.
+4. Apply each reference only to its stated scope. Rules for one CCCL subproject do not automatically apply to another.

.agent/skills/cccl-test/references/common.md

@@ -0,0 +1,31 @@
+# Common CCCL Test Guidance
+
+Apply this guidance across CCCL tests unless a path-specific test reference says otherwise.
+
+## Local Consistency
+
+- Read nearby tests first and mirror their directory layout, file names, helper types, includes, assertion style, and local gating or skip mechanisms.
+
+## Coverage
+
+- Cover relevant edge cases.
+- Cover relevant input and output types.
+- Cover error behavior when applicable.
+- Cover runtime and compile-time behavior when applicable.
+- Cover device and host behavior when applicable.
+
+## Test Structure
+
+- All tests must have the correct license banner.
+- Use the local test harness assertions and helpers.
+- Use compile-time checks for compile-time guarantees and constexpr coverage when relevant.
+- Negative tests should check the intended diagnostic or failure mode when the local harness supports it.
+
+## Portability
+
+- Prefer project test macros and helpers for compiler, dialect, exception, host/device, and platform probes instead of spelling ad hoc checks directly.
+- If a test is unsupported, expected to fail, disabled, or skipped on a platform, motivate it with a comment.
+
+## Validation
+
+- Use targeted test runs for the project and files being changed.

.agent/skills/libcudacxx-test/SKILL.md → .agent/skills/cccl-test/references/libcudacxx.md

@@ -1,8 +1,3 @@
----
-name: libcudacxx-test
-description: Write, update, and validate libcudacxx tests under libcudacxx/test.
----
-
 # libcudacxx Test
 
 ## Organization

.claude/skills/cccl-style/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: cccl-style
+description: Use when editing or reviewing CCCL code for style conventions; read common CCCL guidance and the path-specific references named by this skill.
+---
+
+The skill content is in .agent/skills/cccl-style/SKILL.md

.claude/skills/cccl-test/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: cccl-test
+description: Use when writing, updating, reviewing, or validating CCCL tests; read common CCCL test guidance and the path-specific references named by this skill.
+---
+
+The skill content is in .agent/skills/cccl-test/SKILL.md

.coderabbit.yaml

@@ -75,15 +75,15 @@ reviews:
       instructions: |
         Focus on correctness, ABI/API stability, standard-library conformance, host/device availability,
         NVRTC compatibility, supported C++ standards, tests, and portability across supported CUDA toolchains.
+        For tests, use .agent/skills/cccl-test/SKILL.md as test context.
         Avoid style comments unless the requirement is explicitly mentioned in
-        .agent/skills/libcudacxx-style/SKILL.md.
+        .agent/skills/cccl-style/SKILL.md.
 
     - path: "cudax/**/*"
       instructions: |
         Focus on correctness, lifetime/resource ownership, stream ordering, host/device annotations, experimental
-        API clarity, tests, and compatibility with the supported CUDA toolchains. Use
-        .agent/skills/libcudacxx-style/SKILL.md as style context for cudax/include. Avoid style comments unless
-        the requirement is explicitly mentioned in that skill file.
+        API clarity, tests, and compatibility with the supported CUDA toolchains. Avoid style comments unless
+        the requirement is explicitly mentioned in .agent/skills/cccl-style/SKILL.md.
 
     - path: "cub/**/*"
       instructions: |
@@ -135,7 +135,12 @@ knowledge_base:
     filePatterns:
       - "AGENTS.md"
       - "CONTRIBUTING.md"
-      - ".agent/skills/libcudacxx-style/SKILL.md"
+      - ".agent/skills/cccl-style/SKILL.md"
+      - ".agent/skills/cccl-style/references/common.md"
+      - ".agent/skills/cccl-style/references/libcudacxx.md"
+      - ".agent/skills/cccl-test/SKILL.md"
+      - ".agent/skills/cccl-test/references/common.md"
+      - ".agent/skills/cccl-test/references/libcudacxx.md"
       - "docs/cccl/config_macros.rst"
       - "docs/cccl/development/macro.rst"
       - "docs/cccl/development/visibility.rst"

AGENTS.md

@@ -398,6 +398,14 @@ pre-commit run --all-files
 pre-commit run --files <file1> <file2>
 ```
 
+### Style Guidance
+
+When editing or reviewing CCCL code for style, read `.agent/skills/cccl-style/SKILL.md`. It routes to the common CCCL style reference and any path-specific style reference that applies to the files being changed.
+
+### Test Guidance
+
+When writing, updating, reviewing, or validating CCCL tests, read `.agent/skills/cccl-test/SKILL.md`. It routes to the common CCCL test reference and any path-specific test reference that applies to the files being changed.
+
 ---
 
 ## General Guidelines