Intercompany reconciliation is one of the most persistent bottlenecks in the financial close. For any group with multiple legal entities, the process involves matching hundreds or thousands of reciprocal transactions — intercompany sales, loans, management fees, cost allocations, and dividends — across ERPs, spreadsheets, and inboxes. The matching itself is rarely the hard part. The hard part is the noise: transactions recorded in different currencies on different dates, one-sided entries sitting in suspense accounts, transfer pricing markups applied inconsistently, and the inevitable timing differences that make two perfectly legitimate records look like a dispute.
Controllers and financial analysts typically spend the first week of every close chasing counterparties by email, exporting trial balances from three or four systems, and manually keying adjustments into a consolidation tool. The work is repetitive, error-prone, and heavily dependent on the institutional knowledge of one or two senior people. When those people are on leave, the close slips. When volumes grow, the process breaks. And because the reconciliation sits upstream of consolidation and elimination, every unresolved difference delays group reporting and audit readiness.
Claude Code changes the economics of this work. Because it operates directly on files — CSVs, Excel exports, markdown policy documents, ERP extracts — it can ingest your intercompany data, apply your matching rules, classify exceptions, and produce a structured reconciliation package without you building fragile macros or buying another point solution. It reads your netting policy, your chart of accounts mapping, and your prior-period reconciliation notes, then executes against all of them consistently. The analyst moves from keying data to reviewing exceptions and approving adjustments.
Why the prompt structure matters more than the model
Most failed AI experiments in finance fail at the prompt, not the capability. A vague instruction like “reconcile this intercompany data” produces a plausible-looking output that quietly violates your materiality thresholds and netting conventions. What works is a structured prompt that forces Claude to read your standards first, restate the objective, ask clarifying questions, and present an execution plan before touching the data. That sequence is what turns a generic language model into a controlled reconciliation workflow.
The two prompts below follow that structure. The first builds the matching and exception engine. The second generates the counterparty confirmation pack and the audit-ready reconciliation memo. Adapt the bracketed placeholders to your entity structure, currencies, and tolerance levels.
First, read these files completely before responding:
ic_policy.md — our intercompany netting and settlement policy, including materiality thresholds and approved clearing accounts
coa_mapping.csv — chart of accounts mapping showing which GL accounts are in scope for intercompany matching
prior_period_exceptions.md — last period’s unresolved differences and how each was resolved
fx_rates_[PERIOD].csv — period-end and average rates by currency pair
Here is a reference for what I want to achieve:
[Upload last period’s completed reconciliation workbook as markdown, or describe the output format your consolidation team expects]
Here’s what makes this reference work:
– One row per matched pair, with both entity IDs, GL accounts, amounts in local and group currency, and the FX rate applied
– Exceptions separated into three buckets: timing differences, FX differences, and true disputes
– Every exception carries a root-cause label, an owner, and a target resolution date
– A summary tab showing total intercompany balance by entity and confirmation that the group nets to zero after eliminations
– Tone is factual and audit-defensible: no hedging language, every number traceable to a source file
Here’s what I need for my version / SUCCESS BRIEF:
Type of output + length: Structured reconciliation file plus a 1-page exception summary (max 400 words)
Recipient’s reaction: The group controller should be able to approve eliminations without re-checking the matching logic, and the external auditor should accept the exception log as sufficient documentation
Does NOT sound like: A generic data dump, a list of unmatched rows with no explanation, or anything that requires the reader to open the source files to understand a difference
Success means: 95% or more of intercompany transaction value matched automatically, every remaining exception classified with a root cause and owner, and zero unexplained differences above [MATERIALITY THRESHOLD]
My context file contains my standards, constraints, audience. Read it fully before starting.
DO NOT start executing yet. Ask clarifying questions first.
Give me your execution plan (5 steps max) before you begin.
From reconciliation to confirmation and audit evidence
Matching the data is only half the cycle. The other half is proving it: sending confirmation requests to counterparties, chasing responses, and assembling a memo that explains every remaining difference in language an auditor will accept. This is where most finance teams lose days, because the confirmation pack has to be tailored per entity and the memo has to reconcile back to the exception log without contradiction.
The second prompt handles that downstream work. It takes the reconciliation output and generates both the counterparty-facing confirmation requests and the internal memo, keeping the two consistent by construction. Note the emphasis on the recipient’s reaction — for confirmation requests, the goal is a fast, unambiguous response; for the memo, it is auditor acceptance without follow-up questions.
First, read these files completely before responding:
reconciliation_output_[PERIOD].md — the matched pairs and classified exceptions from the matching step
ic_policy.md — our confirmation thresholds and required response windows
entity_contacts.csv — counterparty contact names, emails, and preferred language per entity
prior_memo_[PERIOD-1].md — last period’s memo, used as the tone and structure reference
Here is a reference for what I want to achieve:
[Upload last period’s confirmation email template and memo as markdown, or describe the format your audit team signed off on]
Here’s what makes this reference work:
– Confirmation requests state the balance, the currency, the as-of date, and a single clear action with a deadline
– Each request is entity-specific: no group-level jargon, no references to accounts the counterparty does not own
– The memo opens with the reconciliation result, then walks through exceptions by category, then states the proposed adjustment
– Every claim in the memo cites a source file and line reference
– Tone is neutral and precise: no adjectives, no speculation about causes that are not evidenced
Here’s what I need for my version / SUCCESS BRIEF:
Type of output + length: One confirmation request per counterparty (max 150 words each) plus a reconciliation memo of 600-800 words
Recipient’s reaction: Counterparties should reply with a yes or no without needing clarification, and the auditor should sign off without requesting supporting schedules
Does NOT sound like: A legal notice, a marketing email, or a memo that buries the adjustment in the middle of a paragraph
Success means: Confirmation response rate above [X]% within [X] business days, and zero auditor follow-up questions on the memo
My context file contains my standards, constraints, audience. Read it fully before starting.
DO NOT start executing yet. Ask clarifying questions first.
Give me your execution plan (5 steps max) before you begin.
A practical tip before you run either prompt: build your context file first. Spend thirty minutes writing down your materiality thresholds, your approved clearing accounts, your netting conventions, and the two or three things your auditor always asks about. That single markdown file is what separates a reconciliation you can defend from one you have to re-explain every quarter. Store it alongside your policy documents so both prompts read the same source of truth.
Once the matching engine is stable, the natural next step is scheduling it. Claude Code can run the reconciliation on a fixed cadence during close, flagging exceptions to owners automatically and versioning each period’s output. From there, extend the same pattern to other high-friction close tasks: intercompany profit elimination, transfer pricing true-ups, and FX revaluation checks. The structure stays the same — read the standards, restate the objective, plan, execute, document.
Published on 20 September 2026 on growwithgpt.com