Cost Telemetry for Claude Code Across a PE Portfolio

Table of Contents

1. Why Cost Telemetry Matters for PE-Owned Tech
2. Understanding Claude Code Costs at Scale
3. Setting Up Per-Engineer Usage Dashboards
4. Building Cost Attribution by Repository
5. Portfolio-Wide Visibility and Aggregation
6. Using Telemetry Data to Negotiate Enterprise Tiers
7. Real-World Implementation: From Chaos to Control
8. Optimising Claude Code Spend Across Your Portfolio
9. Compliance and Security in Cost Tracking
10. Next Steps and Quick Wins

---

Why Cost Telemetry Matters for PE-Owned Tech

Private equity firms acquiring software companies face a brutal reality: technology debt, sprawling AI tool adoption, and opaque vendor spend. When you own 15 portfolio companies, each with their own engineering teams, tracking where AI coding spend actually lands becomes a competitive advantage.

Claude Code—Anthropic’s AI-powered coding assistant—has become a standard in modern development workflows. Engineers use it for everything from bug fixes to full feature scaffolding. But without visibility into per-engineer, per-repository, and per-portfolio-company usage, you’re flying blind.

Here’s the hard truth: most PE operating partners don’t know what they’re paying for Claude Code across their portfolio. Some engineers max out their Pro subscriptions. Others never use it. Some portfolio companies have negotiated enterprise tiers; others are still on individual plans. This fragmentation costs money and leaves value on the table.

Cost telemetry solves this. By instrumenting Claude Code usage with tools like D23.io and OpenTelemetry, you can:

• Track spend per engineer and correlate it with output (lines of code, bugs fixed, features shipped)
• Attribute costs to repositories and understand which projects are driving AI tool investment
• Aggregate usage across portfolio companies to identify negotiation leverage with Anthropic
• Optimise licensing tiers by matching actual usage patterns to enterprise pricing models
• Demonstrate ROI to stakeholders by linking Claude Code spend to engineering velocity gains

This guide walks you through building a cost telemetry system from scratch—and using that data to negotiate better enterprise terms.

---

Understanding Claude Code Costs at Scale

Before you can track Claude Code spend, you need to understand the cost structure. Anthropic’s pricing has shifted significantly, and the economics matter for portfolio-wide planning.

Claude Code Pricing Models

As of 2025, Anthropic offers three main tiers:

Claude Pro ($20/month per user) Designed for individual developers. Includes Claude 3.5 Sonnet with Claude Code and web search. Each user gets a monthly token budget. For a single engineer, this is cheap. For 50 engineers across your portfolio, it’s $12,000 per month—and you have no visibility into whether they’re actually using it.

Claude Max ($100/month per user, recently introduced) Higher token limits and priority access to Claude’s largest models. Aimed at power users and teams doing heavy AI-assisted development. The jump from Pro to Max is 5x the cost, but token budgets scale accordingly.

Enterprise Tiers (custom pricing) For portfolio companies or large engineering teams, Anthropic negotiates custom contracts based on monthly token consumption, seat count, and contract length. This is where cost telemetry becomes essential—you need data to justify the investment and negotiate volume discounts.

The Anthropic documentation on pricing breaks down token costs per model. Claude 3.5 Sonnet (the model powering Claude Code) costs roughly $3 per 1M input tokens and $15 per 1M output tokens. For a portfolio company shipping 10 features per sprint using Claude Code heavily, token consumption can easily hit 500M–1B tokens per month.

Why Telemetry Changes the Negotiation

Without telemetry, you’re negotiating blind. Anthropic’s sales team will quote you a price based on seat count and assumptions about usage. But if you walk into a negotiation with 12 months of actual usage data—showing that your portfolio companies consume 50B tokens per month, with clear per-company breakdowns—you have leverage.

Operating partners at firms like Accenture Song and Deloitte Digital use this exact playbook: instrument first, negotiate second.

---

Setting Up Per-Engineer Usage Dashboards

The foundation of cost telemetry is per-engineer visibility. You need to know which engineers are using Claude Code, how often, and for what.

