The AI-Augmented Analyst: Applying AI Across Your Work

Finance galaxy · AI-Augmented branch · Capstone node AI0.07 · ~16 focused hours · Mastery gate ≥ 85%

Six nodes of this branch have handed you six separate tools. AI0.01 opened the machine and gave you the one sentence that explains it, the model optimizes for plausible, not true. AI0.02 through AI0.05 gave you a map of tool categories, the craft of prompting, the mechanics of grounding a model in a document, and the shape of an agent loop. AI0.06, the crown, forged all of it into a single reflex: the Primary-Source Guardrail, five checks (Trace, Match, Recompute, Date-check, Cite) run on every figure before it enters your work. What none of those nodes did, on purpose, was show you what a whole week at a desk looks like once you actually try to live by that reflex, across a research note, a model, a memo, a deck, a script, and a dataset, back to back, with a real employer's data-handling rules and a real profession's expectations of you sitting on top of all of it. That is this node's entire job.

This is the integration capstone of the AI-Augmented branch, and it is built differently from the six before it. There is very little new mechanism here, you already know how a model fails and how to catch it. What is new is breadth and consequence: the same five-check discipline, re-derived for six different kinds of work, so that "I verified it" means something concrete whether the artifact is a paragraph, a spreadsheet, a slide, or a function; the professional layer around the technical one, who is accountable for an AI-assisted deliverable, what you owe a client or a reviewer by way of disclosure, and what you are legally and ethically permitted to type into a text box in the first place; and, at the end, the discipline of building a lightweight, personally-owned verified workflow you can actually run under deadline pressure, rather than a checklist you only follow when you have time to spare.

Two words will recur throughout this node, and it is worth fixing them now. Verified means every figure and claim you ship has been traced, matched, and recomputed against a primary source before anyone else sees it, not "it sounded right," not "the model was confident," not "I asked it twice." Yours means that when a client, a manager, or a regulator asks who is responsible for a number in your memo, the answer is you, in full, every time, regardless of which tool drafted the sentence around it. Everything in this node, the six domain passes, the ethics, the disclosure norms, the privacy law, the workflow you will build, and the capstone project that closes it, is in service of those two words holding at once, permanently, as a habit rather than an occasion.

One last framing point before the content starts. This node deliberately does not re-teach the deep by-hand skill of research, modeling, memo-writing, deck-building, coding, or data analysis, those live in their own galaxies (existing and forthcoming), and this node points to each one explicitly rather than duplicating it. What this node teaches is the seam between "I know how to do this by hand" and "I am using AI to do it faster", the seam every analyst now lives on, in every domain, for the rest of a career that will only get more AI-saturated from here. Master the seam once, generally, and it holds no matter which specific tool, model, or interface changes underneath it next year.

Learning objectives

By the end you can:

1. (Understanding, gated) Apply the full Primary-Source Guardrail (Trace, Match, Recompute, Date-check, Cite) as a domain-general verified pass, adapting what counts as "the source" and "the recompute" across six analyst work types: research, financial modeling, memo drafting, deck building, coding, and data analysis.
2. (Understanding (gated) State the professional-accountability principle of AI authorship) the human who submits a deliverable is fully accountable for its correctness regardless of what tool drafted it, and explain why "the AI made the error" is never a valid defense.
3. (Understanding, gated) Distinguish legitimate AI-assisted drafting from professional-integrity failures (unverified reliance, presenting ungoverned AI output as fully vetted original work), and name the concrete intellectual-property risks of pasting proprietary firm or client material, or copyrighted content, into a third-party AI tool.
4. (Understanding (gated) Decide when and how to disclose AI use in a work product) to a manager, a client, or a regulator, using a concrete trigger-based framework, and explain why appropriately-verified, silent AI-assisted drafting differs from concealment of unverified output.
5. (Understanding, gated) Explain the core roles and duties under India's Digital Personal Data Protection Act, 2023 (Data Fiduciary, Data Processor, Data Principal; lawful basis; breach and erasure duties; cross-border transfer; Significant Data Fiduciary; children's data) well enough to correctly diagnose a DPDPA-relevant paste decision.
6. (Understanding (gated) Explain the US privacy and confidentiality patchwork relevant to an analyst) state comprehensive privacy laws, the GLBA Safeguards Rule, HIPAA, FCRA, and, separately, why material non-public information (MNPI) and Regulation FD are a securities-law risk category distinct from privacy law entirely.
7. (Understanding, gated) Apply a concrete may-paste / may-not-paste field guide to a real analyst scenario in both an Indian and a US context, correctly separating personal-data risk from confidentiality/IP risk from MNPI/insider-trading risk.
8. (Understanding (gated) Design your own lightweight, personally-verified AI workflow for a recurring piece of work) naming the tool category, the prompt pattern, the specific verification step, and the by-hand skill it never replaces.
9. (Productivity, tool awareness) For any of the six domains, select which category of AI tool to reach for and what its data-handling and verification profile is, cross-referencing the program's other galaxies for the deep by-hand skill each domain rests on.
10. (Understanding (gated) Complete a guided run-in-your-own-tool project end to end) brief, independent AI-assisted attempt, and a deterministic verification worksheet graded only against a bundled primary source, producing a verification log a reviewer could act on.

The duality, stated once more (R10). Every module in this branch carries both an understanding objective the gate rewards and a productivity objective that is simply the payoff you keep. Here the split is starker than usual, because this whole node sits at the seam between the two: objectives 1–8 and 10 are what the ≥85% gate tests, the generalized verification discipline, the professional and legal judgment, and the capstone artifact, all things a tool cannot do for you. Objective 9, knowing which tool category to reach for in a given domain, is the awareness you carry day to day, and it is real and valuable, but it never substitutes for the trace-and-recompute that objectives 1 and 10 demand. A learner who can name every AI tool category perfectly and skips the verified pass has not passed this node in any sense that matters.

Prerequisites & connections

