Claude Cowork for FinOps Practitioners

What is Claude Cowork?

Claude Cowork is the practice of using Claude as a persistent, context-aware co-worker embedded in your FinOps workflow. This is not about asking a general AI "how do I save money on OpenAI." It is about configuring Claude with your org structure, your vendor list, and your allocation rules so it produces structured spend work — normalized inventories, showback tables, cost-per-successful-task analyses, executive reports — that you can actually take into a finance review.

Claude-native prompts. The prompts in this guide use Claude's native XML tag structure (<context>, <instructions>, <format>, <avoid>) for more precise, consistent output. These tags help Claude parse your intent with less ambiguity. They work in ChatGPT too, but are optimized for Claude.

AI spend has outgrown the tooling. Cloud FinOps platforms see your cloud bill but not your ChatGPT Business seats; expense systems see the subscriptions but not the API burn; nobody sees the credits quietly expiring. Most practitioners are reconciling this in a spreadsheet. Claude, configured correctly, compresses the reconciliation, allocation, and reporting work — with your judgment driving every number that reaches a stakeholder.

This guide walks you through configuring Claude for AI spend work, the five workflows that compress the most time, and the accuracy guardrails that keep working estimates from being mistaken for accounting records.

Install the FinOps Practitioner Plugin

This guide works on three Claude surfaces. The plugin is the fastest path on two of them. Pick whichever you use:

If you're on Cowork (desktop or mobile app)

Claude Cowork is Anthropic's agentic workspace — Claude completes work autonomously and returns finished deliverables. The FinOps Practitioner plugin packages the workflows below as native skills and slash commands.

1. Open the Cowork plugin directory in your desktop app.
2. Filter by Cowork, search for "FinOps Practitioner", and click Install.
3. The plugin's slash commands and ambient skills are now available in any Cowork task.

If you don't see the plugin in the directory yet, install via custom marketplace: paste https://github.com/alexclowe/awesome-claude-cowork-plugins in your Cowork plugin settings.

If you're on Claude Code (CLI)

Install from your terminal:

claude plugin add alexclowe/awesome-claude-cowork-plugins/finops-practitioner

The plugin's slash commands and skills load on next session.

If you're on Claude.ai (web chat only)

Plugins aren't directly installable on the web chat surface. You have two options:

1. Use the prompts in this guide directly in a Claude Project (covered in the next section). Same outputs, more typing.
2. Upload the plugin's skills as a zip via Settings → Features → Custom Skills (Pro/Max/Team/Enterprise plans). Higher friction; only worth it if you want the auto-activating skills, not the slash commands.

What the plugin gives you (any surface)

Slash command	What it does
/ai-spend-inventory	Consolidate AI subscriptions, API usage, credits, and embedded AI into one normalized spend inventory with owners, renewal dates, and flags
/allocate-ai-costs	Turn consolidated AI bills into a team-level showback or chargeback allocation with explicit rules and an unallocated remainder
/cost-per-task	Compute cost-per-successful-task unit economics from usage and cost data, including retries, failures, and quality thresholds
/ai-spend-report	Draft an executive-ready monthly AI spend report — headline, drivers, per-team view, anomalies, and decisions needed
/vendor-renewal-brief	Build a renewal negotiation brief for an AI vendor — utilization evidence, consolidation options, ask list, and walk-away position

It also ships two ambient skills:

• AI Billing Models — fluency across seat, usage, credit, reserved-capacity, hybrid, and embedded-AI billing, with normalization rules and contract mechanics
• AI Unit Economics — the cost-per-successful-task discipline: honest numerators, quality-bar denominators, and the counterfactual

The plugin works standalone for one-off tasks. Pair it with the surface-specific setup below for persistent context across every task — that combination is the full Claude Cowork setup.

Setting Up Claude for FinOps Work

Surface note: The Project setup below is for claude.ai web users. Cowork users have their own task-context mechanism (set context once when starting a Cowork task). Claude Code users get the plugin's ambient skills automatically — no Project setup needed. The workflows themselves are surface-agnostic — paste the prompts wherever you're working.

The key to consistent output is using Claude Projects. A Project stores your org structure, vendor list, and allocation conventions across every conversation.

Step 1: Create an AI Spend Project. In Claude, click "Projects" and create one called "AI Spend — [Company]."