Step 1: Instrument Claude Code with OpenTelemetry

OpenTelemetry is the open standard for collecting telemetry data across systems. It’s vendor-agnostic, battle-tested, and widely supported.

To track Claude Code usage, you’ll instrument the Claude API client in your engineering environments. Here’s the conceptual flow:

1. Capture API calls: Every time an engineer invokes Claude Code (or the underlying Claude API), log the request with metadata: engineer ID, repository, timestamp, tokens used (input and output), and model.
2. Attach context: Use OpenTelemetry’s baggage feature to attach engineer identity, team, and portfolio company to each span.
3. Export metrics: Send telemetry to a collector (e.g., OpenTelemetry Collector) and then to your observability backend.
4. Visualise: Build dashboards in D23.io or similar tools to aggregate and display usage patterns.

For teams using the Claude API directly, this is straightforward. You add OpenTelemetry instrumentation to your API client library and configure exporters.

For teams using Claude Code through the IDE (JetBrains, VS Code), you’ll need a proxy or sidecar process that intercepts API calls. Tools like LiteLLM can act as a proxy layer, logging all requests before forwarding them to Anthropic.

Step 2: Build Per-Engineer Dashboards in D23.io

D23.io (or similar observability platforms) lets you create custom dashboards that slice and dice telemetry data.

For per-engineer visibility, create a dashboard with these key metrics:

• Monthly token spend per engineer: A bar chart showing which engineers are consuming the most tokens. Quickly identify power users.
• Cost per engineer: Multiply token consumption by current pricing. Show which engineers are driving the highest spend.
• API call frequency: How many times per day does each engineer invoke Claude Code? High frequency might indicate heavy reliance; low frequency might suggest underutilisation.
• Average tokens per call: Some engineers might make many small calls; others make fewer, larger calls. This metric reveals usage patterns.
• Cost per line of code shipped: Advanced metric—correlate token spend with actual code output (commits, PRs merged, features shipped).

Example dashboard layout:

┌─────────────────────────────────────────────────────────┐
│ Claude Code Usage — Engineering Team Dashboard          │
├─────────────────────────────────────────────────────────┤
│ Period: Last 30 days | Total Spend: $8,432              │
├─────────────────────────────────────────────────────────┤
│ Top 10 Engineers by Token Consumption                    │
│ 1. Alice Chen       | 150M tokens | $2,250              │
│ 2. Bob Smith        | 120M tokens | $1,800              │
│ 3. Carol Davis      |  95M tokens | $1,425              │
│ ...                                                      │
├─────────────────────────────────────────────────────────┤
│ Cost per Engineer (Last 30 Days)                         │
│ [Bar chart showing cost distribution]                    │
├─────────────────────────────────────────────────────────┤
│ API Calls per Engineer (Daily Average)                   │
│ [Line chart showing usage trends]                        │
└─────────────────────────────────────────────────────────┘

This dashboard gives operating partners immediate visibility. If one engineer is spending $3,000 per month while others spend $200, that’s a signal to investigate—are they training? Are they less experienced and relying on Claude Code more? Are they shipping more value?

Step 3: Alert on Anomalies

Set up alerts for unusual patterns:

• Cost spike: If an engineer’s monthly spend jumps 50% month-over-month, alert the engineering lead.
• Idle usage: If an engineer hasn’t used Claude Code in 14 days but is still on a Pro subscription, flag for review.
• Portfolio-wide threshold: If total monthly spend across all engineers exceeds a budget, escalate to the CFO.

These alerts prevent runaway costs and surface opportunities for optimisation.

---

Building Cost Attribution by Repository

Per-engineer visibility is a start. But operating partners need to understand where Claude Code spend is actually landing—which repositories, which projects, which features.

Why Repository-Level Attribution Matters

Consider this scenario: Your portfolio company is building a new product. Engineering leadership claims it’s a strategic priority, but the budget is unclear. By attributing Claude Code spend to repositories, you can see:

• How many engineers are working on the project
• How heavily they’re using AI-assisted coding
• What the actual AI-assisted development cost is per feature
• Whether the project is over-investing in AI tooling or under-utilising it

This data informs resource allocation decisions and helps operating partners understand true project economics.

Implementing Repository-Level Tracking

When you instrument Claude Code, include repository metadata in each telemetry span. This might come from:

• Git context: The currently checked-out branch or repository name
• IDE context: The open project or workspace
• API headers: If using the Claude API directly, include a custom header like X-Repository: my-repo

Once you’re capturing repository data, build a second set of dashboards:

• Spend per repository: Which repos are consuming the most Claude Code tokens?
• Cost per feature: If you tag commits with feature IDs, correlate spend with shipped features.
• Repositories by team: Which team owns the highest-spend repositories?
• Cost trends: Is spend on a particular repo increasing or decreasing over time?

Example: Repository Cost Attribution

Imagine a portfolio company with three main repositories:

• api-core (backend services): 40% of Claude Code spend ($3,200/month)
• web-frontend (React app): 35% of Claude Code spend ($2,800/month)
• mobile-app (React Native): 25% of Claude Code spend ($2,000/month)

This breakdown reveals that backend development is the heaviest user of AI-assisted coding. Operating partners might ask:

• Are backend engineers less experienced, requiring more AI support?
• Is the backend architecture more complex, justifying higher AI usage?
• Should we invest in better code reviews or architecture documentation to reduce Claude Code dependency?
• Or is this the right level of investment, and we should standardise it across other portfolio companies?

Without telemetry, you’re guessing. With it, you’re making data-driven decisions.

---

Portfolio-Wide Visibility and Aggregation

For PE operating partners managing 10, 20, or 50 portfolio companies, the real value of cost telemetry emerges at the portfolio level.

Building a Master Dashboard

Create a top-level dashboard that aggregates Claude Code spend across all portfolio companies. Key metrics:

• Total monthly spend: Sum of all Claude Code costs across the portfolio.
• Spend per portfolio company: Which companies are investing most heavily in AI-assisted development?
• Cost per engineer (portfolio average): Benchmark across companies to identify outliers.
• Trend analysis: Is total spend growing or shrinking? At what rate?
• Cost per dollar of revenue: For portfolio companies with known revenue, calculate the efficiency metric—how much Claude Code spend is required to generate $1M in revenue?

Identifying Patterns and Opportunities

With portfolio-wide data, you can spot patterns:

Pattern 1: Underutilisation Some portfolio companies barely use Claude Code. This might mean:

• Engineers are unfamiliar with the tool
• The company’s tech stack isn’t compatible with Claude Code
• The engineering culture doesn’t embrace AI-assisted development

Operating partners can investigate and, if appropriate, invest in training or tool adoption.

Pattern 2: Over-reliance Other companies show very high Claude Code spend relative to team size. This might indicate:

• Heavy investment in shipping speed (which might be appropriate for a growth-stage company)
• Inexperienced engineering teams (which might signal a hiring need)
• Inefficient development practices (which might benefit from process improvement)

Pattern 3: Licensing inefficiency If most engineers are on Pro ($20/month) but actual token consumption suggests they’d benefit from Max ($100/month), you’re leaving money on the table. Conversely, if engineers on Max are underutilising their tokens, you’re overpaying.

Portfolio-wide telemetry surfaces these inefficiencies.

Aggregation Architecture

To aggregate data across portfolio companies, you need a centralised telemetry infrastructure:

1. Distributed collection: Each portfolio company’s engineering environment exports telemetry to a central collector.
2. Normalisation: Ensure consistent tagging (company ID, team, engineer ID) across all sources.
3. Centralised storage: Aggregate all telemetry into a single data warehouse or observability platform.
4. Unified dashboards: Build portfolio-level views on top of the aggregated data.

This architecture also supports security and compliance—you can audit Claude Code usage across the portfolio and ensure it aligns with data governance policies.

---

Using Telemetry Data to Negotiate Enterprise Tiers

Here’s where cost telemetry delivers immediate ROI: negotiating better rates with Anthropic.

