How to use Claude For Finance Better Than 99% of People

In this video, I'm going to show you exactly how to use Claude for finance better than 99% of people by teaching you nine high-level tips that turn generic Claude outputs into high-level finance work. I'm a quant and finance automation developer and I've spent several years building these systems and made it my goal to help finance experts like you to work more efficiently with AI.

Now the main concern people have with Claude is that the outputs may feel inconsistent, but with the right prompts and the right structure we can train it to work extremely efficiently. So today I'm going to walk you through nine stages that will help you master Claude for your finance work so that you can move from unstructured prompts and fragile outputs to controlled, auditable, and boardroom-ready financial workflows that hold up in the real FP&A world. If you want to get all the prompts, the frameworks, and the implementation templates that I'll use, you can join my free community with the link in the description below.

Okay. So, in stage one, I'm going to explain to you why it's important to do proper source collection. Because if the inputs aren't verified, nothing we do later is going to be reliable. So, this stage ensures that every number you use later is verifiable.

Now, in real finance work, the biggest modeling errors really come from formulas. They usually come from inputs that were never properly examined or mislabeled period, column, or it could also be from half-filled product tables or a covenant buried in narrative text that was never translated into numbers or could be something as simple as a revenue total that doesn't add up to the product detail. So these issues don't immediately break the model. That's why you don't notice them instantly. Most teams discover these structural weaknesses only after the model has already been built when fixing them is costly and your credibility is already on the line.

So this is precisely why we need to verify if the information we're giving AI holds up in real life. And the way we do this is pretty simple. We want Claude to create a complete, documented inventory of the workbook so that nothing remains implicit. Basically, this means that every sheet must be accounted for. Every modeling critical column must be either present or clearly flagged. Missing data must be visible early. And most importantly, any assumptions must be eliminated before they become part of the projections.

Now here's how we do this. The first step is to establish a protected baseline by saving an untouched version of the workbook before ingestion begins. The second step is to open the Claude add-in and select the Opus 4.5 model. Ingestion is a structural reasoning task. Now lastly, you run the ingestion prompt. You're not really looking for insights at this stage. You're training the AI to do inventory before anything else.

Now, this prompt works because it forces Claude to inventory and validate every sheet, every field, and every structural dependency before analysis begins. And that eliminates hidden assumptions at the source. Now, most people upload a workbook and immediately request insights. They assume sheet names reflect content accuracy. And they trust totals without checking the underlying labels. They ignore blanks because the model can handle it. Or worse, they let the AI figure it out. But the result then is unpredictable, plausible outputs built on unstable inputs. That's the worst-case scenario.

So, when the prompt runs correctly, we want to look for a few things. The screen should display a structured table that includes every sheet and make sure you're calling out all the missing fields. Now, each sheet should have a confident score and three clear next actions should be recommended to complete ingestion. Anything less is incomplete. Before trusting the output, I confirm that all sheets appear. I need to see if the required modeling fields, period, revenue, COGS, SGA, capex, debt, cash, and product units and price are accounted for or flagged. If any of those conditions fail, then ingestion is incomplete. There's a possibility that Claude may seem overly optimistic and that marked sheets may be marked as model-ready too quickly. So this is where you need to remain skeptical. If required inputs are missing, you have three options. You could generate synthetic inputs, manually add data, or accept placeholders for prototyping. Now, whichever path you choose, ingestion must be rerun to confirm structural completeness. Now that we've achieved our desired outcome, we can move on to stage two.

Okay. Okay. So, in stage two, I'm going to explain to you why persona configuration and calibration matter. Because if Claude isn't locked into a professional finance role, everything we build afterward becomes unreliable.

Now, look, while I agree that AI is an incredibly useful tool, especially for finance professionals, it can quickly become unstable very fast. So it might use casual language, might hide calculation steps, or return numbers with no clear structure. Now the stakes are very high here. If the persona isn't properly locked in, then future models and executive slides can seem polished, but then it's not really applicable in the real world.

Now, this is precisely why we need to transform Claude from a generic chatbot into a repeatable, auditable CFO and FP&A analyst persona operating within Excel. Every response must consistently use finance terminology. It must cite exact sheets and columns. It must show step-by-step calculation logic. It has to flag data quality issues before analysis, and has to frame recommendations with clear tradeoffs and risks. This isn't about efficiency, but what we can't afford is the wrong output.