Step 2: Set your custom instructions. In the Project settings, add:

You are my AI-spend (FinOps) assistant. Here is my context:

<practitioner-profile>
- Role: [FinOps practitioner / Platform lead / Finance business partner]
- Organization: [size, industry, rough engineering headcount]
- Teams / cost centers: [list them — these are the allocation targets]
- Known AI vendors: [list every subscription, API, and credit pool you know of]
- Reporting cadence: [monthly / quarterly] to [CFO / CTO / leadership]
- Allocation stance: [showback only / working toward chargeback]
</practitioner-profile>

<rules>
- All figures you produce are working estimates for cost visibility, never accounting records — accounting treatment belongs to the controller
- Use only the numbers I provide; mark every estimate or gap with [Confirm: ...] rather than inventing a figure
- Normalize everything to monthly run rate and state the normalization (annual ÷ 12, credit burn rate) each time
- Cost-per-token is never the answer — push every value conversation to cost per successful task at a stated quality bar
- Contract questions (auto-renewal, termination, data terms) get flagged for procurement/legal, not answered as advice
</rules>

Step 3: Upload your spend baseline. Add your latest consolidated AI spend export, subscription list, or the output of your first /ai-spend-inventory run to the Project knowledge base.

Step 4: Add your org chart or team roster. Team names and headcounts are what turn a bill into an allocation — load them once so every conversation can allocate without re-asking.

Step 5: Always work inside this Project. Every new conversation inherits your vendor list and allocation conventions automatically.

Five High-Leverage Workflows

1. The AI Spend Inventory

Every FinOps-for-AI program starts the same way: nobody knows what the org actually pays for AI. Subscriptions, API keys, credit pools, and AI features embedded in existing tools bill in four different shapes across a dozen invoices. Claude does the consolidation and normalization; you confirm the numbers.

<context>
Here is everything I currently know about our AI spend, in no particular
order: [paste invoice lines, subscription notes, expense extracts, and
half-remembered facts — "someone in design pays for Midjourney"]
</context>

<instructions>
Build a normalized AI spend inventory. One row per spend line: vendor,
billing model (seat / usage / credits / reserved / embedded), estimated
monthly cost with the normalization shown, owning team, named owner or
UNKNOWN, renewal date if known, and flags (idle seats, overlap, expiring
credits, auto-renewal inside 60 days). Then list findings: unowned spend,
overlap candidates, renewal radar. End with the 3-5 highest-leverage
next steps ordered by money at stake.
</instructions>

<avoid>
Inventing prices or seat counts. If you reference typical published
pricing, label it [typical published pricing — verify against invoice].
</avoid>

The first run always surfaces the same two findings: spend with no owner, and tools that overlap. Both are worth more than any optimization you'll do later.

2. Team Allocation and Showback

A consolidated bill nobody owns is a bill nobody reduces. This workflow turns the inventory into a per-team view — with allocation rules stated explicitly enough to defend in a finance review.

<context>
Consolidated AI spend for [month]: [paste the inventory or bill].
Teams and headcounts: [paste roster]. Shared resources: [which API keys,
credit pools, or platform subscriptions serve multiple teams].
</context>

<instructions>
Classify each spend line as direct, shared, or platform. Propose an
allocation rule per shared line (seats, usage, headcount, or even split)
with a one-sentence rationale and what better telemetry would unlock a
fairer rule. Produce the showback table by team. Isolate the unallocated
remainder with exactly what data would allocate it. Close with a
chargeback-readiness assessment: what has to improve before this could
be billed internally.
</instructions>

<format>
Allocation model table, showback table, unallocated remainder,
chargeback readiness — in that order.
</format>

Run it as showback for at least two cycles before anyone proposes chargeback. Billing teams on rules they haven't seen destroys the program's credibility.

3. Cost per Successful Task

Token dashboards answer "what are we spending" but never "is it worth it." This workflow computes the number that decides scale-up-or-kill conversations: what one successful outcome costs.

<context>
Workflow: [what it does — e.g., support-ticket summarization].
Last month: [requests, total model cost, retry rate if known, eval/guardrail
overhead if known, any subscription or reserved capacity it rides on].
A successful task is: [your definition — or say "propose definitions"].
</context>