The Negotiation Playbook

Month 1–3: Collect baseline data Instrument Claude Code across your portfolio. Let usage settle into normal patterns. Collect at least 3 months of data—enough to show trends and seasonal patterns.

Month 4: Analyse and prepare Pull together a comprehensive usage report:

• Total monthly token consumption across the portfolio
• Breakdown by portfolio company
• Breakdown by engineer and team
• Cost per company, per engineer, per feature
• Trends (is usage growing? At what rate?)
• Projected annual spend

For example:

Portfolio Claude Code Usage Report (Q4 2024)

Total Portfolio Consumption: 150B tokens/month
Projected Annual Spend: $2.7M (at current Pro/Max pricing)

Top 5 Portfolio Companies by Spend:
1. TechCorp (API platform)     | 45B tokens | $810K/year
2. DataViz (analytics SaaS)    | 35B tokens | $630K/year
3. FinServe (fintech)          | 30B tokens | $540K/year
4. RetailAI (e-commerce)       | 25B tokens | $450K/year
5. HealthTech (healthcare SaaS)| 15B tokens | $270K/year

Growth Rate: +15% month-over-month
Projected Q2 2025 Consumption: 200B tokens/month

Month 5: Reach out to Anthropic Contact Anthropic’s enterprise sales team with your usage data. Frame it as a partnership opportunity:

• You’re a significant customer (150B+ tokens/month)
• You’re growing (15% MoM)
• You’re managing a portfolio of companies, each with their own needs
• You want to consolidate on Claude Code but need enterprise pricing that reflects your scale

Month 6: Negotiate Anthropics’s standard enterprise playbook:

1. Confirm your usage data
2. Propose a monthly or annual contract with volume discounts
3. Discuss custom features or support needs
4. Negotiate per-token pricing or seat-based pricing

With 150B tokens/month, you’re likely to get 20–40% discounts off list pricing. With 200B+ tokens/month, you might negotiate 40–60% discounts.

What to Ask For

When negotiating, don’t just ask for price cuts. Use your telemetry data to request:

• Volume discounts: Lower per-token pricing based on monthly consumption
• Commitment discounts: Annual contracts with 3–6 month prepayment for additional discounts
• Custom models or fine-tuning: If your portfolio companies have domain-specific needs, negotiate access to custom model training
• Priority support: Enterprise-grade SLA and dedicated support contact
• Usage reporting: Direct API access to your usage data (not just dashboards)
• Custom billing: Invoicing that breaks down spend by portfolio company or team, so you can charge back accurately

Real-World Example

A Sydney-based PE firm managing 12 portfolio companies in SaaS and fintech negotiated the following:

• Before: 12 separate Pro subscriptions ($240/month) + scattered individual engineers on Max ($100/month each). Total estimated spend: ~$1,500/month (untracked).
• After: Enterprise tier with Anthropic at $0.015 per 1K tokens (vs. list price of $0.003 per 1K input tokens + $0.015 per 1K output tokens). Actual consumption: 50B tokens/month = $750/month.
• Savings: $750/month, or $9,000/year, with better visibility and support.

But the real win was the data: by tracking usage, the PE firm identified which portfolio companies were ready for AI-assisted development and which needed more investment in engineering fundamentals first.

---

Real-World Implementation: From Chaos to Control

Let’s walk through a real implementation story. This is based on patterns we see at PADISO, working with PE operating partners across Australia and Asia-Pacific.

The Starting Point

A PE firm acquired a portfolio of five B2B SaaS companies. Post-acquisition, the operating team discovered:

• Two companies had no Claude Code usage
• Two companies had engineers on Pro, but no central tracking
• One company had somehow negotiated a custom Anthropic contract (terms unknown)
• Total spend was estimated at $2,000–$3,000/month, but no one knew for sure
• No one understood whether Claude Code was delivering value

The CTO-as-a-service partner (PADISO) recommended a phased approach:

Phase 1: Baseline Instrumentation (Weeks 1–4)

Week 1: Audit current Claude Code usage