So, here's how we do this. The first step is to open the Claude add-in in Excel and set the model to Opus 4.5. Now, persona calibration is a reasoning task and this model balances capability with stability, making it ideal for configuration. The second step is to paste the exact persona prompt and require Claude to explicitly confirm acceptance of the rules. It must include three demonstration examples, a step-by-step financial calculation, a model audit comment, and a concise executive summary that includes risk implications. And lastly, you review the responses carefully.

Now, at this stage, Claude's job is calibration only. It's not supposed to edit sheets just yet. You're training Claude and checking if it can behave like an analyst before you get into more technical modeling.

Now, the thing is most teams skip this. They dive straight into modeling. They accept conversational answers. They trust default tones, or casually they tell Claude to act like an analyst but without any strict rules. Some even allow sheet edits before calibration. Now it feels faster, but unguarded outputs quietly break down further down the line and they break downstream models. And when the configuration runs correctly, then look for these things. Claude should confirm rule acceptance. The demonstration calculation must show clear logic and reference actual sheets and columns. The audit comment should read like a real FP&A review. Now, the executive summary must be concise. It has to be professional and it has to be risk-aware. Anything less is incomplete. Before trusting the setup, confirm that citations are present, that calculations are shown before conclusions, and that recommendations include trade-offs and that no edits were attempted. If any of those conditions fail, then calibration is incomplete. There's a possibility that Claude may appear compliant while drifting into conversational tone or maybe skipping citations. And this is where you have to remain skeptical because these minor issues will add up. If demonstration examples fall short, reinforce the rules and rerun calibration. Do not proceed until analyst-level behavior is consistent. Now that we've locked in professional standards, we can move into stage three.

Okay, so in stage three, I'm going to explain to you why plan-first prompting is non-negotiable. Because if Claude starts making fixes before you approve a plan, hidden assumptions quietly turn into formulas. Now, once that happens, audit trails weaken and credibility drops instantly.

Stage three requires Claude to act like a senior FP&A lead, not like an operator. It must produce a detailed, step-by-step work plan for your approval before any modeling or any edits are made.

Now, in real-world finance, uncontrolled changes are very dangerous. Many teams allow logic to unfold incrementally, accepting fixes as they appear. At first, it feels productive, but over time, ad hoc edits compound, assumptions go undocumented, and then accountability disappears. By the time someone asks how a number was derived, there's no structured explanation, only a trail of scattered adjustments. And this is precisely why we design the work plan before touching the model.

The objective here is to generate a prioritized, auditable plan, ideally between six and 12 steps that converts the workbook into a driver-based three-statement model plus a DCF. Now, each step must clearly define the objective, the sheets involved, the required inputs with precise columns or cells, the outputs produced, explicit acceptance checks, and a "do not proceed if" gate. No formulas, no fixes, no execution, just the plan. This ensures that every step afterward is controlled, auditable, and defensible.

Now, here's how we do this. The first step is to open the Claude add-in and select the Opus 4.5 model. Do not use autobuild or transformation buttons. Planning is a reasoning task and you need to have stability before execution. The second step is to paste the plan-first prompt verbatim into the chat. Claude must design a structured, numbered list of six to 12 steps ordered by risk and impact. Now, each step must describe the objective, the sheets, inputs, outputs, acceptance checks, and clear "do not proceed" warnings. Lastly, you review the output carefully. At this stage, Claude does not include formulas or make edits. Its role is planning only. Your role is to refine any vague steps to enforce clarity and approve the plan only when it's complete. Once approved, then copy the finalized plan into a new sheet titled "Stage Checklist." This becomes your formal governance artifact.

Now, most teams skip this step. They begin fixing immediately. They accept inconsistent plans and they ask Claude to build the model in one step, or they'll settle for a short checklist like "clean data, build model." Now it feels faster. I get it. But shortcuts eliminate risk control and they remove all accountability.

