Skip to main content
skill CX Codex

finops-expert — Claude Code skill for cloud cost analysis

The finops-expert skill helps analyze cloud spending and explore cost-saving options. Use it for AWS cost reviews, forecasts, and EC2 sizing recommendations.

Apache-2.0 239 installs ★ 45 updated 2026-10-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add personamanagmentlayer/pcl --skill finops-expert -a claude-code
Open on GitHub

What finops-expert does

finops-expert covers cloud cost visibility, allocation, budgets, and forecasting. Its guidance also addresses resource choices such as Reserved Instances, Savings Plans, Spot instances, right-sizing, and idle-resource cleanup. It provides FinOps guidance and code examples; it does not apply cloud changes automatically.

The AWS example uses AWSCostAnalyzer to query Cost Explorer, group spending by service, forecast costs, and retrieve EC2 sizing recommendations. CostOptimizer checks for stopped EC2 instances, unattached EBS volumes, and Elastic IPs without an instance association. The sample imports boto3 and pandas, and AWS API access is needed to make those requests. Its Reserved Instance savings calculation is explicitly simplified and does not use live pricing data, so treat that estimate as a rough model rather than a quote.

What it helps with

  • break down AWS spending by service
  • forecast cloud costs
  • find stopped EC2 instances and unattached EBS volumes
  • compare On-Demand and Reserved Instance costs with a simplified model

Example prompts for the agent

  • Break down AWS spending by service and identify the largest costs.
  • Find stopped EC2 instances, unattached EBS volumes, and Elastic IPs without an instance.
  • Forecast AWS costs and explain the EC2 sizing recommendations.

How to install finops-expert

1Skills CLI (Vercel)

npx skills add personamanagmentlayer/pcl --skill finops-expert -a claude-code

2Manually: put the files in place

~/.claude/skills/finops-expert/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/finops-expert/

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

Questions about finops-expert

How do I install finops-expert in Claude Code?

Run npx skills add personamanagmentlayer/pcl --skill finops-expert -a claude-code. The skill is placed at ~/.claude/skills/finops-expert/SKILL.md.

What does finops-expert do?

It guides cloud cost analysis, forecasting, and optimization. Its AWS examples query Cost Explorer and retrieve EC2 sizing recommendations.

What do I need to analyze AWS costs?

The example imports boto3 and calls AWS Cost Explorer, so you need AWS access and permission to use the relevant APIs.

Source text

SKILL.md · Apache-2.0
---
name: finops-expert
version: 2.0.0
description: >-
  Expert-level cloud financial operations, cost optimization, and cloud economics. Use when
  the user mentions cloud cost, optimization, cloud economics, or AWS cost, or when the
  task involves FinOps Fundamentals, Cost Management, FinOps Practices, or Cost Visibility.
category: professional
tags: [finops, cloud-cost, optimization, cloud-economics, aws-cost]
allowed-tools:
  - Read
  - Write
  - Edit
  - Bash(python:*, python3:*, pip:*, pytest:*)
---

# FinOps Expert

Expert guidance for cloud financial operations, cost optimization, resource management, and cloud economics.

## Core Concepts

### FinOps Fundamentals

- Cloud cost visibility
- Usage optimization
- Rate optimization
- Architecture optimization
- Cloud unit economics
- Showback and chargeback

### Cost Management

- Reserved Instances (RIs)
- Savings Plans
- Spot instances
- Right-sizing resources
- Idle resource cleanup
- Storage lifecycle policies

### FinOps Practices

- Tagging strategies
- Budgets and alerts
- Cost allocation
- Forecasting and planning
- Cross-team collaboration
- Continuous optimization

## AWS Cost Analysis