• Identify which engineers have Pro or Max subscriptions
• Check Anthropic invoices and contracts
• Understand current tech stacks and development workflows

Week 2–3: Instrument the first two portfolio companies

• Deploy OpenTelemetry collectors in their CI/CD pipelines
• Configure Claude API logging (for teams using the API directly)
• Set up a centralised observability backend

Week 4: Build initial dashboards

• Per-engineer usage and cost
• Repository-level attribution
• Daily trend charts

Phase 2: Expansion and Optimisation (Weeks 5–12)

Week 5–8: Roll out to remaining portfolio companies

• Repeat instrumentation across all five companies
• Normalise tagging and metadata across companies
• Aggregate data into portfolio-level dashboards

Week 9–10: Analyse usage patterns

• Identify which engineers are power users
• Spot underutilisation and over-reliance
• Calculate cost per feature shipped

Week 11–12: Optimise licensing

• Move high-consumption engineers from Pro to Max where it makes economic sense
• Consolidate individual subscriptions into portfolio-level contract
• Contact Anthropic with usage data

Phase 3: Negotiation and Execution (Weeks 13–16)

Week 13: Prepare negotiation package

• Compile 12 weeks of usage data
• Project annual spend and growth
• Identify value drivers (cost per feature, engineering velocity gains)

Week 14–15: Negotiate with Anthropic

• Present usage data and growth trajectory
• Request volume discounts and enterprise terms
• Agree on custom reporting and billing

Week 16: Implement new contract

• Update API keys and billing across portfolio companies
• Configure custom reporting
• Brief engineering teams on new terms

Results

After 16 weeks:

• Visibility: Operating partners had complete visibility into Claude Code spend across all five companies
• Cost control: Monthly spend was now tracked and budgeted (previously unknown)
• Optimisation: Licensing tiers were right-sized to actual usage
• Negotiation: Enterprise contract with Anthropic saved 30% on projected annual spend
• Value: Engineering teams were more intentional about Claude Code usage, leading to better code quality and faster shipping

Total investment (PADISO’s CTO-as-a-service engagement): ~$25,000 Annual savings from Anthropic negotiation: ~$35,000 ROI: 140% in year one, plus ongoing visibility and optimisation

---

Optimising Claude Code Spend Across Your Portfolio

Once you have telemetry, the real work begins: using the data to optimise spend and drive better outcomes.

Strategy 1: Right-Size Licensing Tiers

Not every engineer needs Max. Use telemetry to match licensing to actual needs:

• Baseline Pro: For engineers using Claude Code occasionally (< 10 calls/day)
• Upgrade to Max: For engineers using Claude Code heavily (> 30 calls/day) or working on complex features
• Custom seat: For teams with predictable, high consumption—negotiate custom pricing

Example optimisation:

Before: 50 engineers on Pro ($20/month each) = $1,000/month
After: 
  - 35 engineers on Pro = $700/month
  - 12 engineers on Max = $1,200/month
  - 3 engineers on custom seat = $300/month
  - Total: $2,200/month

But with enterprise discount (30% off):
  - Total: $1,540/month
  - Savings: $540/month vs. before + better right-sizing

Strategy 2: Invest in Training and Adoption

Telemetry reveals which teams are underutilising Claude Code. This is an opportunity, not a problem.

Investment in training—showing engineers how to use Claude Code effectively for their specific workflows—can drive adoption and, ultimately, engineering velocity gains.

For example, if a team of 10 backend engineers is barely using Claude Code, but telemetry shows that similar teams in other portfolio companies are 30% more productive with it, that’s a signal to invest in training or mentorship.

Strategy 3: Correlate Spend with Outcomes

The most sophisticated operating partners go beyond cost tracking—they correlate Claude Code spend with business outcomes.

Metrics to track:

• Cost per feature shipped: Total Claude Code spend / features shipped
• Cost per bug fixed: Total Claude Code spend / bugs fixed
• Engineering velocity: Features shipped per engineer per sprint, correlated with Claude Code usage
• Code quality: Defect rate or post-release bugs, correlated with Claude Code usage
• Time to market: Cycle time from feature request to production, correlated with Claude Code spend