When the prompt runs correctly, then you need to look for these things. The plan should be numbered and logically ordered. Each step must clearly state objectives, inputs, outputs, acceptance checks, and a "do not proceed" gate. There should be no formulas and no execution language. Anything less is incomplete. Before approving the plan, confirm that every step is auditable and tied to a specific sheet and input. Ensure risks are addressed early in the sequence. If any step feels vague or it lacks acceptance criteria, then it requires refinement. There's always a chance that Claude may sneak in execution logic or implied fixes. And this is where you have to remain vigilant. If the plan is incomplete, reinforce the constraints and then rerun the prompt. Do not proceed until the work plan is structured, prioritized, and defensible. Now that we have a controlled roadmap in place, we can move into stage four.

Okay. So in stage four, I'm going to explain to you why scope control and data filtering matter. And it's because financial workbooks often contain dozens of sheets. They have legacy tabs, helper tables, things like that. And if Claude is allowed to see everything, then it can draw from the wrong context. It can hallucinate joins. It can mix unrelated data and eventually it will compromise the model's integrity.

Now, without scope control, there's a very strong chance that you'll get overanalysis, or context confusion, or ad hoc sheet usage, and maybe structural failures. And at this stage, we're making Claude more particular to our requirements. So in everyday finance work, if the data isn't fully transparent, it can lead to uncertainty. Sometimes data slips through or mismatches are fixed without explanation, which then makes it hard to track what actually happened. So these problems may not be obvious right away, but once someone questions the record-keeping, then you're going to be left totally confused.

Now, most teams only realize there's an issue after reconciliation problems arise or when they can't confidently justify their numbers. This is precisely why we must produce a clean, modeling-ready data set before anything else. The objective here is simple: create a structured input history table and a transparent mapping log. All mismatches must be documented, not autofixed. You must be able to trace from source to output without and you need to specify no modeling and no assumptions. Now, this stage focuses strictly on controlled inputs and structural integrity.

Now, here's how we do this. The first step is to open the Claude add-in and select Opus 4.5. Stay in normal chat mode and do not use auto-build buttons. The second stage is to paste the stage 4 prompt exactly. Claude must create `input_history` using only historical financials, `revenue_by_products`, and `drivers`. It extracts specified columns, validates revenue sums, flags mismatches, quantifies differences, and builds a mapping log. It does not fix issues or generate formulas at this stage. Lastly, you review the output tables carefully, check reconciliation results, and confirm that all mismatches are documented. Only after review can structural cleanup begin. So, following the stage checklist priorities.

Now, most teams fumble here. They let Claude scan the entire workbook freely. They accept blended data from multiple sheets. They enable silent reconciliations, or they fix mismatches without logging. Now, others manually copy columns or skip mapping documentation. But it might feel faster, but it completely destroys traceability.

Now, when the prompt runs correctly, look for these things. You should see a clean input history table, a clearly structured mapping log, and quantified reconciliation differences. No formulas should be applied. No mismatches should be corrected without reason. Now, before proceeding, don't forget to confirm that only approved sheets were used, mismatches are visible, totals reconcile, and no assumptions were introduced. If any of those conditions fail, scope control is incomplete. There's always a possibility that Claude may attempt to reconcile without your knowledge or draw from additional context. But this is where you remain vigilant. If discrepancies appear, then you have to review them and escalate if needed and then rerun the extraction until traceability makes sense. Now that we've secured clean, controlled inputs, we can move into stage five.

Okay, so in stage five, I'm going to explain to you why the foundation of the three-statement model must be formula-driven and auditable. Because if the model is built with hard-coded numbers or hidden logic or missing links, everything downstream like scenarios, valuation, and board reporting becomes non-auditable. Every formula, every link, and every audit check must be established before considering valuation or sensitivity analysis.

In finance, models often look polished on the surface, but they fail under questioning. Teams sometimes paste numbers instead of formulas, or they superficially link net income without flowing it properly to equity or cash flow, or they skip formal audit checks. The results appear complete, but they aren't trustworthy. And trust me, those weaknesses usually surface at the worst possible time. It's just the way it goes.

Now, this is precisely why we have to construct a driver-based, formula-first three-statement model using input history as the historical base. We create new sheets for the income statement, balance sheet, and cash flow, and each statement must be fully linked and auditable. An audit sheet must verify that statements reconcile correctly, and Claude must return a complete, machine-readable list of added formulas. At this stage, there is no valuation, no scenarios, no sensitivities, and no slides. The foundation must be solid before analytical layers can be added.