<instructions>
Compute cost per successful task. Numerator: model calls including retries
and failures, eval overhead, and the amortized share of fixed capacity.
Denominator: only outcomes meeting the quality bar. Show cost per attempted
task alongside. Identify the one or two inputs the number is most sensitive
to, then rank the 2-3 levers that would most improve it — flagging any
lever that trades quality for cost.
</instructions>

<avoid>
Presenting cost-per-token or cost-per-request as the deliverable. If retry
or failure data is missing, label the result a floor, not the number.
</avoid>

Pair the output with a counterfactual — what the task cost before AI — and you have the only spend justification a CFO actually wants.

4. The Monthly AI Spend Report

The report is where the program becomes visible. The failure mode is a data dump; the fix is a document a CFO, CTO, and team leads can absorb in five minutes, ending in decisions rather than awareness.

<context>
This month's AI spend: [totals, per-team or per-vendor breakdown].
Last month for comparison: [same]. Notable events: [rollouts, migrations,
spikes, renewals closed].
</context>

<instructions>
Draft the monthly AI spend report: headline (total, delta, one-sentence
cause); the 2-4 drivers behind the delta with numbers; the per-team table;
watch items (anomalies, unowned spend, credit burn, renewal exposure) each
with a status; and a numbered decisions-needed list with owner and
needed-by date. Close with a one-line method note on inclusions and
estimates.
</instructions>

<avoid>
Judging spend up or down as inherently good or bad — tie judgments to
outcomes or unit economics if provided, otherwise write "value not yet
measured."
</avoid>

5. The Vendor Renewal Brief

Renewals are where visibility converts to money. Utilization evidence — seats bought versus seats active, credits bought versus burned — is the strongest card you hold, and the one most orgs walk in without.

<context>
Vendor: [name, plan, price, renewal date, notice window].
Utilization: [seats active vs. purchased, credit burn, tier features used].
Alternatives in play: [overlapping tools, migration appetite].
</context>

<instructions>
Build the renewal negotiation brief: position summary with the single
strongest fact; utilization-evidence table (bought / used / gap / monthly
waste); options table (renew, downgrade, right-size, consolidate, switch)
with money impact and honest risk; an ask list ordered most-winnable
first, each backed by a utilization fact; and the walk-away position with
the preconditions that make it credible. End with prep gaps to gather
before the call.
</instructions>

<avoid>
Invented list prices or "typical discount" figures. Overplaying leverage —
deep workflow dependence is weak leverage and the brief should say so.
</avoid>

Flag the contract mechanics (auto-renewal clause, true-down rights, credit rollover) for procurement before the call — the brief informs the negotiation; it isn't contract advice.

What This Looks Like in Your Week

• Monday: Paste the weekend's billing exports into /ai-spend-inventory — ten minutes to an updated baseline instead of an hour of spreadsheet reconciliation
• When the bill lands: /allocate-ai-costs turns it into the showback table before anyone asks "who spent that"
• Before the platform review: /cost-per-task on the one workflow everyone argues about, with the quality bar written down
• Month-end: /ai-spend-report drafts the stakeholder report; you edit the narrative, not the arithmetic
• 60 days before any renewal: /vendor-renewal-brief — the notice window is the real deadline, not the renewal date

What to Avoid

• Presenting working estimates as accounting records. Normalized run rates are for visibility and decisions; amortization and capitalization are the controller's calls. Keep the two vocabularies separate in every document
• Optimizing cost before defining success. A cheaper model that fails the quality bar is a regression wearing a trend line. Unit definition comes first, always
• Chargeback before showback. Two clean showback cycles minimum — teams must trust the rules before the rules bill them
• Letting Claude fill data gaps. The plugin's rails mark gaps with [Confirm: …]; if you see a number you didn't provide and can't trace, treat it as wrong until verified
• Tracking only the obvious spend. Embedded AI features and cloud inference are the lines every first inventory misses — ask about them explicitly

Resources

• The FinOps Practitioner plugin — the five commands and two skills from this guide, installable in one step
• AI Spend Intelligence hub — the full editorial library: what to track beyond tokens, allocation templates, vendor playbooks for Copilot, Claude Enterprise, and ChatGPT Enterprise
• What Is FinOps for AI? — the operating model this plugin implements
• Cost per successful AI task — the unit-economics method behind /cost-per-task
• FinOps Practitioner profession hub — free tools, guides, and the AI readiness audit