```python
import boto3
from datetime import datetime, timedelta
from typing import Dict, List
import pandas as pd

class AWSCostAnalyzer:
    """Analyze AWS costs using Cost Explorer API"""

    def __init__(self):
        self.ce_client = boto3.client('ce')

    def get_cost_and_usage(self, start_date: str, end_date: str,
                          granularity: str = 'DAILY',
                          metrics: List[str] = None) -> Dict:
        """Get cost and usage data"""
        if metrics is None:
            metrics = ['UnblendedCost', 'UsageQuantity']

        response = self.ce_client.get_cost_and_usage(
            TimePeriod={
                'Start': start_date,
                'End': end_date
            },
            Granularity=granularity,
            Metrics=metrics,
            GroupBy=[
                {'Type': 'DIMENSION', 'Key': 'SERVICE'}
            ]
        )

        return response['ResultsByTime']

    def get_top_services_by_cost(self, days: int = 30, top_n: int = 10) -> pd.DataFrame:
        """Get top services by cost"""
        end_date = datetime.now().strftime('%Y-%m-%d')
        start_date = (datetime.now() - timedelta(days=days)).strftime('%Y-%m-%d')

        results = self.get_cost_and_usage(start_date, end_date, 'MONTHLY')

        service_costs = {}
        for result in results:
            for group in result['Groups']:
                service = group['Keys'][0]
                cost = float(group['Metrics']['UnblendedCost']['Amount'])

                if service in service_costs:
                    service_costs[service] += cost
                else:
                    service_costs[service] = cost

        df = pd.DataFrame(list(service_costs.items()),
                         columns=['Service', 'Cost'])
        return df.nlargest(top_n, 'Cost')

    def get_cost_forecast(self, days_ahead: int = 30) -> Dict:
        """Get cost forecast"""
        start_date = datetime.now().strftime('%Y-%m-%d')
        end_date = (datetime.now() + timedelta(days=days_ahead)).strftime('%Y-%m-%d')

        response = self.ce_client.get_cost_forecast(
            TimePeriod={
                'Start': start_date,
                'End': end_date
            },
            Metric='UNBLENDED_COST',
            Granularity='MONTHLY'
        )

        return {
            'forecasted_cost': float(response['Total']['Amount']),
            'mean_value': float(response['ForecastResultsByTime'][0]['MeanValue'])
        }

    def get_rightsizing_recommendations(self) -> List[Dict]:
        """Get EC2 rightsizing recommendations"""
        response = self.ce_client.get_rightsizing_recommendation(
            Service='AmazonEC2'
        )

        recommendations = []
        for rec in response['RightsizingRecommendations']:
            recommendations.append({
                'instance_id': rec['CurrentInstance']['ResourceId'],
                'current_type': rec['CurrentInstance']['InstanceType'],
                'recommended_type': rec['ModifyRecommendationDetail']['TargetInstances'][0]['InstanceType']
                    if rec.get('ModifyRecommendationDetail') else None,
                'estimated_savings': float(rec['EstimatedMonthlySavings']['Value'])
                    if rec.get('EstimatedMonthlySavings') else 0
            })

        return recommendations

class CostOptimizer:
    """Optimize cloud costs"""

    def __init__(self):
        self.ec2_client = boto3.client('ec2')
        self.rds_client = boto3.client('rds')
        self.s3_client = boto3.client('s3')

    def find_idle_resources(self) -> Dict[str, List]:
        """Find idle/unused resources"""
        idle_resources = {
            'ec2_instances': [],
            'ebs_volumes': [],
            'elastic_ips': [],
            'load_balancers': []
        }

        # Idle EC2 instances (stopped for > 7 days)
        instances = self.ec2_client.describe_instances(
            Filters=[{'Name': 'instance-state-name', 'Values': ['stopped']}]
        )

        for reservation in instances['Reservations']:
            for instance in reservation['Instances']:
                idle_resources['ec2_instances'].append({
                    'id': instance['InstanceId'],
                    'type': instance['InstanceType'],
                    'state': instance['State']['Name']
                })

        # Unattached EBS volumes
        volumes = self.ec2_client.describe_volumes(
            Filters=[{'Name': 'status', 'Values': ['available']}]
        )

        for volume in volumes['Volumes']:
            idle_resources['ebs_volumes'].append({
                'id': volume['VolumeId'],
                'size': volume['Size'],
                'type': volume['VolumeType']
            })

        # Unattached Elastic IPs
        addresses = self.ec2_client.describe_addresses()

        for address in addresses['Addresses']:
            if 'InstanceId' not in address:
                idle_resources['elastic_ips'].append({
                    'allocation_id': address['AllocationId'],
                    'public_ip': address['PublicIp']
                })

        return idle_resources

    def calculate_reserved_instance_savings(self,
                                           instance_type: str,
                                           count: int,
                                           term: int = 1) -> Dict:
        """Calculate RI savings"""
        # Simplified calculation (would use actual pricing API)
        on_demand_hourly = self._get_on_demand_price(instance_type)
        ri_hourly = on_demand_hourly * 0.65  # ~35% discount

        hours_per_year = 24 * 365
        annual_on_demand = on_demand_hourly * hours_per_year * count
        annual_ri = ri_hourly * hours_per_year * count

        return {
            'instance_type': instance_type,
            'count': count,
            'annual_on_demand_cost': annual_on_demand,
            'annual_ri_cost': annual_ri,
            'annual_savings': annual_on_demand - annual_ri,
            'savings_percentage': ((annual_on_demand - annual_ri) / annual_on_demand) * 100
        }

    def _get_on_demand_price(self, instance_type: str) -> float:
        """Get on-demand hourly price (simplified)"""
        # In production, use AWS Pricing API
        prices = {
            't3.micro': 0.0104,
            't3.small': 0.0208,
            't3.medium': 0.0416,
            'm5.large': 0.096,
            'm5.xlarge': 0.192
        }
        return prices.get(instance_type, 0.10)
```

