Skip to main content
skill CX Codex

ros2-robotics · mindrally — Claude Code skill: features and installation

The ros2-robotics Claude Code skill guides ROS 2 package and node development. It activates for work on topics, QoS, tf2, launch files, or colcon workspace tests.

Apache-2.0 111 installs ★ 312 updated 2026-10-08

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add Mindrally/skills --skill ros2-robotics -a claude-code
Open on GitHub

What ros2-robotics does

The skill explains how to build ROS 2 packages and write nodes with rclpy or rclcpp. It covers choosing topics, services, or actions for communication, setting QoS, composing launch files, declaring parameters, and handling time and coordinate frames with tf2.

Its guidance also covers package layout, colcon builds, and tests with pytest, gtest, or launch_testing. Custom .msg, .srv, and .action interfaces are suggested only when standard message types do not fit. ROS 2 and colcon are needed to run the workspace build commands.

What it helps with

  • scaffold a ROS 2 package in Python or C++
  • choose topics, services, or actions for node communication
  • set QoS for sensor streams or command paths
  • build and test a colcon workspace

Example prompts for the agent

  • Create a Python ROS 2 package with a node that publishes velocity commands.
  • Set QoS for a lidar data topic and explain the profile choice.
  • Add a launch file and tests for communication between several nodes.

How to install ros2-robotics

1Skills CLI (Vercel)

npx skills add Mindrally/skills --skill ros2-robotics -a claude-code

2Manually: put the files in place

~/.claude/skills/ros2-robotics/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/ros2-robotics/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about ros2-robotics

How do I install ros2-robotics in Claude Code?

Run npx skills add Mindrally/skills --skill ros2-robotics -a claude-code. The skill file is at ~/.claude/skills/ros2-robotics/SKILL.md.

What does ros2-robotics do?

It provides guidance for ROS 2 packages and nodes, messaging patterns, QoS, tf2, and colcon build and test workflows.

When should I define custom ROS 2 interfaces?

The skill recommends .msg, .srv, or .action definitions when standard types such as geometry_msgs or sensor_msgs do not meet the need.

Source text

SKILL.md · Apache-2.0
---
name: ros2-robotics
description: "Best practices for ROS 2 robotics development, covering package structure, nodes, topics/services/actions, launch files, QoS, tf2 transforms, and testing. Use when creating ROS 2 packages, writing nodes in rclpy or rclcpp, defining custom messages/services/actions, writing launch files, configuring QoS profiles, working with tf2 transforms, or building and testing a colcon workspace."
metadata:
  maintainer: Mindrally
  source: https://github.com/Mindrally/skills
---

# ROS 2 Robotics Development

This skill covers building ROS 2 packages and nodes, including package structure, communication patterns (topics, services, actions), timing and frames, build/test workflows with colcon, and common pitfalls in robotics software.

## Workflow for Building a ROS 2 Package

1. **Scaffold the package** — Run `ros2 pkg create --build-type ament_python <name>` (Python) or `--build-type ament_cmake <name>` (C++) inside a colcon workspace's `src/` directory.
2. **Define interfaces** — Add custom `.msg`, `.srv`, or `.action` files under `msg/`, `srv/`, `action/` only when a standard interface (`std_msgs`, `geometry_msgs`, `sensor_msgs`, `nav_msgs`) doesn't fit.
3. **Implement nodes** — Write focused, composable nodes; declare parameters explicitly; choose topics for streams, services for quick request/response, and actions for long-running goals with feedback and cancellation.
4. **Write launch files** — Compose nodes, parameters, and remappings in a `launch/*.launch.py` file using `launch_ros.actions.Node`.
5. **Set QoS profiles intentionally** — Match publisher/subscriber QoS (reliability, durability, history depth) for sensor data vs. command/control paths.
6. **Build the workspace** — Run `colcon build --symlink-install` from the workspace root, then `source install/setup.bash`.
7. **Test** — Add unit tests (`pytest` for Python, `gtest`/`launch_testing` for C++/integration) and run `colcon test`.
8. **Run and inspect** — Use `ros2 run`, `ros2 launch`, `ros2 topic echo`, `ros2 node info`, and `ros2 doctor` to verify runtime behavior.

## Package Structure

