菜单
Analyze and optimize cloud infrastructure costs using specialized subagent. Use when reviewing spending, identifying savings opportunities, or planning cost reduction strategies.
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
基于 SOC 职业分类
Use this skill to automate the full SaaS tenant lifecycle: provisioning, configuration, scaling, suspension, and deprovisioning across multi-cloud environments. Triggers: requests to onboard a new tenant, offboard or deprovision a tenant, resize/scale a tenant's resources, clone an environment for testing, or audit tenant resource allocation and billing tags.
Discover and visualize infrastructure resources with interactive HTML output. Use when exploring new environments, understanding resource relationships, or creating infrastructure documentation.
Orchestrate and coordinate multiple AI agents for complex workflows. Use when managing agent interactions, coordinating multi-agent tasks, or implementing agent communication patterns.
Use this skill to collect, forward, and query audit logs and security events from cloud infrastructure, Kubernetes, and application layers into a SIEM. Triggers: any request to set up audit logging, query who accessed secrets, vault access, audit who accessed, accessed secrets, configure log forwarding to Sentinel or Splunk, investigate a security event, search audit logs for suspicious activity, generate a SOC compliance evidence package, configure detection rules, or produce an audit trail for a specific user/resource/time.
Manage Backstage software catalog, components, and API documentation. Use when creating catalog entities, managing component metadata, or organizing software inventory.
Use this skill to forecast resource capacity needs, identify headroom risks, recommend scaling actions, and produce capacity plans for cloud infrastructure. Triggers: any request to forecast compute or storage needs, check whether current resources can handle projected growth, plan for a product launch or traffic spike, assess autoscaler configuration, model different scaling scenarios, or produce a quarterly capacity report.
| name | cost-optimization |
| description | Analyze and optimize cloud infrastructure costs using specialized subagent. Use when reviewing spending, identifying savings opportunities, or planning cost reduction strategies. |
| argument-hint | [targetResource] [analysisType] [timeframe] |
| context | fork |
| agent | Plan |
| disable-model-invocation | false |
| user-invocable | true |
Advanced cost analysis and optimization using specialized subagent execution. This skill runs in isolation to perform comprehensive cost analysis without affecting your main conversation context.
/cost-optimization all-resources full 30d
/cost-optimization production-cluster usage 7d
/cost-optimization database-tier optimization 90d
This skill uses context: fork with agent: Plan to create an isolated execution environment optimized for:
The subagent automatically discovers and categorizes resources:
# Resource classification logic
resource_types = {
'compute': ['VMs', 'Containers', 'Serverless'],
'storage': ['Block Storage', 'Object Storage', 'Database Storage'],
'network': ['Load Balancers', 'CDN', 'Data Transfer'],
'database': ['SQL Databases', 'NoSQL Clusters', 'Caching'],
'services': ['Monitoring', 'Security', 'Analytics']
}
# Cost pattern recognition
def analyze_cost_patterns(historical_data):
patterns = {
'seasonal': detect_seasonal_trends(historical_data),
'growth': identify_growth_rates(historical_data),
'anomalies': detect_cost_anomalies(historical_data),
'efficiency': calculate_resource_efficiency(historical_data)
}
return patterns
The subagent identifies optimization opportunities across multiple dimensions:
Focuses on resource utilization patterns:
Output: Utilization heatmaps, performance trends, capacity planning recommendations
Identifies specific cost-saving opportunities:
Output: Actionable optimization list with estimated savings
Predicts future costs based on trends:
Output: 12-month cost forecast with confidence intervals
Comprehensive analysis including all types:
The Plan subagent provides:
# Cost prediction model
class CostPredictor:
def __init__(self):
self.models = {
'linear_regression': LinearRegression(),
'random_forest': RandomForestRegressor(),
'lstm': LSTMModel()
}
def predict_costs(self, historical_data, horizon_days):
# Ensemble prediction using multiple models
predictions = {}
for name, model in self.models.items():
predictions[name] = model.predict(historical_data, horizon_days)
# Weighted ensemble
return self._ensemble_predictions(predictions)
# Resource optimization engine
class ResourceOptimizer:
def optimize_compute_resources(self, usage_data):
# Right-sizing recommendations
recommendations = []
for resource in usage_data:
current_size = resource.current_instance
utilization = resource.avg_utilization
if utilization < 0.3:
# Downsize recommendation
new_size = self._calculate_optimal_size(utilization)
savings = self._calculate_savings(current_size, new_size)
recommendations.append({
'type': 'downsize',
'resource': resource.id,
'from_size': current_size,
'to_size': new_size,
'monthly_savings': savings
})
return recommendations
The subagent evaluates optimization risks:
| Optimization Type | Risk Level | Rollback Complexity | Impact |
|---|---|---|---|
| Instance Resize | Low | Simple | Minimal |
| Storage Tier Change | Medium | Moderate | Medium |
| Database Migration | High | Complex | High |
| Network Redesign | Critical | Complex | Critical |
def assess_business_impact(optimization, business_context):
impact_factors = {
'performance_degradation': estimate_performance_impact(optimization),
'availability_risk': calculate_availability_risk(optimization),
'data_loss_risk': assess_data_risk(optimization),
'compliance_impact': check_compliance_impact(optimization)
}
return {
'overall_risk': calculate_overall_risk(impact_factors),
'mitigation_strategies': generate_mitigations(impact_factors),
'approval_required': determine_approval_level(impact_factors)
}
Cost Analysis Summary for: $TARGET_RESOURCE
Analysis Period: $TIMEFRAME
Analysis Date: $(date)
Current Monthly Cost: $X,XXX.XX
Projected Monthly Savings: $XXX.XX (X%)
Implementation Cost: $XX.XX
Net 12-Month Savings: $X,XXX.XX
ROI: XXX%
Risk Level: Low/Medium/High/Critical
Recommended Actions: X immediate, Y short-term, Z long-term
Optimization Opportunities:
1. Compute Optimization
- Underutilized VMs: 5 instances
- Potential savings: $250/month
- Risk: Low
- Implementation: 1-2 weeks
2. Storage Optimization
- Cold data to archive: 2TB
- Potential savings: $180/month
- Risk: Medium
- Implementation: 2-4 weeks
3. Network Optimization
- CDN optimization: 30% reduction
- Potential savings: $120/month
- Risk: Low
- Implementation: 1 week
Phase 1 (0-30 days): Quick Wins
- Resize underutilized instances
- Implement basic scheduling
- Enable storage lifecycle policies
Phase 2 (30-90 days): Strategic Changes
- Database optimization
- Network redesign
- Advanced autoscaling
Phase 3 (90+ days): Long-term Optimization
- Architecture review
- Cloud provider evaluation
- Cost governance implementation
start_cost_analysis: Initiates cost optimization workflowget_cost_recommendations: Retrieves detailed recommendationsimplement_optimization: Executes approved optimizationsmonitor_savings: Tracks actual savings vs projections# Real-time cost tracking
class CostMonitor:
def __init__(self):
self.alert_thresholds = {
'daily_budget': 1000,
'anomaly_detection': 0.5, # 50% increase
'unusual_spend': 500
}
def monitor_costs(self):
current_spend = self.get_current_spend()
if current_spend > self.alert_thresholds['daily_budget']:
self.trigger_budget_alert(current_spend)
if self.detect_anomaly(current_spend):
self.trigger_anomaly_alert(current_spend)
# Automated optimization engine
class AutoOptimizer:
def __init__(self):
self.auto_approve_threshold = {
'savings_amount': 100,
'risk_level': 'low',
'implementation_time': 7 # days
}
def evaluate_auto_optimization(self, recommendation):
if (recommendation.savings >= self.auto_approve_threshold['savings_amount'] and
recommendation.risk <= self.auto_approve_threshold['risk_level'] and
recommendation.implementation_time <= self.auto_approve_threshold['implementation_time']):
return self.execute_optimization(recommendation)
return self.request_approval(recommendation)
/cost-optimization all-resources full 30d
/cost-optimization production-cluster usage 7d
/cost-optimization enterprise-infrastructure optimization 90d
/compliance-check: Ensure optimizations maintain compliance/security-analysis: Verify security implications of changes/infrastructure-discovery: Identify optimization targets/workflow-management: Orchestrate optimization workflowsThis section documents the OpenAI Codex-style cost optimization that has been integrated into the Claude skills framework.
When performing cost optimization, follow these systematic steps:
# Resource utilization
# Cost per unit of work
# Spending trends
# Budget variance
# ROI analysis
backend/cost/scripts/cost-optimization/reports/cost/config/cost.yaml