If engineers using Claude Code heavily are shipping features 20% faster with no increase in defect rate, that’s a strong ROI signal. If they’re shipping faster but with higher defect rates, that’s a red flag—you might need code review improvements or training.

Strategy 4: Portfolio-Wide Best Practices

Use telemetry to identify and share best practices across portfolio companies.

Examples:

• High-performing team: Company A’s backend team is shipping 30% more features than Company B’s team, with similar Claude Code spend. What’s different? (Architecture? Code review process? Team experience?)
• Cost-efficient workflows: Which teams are getting the most value per token spent? Document their Claude Code usage patterns and share with other teams.
• Tool combinations: Some teams combine Claude Code with other tools (e.g., GitHub Copilot, local LLMs). Which combinations drive the best ROI?

Strategy 5: Capacity Planning

With 3–6 months of historical data and growth trends, you can forecast future Claude Code costs and plan accordingly.

Example:

Historical Data (Last 6 Months):
Jan: 80B tokens | Feb: 90B | Mar: 105B | Apr: 120B | May: 135B | Jun: 150B

Growth Rate: ~12% month-over-month

Projected Consumption:
Jul: 168B tokens
Aug: 188B tokens
Sep: 211B tokens
Q3 Total: ~567B tokens

At enterprise pricing ($0.015/1K tokens): ~$8,505 for Q3

With this forecast, you can budget accurately, plan for infrastructure changes, and proactively negotiate with Anthropic for the next contract period.

---

Compliance and Security in Cost Tracking

When you’re instrumenting Claude Code across a portfolio of companies, compliance and security matter.

Data Privacy

When you capture telemetry, you’re logging API calls—which might include:

• Engineer names and IDs
• Repository names and code snippets
• Prompts sent to Claude (which might contain sensitive information)

Best practices:

1. Anonymise engineer identities in shared dashboards (use engineer IDs instead of names)
2. Don’t log prompt content in central dashboards (log only metadata: tokens, model, timestamp)
3. Secure telemetry storage with encryption at rest and in transit
4. Limit access to telemetry data—only operating partners and relevant engineering leads should see cost data
5. Audit access: Log who accesses telemetry data and when

Regulatory Compliance

If your portfolio companies handle regulated data (healthcare, financial services, PII), ensure that Claude Code usage complies with relevant regulations:

• HIPAA (healthcare): Ensure Claude API calls don’t transmit patient data
• PCI DSS (payment cards): Ensure Claude Code isn’t used to write code handling card data
• GDPR (EU data): Ensure telemetry doesn’t log personal data

Document these controls and include them in your compliance audit (SOC 2, ISO 27001, etc.).

Security of Telemetry Infrastructure

Your telemetry system is a potential attack surface. Secure it:

1. Authentication: Require API keys or OAuth for telemetry exports
2. Encryption: Use TLS for all telemetry transmission
3. Access control: Implement role-based access to dashboards
4. Audit logging: Log all telemetry access and modifications
5. Data retention: Set a retention policy (e.g., delete raw telemetry after 12 months)

If your portfolio companies pursue SOC 2 compliance or ISO 27001 compliance, telemetry controls should be documented as part of your information security program.

---

Connecting Cost Telemetry to Broader AI Strategy

Cost telemetry for Claude Code is one piece of a larger puzzle. To maximise ROI, connect it to your broader AI strategy.

AI Strategy and Readiness

Before investing heavily in Claude Code across your portfolio, ensure your portfolio companies are ready. This includes:

• Engineering maturity: Do teams have strong fundamentals (code review, testing, CI/CD)?
• Data readiness: Do teams have clean data and robust data pipelines?
• Security posture: Can teams safely use external AI tools without exposing sensitive data?

Reading AI Strategy & Readiness guides can help you assess portfolio companies and identify which are ready for aggressive Claude Code investment and which need foundational work first.

Agentic AI and Automation