- Keep each package focused on one robot capability or integration boundary (e.g., `lidar_driver`, `path_planner`, `arm_controller`) rather than a monolithic package.
- Use `package.xml` consistently with the build type declared in it, and either `CMakeLists.txt` (ament_cmake, C++) or `setup.py`/`setup.cfg` (ament_python).
- Organize files with `launch/` for launch scripts, `config/` for YAML parameter files, `msg/` for message definitions, `srv/` for services, `action/` for actions, and `urdf/`/`xacro/` for robot descriptions.
- Use namespaces and topic remapping instead of hardcoded topic names whenever a node might run multiple times (e.g., multi-robot setups) or be reused across projects.
- Declare all dependencies explicitly in `package.xml` (`<depend>`, `<exec_depend>`, `<build_depend>`) so the workspace builds reproducibly.

## Nodes and Interfaces

- Keep nodes small and composable — one node per logical responsibility, wired together via topics/services/actions rather than one giant node doing everything.
- Declare ROS 2 parameters explicitly with `self.declare_parameter('rate_hz', 10.0)` and read them with `self.get_parameter('rate_hz').value`; never rely on undeclared parameters.
- Prefer messages (topics) for continuous state streams, services for quick, blocking request/response operations, and actions for long-running goals that report feedback and support cancellation/preemption.
- Use standard message types (`geometry_msgs/Twist`, `sensor_msgs/LaserScan`, `nav_msgs/Odometry`) before creating custom interfaces — custom types fragment the ecosystem and lose compatibility with existing tools.
- Document topic, service, action, frame, and parameter contracts (name, type, units, frame_id, update rate) in the package README or node docstring.

### Example: A Minimal rclpy Publisher Node

```python
import rclpy
from rclpy.node import Node
from rclpy.qos import QoSProfile, ReliabilityPolicy, HistoryPolicy
from geometry_msgs.msg import Twist


class SafeVelocityPublisher(Node):
    """Publishes bounded velocity commands at a fixed rate."""

    def __init__(self) -> None:
        super().__init__("safe_velocity_publisher")

        self.declare_parameter("rate_hz", 10.0)
        self.declare_parameter("max_linear_speed", 0.5)
        rate_hz = self.get_parameter("rate_hz").value
        self._max_linear = self.get_parameter("max_linear_speed").value

        # Reliable QoS for a low-rate command topic; sensor streams would
        # typically use BEST_EFFORT with a shallow history instead.
        qos = QoSProfile(
            reliability=ReliabilityPolicy.RELIABLE,
            history=HistoryPolicy.KEEP_LAST,
            depth=10,
        )
        self._publisher = self.create_publisher(Twist, "cmd_vel", qos)
        self._timer = self.create_timer(1.0 / rate_hz, self._on_timer)
        self._target_linear = 0.0

    def _on_timer(self) -> None:
        msg = Twist()
        msg.linear.x = max(-self._max_linear, min(self._max_linear, self._target_linear))
        self._publisher.publish(msg)


def main(args: list | None = None) -> None:
    rclpy.init(args=args)
    node = SafeVelocityPublisher()
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.destroy_node()
        rclpy.shutdown()


if __name__ == "__main__":
    main()
```

## Timing and Frames

- Use ROS time (`self.get_clock().now()`, and `use_sim_time` when a simulation clock is in play) instead of wall-clock time whenever simulation or bag replay matters.
- Use `tf2` (`tf2_ros.Buffer` + `TransformListener`) for all frame transforms; never hand-roll coordinate transforms between named frames.
- Document frame names (`base_link`, `odom`, `map`, sensor frames) and their conventions (REP-103 for axis orientation, REP-105 for the `map`→`odom`→`base_link` tree).
- Avoid blocking callbacks in a node's executor thread — move long-running work to timers, a `MultiThreadedExecutor`, worker threads, or actions so the node keeps servicing other callbacks.
- Set QoS profiles intentionally: `BEST_EFFORT`/volatile for high-rate sensor data where dropped samples are acceptable, `RELIABLE`/`TRANSIENT_LOCAL` for latched-like configuration topics, and `RELIABLE`/volatile for command paths.

## Build and Test

- Use `colcon build` (typically `--symlink-install` during development) and keep inter-package dependencies explicit in `package.xml`.
- Run the linters and formatters the workspace already uses — `ament_flake8`, `ament_pep257` for Python; `ament_cpplint`, `ament_uncrustify` for C++ — via `colcon test`.
- Add `launch_testing`-based integration tests for multi-node behavior (e.g., "does node A receive what node B publishes within N seconds").
- Use simulation (Gazebo/Ignition), recorded rosbags, or fixture data for repeatable sensor scenarios instead of relying on live hardware for every test run.
- Explicitly test failure cases: missing/late transforms (`tf2.LookupException`), stale sensor data, and services or actions that are unavailable when called.

