I’ve built an app that helps me read annual reports.
The cool thing is, you can select Buffett, and Buffett will assist you during the read-through. You’ll see the master’s comments in the margins.
The app still needs some love, but it will be included in the release of our Claude skill library and video course in September. If you’d like early access, you can sign up for our private beta program, which launches next week.
Only 20 spots in the private beta. The private beta will provide a significant discount, but in exchange, we ask for your help working with us for a couple of weeks to make everything better. You’ll get access to a private Discord.
So today, we’re going to take a look at how you actually build a “Buffett-persona” so that it, and others, can become your “Board of superinvestors” that assist you with your reading and decision-making.
Building a persona that mimics how Buffett thinks is not that hard. Of course, the quality of the persona will depend on how far you want to take this build.
I’ve defined 3 levels of how you can build this. Let’s explore all 3 and see what each one adds to the result.
Note: If you can do this for Buffett, you can do it for any famous investor. But the corpus of knowledge out there on Buffett is so large that you’ve got more data than any other investor to build with.
Let’s say our goal is to analyze a company called XPEL. XPEL creates and sells high-quality paint protection film that you wrap around your fancy car to protect its paint.
Yep, XPEL has become a solid multibagger since its IPO.
So let’s use the simplest prompts possible, combined with Claude Opus 5.
Retrieve XPEL’s latest 10k and analyze it the way Warren Buffett would.
There’s nothing wrong with this. It’s quick. It’s fast. And if you use a model like Opus 5, it will do a pretty good job.
Let’s see what it gives us. Now, bear in mind I had Claude fetch the 10-K from the SEC website. It would be better to use connectors, as we discussed in a previous article, but for this test, I want it to simulate the easiest and fastest way.
I published a live Claude artifact with the result
I ran this prompt twice in both cases and created a diff table (to spot the differences and similarities in 2 runs).
Conclusion: Even though the prose is quite different, the differences are small in the most important aspects.
This was not possible a year ago. It’s a testament to how good the models have become.
Now, a variation on this is to use research mode in Claude.
Activate research mode and then add this simple prompt:
Create a Markdown file on how Buffett would analyze a business when he reads its 10-K.
Claude will work its magic:
It will take about 10 minutes for it to create a Markdown file.
And then we just do this, in a new chat, give it the file.
Now we’ve given Claude a framework to do the analysis. I expect this to deliver better results.
And the actual result is more structured.
As demanded by the markdown file, the output in both runs is structured as follows:
Circle of competence check: State in one sentence how the company makes money and where it will plausibly be in 10 years. If you cannot, it’s outside of the circle.
Run a franchise test: Apply the 1991 three-part franchise test and run the pricing power question: Could it raise prices by 10% without losing customers?
Check owner’s earnings: Rebuild owner’s earnings through a formula. (Note: when doing this, Claude did not use Python)
ROIC and the 1 dollar test: Chart 10 years of ROE/ROIC. Then test whether cumulative retained earnings produced at least $1 of market value each over rolling 5-year windows. (It’s a great test, but I do not think Claude did it as asked, as I did not have the data)
Footnote audit: Check debt term maturities, operating leases, SBC (add it back as a real expense), etc.
Candor Audit: Does management explain bad news plainly and admit mistakes, or do they feature adjusted metrics and a glossy narrative?
Red-Flag Sweep: Check for recurring “one-time” charges, accounting policy changes, late filings, etc.
Where the markdown file we uploaded explains how to calculate certain numbers, it follows those calculations. Where context is missing, Claude will fill it in.
All in all, this file contains a lot of information. But it asks Claude to run numbers and do checks where a single 10k isn’t enough to spot these. Let alone be sure that Claude “understands” what all these checks mean.
Let’s again run a diff table and see what happens:
Again, both runs are quite similar. The only red flag in the diff table is that, apparently, in the second run, Claude decided to go beyond the 10k and also fetch 2 other data points. So that’s not really a problem. Claude just improvised in the second run.
Why do we run these “diff” tables?
Because it’s an easy way to see what we need to improve to remove the differences as much as possible.
For example, in this case, we can just instruct inside the markdown file exactly which data to retrieve and which data not to retrieve. And to make it better, for each formula, we could provide the formula and ask it to use Python for calculations.
That way, we can get something more predictable, so every run would provide almost the same result.
Here are the results of using Claude research
So what does the markdown method add to the mix:
More structure (the file has a method)
The chapters it proposes are very Buffett-like
A bit more reproducibility (it follows the structure in each run)
In fact, when you ask Claude to read the 10k like Buffett in 2 different sessions, its conclusions are more or less similar, but the analysis itself differs.
That is to be expected. LLMs are probabilistic; the output will be different on every run.
Our goal here is to build the best “Buffett-like agent” we can so it becomes a true assistant.
So how can we take it up a notch?
Instead of iterating and building our assistant from scratch, let’s see if someone else hasn’t built something out there that is better than a simple markdown file.
Then we might copy that codebase, fork it, adapt it, and make it suit our specific purposes.
(We used our /findcoworkskills with the keyword Buffett to see what it could find online.)
And as expected, there is a lot of stuff out there:
Here’s one that stood out: github.com/agi-now/buffett-skills
So usually, for a GitHub repository, I’d ask Claude Code how to install and test it. But let’s try it in Claude Cowork and see if we can get it to work.
And if you just create a new task in Claude Cowork, it will start reading the repo:
So Cowork will do its magic.
It will mention that normally this is only used for Claude Code, but that it read everything, converted it into a skill, and voila:
So before running this, how does it compare to our previous markdown file?
As you can see, it has a lot more context, with the skill file itself containing 8 reference files.
Let’s run it on the same company as before: XPEL, and see what happens:
So Cowork started going through all the documents and spun up some research agents:
I ran 2 instances of this skill again. In the first one, I let it use the free data available online. In the second run, I let it use my EODHD connector.
I use EODHD as a worldwide data provider. As I’ve shown you in this article, it all starts with great data. You can check out EODHD here.
So, back to the results.
This skill will go through the following 5 steps inside Cowork:
And I admit, it produced a concise, but in my view, the best report yet.
You can check out the artifact here.
But although it talks about moat, owner’s earnings, etc. It is less Buffett-like than before. No management candor or red flag analysis.
So I think we could fork this codebase and make it even better by using the research document we created with Claude and adapting the reference files.
My only beef with this: It’s all pure Markdown files. There is no real “CODE” inside. The skills we build for our own analysis are usually a combination of a narrative layer (the LLM) and a deterministic layer (Python).
And that takes us to level 3
More than a year ago, I wrote an article on how Buffett reads financial statements.
In that article, I proposed certain thresholds, a framework that could be used when walking through a company.
So we’ll add that to everything we said before. We’ll take the Buffett research file, add those thresholds in, but we won’t let Claude decide and calculate.
The setup looks like this:
Input financial data
Threshold calculated through Python
Add the Buffett layer and analysis on top
Now, why are we doing this?
Well, as mentioned in the introduction, we can integrate it into our 10kassistedreaderapp.
I know, it’s not a fancy name- a bit of a mouthful but what it does is:
Loads a 10-K
Makes it more readable
Adds assistants (in this case, Buffett) that chime in while you’re reading.
And the beauty of adding it as a level 3 is that it will calculate financial metrics and compare them to thresholds based on “How to read financial statements like Buffett”.
It looks like this:
But you could turn it into a chatbot, or find other ways to use this Buffett persona.
We used Markdown files based on what a person created on GitHub and added our own framework, with calculated thresholds through Python.
So how to make it even better?
By taking all the annual letters and the Berkshire Hathaway transcripts and parsing the data. You get a better assistant, and here’s why:
Rejections: Online knowledge is skewed toward what Buffett bought and why. So Opus will lean toward affirmation, not rejection. Re-parsing all the data lets us find when Buffett said no, and why.
Auditability: Every decision or calculated threshold could be traced back to a specific letter and date. In other words, you would know this is not an “interpretation” by Claude
Better calibration: Instead of the model saying, “It’s a pass and here’s why,” it would be able to source the actual past decisions and provide evidence for its reasoning.
So what does this re-parsing mean? Here’s the method I would use to build this:
Label each letter: Date, page, etc., so that you know exactly what he said, when, and where the proof is. Create data with a time series
Chop the letters up: For example, look specifically for decisions on investments. Or for a 10k reader, everything that relates to accounting. If you just let the LLM read a letter, it will give you a summary. So you need smaller pieces.
Remove all the pieces not related to what you’re looking for.
Create a standard form you fill out with each data file you extract. This allows you to standardize and build a database
Double-check: Let the software take the data, and recheck where it was mentioned in the letters. If it cannot find it, it might have been made up.
Now sort the data and see if the sorting reveals certain rules for investing.
Convert those rules into numbers and thresholds if possible
Now write out the Buffett persona. A persona file: a JSON file with all the results of the data.
The end result:
Buffett will add his comment inside the 10k
You can click it and go to the exact letter from the past to understand his reasoning
Well, that’s what we’re building.
Thanks a lot for reading, as always.
May the markets be with you!
Kevin
No posts
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.