## Cost Allocation and Tagging

```python
class CostAllocation:
    """Manage cost allocation with tags"""

    def __init__(self):
        self.ec2_client = boto3.client('ec2')
        self.ce_client = boto3.client('ce')

    def define_tagging_strategy(self) -> Dict[str, List[str]]:
        """Define mandatory tags"""
        return {
            'environment': ['prod', 'staging', 'dev'],
            'team': ['engineering', 'data', 'product'],
            'cost_center': ['CC001', 'CC002', 'CC003'],
            'project': ['project-a', 'project-b'],
            'owner': ['email addresses']
        }

    def audit_resource_tags(self, resource_type: str = 'instance') -> List[Dict]:
        """Audit resources for missing tags"""
        mandatory_tags = ['environment', 'team', 'cost_center']
        untagged_resources = []

        if resource_type == 'instance':
            instances = self.ec2_client.describe_instances()

            for reservation in instances['Reservations']:
                for instance in reservation['Instances']:
                    tags = {tag['Key']: tag['Value']
                           for tag in instance.get('Tags', [])}

                    missing_tags = [tag for tag in mandatory_tags
                                  if tag not in tags]

                    if missing_tags:
                        untagged_resources.append({
                            'resource_id': instance['InstanceId'],
                            'missing_tags': missing_tags
                        })

        return untagged_resources

    def get_cost_by_tag(self, tag_key: str, start_date: str,
                       end_date: str) -> pd.DataFrame:
        """Get costs grouped by tag"""
        response = self.ce_client.get_cost_and_usage(
            TimePeriod={
                'Start': start_date,
                'End': end_date
            },
            Granularity='MONTHLY',
            Metrics=['UnblendedCost'],
            GroupBy=[
                {'Type': 'TAG', 'Key': tag_key}
            ]
        )

        costs = []
        for result in response['ResultsByTime']:
            for group in result['Groups']:
                costs.append({
                    'tag_value': group['Keys'][0].split('$')[1]
                        if '$' in group['Keys'][0] else 'Untagged',
                    'cost': float(group['Metrics']['UnblendedCost']['Amount'])
                })

        return pd.DataFrame(costs)
```

## Budget Management

