Skip to main content
skill CX Codex

agent-orchestration-improve-agent — Claude Code skill

The agent-orchestration-improve-agent Claude Code skill helps improve existing AI agents. It examines failures, refines prompts, and tests changes against representative cases.

MIT 141 installs ★ 2,070 updated 2026-10-14

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add rmyndharis/antigravity-skills --skill agent-orchestration-improve-agent -a claude-code
Open on GitHub

What agent-orchestration-improve-agent does

The skill guides improvements to an existing agent by analyzing its performance and revising its prompts. It starts with baseline metrics and examples, then groups failures by cause, such as misunderstood instructions or poor tool selection.

Next, it proposes prompt and workflow changes with measurable goals, followed by tests and a staged rollout. The workflow uses context-manager, prompt-engineer, and parallel-test-runner. It is not meant for a new agent or for cases with no metrics, feedback, or test scenarios.

What it helps with

  • trace recurring failures in an existing agent
  • identify prompt and tool-use problems
  • revise an agent's workflow based on performance
  • compare an agent before and after changes

Example prompts for the agent

  • Analyze this existing agent's performance and group its recurring failures.
  • Revise the agent's prompt based on examples of unsuccessful responses.
  • Plan tests to compare the original agent with the revised version.

How to install agent-orchestration-improve-agent

1Skills CLI (Vercel)

npx skills add rmyndharis/antigravity-skills --skill agent-orchestration-improve-agent -a claude-code

2Manually: put the files in place

~/.claude/skills/agent-orchestration-improve-agent/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/agent-orchestration-improve-agent/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about agent-orchestration-improve-agent

How do I install agent-orchestration-improve-agent in Claude Code?

Run npx skills add rmyndharis/antigravity-skills --skill agent-orchestration-improve-agent -a claude-code. The skill file is at ~/.claude/skills/agent-orchestration-improve-agent/SKILL.md.

What does agent-orchestration-improve-agent do?

It helps assess an existing agent, categorize its failures, and refine its prompts or workflow. The suggested changes are then tested.

When should I use agent-orchestration-improve-agent?

Use it to improve an existing agent when metrics, feedback, or test cases are available. It is not intended to build an agent from scratch.

Source text

SKILL.md · MIT
---
name: agent-orchestration-improve-agent
description: "Systematic improvement of existing agents through performance analysis, prompt engineering, and continuous iteration."
---

# Agent Performance Optimization Workflow

Systematic improvement of existing agents through performance analysis, prompt engineering, and continuous iteration.

[Extended thinking: Agent optimization requires a data-driven approach combining performance metrics, user feedback analysis, and advanced prompt engineering techniques. Success depends on systematic evaluation, targeted improvements, and rigorous testing with rollback capabilities for production safety.]

## Use this skill when

- Improving an existing agent's performance or reliability
- Analyzing failure modes, prompt quality, or tool usage
- Running structured A/B tests or evaluation suites
- Designing iterative optimization workflows for agents

## Do not use this skill when

- You are building a brand-new agent from scratch
- There are no metrics, feedback, or test cases available
- The task is unrelated to agent performance or prompt quality

## Instructions

1. Establish baseline metrics and collect representative examples.
2. Identify failure modes and prioritize high-impact fixes.
3. Apply prompt and workflow improvements with measurable goals.
4. Validate with tests and roll out changes in controlled stages.

## Safety

- Avoid deploying prompt changes without regression testing.
- Roll back quickly if quality or safety metrics regress.

## Phase 1: Performance Analysis and Baseline Metrics

Comprehensive analysis of agent performance using context-manager for historical data collection.

### 1.1 Gather Performance Data

```
Use: context-manager
Command: analyze-agent-performance [agent name] --days 30
```

Collect metrics including:

- Task completion rate (successful vs failed tasks)
- Response accuracy and factual correctness
- Tool usage efficiency (correct tools, call frequency)
- Average response time and token consumption
- User satisfaction indicators (corrections, retries)
- Hallucination incidents and error patterns

### 1.2 User Feedback Pattern Analysis

Identify recurring patterns in user interactions:

- **Correction patterns**: Where users consistently modify outputs
- **Clarification requests**: Common areas of ambiguity
- **Task abandonment**: Points where users give up
- **Follow-up questions**: Indicators of incomplete responses
- **Positive feedback**: Successful patterns to preserve

### 1.3 Failure Mode Classification

Categorize failures by root cause:

- **Instruction misunderstanding**: Role or task confusion
- **Output format errors**: Structure or formatting issues
- **Context loss**: Long conversation degradation
- **Tool misuse**: Incorrect or inefficient tool selection
- **Constraint violations**: Safety or business rule breaches
- **Edge case handling**: Unusual input scenarios

### 1.4 Baseline Performance Report

Generate quantitative baseline metrics:

```
Performance Baseline:
- Task Success Rate: [X%]
- Average Corrections per Task: [Y]
- Tool Call Efficiency: [Z%]
- User Satisfaction Score: [1-10]
- Average Response Latency: [Xms]
- Token Efficiency Ratio: [X:Y]
```

## Phase 2: Prompt Engineering Improvements

Apply advanced prompt optimization techniques using prompt-engineer agent.

### 2.1 Chain-of-Thought Enhancement

Implement structured reasoning patterns:

```
Use: prompt-engineer
Technique: chain-of-thought-optimization
```

- Add explicit reasoning steps: "Let's approach this step-by-step..."
- Include self-verification checkpoints: "Before proceeding, verify that..."
- Implement recursive decomposition for complex tasks
- Add reasoning trace visibility for debugging

### 2.2 Few-Shot Example Optimization

Curate high-quality examples from successful interactions:

- **Select diverse examples** covering common use cases
- **Include edge cases** that previously failed
- **Show both positive and negative examples** with explanations
- **Order examples** from simple to complex
- **Annotate examples** with key decision points

Example structure:

```
Good Example:
Input: [User request]
Reasoning: [Step-by-step thought process]
Output: [Successful response]
Why this works: [Key success factors]

Bad Example:
Input: [Similar request]
Output: [Failed response]
Why this fails: [Specific issues]
Correct approach: [Fixed version]
```

### 2.3 Role Definition Refinement

Strengthen agent identity and capabilities:

- **Core purpose**: Clear, single-sentence mission
- **Expertise domains**: Specific knowledge areas
- **Behavioral traits**: Personality and interaction style
- **Tool proficiency**: Available tools and when to use them
- **Constraints**: What the agent should NOT do
- **Success criteria**: How to measure task completion

### 2.4 Constitutional AI Integration

Implement self-correction mechanisms:

```
Constitutional Principles:
1. Verify factual accuracy before responding
2. Self-check for potential biases or harmful content
3. Validate output format matches requirements
4. Ensure response completeness
5. Maintain consistency with previous responses
```

Add critique-and-revise loops:

- Initial response generation
- Self-critique against principles
- Automatic revision if issues detected
- Final validation before output

### 2.5 Output Format Tuning

Optimize response structure:

- **Structured templates** for common tasks
- **Dynamic formatting** based on complexity
- **Progressive disclosure** for detailed information
- **Markdown optimization** for readability
- **Code block formatting** with syntax highlighting
- **Table and list generation** for data presentation

## Phase 3: Testing and Validation

Comprehensive testing framework with A/B comparison.

### 3.1 Test Suite Development

Create representative test scenarios:

```
Test Categories:
1. Golden path scenarios (common successful cases)
2. Previously failed tasks (regression testing)
3. Edge cases and corner scenarios
4. Stress tests (complex, multi-step tasks)
5. Adversarial inputs (potential breaking points)
6. Cross-domain tasks (combining capabilities)
```

### 3.2 A/B Testing Framework

Compare original vs improved agent:

```
Use: parallel-test-runner
Config:
  - Agent A: Original version
  - Agent B: Improved version
  - Test set: 100 representative tasks
  - Metrics: Success rate, speed, token usage
  - Evaluation: Blind human review + automated scoring
```

Statistical significance testing:

- Minimum sample size: 100 tasks per variant
- Confidence level: 95% (p < 0.05)
- Effect size calculation (Cohen's d)
- Power analysis for future tests

### 3.3 Evaluation Metrics

Comprehensive scoring framework:

**Task-Level Metrics:**

- Completion rate (binary success/failure)
- Correctness score (0-100% accuracy)
- Efficiency score (steps taken vs optimal)
- Tool usage appropriateness
- Response relevance and completeness

**Quality Metrics:**

- Hallucination rate (factual errors per response)
- Consistency score (alignment with previous responses)
- Format compliance (matches specified structure)
- Safety score (constraint adherence)
- User satisfaction prediction

**Performance Metrics:**

- Response latency (time to first token)
- Total generation time
- Token consumption (input + output)
- Cost per task (API usage fees)
- Memory/context efficiency

### 3.4 Human Evaluation Protocol

Structured human review process:

- Blind evaluation (evaluators don't know version)
- Standardized rubric with clear criteria
- Multiple evaluators per sample (inter-rater reliability)
- Qualitative feedback collection
- Preference ranking (A vs B comparison)

## Phase 4: Version Control and Deployment

Safe rollout with monitoring and rollback capabilities.

### 4.1 Version Management

Systematic versioning strategy:

```
Version Format: agent-name-v[MAJOR].[MINOR].[PATCH]
Example: customer-support-v2.3.1

MAJOR: Significant capability changes
MINOR: Prompt improvements, new examples
PATCH: Bug fixes, minor adjustments
```

Maintain version history:

- Git-based prompt storage
- Changelog with improvement details
- Performance metrics per version
- Rollback procedures documented

### 4.2 Staged Rollout

Progressive deployment strategy:

1. **Alpha testing**: Internal team validation (5% traffic)
2. **Beta testing**: Selected users (20% traffic)
3. **Canary release**: Gradual increase (20% → 50% → 100%)
4. **Full deployment**: After success criteria met
5. **Monitoring period**: 7-day observation window

### 4.3 Rollback Procedures

Quick recovery mechanism:

```
Rollback Triggers:
- Success rate drops >10% from baseline
- Critical errors increase >5%
- User complaints spike
- Cost per task increases >20%
- Safety violations detected

Rollback Process:
1. Detect issue via monitoring
2. Alert team immediately
3. Switch to previous stable version
4. Analyze root cause
5. Fix and re-test before retry
```

### 4.4 Continuous Monitoring

Real-time performance tracking:

- Dashboard with key metrics
- Anomaly detection alerts
- User feedback collection
- Automated regression testing
- Weekly performance reports

## Success Criteria

Agent improvement is successful when:

- Task success rate improves by ≥15%
- User corrections decrease by ≥25%
- No increase in safety violations
- Response time remains within 10% of baseline
- Cost per task doesn't increase >5%
- Positive user feedback increases

## Post-Deployment Review

After 30 days of production use:

1. Analyze accumulated performance data
2. Compare against baseline and targets
3. Identify new improvement opportunities
4. Document lessons learned
5. Plan next optimization cycle

## Continuous Improvement Cycle

Establish regular improvement cadence:

- **Weekly**: Monitor metrics and collect feedback
- **Monthly**: Analyze patterns and plan improvements
- **Quarterly**: Major version updates with new capabilities
- **Annually**: Strategic review and architecture updates

Remember: Agent optimization is an iterative process. Each cycle builds upon previous learnings, gradually improving performance while maintaining stability and safety.

© rmyndharis · MIT · rmyndharis/antigravity-skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set17

The whole set →
bash-pro The bash-pro Claude Code skill guides Bash scripting for automation, CI/CD, and system tasks. It helps structure argument handling, error recovery, and script checks. CX Codex +1 123installs quant-analyst quant-analyst — a skill for Claude Code and Codex designed for financial modeling and backtesting. Handles portfolio optimization, risk metrics, and time series analysis. CX Codex +1 123installs unity-developer unity-developer — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that brings Unity 6 LTS expertise into the agent context: rendering pipelines, C# performance patterns, and cross-platform builds. CX Codex +1 3,000installs dotnet-architect dotnet-architect — a skill for Claude Code, Codex, Cursor, GitHub Copilot, and Gemini CLI that gives the agent the role of a senior .NET backend architect: C#, ASP.NET Core, Entity Framework, Dapper, and enterprise patterns. CX Codex +1 353installs java-pro The java-pro skill for Claude Code supports Java 21+ work, Spring Boot 3.x design, and JVM performance tasks. Ask for implementation steps, architecture choices, or code checks. CX Codex +1 237installs csharp-pro csharp-pro — a skill for Claude Code, Codex, and Cursor. Guides the AI agent in modern C# development, architecture design, and .NET runtime performance tuning. CX Codex +1 136installs minecraft-bukkit-pro The minecraft-bukkit-pro skill for Claude Code supports Minecraft plugin work with Bukkit, Spigot, and Paper. It covers event logic, commands, world changes, and server performance. CX Codex +1 131installs ios-developer ios-developer — a skill for Claude Code guides the assistant through native iOS app development. Activates when designing architectures, building UI screens, or configuring deployment workflows. CX Codex +1 114installs

Project sponsors

Companies that keep this analytics open