skills.rest
seqis
seqisCOMMUNITY
Explore all skills by this author →
GitHub

agent-performance-optimizer

Profile software performance with baseline measurements and verify optimizations.

Updated Aug 27, 2026
Search Tags:#performance#optimization#verification#profiling#bottleneck#measurement
One-click install
npx skills add https://github.com/seqis/OpenClaw-Skills-Converted-From-Claude-Code --skill agent-performance-optimizer
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: agent-performance-optimizer
Source: https://github.com/seqis/OpenClaw-Skills-Converted-From-Claude-Code/tree/main/skills_tree/agent-performance-optimizer
Command: npx skills add https://github.com/seqis/OpenClaw-Skills-Converted-From-Claude-Code --skill agent-performance-optimizer

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires mcp__sequential-thinking__sequentialthinking, and includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill addresses the challenge of inefficient software performance by providing a structured approach to measurement, bottleneck identification, and optimization, ensuring improvements are data-driven and verifiable.

Core Features & Use Cases

  • Mandatory Baseline Measurement: Ensures all performance claims are backed by pre-optimization data.
  • Bottleneck Identification: Utilizes sequential thinking to pinpoint performance issues across CPU, memory, I/O, and database layers.
  • Optimization Strategies: Offers concrete patterns for algorithmic improvements, caching, database tuning, and memory management.
  • Verification & Reporting: Guarantees that optimizations are validated with post-optimization measurements and provides a standardized report format.
  • Use Case: A web application is experiencing slow response times. This skill would be used to measure the current response time, identify if the bottleneck is in the database queries or CPU-bound processing, implement optimizations like adding a database index or optimizing an algorithm, and then re-measure to quantify the improvement.

Quick Start

Use the agent-performance-optimizer skill to measure the current response time of the /api/v1/users endpoint before applying any optimizations.

Frequently Asked Questions about agent-performance-optimizer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I identify a performance bottleneck in my web application?▼

Performance bottleneck identification requires systematic profiling across CPU, memory, I/O, and database layers. This skill utilizes sequential thinking to pinpoint the exact operations causing slow response times before applying any optimizations.

What is the best way to measure software performance before optimizing?▼

Measuring software performance requires capturing mandatory baseline metrics before making any changes. This skill enforces pre-optimization data collection to ensure all subsequent performance improvements are fully data-driven and verifiable.

How do I verify that my code optimizations actually improved performance?▼

Verifying code optimizations requires taking post-optimization measurements and comparing them against your baseline data. This skill mandates quantifiable metrics validation and provides a standardized report format to confirm improvements.

What optimization patterns can I apply to fix slow database queries and CPU-bound processing?▼

Optimization patterns for slow database queries and CPU-bound processing include algorithmic improvements, caching, database tuning, and memory management. This skill guides the implementation of these specific strategies based on identified bottlenecks.

Does this performance optimization approach work for analyzing specific API endpoints?▼

Performance optimization can target specific API endpoints by measuring current response times, identifying the bottleneck source, and re-measuring after applying fixes. This skill provides a structured process for endpoint-level profiling and improvement.

Why do I need sequential thinking to profile and optimize software performance?▼

Sequential thinking provides a structured reasoning process to systematically analyze performance profiling data across multiple system layers. This dependency ensures bottleneck identification is methodical rather than based on guesswork.

Related Skills

Explore More Software Engineering Skills→
nguyenthienthanhnguyenthienthanh
24

performance-optimizer

Profile software systems and resolve performance bottlenecks with targeted optimizations.

Community
Basic
krzemienskikrzemienski
2

performance-regression-detection

Detect performance regressions against baseline metrics above a 10% threshold.

Community
Advanced
4lerman4lerman

performance-profiler

Profile Node.js, Python, and Go applications for CPU, memory, and I/O bottlenecks.

Community
Advanced
curiositechcuriositech
181

performance-profiling

Analyze Node.js application performance via CPU profiling and database query analysis.

Official
Advanced