```python
class BudgetManager:
    """Manage AWS budgets and alerts"""

    def __init__(self):
        self.budgets_client = boto3.client('budgets')
        self.account_id = boto3.client('sts').get_caller_identity()['Account']

    def create_monthly_budget(self, name: str, amount: float,
                             email: str) -> Dict:
        """Create monthly cost budget with alerts"""
        budget = {
            'BudgetName': name,
            'BudgetLimit': {
                'Amount': str(amount),
                'Unit': 'USD'
            },
            'TimeUnit': 'MONTHLY',
            'BudgetType': 'COST'
        }

        # Alert at 80% and 100%
        notifications = [
            {
                'Notification': {
                    'NotificationType': 'ACTUAL',
                    'ComparisonOperator': 'GREATER_THAN',
                    'Threshold': 80,
                    'ThresholdType': 'PERCENTAGE'
                },
                'Subscribers': [{
                    'SubscriptionType': 'EMAIL',
                    'Address': email
                }]
            },
            {
                'Notification': {
                    'NotificationType': 'ACTUAL',
                    'ComparisonOperator': 'GREATER_THAN',
                    'Threshold': 100,
                    'ThresholdType': 'PERCENTAGE'
                },
                'Subscribers': [{
                    'SubscriptionType': 'EMAIL',
                    'Address': email
                }]
            }
        ]

        response = self.budgets_client.create_budget(
            AccountId=self.account_id,
            Budget=budget,
            NotificationsWithSubscribers=notifications
        )

        return response
```

## Best Practices

### Cost Visibility

- Implement comprehensive tagging
- Enable Cost Explorer
- Set up cost allocation tags
- Create custom cost reports
- Use dashboards for visualization
- Monitor costs daily

### Optimization

- Right-size resources regularly
- Use Reserved Instances/Savings Plans
- Leverage Spot instances for flexible workloads
- Implement auto-scaling
- Clean up idle resources
- Use storage lifecycle policies

### Governance

- Set budgets and alerts
- Implement approval workflows
- Regular cost reviews
- Cross-team accountability
- Document cost optimization wins
- Automate cost controls

## Anti-Patterns

❌ No tagging strategy
❌ Ignoring rightsizing recommendations
❌ Not using Reserved Instances
❌ No budget alerts
❌ Keeping idle resources
❌ Manual cost tracking
❌ Siloed cost responsibility

## Resources

- AWS Cost Explorer: https://aws.amazon.com/aws-cost-management/aws-cost-explorer/
- FinOps Foundation: https://www.finops.org/
- AWS Well-Architected Cost Optimization: https://wa.aws.amazon.com/wat.pillar.costOptimization.en.html
- Boto3 Cost Explorer: https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/ce.html

© personamanagmentlayer · Apache-2.0 · personamanagmentlayer/pcl

Similar skills

All skills for Cloud: AWS, Azure, GCP →

From the same set104

The whole set →
helm-expert helm-expert is a Claude Code skill for building Helm charts and managing Kubernetes releases. It activates for requests involving charts, templates, or deployments. CX Codex +1 251installs cpp-expert cpp-expert — an agent skill for C++20/23 work: STL, ownership, concurrency and CMake. Handy when the agent has to write or repair modern C++. CX Codex +1 250installs ai-engineer-expert The ai-engineer-expert skill covers LLM integration, RAG, and production AI systems. Use it when an agent needs to design or deploy AI features. CX Codex +1 242installs quantum-expert quantum-expert gives the agent working knowledge of quantum circuits: Bell states, teleportation, Grover, VQE and Qiskit classifiers. CX Codex +1 240installs snowflake-expert snowflake-expert — a skill that walks your agent through Snowflake warehouse sizing, clustering, streams and query tuning. CX Codex +1 239installs iot-expert iot-expert is a Claude Code skill for IoT architecture, MQTT, embedded firmware, and edge computing. It generates architecture guides and microcontroller code. CX Codex +1 239installs biological-expert biological-expert configures the coding agent for computational biology, genetics, and sequence analysis. It assists with DNA parsing, alignment, and variant annotation. CX Codex +1 235installs security-expert security-expert is a Claude Code skill that provides application security guidance for OWASP checks, vulnerability reviews, and secure coding. It covers tasks involving authentication, encryption, or access control. CX Codex +1 231installs

Project sponsors

Companies that keep this analytics open