Now, here's how we do this. The first step is to use Opus 4.6 and the "Build Financial Models" button exactly as instructed. So, paste the prompts verbatim. The second step is to ensure that Claude creates new sheets like IS, BS, CF, and Audit using only formulas. Now, revenue must be separated into price multiplied by volume where product data exists. Fixed and variable costs should be distinguished where reasonable. Lastly, review the outputs carefully. Confirm that formulas exist in forecast calls and are not hard-coded numbers. Run "Debug My Formulas." Review the audit sheet and examine the return formula list. The audit must pass before moving forward.

Usually at this stage, most teams take shortcuts. They paste totals. They build valuations prematurely, or they ignore reconciliation checks, or they skip the audit sheet entirely. Uh, may seem and look efficient, but it eliminates defensibility. When executed correctly, you got to look for these things. Revenue is calculated as price times volume. Net income flows correctly to equity and cash flow. A balanced balance sheet and there's a reconciling cash flow. There's a populated audit sheet and most importantly, a full formula list. Ending list is incomplete. Before proceeding, verify that there are no circular references, no missed link cells, and no hard-coded values in forecast areas. If any deviation appears, correct it immediately. Once everything is reconciled and passes audit, then stage five is complete. Now that the model foundation is secure, we can now move into stage six.

Okay. So in stage six, I'm going to explain to you why valuation must be built carefully on top of a working three-statement model because even small mistakes here can mislead leadership when things count. Now, using the wrong cash flow or forgetting to discount the terminal value or building sensitivities that don't reference the DCF output can completely distort decision-making, and we don't want that for obvious reasons.

Now, this is precisely why we produce a fully auditable DCF in a new DCF sheet. Free cash flow must be defined as CFO minus capex from the CF sheet. Cash flows are discounted using assumptions WACC. A Gordon growth terminal value must be calculated and discounted correctly. The DCF must compute enterprise value, equity value, and value per share, assuming 1 million shares by default. A scenario toggle should allow base, upside, and downside cases to adjust revenue growth, gross margin, and WACC. And sensitivity metrics for revenue growth, WACC, and gross margin plus or minus 10% or plus or minus 20% must directly link to the DCF output. Now, the top five value drivers should be ranked by NPV impact. Historical sheets must remain untouched.

Now, here's how we do this. The first step is to select Opus 4.5 and stay in chat mode. Paste the stage six prompt verbatim. The second step is to instruct Claude to create a new DCF sheet. Calculate FCF from CF. Apply WACC and terminal growth assumptions. Discount cash flows. Compute enterprise and equity value and build link scenario logic and sensitivity matrices. It must return a full list of formulas for review. Lastly, review the DCF sheet thoroughly. Spot checks must confirm correct FCF sourcing, terminal value calculation, scenario toggling, and sensitivity behavior.

Now, most teams make avoidable mistakes here. They pull net income instead of CFO minus capex. They forget to discount the terminal value. Or they build static sensitivity tables and hardcode assumptions. Some create a single value cell with pasted numbers. And these shortcuts might seem efficient, but they eliminate all auditability.

Now, when executed correctly, look for these things. The DCF sheet should include forecasted FCF rows, discount factors, PV calculations, a terminal value row, enterprise value, equity value, and value per share. Scenario toggles should adjust assumptions dynamically. Sensitivity tables must link to the DCF NPV cell. Anything less is incomplete. Now, before approving, confirm that FCF references CF correctly. WACC and growth rates are linked. Sensitivity tables are formula-driven and no historical sheets were modified. If discrepancies appear, correct them immediately. Once valuation behaves as expected and all formulas are auditable, stage six is complete. Now that the system is stable and defensible, we can move into stage seven.

Okay. So in stage seven, I'm going to explain to you why liquidity visibility matters. Because executives don't just see risk, they see cash. Now, without a simplified, dynamic cash forecast, liquidity risk remains abstract. Scenarios feel unrealistic, and leadership engagement is going to drop.

Now, stage seven turns the model into a visible decision tool. Even with a complete valuation model, if cash timing isn't clear, the conversation shifts away from strategy towards uncertainty. So overcomplicated treasury logic or static tables only add to the confusion here. So this is precisely why we build a simple 13-week rolling cash forecast that updates dynamically, that reacts to a single input, displays a line chart, and triggers a basic liquidity alert. The stage is about clarity, not about complexity.

