Results for “profiling”

Build threat actor profiles from public reports, social media, code repositories, and other intelligence sources. Correlates indicators, maps related infrastructure and attack techniques, and produces structured dossiers with confidence assessments about who may be responsible.

• Consolidating public information about an attacker group
• Comparing aliases, targets, and motivations across sources
• Mapping related domains, IP addresses, and infrastructure

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.

• Comparing loss and accuracy across training runs
• Inspecting weight and gradient distributions
• Exploring embeddings in two or three dimensions

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.

• Investigating slow API responses
• Tracking memory growth and suspected leaks
• Analyzing bundle growth after adding dependencies

Investigate cmux interface and runtime problems using debug logs, profiling, and the Debug menu. It guides changes to terminal rendering and tab lists, with checks for typing latency, SwiftUI state handling, and differences between macOS versions.

• Investigating focus and tab switching problems
• Checking typing latency after rendering changes
• Tuning layout and colors through Debug windows

Review game code for likely performance bottlenecks in processing, memory, rendering, and data loading. Compare available estimates with configured limits and produce ranked optimization recommendations, including expected impact, effort, risks, and areas needing runtime measurement.

• Finding performance bottleneck candidates in one game system
• Reviewing performance across the whole game
• Comparing available estimates with configured performance limits

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.

• Refactoring Python code with type hints and tests
• Organizing package settings and dependencies
• Implementing concurrent input and output tasks

Build Apple platform applications with Swift, including SwiftUI screens and state management. Design reusable interfaces with protocols, implement asynchronous tasks, protect shared data with actors, and check code through builds, performance profiling, and tests.

• Building SwiftUI screens and state management
• Fixing concurrency issues with async/await and actors
• Designing protocol-based application architecture

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.

• Refactoring existing code with C++20/23 features
• Investigating memory errors and undefined behavior
• Improving performance through profiling and benchmarks

Build game systems in Unity or Unreal Engine, including physics, AI, and multiplayer networking. The skill guides architecture, implementation, profiling, and testing to work toward frame rate targets and reduce memory use.

• Implementing game mechanics in Unity or Unreal Engine
• Reducing frame drops and memory use
• Building multiplayer networking with lag compensation

Build cross-platform apps with Flutter and Dart, from reusable interface components to state management and navigation. The skill covers Riverpod or Bloc, GoRouter routing, automated tests, and profiling to reduce stuttering and unnecessary screen updates.

• Building reusable Flutter widgets and animations
• Managing application state with Riverpod or Bloc
• Setting up navigation and deep links with GoRouter

Diagnose slow loading, high memory use, and low frame rates in USD 3D scenes. Coordinate scene structure checks, validation, optimization, and before-and-after performance comparisons, then produce a report documenting findings and changes.

• Investigating slow USD scene loading
• Diagnosing low frame rates in CAD scenes
• Investigating high GPU or system memory use

Investigate slow rendering, uneven scrolling, and excessive updates in SwiftUI apps by reviewing code first. When needed, use runtime measurements to assess likely causes, prioritize fixes, and compare performance before and after changes.

• Investigate uneven scrolling and dropped frames
• Find causes of excessive view updates
• Review high CPU use or memory growth

Inspect and control live Chrome pages to investigate display problems, console errors, failed requests, and slow loading. Capture screenshots, automate page interactions, and record performance traces to identify where delays or layout shifts occur.

• Investigating page errors and failed network requests
• Finding causes of slow loading and layout shifts
• Capturing screenshots of pages or individual elements

Investigate MSBuild failures, measure slow builds, or review existing build definitions. Use binary logs, project settings, and comparable timing measurements to identify causes, propose focused repairs, and verify behavior without broad configuration changes.

• Investigating build failures from binary logs
• Measuring bottlenecks and comparing build times
• Finding why unchanged projects rebuild

Configure automatic crash dumps, files that capture application state, or collect one from a running modern .NET process. Follow platform and runtime guidance for desktop, server, Docker, or Kubernetes environments and receive the saved file location.

• Enabling automatic dump collection when a .NET app crashes
• Capturing a dump from a running .NET process
• Setting up dump collection in Docker or Kubernetes

Design, configure, run, and review BenchmarkDotNet measurements of small .NET operations. Compare implementations, runtime versions, or input sizes, while controlling setup work, measurement errors, and case counts so results support a concrete performance decision.

• Compare the performance of alternative implementations
• Reproduce a reported performance problem
• Measure performance before and after a code change

Comprehensive performance analysis, bottleneck detection, and optimization recommendations for Claude Flow swarms

The English summary is being prepared. Showing the original description.

Provides React Native performance optimization guidelines for FPS, TTI, bundle size, memory leaks, re-renders, and animations. Applies to tasks involving Hermes optimization, JS thread blocking, bridge overhead, FlashList, native modules, or debugging jank and frame drops.

The English summary is being prepared. Showing the original description.

Inspect and profile React Native component trees from agent-device. Use for React Native performance, profiling, props, state, hooks, render causes, slow components, excessive rerenders, or questions like why a component rerendered.

The English summary is being prepared. Showing the original description.

Audit and improve SwiftUI runtime performance from code review and architecture. Use for requests to diagnose slow rendering, janky scrolling, high CPU/memory usage, excessive view updates, or layout thrash in SwiftUI apps, and to provide guidance for user-run Instruments profiling when code review alone is insufficient.

The English summary is being prepared. Showing the original description.

Instrument C/C++ with -finstrument-functions for execution tracing and Perfetto visualisation

The English summary is being prepared. Showing the original description.

Visualize training metrics, debug models with histograms, compare experiments, visualize model graphs, and profile performance with TensorBoard - Google's ML visualization toolkit

The English summary is being prepared. Showing the original description.

Produce a prioritized performance-optimization roadmap across frontend, backend, and infrastructure. Use as an explicit/manual helper after bottlenecks are known or suspected, not as the owner of regression detection, profiling capture, or test execution.

The English summary is being prepared. Showing the original description.

Compare current benchmark results against historical baselines to spot performance regressions. Use as an explicit/manual helper for build-to-build degradation review, not for broad optimization strategy or low-level profiling ownership.

The English summary is being prepared. Showing the original description.