Claude Code is powerful for individual developers, but the next frontier is agentic AI—autonomous agents that can handle entire workflows. Understanding the difference between agentic AI and traditional automation helps you make smarter investment decisions.

For example, if a portfolio company is spending heavily on Claude Code for repetitive tasks (code generation, refactoring), it might be more cost-effective to invest in agentic workflows that run autonomously.

Platform Engineering and Custom Solutions

Some portfolio companies might benefit from custom AI solutions beyond Claude Code—fine-tuned models, domain-specific agents, or integrated AI platforms. Cost telemetry for Claude Code provides a baseline; custom solutions might offer better ROI for specific use cases.

For portfolio companies pursuing platform engineering initiatives, integrating Claude Code (and broader AI tooling) into the platform can amplify its value across teams.

---

Practical Implementation: Building Your First Dashboard

Ready to start? Here’s a step-by-step guide to building your first cost telemetry dashboard.

Step 1: Choose Your Observability Platform

Options:

• D23.io: Purpose-built for AI cost tracking, with Claude Code templates
• Datadog: General observability, strong support for OpenTelemetry
• New Relic: Similar to Datadog, good for distributed systems
• Self-hosted: ELK Stack (Elasticsearch, Logstash, Kibana) or Prometheus + Grafana

For a PE portfolio, D23.io is a good starting point—it’s designed for this exact use case.

Step 2: Instrument Your First Engineering Team

Start small. Pick one portfolio company and one engineering team (5–10 engineers).

1. Install OpenTelemetry SDK in your development environment
2. Configure Claude API logging to capture calls
3. Set up exporter to send telemetry to your observability platform
4. Test with a few engineers (1–2 weeks)
5. Refine based on feedback
6. Roll out to full team

Step 3: Build Initial Dashboards

Start with these three dashboards:

Dashboard 1: Team Overview

• Total monthly spend
• Spend by engineer
• Cost per day (trending)
• Total tokens consumed

Dashboard 2: Engineer Drill-Down

• Spend per engineer
• Calls per engineer
• Average tokens per call
• Top repositories by engineer

Dashboard 3: Repository View

• Spend per repository
• Calls per repository
• Trending (increasing or decreasing)

Step 4: Expand to Full Portfolio

Once the first team is stable (2–4 weeks), expand:

1. Replicate to other teams in the same company
2. Add portfolio company #2
3. Aggregate into portfolio dashboards
4. Set up alerts for cost anomalies

Step 5: Analyse and Optimise

After 4–6 weeks of data:

1. Identify patterns: Which engineers, teams, and companies are high-spend?
2. Correlate with outcomes: Are high-spend teams shipping more or faster?
3. Right-size licensing: Move engineers to appropriate tiers
4. Prepare negotiation: Compile data for Anthropic discussion

---

Measuring ROI of Your Cost Telemetry Investment

You’re investing time and money to build cost telemetry. What’s the ROI?

Direct Savings

1. Licensing optimisation: Right-sizing tiers saves 10–20% on software costs
2. Enterprise negotiation: Volume discounts with Anthropic save 20–40% on projected spend
3. Waste elimination: Identifying unused subscriptions and cancelling them

Indirect Gains

1. Engineering velocity: Better visibility into which tools drive productivity, enabling targeted investment
2. Decision quality: Data-driven decisions on AI adoption, training, and tool selection
3. Risk reduction: Early detection of runaway costs or security issues
4. Compliance: Documentation of AI tool usage for audits (SOC 2, ISO 27001)

How to Calculate Total ROI

Investment:
- Setup and instrumentation: $15,000–$30,000
- Ongoing platform and support: $2,000–$5,000/month

Returns (Year 1):
- Licensing optimisation: $20,000–$40,000
- Enterprise negotiation savings: $50,000–$150,000
- Engineering velocity gains (estimated): $100,000–$300,000

Total Year 1 ROI: 200–600%

For a PE portfolio with $500K–$2M annual Claude Code spend, cost telemetry typically pays for itself in 2–4 months.

---

Next Steps and Quick Wins