So, here's how we do this. The first step is to paste the exact stage seven prompt. The second step is to instruct Claude to create a new rolling cash sheet. Spread cash flows weekly using formulas. Incorporate one driver cell. Generate a simple line chart and add an alert if cash falls below a covenant threshold. Lastly, run only four checks. Confirm the driver updates cash, the chart moves, the alert triggers correctly, and that there are no formula errors. Avoid optimizing or redesigning anything at this stage.

Most teams overengineer this. They add too many drivers. They build daily operations logic, or they create static tables with no alert logic. It becomes confusing instead of useful. When executed correctly, you got to look for these things. A rolling cash sheet with 13 weekly columns, inflows and outflows spread properly, net change and ending cash rows, one driver cell controlling inflows, a moving line chart, and an alert cell showing "Okay" or "Alert." Anything else here is incomplete. If the driver doesn't update cash or alerts don't trigger under extreme scenarios, then corrections are required. Passing all four tests means stage seven is complete. And now we move into stage eight.

Okay. So in stage eight, I'm going to explain to you why presentation discipline matters because even the most rigorous model loses influence if it's communicated poorly. Weak tone, missing citations, or unclear recommendations can derail approvals and waste board time. So when you dump technical analysis into slides, or when you use casual language, it gives an unprofessional impression. On the other hand, writing long essays or cluttered bullet slides makes it look like, you know, work product instead of executive communication.

So this is precisely why we produce a one-page CFO memo under 400 words with four slide-style sections and save it to a deliverables sheet. Now, it must clearly state the decision ask, present strategic options, surface key metrics including enterprise value, equity value, value per share, and the liquidity outlook, and has to include direct cell citations, has to summarize drivers and sensitivities, and has to end with a single clear recommendation. Claude cannot invent or alter numbers.

Now, here's how we do this. The first step is to switch to set 4.5 and paste the prompt verbatim. The second step is to require four labeled sections: Key Ask, Options, Drivers and Sensitivity, and Recommendation with exact cell references such as `DCF!B28`. Lastly, review the draft carefully. Confirm every number matches the reference cells and that the tone reads like executive communication, not explanation.

When executed correctly, look for these things. A deliverables sheet containing the memo and four structured sections. Inline citations, clear recommendations beginning with "Recommend." If you have anything less here, then it's incomplete. Approve only when numbers match exactly, when tone is decisive, and the recommendation is explicit. Now that the presentation is board-ready, we move to stage nine.

Okay. So in stage nine, I'm going to explain to you why converting contract language into structured risk is vital. Now, this is because contracts hide payment clauses, termination triggers, and covenant thresholds that are often never included in forecasts. Now, missing a clause can lead to liquidity shortfalls or covenant breaches. Finance teams frequently leave legal language unexplained, like timing clauses, or earnouts, or step-up payments, which are they're just ignored. Now, copying clauses into notes documents without any knowledge is neither auditable nor repeatable.

Now, this is precisely why we extract structured, modelable risk. Claude must review contracts, summary, and confidence. Then create a `contracts_mapped` table identifying payment terms, commitments, termination notice periods, and cash flow impacts. Each contract must receive a low, medium, or high risk flag with a short model note explaining forecast implications. Liquidity or covenant impacts within 12 months must be highlighted, while keeping the original sheets untouched.

Now, here's how we do this. The first step is to use Opus 4.5 and paste the prompt exactly. The second step is to instruct Claude to extract standardized fields, flag risks, and provide model notes without modifying source data. Lastly, review `contracts_mapped` line by line. Confirm materiality thresholds and immediately escalate high-risk items.

When executed correctly, look for these things. One row per contract, including contract ID, next payment timing, annual commitment, termination notice days, risk flag, and a concise model note. 12-month risks are clearly flagged, and no source sheets have been modified. Anything less than that is incomplete. Approve only when every contract is accounted for and it makes sense when you read it.

And that's it. You now know how to use Claude for finance better than 99% of people and you have successfully created a financial model that belongs in the top 1%. If you want all the prompts I just used, you can join my free community using the link in the description below. And let me know what you think in the comments. And I thank you for watching and I look forward to seeing you next.