iot-expert — Claude Code skill: what it does, how to install
iot-expert is a Claude Code skill for IoT architecture, MQTT, embedded firmware, and edge computing. It generates architecture guides and microcontroller code.
Apache-2.0 239 installs ★ 45 updated 2026-10-12
npx skills add personamanagmentlayer/pcl --skill iot-expert -a claude-codeWhat iot-expert does
This skill guides coding assistants through Internet of Things architectures, spanning physical sensors, edge compute nodes, network connectivity, and cloud platforms. It structures decisions around popular telemetry protocols such as MQTT, CoAP, HTTP/REST, WebSockets, LoRaWAN, and Zigbee.
The reference material contains runnable patterns for both embedded targets and host services. It provides Arduino and ESP32 C code for reading DHT22 sensors over Wi-Fi, alongside a Python MQTT client built on paho-mqtt that handles automated reconnections and payload parsing. It also covers edge-layer buffering routines.
Running the suggested implementations requires hardware-specific toolchains or host packages like paho-mqtt and PubSubClient.
What it helps with
- write ESP32 firmware that publishes telemetry to an MQTT broker
- structure end-to-end IoT platform layers from sensors to cloud
- implement a reconnecting Python MQTT subscriber for sensor topics
- buffer sensor telemetry locally on edge compute nodes
Example prompts for the agent
- Generate an ESP32 firmware sketch that reads DHT22 and streams values via MQTT
- Design a multi-layer IoT architecture for remote sensor fleet monitoring
- Write a Python wrapper around paho-mqtt with topic callbacks
How to install iot-expert
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill iot-expert -a claude-code2Manually: put the files in place
~/.claude/skills/iot-expert/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/iot-expert/
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill iot-expert -a codex2Manually: put the files in place
.agents/skills/iot-expert/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill iot-expert -a cursor2Manually: put the files in place
.cursor/skills/iot-expert/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install personamanagmentlayer/pcl stdlib/domains/iot-expert2Manually: put the files in place
.github/skills/iot-expert/SKILL.md1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill iot-expert -a gemini-cli2Platform CLI
gemini skills install https://github.com/personamanagmentlayer/pcl --path stdlib/domains/iot-expertManually: put the files in place
.devin/skills/iot-expert/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill iot-expert -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about iot-expert
How to install iot-expert in Claude Code?
Run npx skills add personamanagmentlayer/pcl --skill iot-expert -a claude-code in your terminal. The configuration is stored at ~/.claude/skills/iot-expert/SKILL.md.
What does iot-expert do?
It equips the agent with knowledge about IoT hardware layers, protocol trade-offs, embedded C patterns, and edge telemetry processing.
Which embedded platforms and languages are covered?
It includes C patterns for microcontrollers like Arduino and ESP32, as well as Python code for edge gateways and MQTT consumers.
Source text
SKILL.md · Apache-2.0
---
name: iot-expert
version: 1.1.0
description: >-
Expert-level IoT systems, embedded devices, edge computing, and IoT protocols. Use when
the user mentions embedded, edge computing, MQTT, sensors, or firmware, or when the task
involves IoT Architecture, IoT Protocols, Embedded Systems, or Device Design.
category: domains
tags: [iot, embedded, edge-computing, mqtt, sensors, firmware]
allowed-tools:
- Read
- Write
- Edit
---
# IoT Expert
Expert guidance for IoT systems, embedded devices, edge computing, sensor networks, and IoT protocols.
## Core Concepts
### IoT Architecture
- Device layer (sensors, actuators)
- Edge computing layer
- Network layer (connectivity)
- Cloud/platform layer
- Application layer
- Security across all layers
### IoT Protocols
- MQTT (Message Queuing Telemetry Transport)
- CoAP (Constrained Application Protocol)
- HTTP/REST for IoT
- WebSocket for real-time
- LoRaWAN for long-range
- Zigbee, Z-Wave for home automation
### Embedded Systems
- Microcontroller programming
- Real-time operating systems (RTOS)
- Power management
- Firmware updates (OTA)
- Hardware interfaces (I2C, SPI, UART)
- Memory constraints
## MQTT Implementation
```python
import paho.mqtt.client as mqtt
import json
from datetime import datetime
from typing import Callable, Dict
class MQTTClient:
def __init__(self, broker: str, port: int = 1883, client_id: str = "iot_device"):
self.broker = broker
self.port = port
self.client = mqtt.Client(client_id)
self.subscriptions: Dict[str, Callable] = {}
self.client.on_connect = self._on_connect
self.client.on_message = self._on_message
self.client.on_disconnect = self._on_disconnect
def _on_connect(self, client, userdata, flags, rc):
if rc == 0:
print(f"Connected to MQTT broker at {self.broker}:{self.port}")
# Resubscribe to topics on reconnect
for topic in self.subscriptions.keys():
self.client.subscribe(topic)
else:
print(f"Connection failed with code {rc}")
def _on_message(self, client, userdata, msg):
topic = msg.topic
payload = msg.payload.decode()
if topic in self.subscriptions:
try:
data = json.loads(payload)
self.subscriptions[topic](data)
except json.JSONDecodeError:
self.subscriptions[topic](payload)
def _on_disconnect(self, client, userdata, rc):
if rc != 0:
print(f"Unexpected disconnect. Reconnecting...")
def connect(self, username: str = None, password: str = None):
if username and password:
self.client.username_pw_set(username, password)
self.client.connect(self.broker, self.port, 60)
self.client.loop_start()
def publish(self, topic: str, payload: Dict, qos: int = 1, retain: bool = False):
"""Publish message to MQTT topic"""
message = json.dumps(payload)
result = self.client.publish(topic, message, qos=qos, retain=retain)
return result.rc == mqtt.MQTT_ERR_SUCCESS
def subscribe(self, topic: str, callback: Callable, qos: int = 1):
"""Subscribe to MQTT topic with callback"""
self.subscriptions[topic] = callback
self.client.subscribe(topic, qos=qos)
def disconnect(self):
self.client.loop_stop()
self.client.disconnect()
# IoT Device Example
class TemperatureSensor:
def __init__(self, device_id: str, mqtt_client: MQTTClient):
self.device_id = device_id
self.mqtt = mqtt_client
self.topic = f"sensors/temperature/{device_id}"
def read_temperature(self) -> float:
# In real device, read from actual sensor
import random
return round(random.uniform(20.0, 30.0), 2)
def publish_reading(self):
temperature = self.read_temperature()
payload = {
"device_id": self.device_id,
"temperature": temperature,
"unit": "celsius",
"timestamp": datetime.utcnow().isoformat()
}
self.mqtt.publish(self.topic, payload)
return payload
```
## Embedded C for Microcontroller
```c
// Arduino/ESP32 Example
#include <WiFi.h>
#include <PubSubClient.h>
#include "DHT.h"
#define DHTPIN 4
#define DHTTYPE DHT22
// Keep credentials out of the sketch: put them in a secrets.h that is
// listed in .gitignore, so they are never committed with the firmware.
#include "secrets.h" // defines WIFI_SSID and WIFI_PASSWORD
const char* ssid = WIFI_SSID;
const char* password = WIFI_PASSWORD;
const char* mqtt_server = "broker.example.com";
WiFiClient espClient;
PubSubClient client(espClient);
DHT dht(DHTPIN, DHTTYPE);
void setup_wifi() {
delay(10);
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
}
void callback(char* topic, byte* payload, unsigned int length) {
Serial.print("Message arrived [");
Serial.print(topic);
Serial.print("] ");
for (int i = 0; i < length; i++) {
Serial.print((char)payload[i]);
}
Serial.println();
}
void reconnect() {
while (!client.connected()) {
Serial.print("Attempting MQTT connection...");
if (client.connect("ESP32Client")) {
Serial.println("connected");
client.subscribe("device/control");
} else {
Serial.print("failed, rc=");
Serial.print(client.state());
Serial.println(" try again in 5 seconds");
delay(5000);
}
}
}
void setup() {
Serial.begin(115200);
setup_wifi();
client.setServer(mqtt_server, 1883);
client.setCallback(callback);
dht.begin();
}
void loop() {
if (!client.connected()) {
reconnect();
}
client.loop();
// Read sensor every 10 seconds
static unsigned long lastRead = 0;
if (millis() - lastRead > 10000) {
float humidity = dht.readHumidity();
float temperature = dht.readTemperature();
if (!isnan(humidity) && !isnan(temperature)) {
char msg[100];
snprintf(msg, sizeof(msg),
"{\"temperature\":%.2f,\"humidity\":%.2f}",
temperature, humidity);
client.publish("sensors/data", msg);
Serial.println(msg);
}
lastRead = millis();
}
}
```
## Edge Computing
```python
import asyncio
from typing import Dict, List
import numpy as np
class EdgeProcessor:
"""Process data at edge before sending to cloud"""
def __init__(self, buffer_size: int = 100):
self.buffer: List[Dict] = []
self.buffer_size = buffer_size
def add_reading(self, reading: Dict):
"""Add sensor reading to buffer"""
self.buffer.append(reading)
if len(self.buffer) >= self.buffer_size:
self.process_buffer()
def process_buffer(self) -> Dict:
"""Process buffered data at edge"""
if not self.buffer:
return {}
# Extract temperature values
temperatures = [r['temperature'] for r in self.buffer]
# Compute statistics at edge
summary = {
"count": len(temperatures),
"mean": np.mean(temperatures),
"std": np.std(temperatures),
"min": np.min(temperatures),
"max": np.max(temperatures),
"anomalies": self.detect_anomalies(temperatures)
}
# Clear buffer
self.buffer = []
return summary
def detect_anomalies(self, values: List[float]) -> List[int]:
"""Detect anomalies using simple threshold"""
mean = np.mean(values)
std = np.std(values)
threshold = 2.5
anomalies = []
for i, v in enumerate(values):
if abs(v - mean) > threshold * std:
anomalies.append(i)
return anomalies
class IoTPipeline:
"""Complete IoT data pipeline"""
def __init__(self, mqtt_client: MQTTClient):
self.mqtt = mqtt_client
self.edge_processor = EdgeProcessor()
self.devices: Dict[str, TemperatureSensor] = {}
def register_device(self, device: TemperatureSensor):
"""Register IoT device"""
self.devices[device.device_id] = device
# Subscribe to device topic
topic = f"sensors/temperature/{device.device_id}"
self.mqtt.subscribe(topic, self.handle_device_data)
def handle_device_data(self, data: Dict):
"""Handle incoming device data"""
# Process at edge
self.edge_processor.add_reading(data)
async def collect_data_loop(self, interval: int = 5):
"""Continuous data collection from devices"""
while True:
for device in self.devices.values():
reading = device.publish_reading()
print(f"Device {device.device_id}: {reading['temperature']}°C")
await asyncio.sleep(interval)
```
## Device Management
```python
from datetime import datetime
from enum import Enum
class DeviceStatus(Enum):
ONLINE = "online"
OFFLINE = "offline"
MAINTENANCE = "maintenance"
ERROR = "error"
class IoTDevice:
def __init__(self, device_id: str, device_type: str):
self.device_id = device_id
self.device_type = device_type
self.status = DeviceStatus.OFFLINE
self.last_seen = None
self.firmware_version = "1.0.0"
self.metadata = {}
def update_status(self, status: DeviceStatus):
self.status = status
self.last_seen = datetime.utcnow()
def needs_firmware_update(self, latest_version: str) -> bool:
return self.firmware_version < latest_version
class DeviceManager:
def __init__(self):
self.devices: Dict[str, IoTDevice] = {}
def register_device(self, device: IoTDevice):
"""Register new device"""
self.devices[device.device_id] = device
def update_device_heartbeat(self, device_id: str):
"""Update device last seen timestamp"""
if device_id in self.devices:
self.devices[device_id].update_status(DeviceStatus.ONLINE)
def get_offline_devices(self, timeout_seconds: int = 300) -> List[IoTDevice]:
"""Get devices that haven't reported recently"""
offline = []
now = datetime.utcnow()
for device in self.devices.values():
if device.last_seen:
elapsed = (now - device.last_seen).total_seconds()
if elapsed > timeout_seconds:
offline.append(device)
return offline
def schedule_firmware_update(self, device_id: str, new_version: str):
"""Schedule OTA firmware update"""
if device_id in self.devices:
# Send update command via MQTT
payload = {
"command": "firmware_update",
"version": new_version,
"url": f"https://updates.example.com/{new_version}.bin"
}
return payload
```
## Best Practices
### Device Design
- Implement power management for battery devices
- Use deep sleep modes when idle
- Handle network disconnections gracefully
- Implement watchdog timers
- Design for remote diagnostics
- Plan for firmware updates (OTA)
### Security
- Use TLS/SSL for MQTT connections
- Implement device authentication
- Encrypt sensitive data
- Secure firmware updates
- Regular security patches
- Network segmentation
### Data Management
- Process data at edge when possible
- Implement data buffering for offline scenarios
- Use efficient data formats (e.g., Protocol Buffers)
- Compress data before transmission
- Handle time synchronization
- Implement data retention policies
## Anti-Patterns
❌ No power management strategy
❌ Unencrypted communications
❌ No error handling for network failures
❌ Sending all raw data to cloud
❌ No device authentication
❌ Hard-coded credentials in firmware
❌ No OTA update mechanism
## Resources
- MQTT: https://mqtt.org/
- ESP32 Documentation: https://docs.espressif.com/
- Arduino: https://www.arduino.cc/
- AWS IoT: https://aws.amazon.com/iot/
- Azure IoT: https://azure.microsoft.com/en-us/overview/iot/
© personamanagmentlayer · Apache-2.0 · personamanagmentlayer/pcl