From superpowers
Detects CPU, GPU, memory, and disk resources to recommend parallel processing, GPU acceleration, or out-of-core computing strategies for scientific tasks.
How this skill is triggered — by the user, by Claude, or both
Slash command
/superpowers:get-available-resourcesThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Detect available computational resources and generate strategic recommendations for scientific computing tasks. This skill automatically identifies CPU capabilities, GPU availability (NVIDIA CUDA, AMD ROCm, Apple Silicon Metal), memory constraints, and disk space to help make informed decisions about computational approaches.
Detect available computational resources and generate strategic recommendations for scientific computing tasks. This skill automatically identifies CPU capabilities, GPU availability (NVIDIA CUDA, AMD ROCm, Apple Silicon Metal), memory constraints, and disk space to help make informed decisions about computational approaches.
Use this skill proactively before any computationally intensive task:
Example scenarios:
The skill runs scripts/detect_resources.py to automatically detect:
CPU Information
GPU Information
Memory Information
Disk Space Information
Operating System Information
The skill generates a .claude_resources.json file in the current working directory containing:
{
"timestamp": "2025-10-23T10:30:00",
"os": {
"system": "Darwin",
"release": "25.0.0",
"machine": "arm64"
},
"cpu": {
"physical_cores": 8,
"logical_cores": 8,
"architecture": "arm64"
},
"memory": {
"total_gb": 16.0,
"available_gb": 8.5,
"percent_used": 46.9
},
"disk": {
"total_gb": 500.0,
"available_gb": 200.0,
"percent_used": 60.0
},
"gpu": {
"nvidia_gpus": [],
"amd_gpus": [],
"apple_silicon": {
"name": "Apple M2",
"type": "Apple Silicon",
"backend": "Metal",
"unified_memory": true
},
"total_gpus": 1,
"available_backends": ["Metal"]
},
"recommendations": {
"parallel_processing": {
"strategy": "high_parallelism",
"suggested_workers": 6,
"libraries": ["joblib", "multiprocessing", "dask"]
},
"memory_strategy": {
"strategy": "moderate_memory",
"libraries": ["dask", "zarr"],
"note": "Consider chunking for datasets > 2GB"
},
"gpu_acceleration": {
"available": true,
"backends": ["Metal"],
"suggested_libraries": ["pytorch-mps", "tensorflow-metal", "jax-metal"]
},
"large_data_handling": {
"strategy": "disk_abundant",
"note": "Sufficient space for large intermediate files"
}
}
}
The skill generates context-aware recommendations:
Parallel Processing Recommendations:
Memory Strategy Recommendations:
GPU Acceleration Recommendations:
Large Data Handling Recommendations:
Execute the detection script at the start of any computationally intensive task:
python scripts/detect_resources.py
Optional arguments:
-o, --output <path>: Specify custom output path (default: .claude_resources.json)-v, --verbose: Print full resource information to stdoutAfter running detection, read the generated .claude_resources.json file to inform computational decisions:
# Example: Use recommendations in code
import json
with open('.claude_resources.json', 'r') as f:
resources = json.load(f)
# Check parallel processing strategy
if resources['recommendations']['parallel_processing']['strategy'] == 'high_parallelism':
n_jobs = resources['recommendations']['parallel_processing']['suggested_workers']
# Use joblib, Dask, or multiprocessing with n_jobs workers
# Check memory strategy
if resources['recommendations']['memory_strategy']['strategy'] == 'memory_constrained':
# Use Dask, Zarr, or H5py for out-of-core processing
import dask.array as da
# Load data in chunks
# Check GPU availability
if resources['recommendations']['gpu_acceleration']['available']:
backends = resources['recommendations']['gpu_acceleration']['backends']
# Use appropriate GPU library based on available backend
Use the resource information and recommendations to make strategic choices:
For data loading:
memory_available_gb = resources['memory']['available_gb']
dataset_size_gb = 10
if dataset_size_gb > memory_available_gb * 0.5:
# Dataset is large relative to memory, use Dask
import dask.dataframe as dd
df = dd.read_csv('large_file.csv')
else:
# Dataset fits in memory, use pandas
import pandas as pd
df = pd.read_csv('large_file.csv')
For parallel processing:
from joblib import Parallel, delayed
n_jobs = resources['recommendations']['parallel_processing'].get('suggested_workers', 1)
results = Parallel(n_jobs=n_jobs)(
delayed(process_function)(item) for item in data
)
For GPU acceleration:
import torch
if 'CUDA' in resources['gpu']['available_backends']:
device = torch.device('cuda')
elif 'Metal' in resources['gpu']['available_backends']:
device = torch.device('mps')
else:
device = torch.device('cpu')
model = model.to(device)
The detection script requires the following Python packages:
uv pip install psutil
All other functionality uses Python standard library modules (json, os, platform, subprocess, sys, pathlib).
.claude_resources.json file in project directories to document resource-aware decisionsGPU not detected:
Script execution fails:
uv pip install psutilchmod +x scripts/detect_resources.pyInaccurate memory readings:
npx claudepluginhub lunartech-x/superpowers --plugin superpowersDetects CPU, GPU, memory, and disk resources, then recommends parallel processing, GPU acceleration, or out-of-core strategies for scientific computing tasks.
Establishes CPU/GPU baselines before resource-intensive operations like builds, training, or tests. Guides scoping, instrumentation, throttling, and logging for regression detection.
Monitors CPU, memory, disk, and network resources using bash commands and Node.js scripts. Analyzes usage patterns, detects issues like leaks/bottlenecks, sets alerts, and recommends optimizations.