Builds on. Everything in this branch, in full. AI0.01 supplies the root cause (plausible, not true) that every scenario in this node is still, ultimately, a special case of. AI0.02's tool taxonomy and evaluation rubric is what lets you match "which category of tool" to each of the six domains below without re-deriving it from scratch. AI0.03's prompting discipline (ask for citations, confidence, structured output) is what you actually type into the tool once you have chosen it. AI0.04's honest boundary on retrieval (grounding reduces but never eliminates the need to verify) underlies every "trace it yourself anyway" instruction below. AI0.05's agent loops and human-in-the-loop checkpoints are the shape of the coding and data-analysis passes in particular. And AI0.06 is the direct parent of this entire node: the five-check Guardrail taught there is not repeated from scratch here, it is reused, over and over, across six new surfaces. If any of those five checks feel shaky, this is the wrong node to be reading: go back and re-earn AI0.06's gate first. Beyond the branch, this node also leans on the analyst core: you cannot verify a research claim you cannot read a filing well enough to check (Phase 1–3's statement-reading and valuation fluency, M1–M3), you cannot judge a margin or ROCE claim without the ratio mechanics under it (M2), you cannot sanity-check a unit-economics figure without knowing what a clean one looks like (M4.02), and you cannot write a defensible memo without the structuring discipline the program already teaches (M10.03, The Communication Toolkit, the Minto-pyramid, answer-first foundation this node's memo pass assumes).

Feeds forward. This is the seventh and final node of the AI-Augmented branch, nothing inside this branch sits downstream of it. But its discipline is the thread every other galaxy in this program pulls on as AI-augmented content lands there. The six domain passes below point, deliberately, at the modules that will carry each skill to real depth: financial modeling toward the Finance-Plus fixed-income, derivatives, and quant branches (FI, DV, QM); research and the "so what" of a finding toward the Consulting galaxy's structuring and industry branches (CN1, CN4); memo and deck craft toward the Presentation galaxy's storyline and chart-craft branches (PR2, PR4) alongside the existing M10.03; coding toward the Quant-and-Code galaxy's software-engineering crown, which contains a dedicated unit on reviewing AI-generated code (CS2.06); and data analysis toward that same galaxy's data-science branch (DA) together with the Finance-Plus quantitative-methods branch (QM) that supplies its statistical theory. Those modules do not exist on disk yet as of this writing, they are planned, sequenced content in this same program, but the module IDs are stable and the cross-references below are accurate to that plan; when you reach them, the workflow you build in this node's capstone is the exact habit you carry in. Every ai-augment-json callout in every galaxy of this program, present and future, ends in a verify field, and that field is always a domain-specific instance of the Guardrail you are about to re-derive six times over.

Core teaching content

The verified pass, generalized: one Guardrail, six surfaces

Strip away the surface differences and every one of the six domains below asks the same five questions of any AI output before it is allowed to matter: where did this come from (Trace), does it agree with the source on every dimension that matters here (Match), can you independently rebuild it (Recompute), is it current enough to trust (Date-check), and have you recorded where you found it (Cite)? What changes, domain to domain, is what plays the role of "the source" and what counts as "rebuilding it." In research, the source is a named filing or dataset and the recompute is re-deriving a ratio or growth rate by hand. In modeling, the source is the same filing but the recompute is rebuilding the formula in a blank cell to see if it reproduces the AI's output. In memo drafting, the source is still the filing, but Match now also has to check that the prose has not quietly said more than the numbers support. In deck building, "does it match the source" gains a new dimension entirely, a chart can be numerically perfect and still misrepresent the data through the wrong choice of form. In coding, the recompute is a test you run, not a hand calculation, and "the source" is often the specification or the correct output on a known input rather than a filing. In data analysis, the recompute is re-deriving a metric from first principles on a small worked case, and Match has to catch unit and denominator mismatches hiding inside a pipeline rather than a paragraph. Same five questions, six different objects to point them at. Learn the mapping once and every new AI-touched task you meet for the rest of your career is an instance of a pattern you already own, not a fresh problem.

A second idea threads through all six passes, and it is worth stating before the specifics: verification effort should scale with consequence, not with how the output looks. A one-line internal note that nobody will act on and a number that goes into a client-facing recommendation deserve wildly different amounts of your time, even if an AI produced both with identical fluency and identical confidence. The Guardrail is not a tax you pay uniformly on every keystroke; it is a discipline you apply in full on anything that could cost money, cost trust, or cost a client's decision if it were wrong, and you develop the judgment, over time, for telling the two apart quickly. That judgment is itself part of what this node is teaching.

Research: from filings and desk research to a defensible fact base

An AI-accelerated research pass usually starts well and fails quietly at the edges: the model correctly pulls a real figure, then wraps it in language that goes slightly further than the source supports, "revenue grew across every segment" when one segment actually shrank, or a citation to a slide deck or a press summary instead of the filing the numbers actually live in. The verified research pass therefore leans hardest on Trace and Match: every figure must land on a named, primary document, a filed annual report, a 10-K, an exchange disclosure, a regulator's dataset, never an investor-day slide, a news summary, or the model's own memory standing in for one. Investor presentations and press releases are derived artifacts, built by the company's own communications team to tell a story; they are useful for finding where to look, never a substitute for the audited or filed statement underneath them. The second research-specific habit is checking claims that generalize across a set, "every segment," "consistently," "across all quarters", against the full underlying table, not just the segment the AI happened to quote, because a sweeping claim is exactly where an AI's fluency outruns what the data actually shows.

{
  "skill": "Running an AI-accelerated first pass on a company or industry, then verifying it into a defensible fact base",
  "use": "Have an AI draft an initial research note or desk-research summary from documents you supply, to save the first hour of transcription and organizing — never to supply facts it was not given.",
  "tools": ["Chat assistants — Claude, ChatGPT, Gemini (with file upload)", "Document/PDF AI — Claude Projects, NotebookLM for grounding in a specific filing set", "Research/agentic tools — for locating candidate primary sources, not for asserting figures"],
  "prompt": "From ONLY the attached documents <PASTE FILING(S)>, draft a research note covering <TOPICS>. For every figure and claim, cite the exact document, page, and note it came from. Flag any generalizing claim (e.g., 'across all segments') and show the per-item data you are generalizing from. Do not use any information not present in the attached documents.",
  "verify": "Trace every figure to the named primary source yourself — never an investor slide or press summary standing in for it. Match unit/scale/period/entity. Recompute every derived figure and every generalizing claim against the full underlying table before it survives into your note (Guardrail 1-5).",
  "diy": "You must be able to read the filing and locate the figure yourself, cold, without the AI's help (Phase 1-3 statement reading) — the tool only speeds the first draft of organizing what you would otherwise have found by hand."
}

Financial modeling: verifying the number you built, not just the number you got

A model is different from a research note in one important way: it is arithmetic wired together, so an error in one cell propagates invisibly into every cell downstream of it. The Recompute check therefore matters more here than anywhere else in this node, and it has a specific modeling-flavored trap worth naming: an AI asked to project interest expense, working capital, or any balance that changes during a period will often default to the simplest convention available (usually the ending balance) rather than the average balance a careful model uses precisely because the underlying account moved throughout the period. The fix is not "distrust the model's formula," it is rebuild the formula yourself, in a blank cell, from the same inputs, and compare; if your independent build and the AI's model disagree, the disagreement itself is the finding, and you resolve it by checking which convention the source actually calls for (a debt schedule's own disclosed method, a standard textbook convention, or your firm's own house style) rather than by trusting whichever number arrived first.

{
  "skill": "Building or extending a financial model with AI assistance, then verifying the arithmetic independently before it drives a decision",
  "use": "Let AI draft formula structure, a first-pass schedule, or a scenario table quickly — especially the tedious wiring (labels, formatting, a first set of linked cells) — while you retain every assumption and every convention choice.",
  "tools": ["Spreadsheet AI — Excel Copilot, Google Sheets' AI features for formula drafting", "Chat assistants — for explaining or proposing a formula pattern (never for asserting the final number)"],
  "prompt": "Draft the formula/schedule structure for <TASK> using these stated assumptions and conventions <LIST THEM EXPLICITLY, e.g., average-balance interest, straight-line depreciation>. Show your formula in plain text before wiring it into cells, and flag any assumption you had to guess rather than one I stated.",
  "verify": "Rebuild the key formula independently in a blank cell from the same source inputs and compare (#3 Recompute) — never trust an AI-built model's output without an independent build. Confirm the convention used (ending vs average balance; straight-line vs another method) matches the source or your firm's stated policy (#2 Match), and trace every input to its named source (#1 Trace).",
  "diy": "You must be able to build the schedule from a blank sheet, by hand, choosing the correct convention yourself — the tool only saves the typing once you already know what the model should say."
}

Memo and analysis drafting: the words carry the numbers' risk

Every number in a memo is exactly as verified as the worked examples and practice items in AI0.06 already trained you to make it, that part of this pass is not new. What is specific to memo-writing is that the sentence around a verified number can still misstate it. A recomputed 340-basis-point ROCE improvement, itself perfectly correct, becomes a false claim the moment the surrounding prose rounds it to "roughly 300 basis points" for readability, or extends it with a scope the source never supported ("consistent across the standalone and consolidated entity" when only one of the two was ever provided). The Match check therefore has to run on the prose, not just the numbers: read every sentence that touches a figure and ask whether it says anything, a magnitude, a direction, a scope, a causal claim, that the underlying data does not actually establish. This is also where the branch's earlier lesson on sycophancy resurfaces in a new guise: an AI asked to "make the finding sound stronger" or "give this a positive spin" will often oblige by quietly overstating exactly the kind of claim this check is built to catch.

{
  "skill": "Drafting a memo or written analysis with AI assistance, then verifying that the prose says no more than the numbers support",
  "use": "Use AI to draft structure and a first pass of prose around numbers you have already verified — the answer-first shape, the transitions, the executive summary — never to supply the numbers or the characterization of them.",
  "tools": ["Chat assistants — Claude, ChatGPT for drafting and tightening prose", "Writing-focused tools for tone and structure once the facts are locked"],
  "prompt": "Draft a memo section using ONLY these verified figures and this stated conclusion <PASTE VERIFIED FIGURES + YOUR CONCLUSION>. Do not add any figure, comparison, or scope (e.g., consolidated vs standalone, a trend beyond the years given) that is not in what I gave you. Flag any place you feel the prose wants more support than I supplied.",
  "verify": "Re-read every sentence that touches a number and check it against the source data specifically for overstatement, added scope, and rounding drift (#2 Match) — a memo error is often in the WORDS around a correct number, not the number itself. Recompute any bps/percentage change quoted in prose (#3).",
  "diy": "You must be able to write the answer-first structure and the core argument yourself (M10.03) — AI tightens sentences; it does not decide what the finding is or how strong the language claiming it should be."
}

Deck building: a chart can lie even when every number is right

This is the domain where the Guardrail needs a genuinely new dimension, because a chart can pass every numeric check (every value traced, matched, and recomputed) and still misrepresent the underlying data through the choice of chart form itself. A pie or donut chart encodes share-of-a-whole at a single point in time; it structurally cannot represent growth or decline, and it cannot represent a negative value at all, because a slice is a positive proportion by construction. Asked to visualize "growth by region" where one region actually declined, an AI will sometimes still reach for a pie (shrinking that region's slice relative to a prior period it is not actually showing) which does not display the decline so much as quietly launder it into "still a fraction of the pie," an impression a bar chart (one bar per region, allowed to fall below a zero line) or a waterfall (bridging the prior-period total to the current one through each region's contribution) would represent honestly. A second common deck-specific trap is the dual-axis chart: pairing two series with independently chosen scales can make two unrelated lines appear to move together, implying a correlation the data does not establish. Call this check Form-match: confirm the chart type can structurally represent what the data actually contains (sign, scale, and relationship) before checking whether any single number on it is correct.

{
  "skill": "Building a chart or deck slide with AI assistance, then verifying both the numbers on it and the chart form itself",
  "use": "Use AI to draft a first-pass chart or slide layout and suggest a chart type quickly, especially for a large or unfamiliar dataset — never to make the final chart-choice or scaling decision unreviewed.",
  "tools": ["Presentation AI — PowerPoint/Google Slides AI features, Claude/ChatGPT for a first chart-type suggestion", "Spreadsheet AI — for a first-pass chart build off a data table"],
  "prompt": "Suggest a chart type for this data <PASTE DATA, INCLUDING SIGN — note any negative or declining values> and explain why. If any series contains a negative or declining value, do not propose a pie or donut chart. Flag if a dual-axis design is being used and state why the two axes were scaled as they were.",
  "verify": "Check the chart FORM first (#2 Match, extended): can this chart type structurally show a negative value, a trend over time, or an unscaled comparison the data actually contains? Only then verify every number and label traces to the source (#1 Trace) and recomputes correctly (#3).",
  "diy": "You must know the chart-choice grammar yourself — which form fits which data shape, and why a pie cannot show decline — so you can catch a wrong chart even when every number on it checks out."
}

Coding: reviewing AI-generated code like you review an intern's model

AI-generated code fails in a specific, dangerous way: it very often runs without error and produces a plausible-looking number, so the failure mode is never a crash you would notice, it is a silent numeric bug, logic that executes cleanly and returns something in the right neighborhood while being simply wrong. A drawdown function that divides by the current price instead of the running peak, or a growth-rate function that references the wrong index, will both run to completion and hand back a number that looks exactly like a real drawdown or a real growth rate. The tell is structural, not visual: you cannot eyeball code correctness the way you can sometimes eyeball a suspicious-looking paragraph. The Recompute check here means, concretely, an independent test on a known input, a small hand-worked case where you already know the right answer, run through the AI-written function, checked line by line if the output does not match. Treat every AI-written function exactly the way you would treat a junior analyst's first spreadsheet build: impressive-looking until you have run your own numbers through it.

{
  "skill": "Reviewing AI-generated code for silent numeric bugs before trusting its output",
  "use": "Let AI draft a function or script quickly from a plain-language specification — a real time-saver on boilerplate and structure — while you supply the test case that actually proves it works.",
  "tools": ["Coding copilots — GitHub Copilot, Claude/ChatGPT/Cursor for code generation", "The language's own test framework (e.g., pytest) for the independent check, not the AI that wrote the code"],
  "prompt": "Write a function that does <TASK, SPECIFIED PRECISELY>. Then, separately, write a test using this known input and expected output <PROVIDE A HAND-WORKED CASE>. Explain any assumption you made about the input format or edge cases.",
  "verify": "Run the function against a hand-worked case where you already computed the correct answer independently (#3 Recompute) — never accept a function because it ran without error. Trace every formula inside it back to the specification (#1), and re-check on a second, different input before trusting it on real data.",
  "diy": "You must be able to compute the correct answer by hand on a small case (a 6-point drawdown series, a simple growth rate) so you have something real to check the code against — the deep coding skill itself belongs to the quant-and-code side of this program (CS2.06 in particular reviews AI-generated code as its own crown-level unit)."
}

Data analysis: verifying a pipeline, not just a headline figure

A data-analysis result is usually the end of a chain (cleaning, joining, aggregating, dividing) and an error anywhere in that chain produces one final, confident-looking headline number with no visible sign of where it went wrong. The single most common AI-introduced defect here is a unit or denominator mismatch buried inside the chain: a monthly figure silently annualized twice, a rate computed against the wrong population (a single day's signups instead of the month's), a percentage divided by a count that was itself already a percentage. None of these throw an error; they just produce a number that is wrong by a suspiciously round factor, often exactly 12, exactly 30, or some other unit-conversion constant hiding in plain sight. The specific habit worth building here, on top of the standard Recompute, is a magnitude sanity check performed before you even open the code: does this headline number's order of magnitude make sense at all, given what you already know about the business? A customer lifetime value ten times larger than a customer's total realistic multi-year spend should stop you before you have re-derived a single formula.

{
  "skill": "Verifying an AI-assisted data analysis or metric calculation before trusting the headline number",
  "use": "Let AI draft the analysis code, the aggregation logic, or the metric formula quickly on a real dataset — while you separately re-derive the same metric on a small, hand-worked slice to confirm the pipeline's logic.",
  "tools": ["Data-analysis AI — ChatGPT's built-in data analysis (code execution), Claude with code execution, Copilot in a notebook", "Spreadsheet AI for a smaller-scale parallel check"],
  "prompt": "Compute <METRIC> from this dataset <DESCRIBE/ATTACH>. Show the exact formula and the units of every intermediate quantity (state whether each is monthly, annual, per-customer, per-day). Flag any place a rate or period conversion was applied.",
  "verify": "Before opening the code, sanity-check the headline number's order of magnitude against what you already know (#1-adjacent plausibility check). Then re-derive the metric by hand on a small slice of the same data and compare (#3 Recompute) — a unit or denominator mismatch inside a pipeline produces a wrong number that still looks like a real one.",
  "diy": "You must be able to compute the metric by hand on a tiny worked case (a handful of customers, a few months) so you have an independent answer to check the pipeline against — the deep implementation skill (pandas, validated pipelines) belongs to the quant-and-code side of this program (the DA branch), built on the statistical concepts of the QM branch."
}

Ethics: authorship, accountability, and intellectual property

Start with the principle that resolves almost every ethical question this node raises: the human who submits a deliverable is fully accountable for its correctness, in full, regardless of what tool drafted any part of it. This is not a new principle invented for the AI era, it is the same principle that has always applied to a research associate's first draft, a junior analyst's spreadsheet, or a paralegal's memo summary: the person whose name goes on the work owns it. "The AI made the error" carries exactly as much weight as "my analyst made the error" ever did, which is to say none at all, as a defense, because verifying the analyst's (or the tool's) output before it ships was always your job. What is genuinely new is the speed and volume at which AI lets unverified content enter your pipeline, which is precisely why this branch spent an entire crown node building the reflex that catches it before it ships.

Authorship, concretely, means this: using AI to draft, restructure, or accelerate your work is not different in kind from using a calculator, a template, or a research assistant, provided the judgment, the verification, and the final decision are yours. The line into a professional-integrity failure is not "I used a tool"; it is presenting ungoverned AI output as though it already carries your own vetted judgment, shipping a paragraph, a number, or a recommendation you have not actually checked, dressed in the confidence of something you have. A permissive way to think about it: would you be comfortable telling your reviewer exactly which parts of this were AI-drafted and which checks you ran on each? If the honest answer makes you uncomfortable, the discomfort is pointing at a verification gap, not a disclosure gap: fix the gap first.

Intellectual property raises two distinct risks an analyst actually meets in practice. The first is what you might be putting into the tool: pasting a firm's proprietary valuation framework, a client's confidential deal structure, or another author's copyrighted material into a general-purpose AI tool can mean that content leaves your control in ways your firm's confidentiality obligations, your client's engagement letter, or copyright law were never designed around, some consumer-tier tools may retain or train on submitted content depending on the account tier and settings (a detail that changes by provider and by month, check the current terms before you rely on any specific claim about it). The second is what might be coming out of the tool: a model can reproduce text, code, or structure closely resembling material it was trained on, sometimes without any indication that it is doing so, which means AI-drafted content carries a nonzero, generally unquantifiable risk of unoriginal or improperly-sourced material, a further, IP-flavored reason the Trace and Cite checks matter even on prose that never touches a number. Neither risk is exotic or rare; both are resolved the same practical way: treat anything proprietary, confidential, or copyrighted as content whose destination you must consciously choose (an enterprise tier with a no-training agreement, a firm-sanctioned tool, or simply not pasted at all) rather than content you paste by default into whatever window is open.

Disclosure norms: when and how to say AI was used

Most AI-assisted work needs no special disclosure at all, a verified, well-drafted memo is a good memo regardless of what tool helped structure the first paragraph, exactly as a well-researched note was never worse for having used a template. Treat disclosure as triggered by specific conditions, not as a blanket default in either direction (announcing AI use on every trivial draft reads as noise; concealing it when it matters reads, correctly, as concealment). Four triggers cover almost every real situation you will meet:

1. You were asked directly. If a client, manager, or regulator asks whether or how AI was used, answer honestly and specifically, what was used, for which step, and how you verified it. Never claim sole unaided authorship if that is not true; a specific, confident answer ("I used it to draft the structure; every figure was independently traced and recomputed by me") reads as more credible, not less, than a defensive non-answer.
2. Firm policy or an engagement letter requires it. Many firms and many client engagements now carry explicit AI-use policies or disclosure clauses, know your own firm's policy before you need it, and treat a client contract's AI clause the same way you would treat any other contractual scope term.
3. The deliverable's entire value proposition is unaided human judgment. A few work products (a signed audit opinion, a formal fairness opinion, an attestation) derive their professional weight specifically from a licensed human's independent judgment; AI assistance in drafting such a document is generally fine, but its role must be characterized accurately if the format or the standard requires characterizing it at all, and the underlying judgment itself is never delegable.
4. The AI's role is itself material to the reader's decision. If knowing that AI drafted a risk assessment, a recommendation, or a projection would change how a reasonable reader weighs it (for instance, because your judgment on exactly that kind of task is the thing they are paying for) silence starts to look like the concealment of a materially relevant fact, even if every number in the document is correct.

Outside those four triggers, the deeper professional obligation is not disclosure at all, it is verification. A silently AI-assisted memo that was fully traced, matched, and recomputed by you is not a lesser memo for having had AI help; a memo that discloses its AI assistance in a footnote but was never actually verified has disclosed the wrong thing. Disclosure is never a substitute for verification, and a prominent disclosure notice does not launder an unverified number into a safe one.

Data privacy I: India's Digital Personal Data Protection Act, 2023

A note before the specifics: what follows is educational orientation for an analyst's day-to-day paste decisions, not legal advice, laws are amended and reinterpreted over time, so verify the current statutory text and any implementing rules before relying on a specific determination, and route genuine edge cases to your firm's compliance or legal function.

India's Digital Personal Data Protection Act, 2023 (DPDPA) is the framework governing personal data of individuals in India, and it is built around three roles you should be able to name on sight. A Data Fiduciary is the entity that determines the purpose and means of processing personal data, typically your employer, or a client whose data you are handling on their behalf. A Data Processor processes personal data on behalf of a Data Fiduciary, under a contract, this is exactly the role a third-party AI tool provider steps into the moment personal data is pasted into it, whether anyone involved thought of it that way or not. A Data Principal is the individual to whom the personal data relates, the customer, the employee, the counterparty whose name, contact details, or financial information appears in whatever you are about to paste.

The lawful basis for processing personal data under DPDPA is consent, or one of a narrow, enumerated set of "legitimate uses" the Act specifies (such as a Data Principal voluntarily providing data for a specified purpose, certain employment purposes, or specified public-interest functions), there is no open-ended "legitimate business interest" catch-all the way some other privacy regimes allow. This matters directly for an analyst's paste decisions: a customer's original consent to your firm processing their data for, say, account servicing almost never extends automatically to "and also send it to a third-party AI vendor for a churn-analysis prompt", that is very likely a new, unconsented purpose, processed through a Data Processor the Data Principal never agreed to and your firm likely never contracted with for this use.

A handful of further duties round out what an analyst should recognize even without being the one who administers them: Data Fiduciaries carry breach-notification duties (to the Data Protection Board of India and, in some cases, to affected Data Principals) and erasure duties (personal data must generally be erased once its purpose is served or consent is withdrawn, absent a legal retention requirement). Cross-border transfer of personal data takes a blacklist-style approach (transfers are generally permitted except to jurisdictions the government specifically restricts by notification) which means "the AI tool's servers are outside India" is not, by itself, either an automatic block or an automatic green light; you must still confirm the destination is not on any government-restricted list (a detail to check as current, since restricted-jurisdiction lists can change) and that a lawful basis for the underlying processing existed in the first place, since a permitted transfer route never cures a missing lawful basis. Organizations designated Significant Data Fiduciaries (based on data volume, sensitivity, and risk to sovereignty or electoral integrity) carry extra duties, a Data Protection Officer, periodic audits, and data protection impact assessments among them. And children's personal data carries a materially stricter regime: verifiable parental consent is required, and tracking or behavioral monitoring of children is restricted outright, a dataset that includes minors is never a "paste it and see" decision. Enforcement sits with the Data Protection Board of India, empowered to investigate and levy penalties.

Data privacy II: the US patchwork: and why MNPI is a different animal

The same note applies here: this is orientation, not legal advice, the US framework is a genuine patchwork that keeps evolving, so verify current statutory and regulatory text and consult your compliance function on real cases.

The United States has no single omnibus privacy statute the way DPDPA is for India; instead it is a patchwork of sector- and state-specific laws, several of which an analyst meets directly. A growing set of state comprehensive privacy laws (California's CCPA as amended by the CPRA is the anchor and the most influential; a number of other states have since enacted their own, each with its own scope and thresholds) give consumers rights over their personal data and impose obligations on businesses that collect it, relevant whenever you handle US consumer data, even data your firm did not collect directly. In financial services specifically, the Gramm-Leach-Bliley Act (GLBA) and its Safeguards Rule govern nonpublic personal information (NPI), customer account numbers, balances, and similar financial detail, requiring specific administrative, technical, and physical safeguards; pasting NPI into a general consumer-tier AI tool is very likely inconsistent with a financial institution's own Safeguards Rule program, regardless of how convenient it would be. HIPAA governs protected health information in healthcare contexts, relevant if your analyst work ever touches a healthcare client's patient-level data. The Fair Credit Reporting Act (FCRA) governs consumer credit-report information and how it may be used and shared, relevant to any analysis touching credit files or credit-eligibility decisions. Across all of these, the analyst-level habit is the same one DPDPA teaches: before pasting, ask what category of regulated data this is, not just whether it feels sensitive, the specific category determines which specific rule applies.

Now the sharpest distinction this node has to draw, because conflating it with privacy law is a genuine and consequential mistake: material non-public information (MNPI) and Regulation FD are a securities-law and insider-trading concern, not a data-privacy concern at all. If you have material information that is not yet public, something you learned on an earnings call before the public release, in a data room, or from any non-public channel, using or sharing it before public release risks insider-trading exposure for you personally, and, for an issuer or its representatives making a selective disclosure, a Regulation FD violation. This risk exists independent of any AI tool's privacy policy or training practices: even a tool that promises never to train on your inputs and deletes everything within the hour does not remove the risk, because the danger is not "will this data leak," it is "have I used or transmitted material non-public information through any channel before it was public", a question a provider's data-handling promises cannot answer for you. Pasting MNPI into an AI tool before public release is not a data-handling nuance to manage carefully; treat it as an absolute prohibition, full stop, the same way you would treat typing it into any other outside channel.

The may-paste / may-not-paste field guide

Every paste decision an analyst actually meets sorts into one of four risk categories, and the practical habit worth building is naming the category before you paste, not after:

• Personal data of an identifiable individual (a customer, employee, or counterparty's name, contact details, or account activity), governed by DPDPA in an India context or by the relevant state/sector law in a US context. Ask: do I have a lawful basis for this specific secondary use, and am I sending this to a properly contracted Data Processor or an unvetted consumer tool? When in doubt, de-identify first (strip names, replace with a row ID) or route it through a firm-vetted, access-controlled enterprise tool instead of a personal account.
• Confidential or proprietary business information (a firm's internal framework, a client's unannounced deal terms, another party's trade secret), governed by your engagement letter, your firm's confidentiality policy, and ordinary contract law, independent of any privacy statute. Ask: whose confidentiality obligation does this sit inside, and does the destination tool's terms of service and data-retention practice honor it?
• Copyrighted material belonging to someone else: a licensed dataset, another firm's published research, a textbook excerpt. Ask: am I permitted to reproduce or process this at all, regardless of what I do with the AI's output?
• Material non-public information (MNPI): anything price-sensitive and not yet public. This is the one category where the answer is never "de-identify it and proceed", the prohibition is on using or transmitting the information at all before public release, and no data-handling safeguard cures that.

The single most useful habit this field guide teaches is simply stopping to classify before you paste, because the four categories call for entirely different remedies, de-identification helps the first category and does nothing for the fourth; an enterprise no-training tier helps the second and third and is irrelevant to the fourth. Treating "is this data sensitive" as one undifferentiated question is exactly how a real MNPI risk gets waved through with a privacy-flavored fix that was never going to address it.

Building your own lightweight verified workflow

Everything in this node compresses into a habit you actually run, not a binder you consult. A lightweight, personally-owned verified workflow has exactly four elements, and writing them down for one recurring task is the single highest-leverage thing you can do with the rest of this hour: (1) the tool category you default to for this task (not a specific brand, which is perishable, but a category, chat assistant, document AI, coding copilot, and so on, per AI0.02); (2) the prompt pattern you reuse, ideally one that already asks for citations, confidence, and structured output as a matter of habit (AI0.03); (3) the verification step, specific and written down, not "I'll check it if something looks off", the exact Trace/Match/Recompute/Date-check/Cite instance for this particular task; and (4) the by-hand skill you retain, the thing you can still do correctly with the tool switched off, which is both your fallback and your only real check on whether the tool's output is any good in the first place. A workflow with all four elements written down, even briefly, survives a deadline; a workflow that lives only as a vague intention in your head is exactly the one that degrades under pressure, which is precisely when you need it most.

{
  "skill": "Designing your own lightweight, personally-verified AI workflow for a recurring task",
  "use": "Use AI to help you draft the reusable prompt template and the verification checklist itself for a task you do often — turning a one-off habit into a written, repeatable artifact you (and a reviewer) can actually see.",
  "tools": ["Chat assistants — for drafting a reusable prompt template and a verification checklist", "A plain document or note tool for storing the finished workflow — no special software required"],
  "prompt": "Help me draft a reusable prompt template for <RECURRING TASK> that asks for citations, confidence, and structured output by default. Then draft a short verification checklist I can run every time, specific to what could go wrong in THIS task (not a generic checklist).",
  "verify": "Test the drafted prompt template and checklist on a real past instance of the task where you already know the correct answer (#3 Recompute, applied to the workflow itself) before adopting it — a verification checklist that has never caught a real error has not been tested.",
  "diy": "The four elements — tool category, prompt pattern, verification step, retained by-hand skill — are a template AI can help you fill in, but only you can specify what actually goes wrong in your own recurring work; that judgment is the whole point of building the workflow yourself."
}

Common mistakes & how experts think differently

1. Treating one verified domain as proof the whole deliverable is safe. The beginner runs a careful verified pass on the research and assumes that diligence somehow covers the model, the memo, and the deck built on top of it. The expert knows each domain has its own trace-and-recompute surface (a verified number can still be misrepresented by an unverified chart two steps later) and runs the pass fresh in each domain, every time.
2. Treating "the AI drafted it" as shared authorship. The beginner feels that an AI-assisted error is somehow half the tool's fault, softening their own accountability. The expert holds the same standard that always applied to a research associate's first draft: the person who submits the work owns it completely, and "the AI made the error" carries zero weight as a defense, because verifying it before it shipped was always the job.
3. Confusing "using AI is embarrassing" with "using AI requires disclosure." The beginner either over-discloses trivial, well-verified drafting help in a way that reads as insecurity, or under-discloses exactly the cases (a client asking directly, a policy requiring it, a judgment-dependent deliverable) where disclosure is actually owed. The expert uses the trigger-based framework: silent, verified assistance needs no announcement; a direct question, a policy, or a materiality trigger always gets an honest, specific answer.
4. Pasting first, classifying second. The beginner treats a chat window like a private notebook and pastes whatever is convenient, only asking afterward whether it was personal data, confidential material, or MNPI. The expert classifies the data category before typing a single character into any external tool, because the four categories (personal data, confidential/IP, copyrighted material, MNPI) call for entirely different remedies, and the right one only gets chosen if the classification happens first.
5. Treating privacy compliance as someone else's department. The beginner assumes DPDPA, GLBA, or similar obligations belong to legal and compliance and have nothing to do with their own daily prompt habits. The expert knows the paste decision itself is where most of these obligations actually get triggered or avoided, at the individual-analyst level, long before compliance ever sees it.
6. Mistaking a provider's training-opt-out for a clearance to paste anything. The beginner sees "this tool doesn't train on your data" and treats that as the whole analysis, complete. The expert knows a training opt-out addresses only one narrow risk (the provider's own future model) and does nothing to cure a missing lawful basis for processing personal data, a breached confidentiality obligation, or (critically) an MNPI/insider-trading exposure that exists the moment the information moved at all, regardless of what happens to it afterward.
7. Keeping the verified workflow only in your head. The beginner has a real, working sense of "how I use AI carefully" that has never been written down anywhere. The expert writes the four elements (tool category, prompt pattern, verification step, retained by-hand skill) down as an actual short artifact, because an unwritten habit is exactly the one that quietly erodes under deadline pressure, and a written one is the only kind a reviewer (or you, checking your own work in six months) can actually reconstruct.

The thread through all seven: this node's discipline only holds if it is applied fresh in every domain, owned without qualification, classified before it is acted on, and written down, a habit that lives only as a vague good intention is not a habit a deadline will respect.

Worked examples

Each example is a verified pass on one of the six domains: a SYNTHETIC bundled source, an AI-drafted output carrying planted errors, and the solution, enumerate, run the Guardrail, correct, and name where the deep by-hand skill for this domain lives elsewhere in the program. Work each yourself before reading the catch.

Worked example 1: Research: Konkan Spice Traders Ltd (India, ₹ crore)

SYNTHETIC SOURCE, Konkan Spice Traders Ltd, segment revenue note, FY2025 vs FY2024 (from the filed annual report).

AI OUTPUT (drafted from the company's investor presentation, contains 3 planted errors): "Per the FY2025 Investor Presentation (slide 8), Konkan Spice Traders grew revenue by approximately 14% to ₹810 crore, with all three segments (Domestic Retail, Export, and Institutional) growing in double digits."

Solution. Enumerate: (a) growth "~14%"; (b) "all three segments... growing in double digits"; (c) citation to the investor presentation, slide 8.

Error 1: hallucinated growth rate. #3 Recompute. Total growth = (810.0 − 732.0) ÷ 732.0 = 78.0 ÷ 732.0 = 10.7%, not "~14%." Fourteen percent looks like it borrowed the Export segment's own growth rate rather than the company total, a realistic AI slip, mistaking one part for the whole. Correction: revenue grew 10.7%.

Error 2: false generalization. #1 Trace / #2 Match. Check each segment: Domestic Retail (412−370)/370 = 11.4%; Export (268−240)/240 = 11.7%; Institutional (130−122)/122 = 6.6%, not double digits. The claim "all three segments grew in double digits" is directly contradicted by the source's own table. Correction: Domestic Retail and Export grew in double digits; Institutional grew 6.6%.

Error 3: wrong citation tier. #1 Trace / #5 Cite. An investor presentation is a derived, marketing-oriented artifact prepared by the company's own communications function, not the primary filed source the segment table actually lives in. Correction: cite the segment note in the filed annual report directly; use the presentation only to locate where to look.

Read it. All three errors survive a casual read because the headline "grew, and broadly" feels plausible, the discipline that catches them is opening the actual table behind the slide and checking every segment, not just the ones a fluent sentence chose to mention. For the deep research and industry-analysis skill this domain rests on, see the Consulting galaxy's industry-research branch (CN4) and the existing Phase 1–3 statement-reading modules; the AI pass only ever accelerates locating and organizing what those skills would find by hand.

Worked example 2: Financial modeling: Bridgeton Outdoor Supply (US, $ mn)

SYNTHETIC SOURCE, Bridgeton Outdoor Supply, term-loan schedule (extract). Beginning-of-year balance: $180.0 million. Scheduled amortization during the year: $40.0 million. Ending-of-year balance: $140.0 million. Stated annual rate: 5.00%.

AI OUTPUT (a modeling assistant's draft, contains 2 planted errors): "Interest expense = ending balance × rate = $140.0m × 5.00% = $7.00 million. Net debt declined by $40 million this year, improving leverage by roughly one full turn of EBITDA."

Solution. Enumerate: (a) interest expense $7.00m, using the ending balance; (b) "improving leverage by roughly one full turn of EBITDA."

Error 1: wrong balance convention. #3 Recompute. The loan amortized during the year, so it was not at $140.0m the whole time, using the ending balance for the full-year interest calculation understates the true expense. Rebuild it: average balance = (180.0 + 140.0) ÷ 2 = $160.0m; interest = 160.0 × 5.00% = $8.00 million. Correction: interest expense is $8.00 million, not $7.00 million, an $8.00m/$7.00m difference of over 14%, entirely from the convention choice.

Error 2: hallucinated inference. #1 Trace. "One full turn of EBITDA" requires an EBITDA figure, and none appears anywhere in the bundled source. The $40.0 million paydown is confirmed by the schedule; the leverage-turn claim is not traceable to anything given and must be rejected outright, not softened. Correction: the paydown is confirmed at $40.0 million; the leverage-improvement claim is unsupported and should be struck until an EBITDA figure is sourced.

Read it. The interest-expense error is invisible unless you independently rebuild the formula in a blank cell rather than reading the AI's formula and nodding at it, exactly the discipline the Recompute check demands of a model, not just a paragraph. For the deep instrument-pricing and schedule-building skill underneath this pass, see the Finance-Plus fixed-income and derivatives branches (FI, DV) and the quant-developer branch that implements this in code (QD).

Worked example 3: Memo drafting: Deccan Ceramics Ltd (India, ₹ crore)

SYNTHETIC SOURCE, Deccan Ceramics Ltd, standalone financials (extract). FY2024: EBIT ₹139.2 crore; Capital employed ₹1,200.0 crore (ROCE 11.60%). FY2025: EBIT ₹189.0 crore; Capital employed ₹1,260.0 crore (ROCE 15.00%). No consolidated figures are included in this extract.

AI OUTPUT (a draft memo paragraph, contains 2 planted errors): "Deccan Ceramics' ROCE improved by approximately 300 basis points to 15% in FY2025, and this improvement was consistent across both the standalone and consolidated entity."

Solution. Enumerate: (a) ROCE change "~300 bps"; (b) "consistent across both the standalone and consolidated entity."

Error 1: rounding drift. #3 Recompute. Recompute the change directly: 15.00% − 11.60% = 340 basis points, not "~300." The AI's rounding understated the true improvement by 40 basis points, small-looking on the page, but a real misstatement of the finding's magnitude. Correction: ROCE improved by 340 basis points.

Error 2: unsupported scope claim. #1 Trace / #2 Match. The bundled extract contains only standalone figures, there is no consolidated data anywhere in the source to check "consistent across both" against. This is not a small number wrong; it is a claim about an entity the source never addressed at all. Correction: the standalone ROCE improvement of 340 bps is supported; the consolidated claim is unverifiable from this source and must be struck, not softened to "likely."

Read it. Both errors sit in prose wrapped around numbers that were otherwise fine, a reminder that a memo's Match check has to run on every sentence touching a figure, not just on the figure itself. For the deep answer-first synthesis and structuring skill this domain rests on, see the existing Communication Toolkit (M10.03) and the Consulting galaxy's synthesis branch (CN1, whose crown module is built specifically around the "so what" of a finding).

Worked example 4: Deck building: Fernwood Home Goods Corp (US, $ mn)

SYNTHETIC SOURCE, Fernwood Home Goods Corp, regional revenue (extract).

AI OUTPUT (a slide draft, contains 3 planted errors): "Recommended visual: a pie chart of FY2025 revenue by region. Speaker notes: total revenue grew 8.5% this year, with all regions growing."

Solution. Enumerate: (a) chart-form choice, a pie of FY2025 revenue; (b) "grew 8.5%"; (c) "with all regions growing."

Error 1: wrong chart form. Form-match (extended #2). Midwest declined −5.0%. A pie chart encodes positive share-of-a-whole at one point in time; it cannot represent a decline at all, and using one here would launder Midwest's fall into "still a slice of the pie" rather than showing the drop. Correction: use a bar chart (FY2024 vs FY2025 bars per region, Midwest's allowed to read as a fall) or a waterfall bridging the $753.0m total to $804.0m through each region's contribution.

Error 2: hallucinated total growth. #3 Recompute. (804.0 − 753.0) ÷ 753.0 = 51.0 ÷ 753.0 = 6.8%, not 8.5%. Correction: total revenue grew 6.8%.

Error 3: false generalization. #1 Trace / #2 Match. "All regions growing" is directly contradicted by Midwest's −5.0%. Correction: three of four regions grew; Midwest declined 5.0%.

Read it. The chart-form error is the one a purely numeric check would miss entirely, every number could be individually correct and the slide would still mislead through its shape. For the deep chart-craft and storyline skill this domain rests on, see the Presentation galaxy's chart-craft and storyline branches (PR2, PR4) and the existing Communication Toolkit (M10.03).

Worked example 5: Coding: Konark Energy Ltd (India, ₹)

SYNTHETIC SOURCE, Konark Energy Ltd, six monthly closing share prices (₹, illustrative): 100, 112, 84, 90, 105, 95.

AI OUTPUT, a Python function drafted to compute maximum drawdown (contains 1 planted bug):

def max_drawdown(prices):
    peak = prices[0]
    max_dd = 0.0
    for p in prices:
        if p > peak:
            peak = p
        dd = (peak - p) / p          # bug: divides by the current price, not the peak
        if dd > max_dd:
            max_dd = dd
    return max_dd

Run on the series above, this function returns 33.3%.

Solution. Enumerate: the claimed maximum drawdown, 33.3%, and the function that produced it.

The bug. #3 Recompute (an independent test on a known case). Trace the true drawdown by hand: peak reaches ₹112 at month 2, and the trough is ₹84 at month 3. True drawdown = (peak − trough) ÷ peak = (112 − 84) ÷ 112 = 28 ÷ 112 = 25.0%. The function instead divides by the current price: (112 − 84) ÷ 84 = 28 ÷ 84 = 33.3%, a silent numeric bug that runs without error and returns a plausible-looking number at the same month, just the wrong formula. Correction: maximum drawdown is 25.0%, not 33.3%; fix line dd = (peak - p) / p to dd = (peak - p) / peak.

Read it. Nothing about this function's execution would tell you it was wrong, no error, no warning, a number in a perfectly plausible range for a volatile stock. The only thing that catches it is running a small, hand-worked case where you already know the answer through the function and comparing. For the deep software-engineering and AI-generated-code-review skill this domain rests on, see the Quant-and-Code galaxy's software-engineering crown module (CS2.06, which dedicates a unit specifically to reviewing AI-generated code), and this branch's own AI0.05 on agentic, tool-using workflows.

Worked example 6: Data analysis: Sutter Metrics Inc. (US, $)

SYNTHETIC SOURCE: Sutter Metrics Inc., customer economics (extract). Average monthly revenue per customer: $40.00. Average customer lifetime: 30 months. Gross margin: 70%.

AI OUTPUT (a data-analysis assistant's draft, contains 1 planted bug): "Average customer LTV is $10,080, reflecting strong retention. Calculation: annual revenue ($40 × 12 = $480) × 30 (lifetime) × 70% margin."

Solution. Enumerate: the claimed LTV, $10,080, and the calculation shown.

The plausibility check, first. #1-adjacent sanity check. Before touching the arithmetic: a $10,080 lifetime value on a customer paying $40 a month implies roughly 252 months (21 years) of pure undiscounted revenue. That should stop you before you open a single formula; an LTV should be roughly the same order of magnitude as a customer's realistic total spend, and this is not.

The bug. #3 Recompute. The correct formula is monthly revenue × lifetime in months × margin: $40.00 × 30 × 0.70 = $840.00. The AI's version annualized the monthly revenue first ($40 × 12 = $480, itself a correct step) and then multiplied that annual figure by 30 (a quantity still denominated in months, never converted to years) producing a hidden 12x unit mismatch: $480 × 30 × 0.70 = $10,080.00 = $840 × 12 exactly. Correction: LTV is $840.00; the bug is a denominator/unit mismatch between an annualized revenue figure and a months-denominated lifetime.

Read it. The exact 12x relationship between the wrong and right answers is the tell of a unit-conversion bug hiding inside a pipeline, a magnitude sanity check catches it in seconds, before any arithmetic, which is why that check belongs first. For the deep implementation skill this domain rests on, see the Quant-and-Code galaxy's data-science branch (DA) and the Finance-Plus quantitative-methods branch (QM) that supplies its statistical theory, plus the existing unit-economics module (M4.02) for what a clean LTV/CAC framework looks like.

Practice set

Work each before reading its solution. All sources are SYNTHETIC. Items climb from a guided conceptual mapping through each of the six domains to the ethics/disclosure/privacy layer, ending in a full two-market integrative pass.

P1 (guided). Map the domain to its adapted verb. For each domain, name what the Recompute check concretely means: (i) coding; (ii) deck building; (iii) data analysis.

Solution. (i) Coding: run an independent test on a known input and compare, never trust code because it ran without error. (ii) Deck building: Recompute stays numeric (re-derive every value on the chart), but a new check comes first, does the chart form itself (Form-match) even structurally allow what the data contains (sign, trend, relationship)? (iii) Data analysis: re-derive the metric by hand on a small worked slice of the same data, and sanity-check its order of magnitude before opening any code at all.

P2 (Research). Source: "Vindhya Cement Ltd, standalone revenue: FY2025 ₹2,340 crore; FY2024 ₹2,080 crore." An AI summary states "revenue grew approximately 15% to ₹2,340 crore, per the company's investor call." Find the errors.

Solution. Recompute (#3): (2,340 − 2,080) ÷ 2,080 = 260 ÷ 2,080 = 12.5%, not "~15%." Separately (#1 Trace), an investor call is not the primary filed source, cite the standalone financial statements in the annual report or exchange filing directly, using the call only to locate where to look.

P3 (Modeling). Source: term loan, beginning balance $95.0m, ending balance $75.0m, rate 6.0%. An AI states "interest expense = $75.0m × 6.0% = $4.50m using the ending balance." Correct it.

Solution. The balance amortized during the year, so the ending-balance convention understates it (#3 Recompute). Average balance = (95.0 + 75.0) ÷ 2 = $85.0m; interest = 85.0 × 6.0% = $5.10 million: 60,000 dollars more than the AI's figure, entirely from the convention choice.

P4 (Memo). Source: operating margin FY2025 18.2% (EBIT ₹218.4 crore / revenue ₹1,200.0 crore); FY2024 15.9% (EBIT ₹165.4 crore / revenue ₹1,040.0 crore). An AI memo states "margin expanded by roughly 200 basis points." Correct it.

Solution. Recompute (#3): 18.2% − 15.9% = 230 basis points, not 200. A memo's numbers should always be independently re-derived from the underlying EBIT/revenue pair, not accepted from a rounded prose claim.

P5 (Deck). Source: four product lines' YoY growth, A +12%, B +9%, C −4%, D +15%. An AI recommends "a single pie chart titled 'Growth by Product Line.'" Diagnose the error.

Solution. Form-match failure. A pie chart encodes positive share-of-a-whole at one point in time; it cannot represent growth at all, and it structurally cannot show C's negative value. Fix: a bar chart of YoY % by product line (sorted, C's bar shown falling below a zero line), the correct family for signed, comparative data.

P6 (Coding). Source: an AI-written function correctly sums a list of six prices (they total 540) but returns the average by dividing by a hard-coded 10 rather than the list's actual length. What is the true average, and what is the bug?

Solution. True average (#3 Recompute, independent test): 540 ÷ 6 = 90.0. The buggy function returns 540 ÷ 10 = 54.0, a hard-coded denominator instead of len(prices), a silent numeric bug that runs cleanly and returns a plausible-looking but wrong number.

P7 (Data analysis). Source: total ad spend $18,000 for the month; 60 new customers acquired that month. An AI's code instead divides total monthly spend by a single day's signups (3), reporting CAC of "$6,000." Correct it.

Solution. Correct CAC (#3 Recompute): $18,000 ÷ 60 = $300. The bug is a denominator mismatch, a monthly numerator divided by a daily denominator, a 20x distortion. Sanity-check first: a $6,000 CAC on what is evidently a modest-ticket product should already look implausible before any arithmetic is checked.

P8 (Ethics/authorship). You submit a memo drafted substantially by AI without disclosing it, and it later contains an error. Who is accountable, and is the missing disclosure itself a separate problem?

Solution. The analyst who submitted it is fully accountable, in full, "the AI made the error" is not a valid defense, exactly as it never was for an unchecked research associate's draft. The missing disclosure is a separate question, resolved by the trigger-based framework: if no one asked, no policy required it, and the deliverable's value did not hinge on unaided judgment, silence was not itself the failure, the missing verification was.

P9 (IP/plagiarism). May you paste your firm's proprietary valuation framework into a public consumer-tier AI chatbot to get help reformatting it?

Solution. Treat it as a conscious destination choice, not a default: a consumer-tier tool may retain or train on submitted content depending on its terms and account settings (check the current terms before relying on any specific claim). Safer alternatives: use an enterprise tier with a no-training data agreement, a firm-sanctioned tool, or strip the material down to generic, non-proprietary categories before pasting anything at all.

P10 (Disclosure). A client asks, "did you write this analysis yourself?" You used AI substantially to draft it, and you verified every figure. How do you answer?

Solution. Honestly and specifically: describe what AI was used for (drafting/structuring), state that every figure and claim was independently traced, matched, and recomputed by you, and that the judgment and conclusion are yours. A specific, confident answer is more credible than a defensive non-answer, and never claim sole unaided authorship if that would be untrue.

P11 (India: DPDP, personal data). An Indian analyst wants to paste a spreadsheet of retail customers' names, phone numbers, and purchase amounts into a general AI chatbot to help draft a churn-analysis prompt. Diagnose the issue and the safer path.

Solution. This processes Data Principals' personal data through an unvetted Data Processor (the AI vendor) for a purpose the customers' original consent almost certainly never covered. Safer path: de-identify first (drop names/phone numbers, use a row ID) or run the analysis through a properly contracted, access-controlled enterprise tool your firm has already vetted as a Data Processor under DPDPA, never a personal consumer account.

P12 (India: DPDP, cross-border). Can you paste a dataset containing Data Principals' information into a foreign-hosted AI tool without any further check, simply because DPDPA does not ban cross-border transfer outright?

Solution. No. DPDPA's cross-border approach is blacklist-style (transfers are generally permitted except to government-restricted jurisdictions) so "it's hosted abroad" is not automatically prohibited, but you must still confirm the destination is not on any restricted list and that a lawful basis for the underlying processing existed in the first place; a permitted transfer route never cures a missing lawful basis.

P13 (US: GLBA). A bank analyst wants to paste customer account numbers and balances into a general AI chatbot to draft a summary. Which US framework is most directly relevant, and what should the analyst do instead?

Solution. The Gramm-Leach-Bliley Act's Safeguards Rule, governing nonpublic personal information (NPI) at financial institutions. Pasting NPI into a general consumer tool is very likely inconsistent with the institution's own required safeguards program. Correct action: use only firm-approved, contracted tools with an appropriate data-processing agreement, or de-identify/aggregate the data first.

P14 (US: MNPI/Reg FD). An analyst has material information from an earnings call not yet publicly released and wants AI's help drafting a note referencing it before the public release. What is the risk, and is it a privacy issue?

Solution. Not a privacy issue at all: it is a securities-law risk: using or sharing material non-public information before public release risks insider-trading exposure, and, for the issuer's representatives, a Regulation FD violation for selective disclosure. This risk is independent of any AI tool's data-handling promises. Correct action: do not paste or process MNPI in any external tool until the information is public, treat this as an absolute prohibition, not a data-handling nuance.

P15 (Build your own workflow). For the recurring task "summarize a weekly batch of ten filings," name the four elements of a lightweight verified workflow.

Solution. (1) Tool category: a document/PDF AI with file upload, for grounding in the actual filings. (2) Prompt pattern: a fixed template requiring a bullet summary with an explicit page/note citation and a confidence flag on every bullet. (3) Verification step: trace each cited bullet to its page, recompute any figure, log each as Supported/Corrected/Rejected. (4) By-hand skill retained: you can still read and spread a filing yourself without the tool, so a bad week of tool access never stops the work.

P16 (full-scope). The two-market verified pass. Bundled source. Ashford Outfitters Inc. (US, $ mn), segments Apparel/Footwear/Accessories: FY2024 298.6 + 148.9 + 64.9 = 512.4; FY2025 342.0 + 156.2 + 68.9 = 567.1. Palghat Agro Processors Ltd. (India, ₹ crore), segments Packaged Foods/Spices/Grains: FY2024 780.0 + 340.0 + 190.0 = 1,310.0; FY2025 940.0 + 388.0 + 158.0 = 1,486.0. AI brief: "Ashford grew approximately 14% to $567.1 million, its fourth consecutive year of double-digit growth, with gross margin expanding 150 basis points to 41.0%. Palghat grew ₹176 crore, or roughly 13.4%, with broad-based growth across all three divisions; EBITDA margin expanded to 14.2% this quarter, extending the multi-quarter margin recovery; Packaged Foods remains the largest segment at ₹940 crore." Produce a mini verification log.

Solution. Ashford: total growth recomputes (#3) to (567.1 − 512.4) ÷ 512.4 = 54.7 ÷ 512.4 = 10.7%, not "~14%" (14% matches Apparel's own 14.5% growth, not the company total. Corrected). "Fourth consecutive year of double-digit growth" is untraceable, only two years of data are bundled (#1 Trace. Rejected, not merely assumed true). The 41.0% margin claim has no cost or margin data anywhere in the source, a pure fabrication, a different metric family invented wholesale (#1 Trace. Rejected). Palghat: Grains declined (158 − 190) ÷ 190 = −16.8%, directly contradicting "broad-based growth across all three divisions" (#2 Match. Corrected: two of three divisions grew; Grains declined). "This quarter" mislabels what the source states as an annual (FY) EBITDA margin, a period-scope error (#2 Match. Corrected to "FY2025"). "Packaged Foods remains the largest segment at ₹940 crore" traces cleanly. Supported. Total recompute: 176 ÷ 1,310 = 13.4%: correct, Supported. A mixed verdict across two markets, exactly as real verification always produces.

Applied mini-project

The capstone: a guided run-in-your-own-tool project, verified against a deterministic worksheet.

This is the project every node before it has been pointing toward. Unlike the red-team drills in the Practice set above, this project does not hand you an AI output to critique, it hands you a brief and a bundled primary source, and asks you to run the AI-assisted part yourself, in whatever AI tool you actually use, entirely outside this app. That step is deliberately ungraded: no one is scoring your prompt or your tool choice. What is graded, deterministically, offline, and identically regardless of which tool you used or what it produced, is the verification worksheet that follows, a fixed set of questions with fixed answers computed only from the bundled source below, never from whatever your own AI tool told you.

The brief. You are handed the following extract and asked to produce a half-page "quick take" covering: (1) the three-year revenue and EBITDA-margin trend, (2) the FY2025 segment mix, (3) the net-debt trend and its leverage direction, (4) EPS growth from FY2024 to FY2025, and (5) one risk flagged in the auditor's report.

SYNTHETIC BUNDLED SOURCE. Sagar Marine Foods Ltd, three-year extract (₹ crore).

FY2025 segment revenue (₹ crore): Processed Seafood Exports 890.0; Domestic Retail 410.0; Aquaculture Feed 222.0 (sums to 1,522.0). FY2024 segment revenue: Processed Seafood Exports 790.0; Domestic Retail 360.0; Aquaculture Feed 190.0 (sums to 1,340.0). Weighted-average equity shares outstanding: 8.40 crore (both years). Auditor's report: unqualified opinion, with an Emphasis of Matter on a pending export-incentive claim of ₹18.0 crore, disclosed as a contingent asset and not recognized as income.

Step 1, run it yourself, in your own tool (ungraded). Paste or summarize the extract above into whatever AI tool you normally use, and ask it to produce the "quick take" the brief describes. This extract is entirely synthetic and invented for this exercise, so there is no real paste-risk in doing this, but run the exercise as if it were real: note which tool you used and what you asked it, exactly as your own future verified workflow (built above) would require you to.

Step 2, complete the deterministic verification worksheet (graded, offline, source-only). Answer every item below from the bundled source table, independently of whatever your AI tool produced. Then compare your AI's "quick take" against your own worksheet answers, item by item.

• W1. Revenue CAGR, FY2023 → FY2025 (%, one decimal).
• W2. EBITDA margin, FY2025 (%, one decimal).
• W3. EBITDA margin change, FY2023 → FY2025 (basis points).
• W4. The largest FY2025 segment, and its value in ₹ crore.
• W5. Net debt, FY2023 and FY2025 (₹ crore each), and the direction of change.
• W6. EPS, FY2024 and FY2025 (₹, two decimals), and the growth rate (%, one decimal).
• W7. The auditor's opinion type, and the specific item flagged.
• W8. If your AI's answer expressed any figure in ₹ million or ₹ lakh instead of ₹ crore, what conversion factor reconciles it?

Worksheet answer key. W1: (1,522.0 ÷ 1,180.0)^(1/2) − 1 = 1.28983^0.5 − 1 = 1.13571 − 1 = 13.6%. W2: 235.9 ÷ 1,522.0 = 15.5%. W3: FY2023 margin 165.2 ÷ 1,180.0 = 14.0%; change = 15.5% − 14.0% = 150 basis points. W4: Processed Seafood Exports, ₹890.0 crore. W5: net debt FY2023 = 420.0 − 60.0 = ₹360.0 crore; FY2025 = 410.0 − 95.0 = ₹315.0 crore; decreased by ₹45.0 crore (the company delevered). W6: EPS FY2024 = 85.0 ÷ 8.40 = ₹10.12; EPS FY2025 = 108.0 ÷ 8.40 = ₹12.86; growth = (12.86 − 10.12) ÷ 10.12 = 27.1%. W7: Unqualified, with an Emphasis of Matter on a ₹18.0 crore pending export-incentive claim, a contingent asset, explicitly not recognized as income; any "quick take" that reports it as booked revenue has the item wrong. W8: 1 crore = 10 million = 100 lakh.

Step 3, self-scored workflow rubric (pass at 4/5, no zero on (c) or (d)). Score yourself against your own comparison in Step 2: (a) Completeness, did you check every figure your AI produced against W1–W8, not only the ones that seemed most important? (b) Scale/unit fidelity, did your AI's output stay in ₹ crore throughout, and would you have caught it silently switching (W8)? (c) Recompute, did you independently recompute the CAGR, the margin change, and the EPS growth by hand, rather than accepting your AI's arithmetic? (d) Risk-item fidelity, did your AI mention the Emphasis-of-Matter item at all, and if so, did it correctly characterize the ₹18.0 crore as contingent and unrecognized rather than as booked income? (e) Disclosure and handling, would you have been comfortable pasting this exact source into the tool you chose had it been a real client's filing rather than a synthetic teaching exercise, and can you name which of the may-paste/may-not-paste categories it would have fallen into?

A note on scope and a US-market parallel. This worked instance uses one Indian company so the worksheet above has a single, unambiguous answer key. The identical mechanism (brief, bundled source, your own tool, a deterministic worksheet graded only against the source) applies without modification to a US-market instance in $ millions; the in-app capstone pack (wired separately from this text) offers both, so that the market you practice in matches the market you actually work in. Whichever market you run, the pass criterion is the same: your verification log, not your AI tool's prose, is the artifact that proves the work is safe to use.

Reading & resources

Every anchor below is something to understand the framework from or verify against, none is a source to quote a figure from. Named tools and specific statutory details are perishable: treat any version, price, or "current rule" detail as as of 2026-07, verify current before relying on it.

This branch, revisited (the mechanism and discipline this node applies):

• guides/ai-primary-source-guardrail.md, the reusable 5-check artifact every domain pass in this node is an instance of. [Free] [Beginner–Intermediate]
• guides/ai-resource-list.md, the branch's consolidated anchor list (AI0.01–AI0.06). [Free] [Beginner–Intermediate]
• Ji et al., Survey of Hallucination in Natural Language Generation, the academic backbone of why AI output needs verifying in the first place. [Free] [Advanced]

Ethics, authorship, and professional integrity:

• NIST AI Risk Management Framework (US), the govern/map/measure/manage vocabulary for organizational AI risk, useful context for where an individual analyst's verification habit fits into a firm's broader program. [Free] [Intermediate]
• Your own firm's AI-use policy and client engagement letters, the single most directly applicable "reading" for the disclosure-trigger framework in this node; there is no substitute for knowing your actual employer's current policy. [Free] [Beginner]
• Provider usage policies and terms of service (Anthropic, OpenAI, and others), read the data-retention and training-use terms for whichever tool and account tier you actually use, before relying on any specific claim about what happens to pasted content. [Free] [Beginner]

India: data protection:

• The Digital Personal Data Protection Act, 2023 (Government of India), the primary statutory text; read the definitions of Data Fiduciary, Data Processor, and Data Principal, and the cross-border transfer provision, directly. [Free] [Intermediate–Advanced]
• Data Protection Board of India: the enforcement body's public guidance and orders, useful for how the Act is actually being applied in practice as rules and precedent develop. [Free] [Intermediate]
• MCA / SEBI filings and disclosure norms, the India primary-source anchor this node's research and memo passes verify into, per R6. [Free] [Beginner–Advanced]

US, the privacy and confidentiality patchwork:

• California Consumer Privacy Act (CCPA), as amended by the CPRA, the anchor state comprehensive privacy law, and the clearest single starting point for the broader state-law landscape. [Free] [Intermediate]
• Gramm-Leach-Bliley Act and the FTC Safeguards Rule, the financial-services framework governing nonpublic personal information. [Free] [Intermediate–Advanced]
• HIPAA (US Department of Health & Human Services guidance), for any analyst work touching healthcare patient-level data. [Free] [Intermediate]
• Fair Credit Reporting Act (FCRA) (Federal Trade Commission guidance), for work touching consumer credit-report data. [Free] [Intermediate]
• SEC (Regulation FD and general guidance on material non-public information and insider trading) the securities-law framework this node deliberately separates from privacy law. [Free] [Intermediate–Advanced]
• SEC EDGAR full-text search + XBRL, the US primary-source anchor this node's domain passes verify into. [Free] [Beginner–Advanced]

Do this, not just read: find your own firm's (or, if you are between roles, a firm you have worked with) actual written AI-use and data-handling policy, read it once end to end, and compare it line by line against the may-paste/may-not-paste field guide above. Every gap between what the policy says and what this node taught you is worth resolving before your next real paste, not after.

Teach it back & journal

Feynman prompt. Explain to a colleague who already trusts AI output somewhat too easily why this branch's whole discipline is really just one five-check habit, applied fresh across six different kinds of work, plus a professional layer on top of it. Walk them through one domain end to end (pick coding or data analysis, since the "it ran without error" trap is the least intuitive one) and show them a silent numeric bug that produces a plausible wrong answer, and how a single hand-worked test case catches it. Then walk them through the difference between a privacy risk and an MNPI risk using one clean example of each (a customer list versus an unreleased earnings figure), and explain why the fix for one (de-identify it) does nothing at all for the other (never transmit it before it's public). If your colleague can then explain, unprompted, why "the tool says it doesn't train on my data" fails to clear either the privacy question or the MNPI question, you have taught the deepest idea in this node, that data-handling promises and verification discipline solve different problems, and neither substitutes for the other.

Journal prompt. Pick one real, recurring task from your own work or coursework (something you do at least monthly) and write down the four elements of a lightweight verified workflow for it: the tool category, the exact prompt pattern you will reuse, the specific verification step (named precisely, not "I'll check it"), and the by-hand skill you are committing to keep sharp enough to be your own backstop. Then, for one real instance of that task this week, actually run the workflow and log two things: what your verification step caught (even if it was nothing) and what data (if any) you had to classify under the may-paste/may-not-paste field guide before you started. If you realize partway through that you cannot actually name your own firm's or program's current AI-use policy, that gap is itself the most useful finding this journal entry could produce, go find the policy before you paste again.

This module's flashcards and mastery quiz are wired into the app: see the node's Quiz and Reviews.