## Common Mistakes

- Hardcoding absolute filesystem paths instead of resolving them via `ament_index_python.packages.get_package_share_directory`.
- Publishing velocity or actuator commands without validating frame_id, units, and timestamp freshness — a stale or wrong-frame command can move a robot unsafely.
- Creating a custom message/service/action type when an existing standard interface already models the data.
- Ignoring QoS incompatibility warnings between a publisher and subscriber (e.g., a `BEST_EFFORT` publisher with a `RELIABLE` subscriber) — the connection silently never delivers data.
- Doing significant work inside a subscription callback without offloading it, starving the executor and delaying other callbacks (including safety-critical ones).
- Forgetting `use_sim_time:=true` when running against a simulator, causing timestamps and `tf2` lookups to disagree with the simulated clock.

© Mindrally · Apache-2.0 · Mindrally/skills

Similar skills

All skills for Programming languages →

ros2-robotics by other authors comes first.

ros2-robotics omer-metin The ros2-robotics skill guides ROS2 application development and helps investigate common pitfalls. Use it when an agent needs to build or review nodes, launches, or component interactions. CX Codex +1 293installs ros-ros2 PatrickJS ros-ros2 enforces conventions for ROS and ROS2 workspaces, covering composable nodes, package layout, and launch testing. CX Codex +1 ★ 41,178repo stars robotics-subject-expert aiskillstore robotics-subject-expert adds deep background in physical AI and robotics middleware. Helps write robot control nodes and troubleshoot simulated environments. CX Codex +1 1installs robotics-engineer rohitg00 robotics-engineer — a subagent that builds autonomous robots with ROS2: sensor drivers, perception, SLAM localization, motion planning, and real-time control loops. CX Codex ★ 2,858repo stars SlashML (/ ml) Embodied Robotics Trajectory Memory slashml-ai SlashML (/ ml) Embodied Robotics Trajectory Memory is an MCP server for Claude Code that exposes 6-DoF entity tracking, movement histories, and equipment affordances to physical reasoning agents. CX Codex +1 ★ 1repo stars ros sanjeed5 Enforces ROS 2 best practices for C++ and Python inside Cursor. It guides package layout, ament tooling, node composition, and multithreaded executors. CX Codex +1 ★ 3,589repo stars srv-d7aoqmh5pdvs7391dcqg ciprianpater srv-d7aoqmh5pdvs7391dcqg — a remote MCP server that hands your agent the NWO Robotics API: natural-language robot commands, vision-to-action inference, task planning and a ROS2 bridge. CX Codex +1 4,056installs

From the same set247

The whole set →
clean-code The clean-code Claude Code skill guides code writing and review, with an emphasis on clarity and restrained abstractions. It applies to new code, refactors, and quality checks. CX Codex +1 182installs embedded-stm32 embedded-stm32 — a skill for Claude Code and Codex providing engineering rules for embedded C/C++ firmware on STM32 using the HAL. Triggers when writing peripheral drivers, handling interrupts, or setting up DMA. CX Codex +1 132installs network-troubleshooting The network-troubleshooting Claude Code skill diagnoses network failures in commands and services. It activates for DNS, TLS, proxy, connection, and package registry timeout errors. CX Codex +1 131installs readme-best-practices The readme-best-practices Claude Code skill guides README writing and review. It activates for a new project README, a rewrite, or a repository documentation check. CX Codex +1 121installs security-devsecops security-devsecops — a skill for Claude Code and Codex guides DevSecOps and AppSec practices across projects. Activates when handling credentials, user input, auth, or configuring CI/CD pipelines. CX Codex +1 117installs blender-python-addon blender-python-addon — a skill for Claude Code that establishes best practices for Blender add-on development via the bpy API. Triggers when writing operators, UI panels, or bmesh routines. CX Codex +1 111installs automl-hyperparameter-optimization The automl-hyperparameter-optimization Claude Code skill guides AutoML setup and hyperparameter searches. It covers validation design, distributed trials, and checks for judging whether a leaderboard result is production-ready. CX Codex +1 110installs gamemaker-gml gamemaker-gml — a skill for Claude Code that guides GameMaker Language (GML) development. Triggers when writing object event logic, scripts, room transitions, and state machines in GameMaker Studio. CX Codex +1 109installs

Project sponsors

Companies that keep this analytics open