Accounting knowledge. Practical AI. Your own prototype.
Start with an accounting problem. Read a working example, try it, make a change and explain the result. No previous programming experience is assumed.
Build the foundations
Learn Python, Colab, dictionaries and Pandas, then process folders and handle errors.
Get accounting data
Read and write spreadsheets and PDFs, call APIs and build a checked XBRL series.
Connect, scale and test LLMs
Call models from Python, process multiple inputs and compare prompts using accounting checks.
Apply AI to accounting
Work twelve live-LLM practice cases across cash, purchasing, financial reporting, tax and audit.
Decide and build
Work through business cases, then pitch, review and deliver your final project.
Keep the accounting question and its supporting evidence at the center of your project.
The full course plan
Modules are learning units, not fixed weeks. The full path contains twelve modules, organized into short sections and, where useful, submodules, ending with a business case and the final group project. Professors choose which lessons a class follows and when. Professors can adjust these plans to their school; independent learners follow the full sequence at their own pace.
Python for accounting records
- 2.1 Run and rerun a small programNotebooks, cells and runtimes · Running a cell · Editing and rerunning cells
- 2.2 Name values and distinguish their typesVariables and assignment · Data types: numbers, text and True/False · Printing results and comments
- 2.3 Calculate before formattingArithmetic and the order of operations · Getting input from the user
- 2.4 Lists and dictionaries: store related factsLists · Dictionaries · Apply dictionary lookups: company equity · Nested records and lists of dictionaries · JSON text and Python objects · Validating a parsed record · Saving and loading JSON files
- 2.5 Ask precise questions and choose a routeComparisons and True/False values · Conditionals: if, elif and else
- 2.6 Repeat a rule without losing a recordLoops: for and range
- 2.7 Give reusable logic a function nameFunctions: def, parameters and return
- 2.8 Read errors as cluesReading error messages · When something goes wrong
- 2.9 Independent practiceMini project: a simple ledger · Check your understanding
Working with accounting tables
- 3.1 Turn familiar records into a first tableWhat pandas is for
- 3.2 Read rows, columns and typesCreating and reading a DataFrame · Selecting columns and rows
- 3.3 Prepare values without erasing uncertaintyCleaning names and data types
- 3.4 Filter and flag the full populationFiltering rows and review flags
- 3.5 Investigate repeated recordsSorting and finding duplicates
- 3.6 Reconcile summariesGrouping and summarizing
- 3.7 Join reference data without multiplying amountsMerging two tables
- 3.8 Choose checks that can disagreeCheck your understanding
Files as evidence: CSV and Excel
- 4.1 Read and inspect a CSVSee the CSV behind the table · Find and inspect a CSV file
- 4.2 Preserve identifiers and reconcile the importPreserve identifiers during import · Validate the imported population · Optional: compare the csv module after core practice
- 4.3 Write and reopen the selected workpaperWrite and reopen the review CSV · Complete the connected task after the Excel lessons
- 4.4 Choose the intended workbook sheetChoose the Excel sheet before reading · Read and inspect the workbook tables
- 4.5 Distinguish formulas, stored results and displayFind headers and separate report totals · Distinguish formulas, cached results and display
- 4.6 Write an inspectable workbookWrite and reopen a three-sheet workpaper · Add a formula and readable number formats
Documents and services: PDFs and APIs
- 5.1 Read PDF pages with their evidence locationsRead a page and preserve its location · Detect pages needing another reading method
- 5.2 Interpret extracted amounts and report themExtract checked Cedar fields · Write and reopen a source-linked PDF report
- 5.3 Understand an API exchangeInspect a saved API exchange · Build the request before sending it · Check status before reading the body · Retrieve and reconcile two response pages · Validate a POST payload before sending
Asking for answers you can check
- 6.1 Connect to a model safelyGetting access: the book connection and a personal provider account · Keeping keys and costs safe · Making a first API call
- 6.2 Specify the evidence, the audience and the deliverableThe request pattern with ask() · Sending accounting data to a model · Exercise: supplier invoice notes
- 6.3 Request typed fields and check themStructured output with JSON · Checking output against the source
- 6.5 Keep data, instructions and authority separateDrafts, authority and private data · Check your understanding
Testing and improving the workflow
Open this module →Processing many records reliably
- 8.2 Find and combine files with source referencesFile paths and storage locations · Listing files and building a manifest · Combining files with source names
- 8.3 Record a per-file failurePer-file errors and an outcome log · Reruns and duplicate files · Excel and PDF files in bulk · Folder-processing task and check
- 8.4 Make a checked request for each eligible recordLooping over records · Prompt rules and output schemas · Repeated calls and consistency · Collecting results into a table · Exercise: classify an expense batch · Check your understanding
- 8.5 Distinguish a temporary request failure from uncertain evidenceSafe reruns with a completion log · Catching errors with try/except · Retrying with a fixed limit · Retries with a fixed limit · Checking each answer · Fingerprints and source versions · Chapter exercise: failure and rerun · Check your understanding
- 8.6 Save enough evidence to resumePipelines and checkpoints
- 8.7 Estimate API and review effort togetherEstimating API and review cost · API budgets and pilot runs
- 8.8 Use asynchronous processing when the work can waitProvider batch APIs
Purchasing and expenses
- 9.1 Review the desk-set invoiceAn invoice that is not ready for payment: evidence and first review · An invoice that is not ready for payment: changed evidence
- 9.2 Review the employee dinner claimAn employee expense claim: evidence and first review · An employee expense claim: changed evidence
Cash and receivables
- 10.1 Allocate the Orbit Fitness receiptAn unidentified bank deposit: evidence and first review · An unidentified bank deposit: changed evidence
- 10.2 Draft an account-specific collections responseA collections follow-up: evidence and first review · A collections follow-up: changed evidence
Month-end review and reporting
- 11.1 Practice: a plan is not a causeA travel-expense decrease: evidence and first review · A travel-expense decrease: changed evidence
- 11.2 Review an October accrual candidateAn October accrual candidate: evidence and first review · An October accrual candidate: changed evidence
Tax preparation and review
- 12.1 Prepare expense intakeExpense receipts for tax review: evidence and first review · Expense receipts for tax review: changed evidence
- 12.2 Prepare a fixed-asset evidence fileA bundled fixed-asset invoice: evidence and first review · A bundled fixed-asset invoice: changed evidence
- 12.3 Request only the missing evidenceA targeted missing-document request: evidence and first review · A targeted missing-document request: changed evidence
Audit evidence and follow-up
- 13.1 Compare approval evidence with the controlApproval timing for INV-0205: evidence and first review · Approval timing for INV-0205: changed evidence
- 13.2 Turn the journal explanation into a procedureJE-0331 without support: evidence and first review · JE-0331 without support: changed evidence
- 13.3 Trace a subsequent receiptINV-0201, paid or only claimed: evidence and first review · INV-0201, paid or only claimed: changed evidence
Business decisions with incomplete evidence
- 14.1 Acquisition Under PressureAcquisition Under Pressure
- 14.2 The Revenue TargetThe Revenue Target
- 14.3 Fraud or a False AccusationFraud or a False Accusation
- 14.4 Profitable but Running Out of CashProfitable but Running Out of Cash
- 14.5 The Audit Tool Claiming 98 Percent AccuracyThe Audit Tool Claiming 98 Percent Accuracy
- 14.6 The Finance Team After AutomationIndependent practice and project milestone · The Finance Team After Automation
Building and defending your project
- 15.1 Pitch your projectPitch an accounting solution with explicit assumptions · Annotate all ten fields of one project pitch
- 15.2 Review another groupPeer review should challenge the reasoning
- 15.3 Submit your final projectPrepare a demonstration another accountant can follow
Financial data and XBRL
- A.1 Economic series and financial contextFRED economic data
- A.2 SEC filing identities and company factsSEC filing lists · XBRL company facts
- A.3 Non-overlapping quarters and a derived Q4Quarters, year-to-date and Q4
- A.4 Select the filing available at a stated dateChoosing a filing as of a date
- A.5 Build and retain a checked financial seriesBuilding and charting a checked series · A source-linked quarterly workpaper · Exploring real public data · Check your understanding
Environment, Colab and AI assistant reference
Open this module →How I believe AI should be taught in accounting
The following approach adapts my teaching philosophy and experience for this course. The accounting question remains central; Python and model APIs help put it into practice.
Accounting knowledge is the starting point
I teach technology as a way to extend accounting knowledge. An accountant already knows that an amount needs a source, an approval needs evidence and an exception needs an explanation. Those ideas remain central when a language model enters the workflow. The technology changes what we can process and how quickly we can process it; it does not remove the need to decide what should be checked.
In my teaching, the starting question is therefore practical: what repetitive accounting task would you like to improve? It may be reading a memo, following up on missing evidence, classifying expenses or comparing an invoice with a receiving record. We begin with that task and work toward an application that helps somebody perform it. The code has a purpose from the beginning.
This approach comes from teaching business processes, accounting information systems and AI as connected subjects. A process map identifies who does what, which records move between people and where a control belongs. A small program can implement part of that process. A language model can help interpret text or draft a response within it. Students need to understand the relationship between these parts, rather than see technology as a separate subject added to accounting after the important work is finished.
My aim is to help learners become people who can specify, test and improve an application. Knowing the accounting problem gives you a reason to question a result. If the model produces a polished paragraph that promises an unsupported payment date, your accounting judgment should tell you that the paragraph needs correction. Technical fluency is useful; knowing which claim the evidence supports is essential.
Read before you write
Most of the students I teach arrive without a programming background. Asking them to create an application from a blank screen can make a manageable idea feel inaccessible. I prefer a read-before-write progression. First, inspect a small example. Identify the input, trace the instructions and explain the result. Run the original before changing it. Then make one change whose consequence you can predict.
You do not need to memorize every command to benefit from this process. You need to recognize which value you are changing, what the next instruction uses and how to tell whether the result makes sense. Python becomes a means of organizing work: read a record, repeat a check, send a request, retain a response. We introduce the basics when the accounting task gives them a clear use.
The platform follows the same principle. Explanations and small code steps belong together. After reading about a condition, you should be able to try the condition, see what it does and change the input without searching through an unrelated collection of files. More demanding examples provide a separate code workspace, but the learning sequence remains the same.
Move beyond chatting toward a working application
A chat interface is a useful introduction to generative AI, but it is only the beginning of what an accounting application requires. A repeatable workflow must prepare information, send a request, interpret the response, apply checks and retain a record. Public LLM APIs make it possible to connect those operations through a program.
This course concentrates on that practical connection. You will learn to describe a task clearly, supply the relevant facts, request a usable response and recognize when the answer goes beyond the evidence. You will also encounter the less glamorous parts that make an application useful: missing fields, inconsistent units, model failures, changing source documents, costs and repeated runs.
The goal is not to train a language model from scratch. It is to use existing models intelligently within an accounting process. Some jobs are better performed by an explicit calculation or rule. Other jobs benefit from interpreting text. Learning to choose between those methods is part of the course, not an obstacle on the way to using more AI.
Cases connect the method to professional judgment
I use cases because a recognizable problem makes an unfamiliar method easier to understand. My teaching and research have brought together document review, regulatory correspondence, fraud-related signals, controls and accounting automation. The recurring lesson is that the quality of the question, the source material and the evaluation matters as much as the ability to make a model call.
A case also leaves room for students to become co-designers. You can suggest a better source, identify an ambiguity in a rule, propose a more useful output or design a test that reveals a weakness. Those contributions show accounting understanding. You are not limited to reproducing the instructor's sequence of commands.
The course therefore develops through examples and extensions. First see a working case. Next investigate a changed input. Then make an extension you can justify. The platform's additional cases and practice checkpoints give you opportunities to transfer a method rather than repeatedly demonstrate that you can copy the same program.
Introduce the project at the beginning
I introduce the final project early because it gives the course a destination. Think of a boring or repetitive task you have seen in an internship, a job or an accounting exercise. Ask what information a small application would need and what output would be useful to a person doing that work. Keep that idea in mind as each module adds another capability.
The first idea does not have to be the final idea. You may discover that the source data are unavailable, the task is too broad or a simpler check would be more useful. Revising the scope is part of learning. A project becomes stronger when its purpose and limits become clearer, even if its feature list becomes shorter.
By the end, you should have something you can demonstrate: a defined input, a useful output, a few checked test cases and an explanation of the work that still requires human review. That is more informative than a general claim that you have studied AI.
Make mistakes visible and useful
Experimenting with an unfamiliar tool involves errors. I want students to feel able to ask questions, admit confusion and investigate an unsuccessful result. That openness allows the course to remain demanding without turning every technical setback into a judgment about the student's ability.
A learning diary helps make the process visible. Record the goal, the attempt, what happened, a check or mistake and the next revision. A useful entry can be short. “The model filled a missing amount with zero; I added a missing-value check and tested both situations” tells a reader more than a long entry saying that you worked hard.
An ambitious project may be less polished than a simple project that works on a narrow example. Fair assessment should examine the accounting purpose, the design decisions, the quality of testing and the student's explanation of setbacks as well as the finished interface. Taking a thoughtful risk should not be discouraged merely because it exposes a difficult problem.
Assess understanding and progress
Students begin with different levels of technical experience. I do not expect them to finish as identical programmers. I do expect each student to make progress, understand the important decisions in their own work and be able to discuss the evidence behind a result.
In my classroom, a final conversation about the project is especially valuable. Students demonstrate the application, walk through the code and explain a change. Questions about a failed case, a prompt revision or a control help distinguish understanding from surface polish. Slides can support that conversation, but they should not substitute for showing what the application actually does.
For an instructor using this course, the assessment plan should be explained before the project begins. Consider the usefulness of the accounting task, the reasoning behind the design, the test evidence, the diary and the final explanation. Platform activity records can help identify where a student needs support. A click count or time estimate alone cannot establish effort, understanding or an appropriate grade.
Keep the course accessible and current
Clear instructions, legible figures, small examples and opportunities to revisit an explanation help learners with many different needs. The aim is to remove unnecessary barriers to participation while retaining the accounting challenge. A learner should not have to guess which button to press before being able to think about the problem.
The technology will continue to change. Specific models, prices and interfaces will not remain fixed. The durable habits are asking a precise question, preserving the source, testing an answer and explaining a limitation. The platform can update the practical details while this companion keeps the overall learning route clear.
This chapter adapts the teaching philosophy and instructional reflections in my Teaching Portfolio. The program that follows is a learning plan for Applied Generative AI for Accounting, expressed for readers and instructors using this platform.
Start from your own level
Your progress is measured through what you can build, check and explain. A learning diary, test evidence and a demonstration matter more than a polished interface alone. In a class, follow your professor’s published grading scheme.
Open the course →Read the free companion