326 skills · sorted by relevance
Audit page speed in a real browser to find delays in loading, script execution, and layout. Use measured results to identify bottlenecks, compare device and connection conditions, and guide performance improvements.
Coordinate specialist agents to investigate and improve application performance across databases, backend services, frontend code, and delivery infrastructure. Establish baseline measurements, address observed bottlenecks, validate changes with load tests, and set up monitoring to detect future slowdowns.
Improve workflows involving multiple AI agents by measuring bottlenecks, adjusting workload distribution, and managing model costs. This design guide helps compare changes against a measured baseline while checking quality, latency, and resource use.
Design and improve Unity games that process large numbers of entities. Learn ECS, an approach that separates data from behavior, and apply Jobs and Burst patterns to organize parallel processing and address CPU performance bottlenecks.
Measure denoising latency in SGLang diffusion models and identify slow operations with profiler traces. Compare performance and output quality on the same GPUs, check existing optimizations, and gather evidence before starting low-level kernel work.
Use TensorBoard to visualize training loss and accuracy, compare experiments, and inspect model structure. Includes PyTorch and TensorFlow logging examples for examining weight distributions, predictions, and performance bottlenecks during machine learning training.
Review code for performance bottlenecks across database queries, memory use, frontend rendering, network requests, and algorithms. Use a structured checklist to identify optimization opportunities and classify their severity according to expected load and scale.
Investigate slow Node.js, Python, and Go applications by measuring CPU use, memory, database queries, and data transfer. Identify bottlenecks, inspect frontend bundle sizes, run load tests, and compare measurements before and after changes to verify improvements.
Assess startup engineering operations across delivery, hiring, team structure, and production practices. Use delivery metrics, hiring conversion rates, and staffing data to identify bottlenecks, estimate candidate needs, and plan management roles and operational improvements.
Review SaaS and purchasing spend to find growing cost categories, slow approval processes, and overlapping suppliers. Produce categorized reports and consolidation options that account for migration costs, clustered renewals, and the risks of relying on one critical supplier.
Route internal operations questions to six specialist skills covering workflows, vendors, staffing capacity, communications, procedures, and procurement. Receive a brief summary of findings, recommended actions, and links to the documents or data files produced.
Investigate slow or failing requests in Google Cloud using Cloud Trace. Filter traces by duration or error status, inspect spans representing individual operations, and retrieve related Cloud Logging entries to investigate bottlenecks and exceptions.
Plan and troubleshoot large language and vision model training and inference. This guide uses hardware measurements to identify bottlenecks, address memory shortages and unstable training, and improve checkpointing, recovery, and performance across multiple GPUs and machines.
Helps write and improve Python code with type hints, tests, and organized package settings. Covers dependency management, asynchronous tasks that wait on external operations, and profiling to identify performance bottlenecks before making changes.
Measure scripts, running processes, or whole systems to find performance bottlenecks. Select suitable tools, add measurement code when needed, and report CPU, GPU, memory, and communication findings with prioritized recommendations and a record of file changes.
Guide MNN Metal backend development and optimization, from finding performance bottlenecks to changing GPU computation, combining operators, and adjusting execution scheduling. A task-based document index directs work toward relevant implementation rules, benchmarks, and correctness checks.
Improve MNN inference on OpenCL by measuring bottlenecks and refining GPU kernels, the code that performs calculations. The skill guides baseline measurements, correctness checks, Android device benchmarks, and integration of new OpenCL features with compatibility fallbacks.
Optimize and troubleshoot MNN's Hexagon DSP backend, which runs computation on a dedicated processor. The workflow uses device measurements to identify bottlenecks, compare v79 and v81 architectures, verify correctness, and investigate crashes or memory usage.
Improve MNN's Vulkan backend by separating CPU scheduling bottlenecks from GPU computation costs. It guides operator and shader changes, new feature integration with compatibility fallbacks, and device testing to verify both correctness and end-to-end performance.
Use TensorBoard to visualize training loss and accuracy, compare experiments, and inspect model structure. Guides logging for PyTorch and TensorFlow, including weight distributions and performance profiling to investigate training problems and processing bottlenecks.
Write and refactor C++20/23 applications, addressing memory management, concurrency, and performance bottlenecks. Produce interfaces, implementations, tests, and relevant CMake updates, then check runtime errors and measure performance before applying targeted optimizations.
Estimate cross-server traffic, network bottlenecks, and synchronization waits for AI training or inference. Map communication onto physical network paths and assess how topology or communication changes affect the time needed to complete the job.
Comprehensive performance analysis, bottleneck detection, and optimization recommendations for Claude Flow swarms
The English summary is being prepared. Showing the original description.
Golang performance optimization patterns and methodology - if X bottleneck, then apply Y. Covers allocation reduction, CPU efficiency, memory layout, GC tuning, pooling, caching, and hot-path optimization. Use when profiling or benchmarks have identified a bottleneck and you need the right optimization pattern to fix it. Also use when performing performance code review to suggest improvements or benchmarks that could help identify quick performance gains. Not for measurement methodology (→ See `samber/cc-skills-golang@golang-benchmark` skill) or debugging workflow (→ See `samber/cc-skills-golang@golang-troubleshooting` skill).
The English summary is being prepared. Showing the original description.