Ready to implement cost telemetry for Claude Code across your portfolio? Here’s your action plan.

Week 1: Assessment

1. Audit current Claude Code usage: Which engineers and companies are using it? What’s the current spend?
2. Identify quick wins: Any unused subscriptions to cancel? Any obvious licensing mismatches?
3. Choose observability platform: D23.io, Datadog, or self-hosted?
4. Assign owner: Who will lead the telemetry initiative? (CTO, engineering manager, or external partner)

Week 2–4: Pilot

1. Instrument one team: Start with your largest or most active engineering team
2. Build dashboards: Create the three core dashboards (team overview, engineer drill-down, repository view)
3. Collect baseline data: Let it run for 2–4 weeks to establish normal patterns
4. Gather feedback: Ask engineers and managers what additional metrics they need

Week 5–8: Expansion

1. Roll out to full company: Expand from pilot team to all teams
2. Add remaining portfolio companies: Repeat instrumentation across your portfolio
3. Aggregate data: Build portfolio-level dashboards
4. Set up alerts: Configure cost anomaly detection

Week 9–12: Analysis and Optimisation

1. Analyse usage patterns: Identify power users, underutilised teams, high-spend repositories
2. Correlate with outcomes: Link Claude Code spend to engineering velocity, code quality, or business outcomes
3. Right-size licensing: Move engineers to appropriate tiers
4. Document findings: Prepare a report for operating partners and engineering leadership

Week 13–16: Negotiation

1. Compile usage data: Prepare a comprehensive usage report for Anthropic
2. Reach out to Anthropic: Contact their enterprise sales team with your data
3. Negotiate terms: Discuss volume discounts, custom features, or support enhancements
4. Implement new contract: Update API keys, billing, and reporting across portfolio companies

Quick Wins (Do These First)

1. Cancel unused subscriptions: If any engineers haven’t used Claude Code in 30 days, cancel their Pro subscription (save $20/month per engineer)
2. Consolidate billing: If multiple portfolio companies have individual Anthropic contracts, consolidate into one portfolio-level contract (simplify administration, improve negotiation leverage)
3. Audit current spend: Pull together all invoices and subscriptions to understand baseline spend (might reveal surprises)
4. Set up basic tracking: Even before full instrumentation, start logging Claude Code API calls in your CI/CD pipeline (free, instant visibility)

When to Bring in External Help

If your operating team lacks the technical expertise to implement cost telemetry, consider engaging a partner. Look for:

• Venture studio and co-build expertise: Partners who understand portfolio company dynamics
• AI and automation experience: Teams who’ve implemented similar telemetry across multiple companies
• CTO-as-a-service capability: Fractional CTO support for ongoing optimisation

Partners like PADISO—a Sydney-based venture studio and AI digital agency—can help you set up cost telemetry, optimise spend, and negotiate with Anthropic. They work with PE operating partners across Australia and Asia-Pacific.

---

Conclusion: From Chaos to Control to Competitive Advantage

Cost telemetry for Claude Code isn’t just about tracking spend. It’s about building visibility, making data-driven decisions, and unlocking value across your portfolio.

Here’s what you’ve learned:

1. Why it matters: Without telemetry, you’re flying blind on AI tool costs and usage patterns
2. How to build it: Instrument with OpenTelemetry, visualise with D23.io, aggregate across portfolio companies
3. How to use it: Right-size licensing, identify opportunities, correlate spend with outcomes
4. How to negotiate: Use data to secure volume discounts with Anthropic
5. How to optimise: Invest in training, share best practices, plan capacity

The firms that win in the AI era won’t be those spending the most on AI tools. They’ll be the ones who spend intentionally, measure relentlessly, and optimise continuously.

Start small. Pick one portfolio company and one team. Instrument Claude Code. Build dashboards. Collect data. Analyse. Optimise. Then scale.

By month four, you’ll have the data to negotiate better terms with Anthropic. By month six, you’ll have insights to drive engineering velocity gains. By month twelve, cost telemetry will be a standard part of your portfolio company playbook.

The investment is small. The returns are large. Let’s get started.