The original AI Bootcamp launch video follows:

Active investing using AI tools well is a real edge, but only for investors who learn to use them in a way that respects their own philosophy. Generic AI outputs are not enough. Pasted into a research process, they are at best a distraction and at worst a quiet source of error.

The AI Bootcamp for Non-Technical Investors is a 16-lesson series, plus an introduction, that walks you through building your own AI-powered investment idea engine. No coding background is required. No statistics background is required. The only prerequisites are a working investment philosophy, the patience to verify what the machine tells you, and roughly 30 minutes per lesson.

The bootcamp originally ran as a four-week cohort in May 2026. Everything is now published and available for you to work through at your own pace.

What you will actually build

By the end of the series, you will have, on your own machine and in your own accounts:

• A “My Analyst” workspace in both Perplexity and Claude, with a system prompt that encodes your investing philosophy, your “never do this” rules, and your tone.

• A small library of reusable prompt templates and a personal “always verify” checklist that sits between any AI output and a buy, sell, or pass decision.

• A working data layer built on three free or low-cost backbones: SEC EDGAR for primary filings, FRED for macro and sector data, and a data service for fundamentals — with a bench of free fallbacks behind them.

• An idea-record JSON schema and a wide-research workflow that lets you triage 20 companies in an afternoon.

• A real Python screener, version-controlled in Git and GitHub, that pulls from a data service, layers on EDGAR filing freshness and FRED macro context, scores survivors against weights you wrote down, and produces a narrative triage pack on the top three names.

• A scheduled, automated end-to-end run of that engine, delivered to a channel you choose, with a README and a three-month retrospective that hold future-you accountable.

You will end the bootcamp with a working system you understand line by line, not a black box.

Who this is for

• Value investors who want AI in their workflow without surrendering judgment.

• Non-technical investors who have been put off by tutorials written for engineers.

• MOI members and Latticework subscribers who already have a philosophy and want a faster, more disciplined research loop around it.

If you can read a 10-K and you can follow a recipe, you can complete this bootcamp.

What you will need

• Perplexity Pro (~$20/month).

• Claude Pro (~$20/month).

• A data service, optional but recommended (varied cost).

• Free accounts at GitHub, FRED, and SEC EDGAR.

That is the full stack. No Bloomberg terminal, no FactSet seat, no engineering team.

How the bootcamp is structured

The 16 lessons are organized in four phases. Each lesson takes roughly 30 minutes and produces a concrete artifact you keep.

Phase 1: Foundations (Lessons 1–3)

How AI models actually think, the prompt patterns that outperform casual prompting, and the agentic workflows that leave behind clean, reusable artifacts.

• Introduction: Build Your Own Investment Idea Engine — The framing post. Why this series exists, who it is for, what you will build, and how to use it.

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations — LLMs are fluent first, accurate second. The four defenses against hallucination, two hands-on tests against a real 10-Q, and your personal “always verify” checklist.

• Lesson 2: Prompt Patterns That Outperform Casual Prompting — The five-element prompt template (Role, Task, Context, Constraints, Format), a reusable Buffett-style quality screen, and a “My Analyst” Space and Project with your philosophy baked in.

• Lesson 3: Tools, Agents, and Structured Output — Three tiers of output reliability and a small idea-record JSON schema that will accumulate over the four weeks as a library of comparable records, not a pile of notes.

Phase 2: The data layer (Lessons 4–7)

Where investors get clean, free, reliable data, and how to pull it into the engine.

• Lesson 4: SEC EDGAR, the Primary Source — Filing types, the EDGAR API, full-text search operators, a five-bullet risk summary from a real 10-K, and a personal list of EDGAR searches worth monitoring.

• Lesson 5: Free Access to FRED Macro/Sector Data — A free FRED API key, a 10-series macro core (rates, inflation, labor, credit, money, production), and a sector layer for the industries you actually follow.

• Lesson 6: Data API Key and the First Checked Data Pull — Registering for a data service, pulling the three statements and key metrics for one ticker, and verifying one number against the company’s own filing on EDGAR.

• Lesson 7: Other Data Sources, and Idea Engine Formats — A bench of free and low-cost fallbacks (Stock Analysis, Fiscal.ai, Koyfin, OpenInsider, WhaleWisdom, others) and the three formats the engine will speak: CSV, JSON, and Markdown.

Phase 3: Perplexity and Claude as research partners (Lessons 8–11)

Spaces, Projects, connectors, memory, sub-agents, and screening at scale.

• Lesson 8: Spaces, Projects, and Connectors — Three durable research rooms (Watchlist Monitor, Quick Ideas, Deep Dive Workshop) across Perplexity and Claude, with connectors to Drive, Sheets, and GitHub. One room, one job.

• Lesson 9: Memory, Sub-Agents, and Parallel Research — A memory audit, durable preferences vs. task instructions, and five sub-agents researching five companies along five dimensions in parallel — merged by you.

• Lesson 10: Wide Research for Screening at Scale — Qualitative triage across 20 companies with one strict 11-column schema. Five sample universes, from quality compounders to recent spin-offs to distressed equity.

• Lesson 11: Iterating Prompts and Structured Write-Ups — A prompt-evals sheet (five rows, three scores, one failure mode, one fix) and a reverse-DCF prompt you would actually trust.

Phase 4: Build and ship your engine (Lessons 12–16)

Claude Code as a terminal pair-programmer for non-coders, Git and GitHub as editable memory, and the screener, scoring, narrative, and schedule that make the whole thing real.

• Lesson 12: Claude Code, and Building Our First Script — Installing Claude Code, working in Plan Mode, and writing a Python script that pulls the risk-factors section from a 10-K for any ticker. Every line explained in plain English before it runs.

• Lesson 13: Git, GitHub, and a Stock Screener — Version control as editable memory, a private GitHub repository, API keys stored safely in a .env file, and a first real screener against a stock screener endpoint.

• Lesson 14: Layer On EDGAR, FRED, and a Scoring Layer — Filing freshness from EDGAR, dated macro context from FRED, and a 0-to-100 scoring layer whose weights live in a YAML config file you can edit without touching the script.

• Lesson 15: Engine Spec, Narrative Layer, and End-to-End Run — A one-page engine spec (nine questions the code cannot answer for itself), the five-box architecture (Data In → Filter → Score → Narrate → Deliver), and a narrative triage pack on the top three names.

• Lesson 16: Schedule It, Refine It, and Retrospective — Scheduling the engine (GitHub Actions, Perplexity scheduled tasks, APScheduler, or local cron), choosing a delivery channel, a README for future-you, and a one-page three-month retrospective that holds you to your verification standard.

How to use the series

You do not have to do this in four weeks. You can do it in eight, or in four weekends, or one lesson per Sunday morning over a season. The lessons build on each other, so the order matters. Each lesson produces a concrete artifact you keep, so you can stop and start without losing your place.

A few suggestions:

• Treat the artifacts as the deliverables, not the reading. The point of Lesson 2 is your “My Analyst” Space, not the post itself.

• Verify before you trust. The “always verify” checklist from Lesson 1 is the through-line of the entire bootcamp.

• Skip the coding lessons at your peril. Lessons 12 through 16 are where the engine becomes yours rather than a rented chatbot. Plan Mode in Claude Code is gentle on non-coders, and the lessons are designed for someone who has never opened a terminal.

Access

The Introduction and each lesson are partially accessible to everyone. Full access to the lessons, including all prompts, schemas, scripts, and walkthroughs, is included with a paid Latticework subscription or MOI membership.

Start with the Introduction, then work through the lessons in order. The engine you finish with is yours.

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the last lesson in a 16-lesson experiment. I have been doing every lesson alongside you, on the same tools, with the same constraints. Some lessons have landed cleanly. Some have lead to dead ends and needed rework. We’ve figured out what works, together.

If you are catching up, here is what came before this lesson:

• Intro: Build Your Own Investment Idea Engine

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations

• Lesson 2: Prompt Patterns That Outperform Casual Prompting

• Lesson 3: Tools, Agents, and Structured Output

• Lesson 4: SEC EDGAR, the Primary Source

• Lesson 5: FRED Macro and Sector Data, the Free Read

• Lesson 6: Data API Key and the First Checked Data Pull

• Lesson 7: Other Data Sources, and Idea Engine Formats

• Lesson 8: Spaces, Projects, and Connectors

• Lesson 9: Memory, Sub-Agents, and Parallel Research

• Lesson 10: Wide Research for Screening at Scale

• Lesson 11: Iterating Prompts and Structured Idea Write-Ups

• Lesson 12: Claude Code, and Building Your First Useful Script

• Lesson 13: Git, GitHub, and a Stock Screener

• Lesson 14: Layer On EDGAR, FRED, and a Scoring Layer

• Lesson 15: Engine Spec, Narrative Layer, and End-to-End Run

Why This Matters for Investors

During most of our AI bootcamp, the engine has been a thing we ran by hand. In the last lesson it became a pipeline: one driver, one dated CSV, one dated Markdown deliveries file, a YAML front matter block recording the spec version, the config version, the FRED observation dates, the EDGAR user-agent string, and the data API endpoints used. The pipeline runs cleanly when we sit at the keyboard and type the command.

Today the engine stops needing us to start it. It runs on a clock. The output lands in the channel of our choice (e.g., our email inbox). The repository has a README that we can open in three months without re-deriving today’s reasoning. The first scheduled run produces an artifact we read critically, any issues get fixed in the My Analyst prompt file or the scoring config rather than in the script, and the retrospective writes down what surprised us while building and what we will change over the next three months or so. By the end of today the engine is durable enough for the future, not just usable in the present.

The reason this is the right place to end the bootcamp is the same reason we have been writing things down throughout. The engine that survives the test of time is not the engine with the cleverest scoring layer. It is the engine whose owner can still explain, three months in, why each box exists and how to change it. The durability is in the spec, in the diagram, in the My Analyst prompt file, in the YAML scoring config, in the .env file, and in the README we write today. The scoring weights will move. The exclusions will sharpen. The narrative questions will mature. The infrastructure underneath, version-controlled, source-grounded, parameter-driven, is what we keep. The discipline that keeps the engine trustworthy outlives the bootcamp.

There is one more reason today matters. The first lesson asked us to learn when an AI model is being merely fluent versus when it is being right. Every step since has been a small repetition of that question, applied to a different layer: defending against hallucinations, grounding every claim in a source, naming provenance, refusing to commit secrets, naming a user-agent string on every SEC.gov call, separating filter from score, requiring the narrative layer to earn the right to be investigated rather than recommend action. The retrospective at the end of today is where we read back the answer in our own voice. The verification habit is what made the engine worth running in the first place.

Let’s launch into today’s lesson.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the 15th lesson in a 16-lesson experiment. I am doing every lesson alongside you, on the same tools, with the same constraints. Some lessons will land cleanly. Some will lead to dead ends and need rework. We’ll figure out what works, together.

If you are catching up, here is what came before this lesson:

• Intro: Build Your Own Investment Idea Engine

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations

• Lesson 2: Prompt Patterns That Outperform Casual Prompting

• Lesson 3: Tools, Agents, and Structured Output

• Lesson 4: SEC EDGAR, the Primary Source

• Lesson 5: FRED Macro and Sector Data, the Free Read

• Lesson 6: Data API Key and the First Checked Data Pull

• Lesson 7: Other Data Sources, and Idea Engine Formats

• Lesson 8: Spaces, Projects, and Connectors

• Lesson 9: Memory, Sub-Agents, and Parallel Research

• Lesson 10: Wide Research for Screening at Scale

• Lesson 11: Iterating Prompts and Structured Idea Write-Ups

• Lesson 12: Claude Code, and Building Your First Useful Script

• Lesson 13: Git, GitHub, and a Stock Screener

• Lesson 14: Layer On EDGAR, FRED, and a Scoring Layer

Why This Matters for Investors

For the last three lessons the engine has been adding plumbing. We have a private repository, a .env file that holds the data service API key and the FRED key, a screener that hits a data service for fundamentals, an EDGAR layer that stamps every row with the most recent 10-K filing date, a FRED layer that stamps every row with five dated macro observations, a scoring config in YAML, and a composite 0-to-100 score column that ranks the names. The CSV is real and the columns audit cleanly. What we do not yet have is a written-down answer to the question, what is this thing actually trying to do for us, and how would future-us recognize when the engine is helping versus when it is just producing output. Today we write that down.

The one-page specification is the lesson’s first deliverable, and it is the part of the bootcamp where the personalization becomes binding. Every participant has the same scaffolding by now. After today, every member’s engine starts diverging from every other member’s engine, because the spec encodes universe, exclusions, source hierarchy, valuation lens, quality bar, schedule, delivery channel, and the maximum number of ideas we want to see per run. A generic spec produces generic ideas. A personal spec produces ideas we recognize as the kind of ideas we are willing to spend more time on.

The second deliverable is the narrative layer. The composite score sorts the CSV; the narrative layer earns the top three rows the right to be investigated. For each of the three names at the top of today’s run, we ask Claude, with the My Analyst system prompt from Lesson 2, to draft a one-paragraph qualitative take that answers four questions in our voice: why the name surfaced, what evidence in the columns supports the surfacing, what could be wrong with the surfacing, and what the next human check should be. The narrative layer does not recommend action. It earns the right to be investigated. That distinction is the entire reason we are writing it down rather than trusting our memory of the column values.

By the end of today the engine produces, in a single end-to-end run, a sorted CSV with provenance columns, a one-page spec saved alongside the screener, and three short qualitative paragraphs that turn the top three rows into a triage pack we can read over coffee. The next lesson schedules the engine so it runs without us, writes a README so future-us can change parameters without re-deriving today’s reasoning, and runs the first retrospective on what surprised us in the first week of output.

Let’s launch into today’s lesson.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the 14th lesson in a 16-lesson experiment. I am doing every lesson alongside you, on the same tools, with the same constraints. Some lessons will land cleanly. Some will lead to dead ends and need rework. We’ll figure out what works, together.

If you are catching up, here is what came before this lesson:

• Intro: Build Your Own Investment Idea Engine

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations

• Lesson 2: Prompt Patterns That Outperform Casual Prompting

• Lesson 3: Tools, Agents, and Structured Output

• Lesson 4: SEC EDGAR, the Primary Source

• Lesson 5: FRED Macro and Sector Data, the Free Read

• Lesson 6: Data API Key and the First Checked Data Pull

• Lesson 7: Other Data Sources, and Idea Engine Formats

• Lesson 8: Spaces, Projects, and Connectors

• Lesson 9: Memory, Sub-Agents, and Parallel Research

• Lesson 10: Wide Research for Screening at Scale

• Lesson 11: Iterating Prompts and Structured Idea Write-Ups

• Lesson 12: Claude Code, and Building Your First Useful Script

• Lesson 13: Git, GitHub, and a Stock Screener

Why This Matters for Investors

In the last lesson the engine started looking like a usable tool. We have a private repository, a dot env file that holds the data service API key, a dot gitignore file that protects it, and a working stock screener that produces a CSV of names that pass our hard criteria.

Today we do three things on top of that scaffolding, and each one is a step from “screen” toward “engine we trust.”

• We add an EDGAR filing-freshness layer so the screen knows when each name last filed an annual report.

• We add a FRED macro-context layer so the screen carries the dated values of the rates, inflation, and labor series we actually want in the same row as the company data.

• We add a 0-to-100 scoring layer on top, with the weights living in a config file we can edit without rewriting the script.

The non-coder’s instinct on a day like today may be to flinch at the word scoring. We are not building a quant model. We are not estimating expected returns. We are making our preferences explicit, in numbers we can audit, on a screen we can defend. The default weights are a starting point, not a recipe. The point of putting the weights into a config file is the same point as putting the API key into the dot env file: the script becomes a thing we can change without fear, because the part that changes most often is the part that is easiest to find.

The filing-freshness layer is the most underrated of the three. A screen that does not know how old each name’s most recent 10-K is can quietly recommend a company whose disclosures stopped in 2024. That is not a value find. That is a name we should be running an extra audit on, not adding to the engine’s output without comment. The FRED layer is the smallest of the three but the one that earns its keep the fastest: the day the 10-year yield breaks out of the range we built our valuation assumptions around, the screen’s macro columns surface that fact in the same row as the company we are evaluating, with the observation date attached so we can audit the value against the FRED page directly.

By the end of today, the CSV we wrote in the last lesson has two new columns, one new ranking column, and a tiny config file alongside the screener that names what we think a good investment idea looks like.

Let’s launch into today’s lesson.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the 13th lesson in a 16-lesson experiment. I am doing every lesson alongside you, on the same tools, with the same constraints. Some lessons will land cleanly. Some will lead to dead ends and need rework. We’ll figure out what works, together.

If you are catching up, here is what came before this lesson:

• Intro: Build Your Own Investment Idea Engine

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations

• Lesson 2: Prompt Patterns That Outperform Casual Prompting

• Lesson 3: Tools, Agents, and Structured Output

• Lesson 4: SEC EDGAR, the Primary Source

• Lesson 5: FRED Macro and Sector Data, the Free Read

• Lesson 6: Data API and the First Checked Data Pull

• Lesson 7: Other Data Sources, and Idea Engine Formats

• Lesson 8: Spaces, Projects, and Connectors

• Lesson 9: Memory, Sub-Agents, and Parallel Research

• Lesson 10: Wide Research for Screening at Scale

• Lesson 11: Iterating Prompts and Structured Idea Write-Ups

• Lesson 12: Claude Code, and Building Your First Useful Script

Why This Matters for Investors

In the last lesson we put a working script into a folder. Today we do two things that turn that folder into the start of an actual idea engine. We put it under version control with Git, push it to a private GitHub repository, and we add the first real screener on top of a data API. The two changes are not as different as they look. Version control is what lets us change the screener in a later lesson without losing today’s. A private repository is what lets us keep credentials out of our screens, our screens out of our chats, and our chats out of anyone else’s hands. The screener is what we will be editing in the next two lessons.

The non-coder’s instinct here is to flinch at the word Git. We are not going to learn Git. That is not what today is about. The goal is narrow: keep a private versioned record of the engine so we can change it without fear, and keep our API keys out of the repository by default. Those two outcomes are worth the thirty minutes even if we never type a Git command again on our own. Claude Code does the typing. We read the plan, we read the diff, and we approve.

The screener side of today is where the engine starts to feel like a tool we will actually use. A data service gives us fundamentals, ratios, ownership, and the screener endpoint in one place, on a free tier that is enough to complete this lesson. We are going to ask Claude Code to write a small Python script that hits the stock-screener API endpoint with our criteria (in the default scaffold: US-listed, market cap between five hundred million and five billion dollars, return on invested capital above fifteen percent over the trailing five years, and insider ownership above ten percent), and saves the output as a CSV in the project folder. The criteria are ours to change. The script is the part we keep.

By the end of today we will have a private repository, a clean separation between code and credentials, the EDGAR risk-factors script from the previous lesson committed with a plain-English message, and a first screener output we can sanity-check against the names we already know.

Let’s launch into today’s lesson.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the twelfth lesson in a 16-lesson experiment. I am doing every lesson alongside you, on the same tools, with the same constraints. Some lessons will land cleanly. Some will lead to dead ends and need rework. We’ll figure out what works, together.

If you are catching up, here is what came before this lesson:

• Intro: Build Your Own Investment Idea Engine

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations

• Lesson 2: Prompt Patterns That Outperform Casual Prompting

• Lesson 3: Tools, Agents, and Structured Output

• Lesson 4: SEC EDGAR, the Primary Source

• Lesson 5: FRED Macro and Sector Data, the Free Read

• Lesson 6: Data API Key and the First Checked Data Pull

• Lesson 7: Other Data Sources, and Idea Engine Formats

• Lesson 8: Spaces, Projects, and Connectors

• Lesson 9: Memory, Sub-Agents, and Parallel Research

• Lesson 10: Wide Research for Screening at Scale

• Lesson 11: Iterating Prompts and Structured Idea Write-Ups

Why This Matters for Investors

So far we have asked assistants to do things for us. Today we start asking an assistant to build small tools that do those things on our behalf, on our schedule, without us in the room. This matters because everything we have built to date (the Spaces, the Projects, etc.) was research scaffolding. It is excellent at one-off questions and it improves our judgment in real time. What it cannot do is run while we sleep, screen overnight, hand us a triage pack at 7 a.m., or remember last week’s pull date when it builds this morning’s. That is what the next five lessons are for, and Claude Code is the workshop where we build it.

The temptation, when a non-coder opens a terminal, is to either freeze or pretend. Instead, we will walk the middle path: ask Claude Code to plan before it edits, ask it to explain every line in plain English, and refuse to keep any script we could not change later. The non-coder’s superpower is not that we suddenly write Python. It is that we know how to interrogate a thing we did not write until we trust it the same way we trust a sell-side model only after we have verified the inputs.

There is one more reason to take Claude Code seriously today rather than treating it as a developer’s toy. The investment-research artifacts we care about (a screener that runs daily, a watchlist monitor that pings us only when something material changes, a wide-research pass that produces a CSV every Friday morning) are exactly the kind of small, durable tools that hand-coding makes expensive and pair-programming with an assistant makes nearly free. The cost of building the first one used to be a developer relationship. The cost now is thirty minutes, a folder, and the willingness to read every line back.

By the end of today we will have Claude Code installed, a small Python script that pulls a recent 10-K from SEC EDGAR and prints the first 500 words of the risk-factors section for any ticker we choose, a line-by-line plain-English explanation of that script, and the start of a habit we will use for the rest of the bootcamp: plan first, smallest working version next, explain in English, keep only what we understand.

Let’s launch into today’s lesson.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the eleventh lesson in a 16-lesson experiment. I am doing every lesson alongside you, on the same tools, with the same constraints. Some lessons will land cleanly. Some will lead to dead ends and need rework. We’ll figure out what works, together.

If you are catching up, here is what came before this lesson:

• Intro: Build Your Own Investment Idea Engine

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations

• Lesson 2: Prompt Patterns That Outperform Casual Prompting

• Lesson 3: Tools, Agents, and Structured Output

• Lesson 4: SEC EDGAR, the Primary Source

• Lesson 5: FRED Macro and Sector Data, the Free Read

• Lesson 6: Data API Key and the First Checked Data Pull

• Lesson 7: Other Data Sources, and Idea Engine Formats

• Lesson 8: Spaces, Projects, and Connectors

• Lesson 9: Memory, Sub-Agents, and Parallel Research

• Lesson 10: Wide Research for Screening at Scale

Why This Matters for Investors

In the last lesson we ran a twenty-name wide-research triage pass under one strict schema; and the schema, not the universe, was the thing that made the table honest. Today we take that lesson one layer deeper. A prompt is not a clever sentence. A prompt is a small operating procedure that has to behave the same way on the fifth ticker as it did on the first, on a sector we know cold and on one we do not, on a name with a clean filing history and one with a recent restatement. If we do not test it deliberately, we will keep noticing failures only when they show up inside an investment decision.

There is a second reason to slow down here. Most non-technical members get into trouble in the same way: they write a prompt that produces one good output on a ticker they already understand, conclude that the prompt works, and then are surprised when the same prompt produces a polished but unsourced write-up on a name they do not know. That second output is the dangerous one. It will be fluent, it will be plausible, and it will smuggle in assumptions about discount rates, terminal margins, share counts, or filing dates that the model invented because the prompt did not forbid it. Prompt iteration is how we close that gap.

The other half of today is the structured idea write-up itself. Research that does not land in a comparable shape is hard to compound. If every company note has a different structure, we cannot scan across them, cannot revisit our reasoning later, and cannot tell whether our process is improving. A five-bullet house-style write-up, generated from a tested prompt, gives us that comparability without flattening the thinking. And once the write-up exists, we have earned the right to run a simple reverse DCF on one name we know well, where the discipline is to separate market-implied assumptions from our own and to refuse to let the model invent inputs.

By the end of today we will have a small prompt-evals sheet with five rows, one documented failure pattern, one targeted prompt fix, and one reverse-DCF output whose inputs we have personally checked.

Let’s launch into today’s lesson.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the tenth lesson in a 16-lesson experiment. I am doing every lesson alongside you, on the same tools, with the same constraints. Some lessons will land cleanly. Some will lead to dead ends and need rework. We’ll figure out what works, together.

If you are catching up, here is what came before this lesson:

• Intro: Build Your Own Investment Idea Engine

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations

• Lesson 2: Prompt Patterns That Outperform Casual Prompting

• Lesson 3: Tools, Agents, and Structured Output

• Lesson 4: SEC EDGAR, the Primary Source

• Lesson 5: FRED Macro and Sector Data, the Free Read

• Lesson 6: Data API Key and the First Checked Data Pull

• Lesson 7: Other Data Sources, and Idea Engine Formats

• Lesson 8: Spaces, Projects, and Connectors

• Lesson 9: Memory, Sub-Agents, and Parallel Research

Why This Matters for Investors

In the last lesson we ran five parallel sub-agents on five companies, with the same schema and the same source rule for every row. Today we widen the same pattern from five names to twenty. The shape of the work does not change. What changes is that we are no longer treating wide research as a thinking exercise on a small set of companies we already know well. We are using it as a triage layer across a small universe, the kind of universe we would not have time to read through one company at a time.

A classic quantitative screen narrows the field on numbers. Twenty companies above a ROIC threshold, twenty inside a market-cap band, twenty with insider ownership over a line. That is useful, but it is also coarse. It leaves out everything we actually have to read to know whether a name is worth an hour: the recurring concerns inside the last filing, the customer concentration buried in a risk factor, the management quality signals that only show up across two or three years of letters, the ownership patterns that change how an activist or a founder is likely to behave.

“Wide research” adds that qualitative layer at scale, but only if we keep it source-grounded. The reason most members get into trouble here is exactly the same reason most members get into trouble with any AI-assisted research: a smooth comparison table is not evidence. A smooth comparison table is the assistant doing what it is best at (writing fluently across many rows), in a domain where fluency is the failure mode we have been defending against since Lesson 1. So our job today is to set up the run so that the table cannot lie to us without us catching it.

There is a quieter benefit as well. The discipline of writing one schema, one source rule, and one universe definition before any names are pulled is good for our own thinking. It forces us to say out loud what we are actually looking for, and what we are willing to call “missing.” Twenty rows under a strict schema beats two hundred rows we cannot audit.

Let’s launch into today’s lesson.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the ninth lesson in a 16-lesson experiment. I am doing every lesson alongside you, on the same tools, with the same constraints. Some lessons will land cleanly. Some will lead to dead ends and need rework. We’ll figure out what works, together.

If you are catching up, here is what came before this lesson:

• Intro: Build Your Own Investment Idea Engine

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations

• Lesson 2: Prompt Patterns That Outperform Casual Prompting

• Lesson 3: Tools, Agents, and Structured Output

• Lesson 4: SEC EDGAR, the Primary Source

• Lesson 5: FRED Macro and Sector Data, the Free Read

• Lesson 6: Data API Key and the First Checked Data Pull

• Lesson 7: Other Data Sources, and Idea Engine Formats

• Lesson 8: Spaces, Projects, and Connectors

Why This Matters for Investors

In the last lesson we built three durable rooms across Perplexity and Claude. That fixed the “blank window every morning” problem at the room level: the system prompt, the connectors, and the reference files now persist between sessions. Today we go one layer deeper. Memory is how the assistant carries durable facts about us as an investor (our style, our market-cap band, our forbidden behaviors) across every room and every thread. Sub-agents are how that same assistant runs multiple bounded research tracks in parallel, instead of taking one question at a time.

Together they change the shape of the work. A single chat is one analyst answering one question. A room with memory plus sub-agents is closer to a small research operation: a lead who already knows our preferences, two or three junior agents pulling on bounded threads at the same time, and a final hand-off back to us for the part that actually matters, which is judgment about whether the table in front of us is even answering the right question. We still own that judgment. The point of today is to make the support around it materially better.

There is a softer reason as well. As investors we accumulate small, durable preferences over years (the kinds of businesses we trust, the kinds of balance sheets we avoid, the writing voice we prefer, the geographies we read fluently). Most of that detail evaporates inside a generic chat session, so we end up restating it every time. Stored well, those preferences become a quiet compounding asset across the engine.

Let’s launch into today’s lesson.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the eighth lesson in a 16-lesson experiment. I am doing every lesson alongside you, on the same tools, with the same constraints. Some lessons will land cleanly. Some will lead to dead ends and need rework. We’ll figure out what works, together.

If you are catching up, here is what came before this lesson:

• Intro: Build Your Own Investment Idea Engine

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations

• Lesson 2: Prompt Patterns That Outperform Casual Prompting

• Lesson 3: Tools, Agents, and Structured Output

• Lesson 4: SEC EDGAR, the Primary Source

• Lesson 5: FRED Macro and Sector Data, the Free Read

• Lesson 6: Data API Key and the First Checked Data Pull

• Lesson 7: Other Data Sources, and Idea Engine Formats

Why This Matters for Investors

Until now we have been working in disposable chats. A question goes in, an answer comes back, the window closes, and any context we built (the system prompt, the uploaded filings, the source rules, the small examples we trained the model on) leaves with it. That is fine for one-off lookups. It is the wrong shape for an idea engine that has to run all week, every week, on the same philosophy.

Spaces and Projects are the fix. A Space inside Perplexity, and a Project inside Claude, are persistent rooms where the system prompt, the connected files, the source rules, and the previous threads stay in place between sessions. We open the room, ask the question, get an answer that is already aware of how we think, and close the room without losing anything. The room is the unit of investment work. The thread inside it is the unit of conversation. That distinction is what lets us build a research operation that does not start over every morning.

Connectors are the third leg. They are the controlled bridges between these rooms and the rest of our stack: Google Drive, Google Sheets, GitHub, calendars, sometimes email. A connector turns “find the doc I wrote about company X six months ago” from a manual hunt into a one-sentence ask. The point of today is not to connect everything. The point is to connect deliberately, with a clear purpose for each link and a list of what we will not connect yet.

Let’s launch into today’s lesson.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the seventh lesson in a 16-lesson experiment. I am doing every lesson alongside you, on the same tools, with the same constraints. Some lessons will land cleanly. Some will lead to dead ends and need rework. We’ll figure out what works, together.

If you are catching up, here is what came before this lesson:

• Intro: Build Your Own Investment Idea Engine

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations

• Lesson 2: Prompt Patterns That Outperform Casual Prompting

• Lesson 3: Tools, Agents, and Structured Output

• Lesson 4: SEC EDGAR, the Primary Source

• Lesson 5: FRED Macro and Sector Data, the Free Read

• Lesson 6: Data API Key and the First Checked Data Pull

Why This Matters for Investors

The first half of today is about resilience. No investor should be one vendor away from a broken workflow, and the public web offers a surprisingly deep bench of free or low-cost data sources that fill in around EDGAR, FRED, and a data service. An API quota changes, a free tier shrinks, a website redesigns away the page we relied on, or a provider gets acquired and shifts its terms. None of these events is catastrophic on its own, but each is enough to break a workflow on a Friday afternoon. Knowing the next two or three credible places to get the same number, in roughly the same shape, is the difference between a one-hour detour and a research week lost.

Format literacy matters for a different reason. The engine we are building is a small system that hands data from one tool to another (Perplexity Computer to Claude, Claude to a Google Doc, a Google Sheet to a script). Each handoff has a preferred format. CSV is the right answer when we want to open something in a spreadsheet and sort it. JSON is the right answer when a script or an agent will read it next. Markdown is the right answer when an LLM will read it next, or when a person will.

Let’s launch into today’s lesson.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the sixth lesson in a 16-lesson self-paced course. I did every lesson on the same tools, with the same constraints, that you will use. Some lessons will land cleanly. Some will lead to dead ends and need rework.

If you are catching up, here is what came before this lesson:

• Intro: Build Your Own Investment Idea Engine

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations

• Lesson 2: Prompt Patterns That Outperform Casual Prompting

• Lesson 3: Tools, Agents, and Structured Output

• Lesson 4: SEC EDGAR, the Primary Source

• Lesson 5: Free Access to FRED Macro/Sector Data

EDGAR is the primary source. FRED is the macro backbone. A financial data service is the practical fundamentals layer that sits in between. The point of today is not to learn an API. The point is to give our idea engine a single, predictable way to ask for income statements, balance sheets, cash flow statements, ratios, ownership, and screening results, and to verify a number we get back.

Why This Matters for Investors

Fundamentals, ratios, ownership, screens, ETF holdings, and analyst estimates all live somewhere. If we leave the choice to whichever website happens to surface in a chat, we end up with inconsistent numbers across companies and across days. Using one fundamentals API gives us a stable schema, a stable vendor, and a single place to check when something looks off.

Let’s launch into today’s lesson.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the fifth lesson in a 16-lesson self-paced course. I did every lesson on the same tools, with the same constraints, that you will use. Some lessons will land cleanly. Some will lead to dead ends and need rework.

If you are catching up, here is what came before this lesson:

• Intro: Build Your Own Investment Idea Engine

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations

• Lesson 2: Prompt Patterns That Outperform Casual Prompting

• Lesson 3: Tools, Agents, and Structured Output

• Lesson 4: SEC EDGAR, the Primary Source

Today is not about forecasting macro variables. Economists and investors alike are bad at that, and the people who are good at it do not publish their answers. The point is to control our inputs. We want to pull the live series ourselves, know the series IDs we want to track, and stop letting stale macro numbers (or stale assumptions) sit inside our investment notes.

Why This Matters for Investors

Rates, employment, money supply, CPI, sector indices, sector-specific data, and the full revision history of every series we care about all live in FRED, the St. Louis Fed’s public economic database. It is free, official, and reliable. Most of us already glance at FRED charts. What we will do in this lesson is one step better: pull the series directly into our workflow, with the IDs, the latest observation dates, and an explicit note on whether the number we are using has been revised.

Let’s launch into today’s lesson.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the fourth lesson in a 16-lesson self-paced course. I did every lesson on the same tools, with the same constraints, that you will use. Some lessons will land cleanly. Some will lead to dead ends and need rework.

If you are catching up, here is what came before this lesson:

• Intro: Build Your Own Investment Idea Engine

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations

• Lesson 2: Prompt Patterns That Outperform Casual Prompting

• Lesson 3: Tools, Agents, and Structured Output

A quick note before we begin: our goal today is not to become EDGAR power users in 30 minutes. It is to build a habit. When an AI-generated statement could change an investment conclusion, we verify it against the primary filing.

Why This Matters for Investors

If we only learn one data source in this bootcamp, it should be EDGAR, because every U.S.-listed company’s filings live there, free, official, and close to the source of truth. The models can summarize, compare, and extract, but EDGAR is where we verify.

In addition to EDGAR basics, I’ll share some slightly advanced tips for using EDGAR, and we’ll also take a quick look at similar databases in other countries, using Japan as an example.

Let’s launch into today’s lesson.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the third lesson in a 16-lesson self-paced course. I did every lesson on the same tools, with the same constraints, that you will use. Some lessons will land cleanly. Some will lead to dead ends and need rework.

If you are catching up, here is what came before this lesson:

• Intro: Build Your Own Investment Idea Engine

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations

• Lesson 2: Prompt Patterns That Outperform Casual Prompting

We are building an idea engine, so the next step is to make our workflow agent-friendly and our outputs machine-readable. This way, we can reuse them, validate them, and eventually automate them.

Why This Matters for Investors

When we evaluate investment ideas, we accumulate small facts and judgments: what the business does, why it surfaced, what could break the thesis, what we need to verify next. If those notes live only as free-form prose, they do not travel well. We cannot reliably sort, compare, or feed them into a sheet, dashboard, or follow-up workflow.

Agents and structured outputs are how we close that gap. An agent is simply a model that can use tools, read and write files, and show its work. Structured output is what makes the result reusable, not just readable.

Let’s launch into today’s lesson.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the second lesson in a 16-lesson self-paced course. I did every lesson on the same tools, with the same constraints, that you will use. Some lessons will land cleanly. Some will lead to dead ends and need rework.

If you are catching up, here’s what came before this lesson:

• Intro: Build Your Own Investment Idea Engine

• Lesson 1: How LLMs Work, and How to Defend Against Hallucinations

We are going to spend the bootcamp interacting with AI through prompts. Today is where we build the habits that keep that interaction disciplined.

The practical goal is simple: we want the same model, in the same session, to do materially better work, with fewer silent errors, just because we gave it a better job description.

Let us launch into the lesson.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

A note before we begin: This is the first lesson in a 16-lesson self-paced course. I did every lesson on the same tools, with the same constraints, that you will use. Some lessons will land cleanly. Some will lead to dead ends and need rework.

Let’s launch into our first lesson.

We start with one of the most important insights in the entire bootcamp: learning when an AI model is being fluent versus when it is being right.

Every limit or hallucination in your future idea engine traces back to how large language models (LLMs) read and write text. If we understand tokens and context windows, we avoid the most expensive mistakes. If we do not, confident-sounding fabrications about earnings, ratios, quoted language, or filing dates can quietly corrupt an investment thesis.

Read more

Join the Latticework AI Bootcamp and progress at your own pace. Participation is open to members and paid subscribers.

I’ve been working on an AI-powered system to help generate investment ideas in line with my own approach: value-oriented, quality-tilted, with room for special situations and small-caps. The tools available are capable, but the instructions for using them are scattered, and there isn’t much guidance aimed at investors who are sophisticated but haven’t written a line of code.

Rather than wait until I had worked it all out, I shared the process as I went and invited interested members to learn alongside me. I completed every lesson on the same tools, with the same constraints, that you will use.

Bootcamp overview

Sixteen lessons, designed to be completed at your own pace. Each lesson is about 30 minutes of focused work that ends with one tangible deliverable, plus optional “Go deeper” content (podcasts, videos, papers) for those who want to spend more time on a topic. By the final lesson, the goal is to have a personal investment-idea engine that runs on your schedule, screens with your criteria, and delivers ideas in your preferred format.

This is not a polished syllabus. Some lessons will land well. Some will lead to dead ends and require rework. We’ll iterate here on Latticework, share what’s working, and improve the curriculum in real time as we go.

Why I’m doing it this way

Active investing using AI tools well is a real edge, but only for investors who learn to use them in a way that respects their own philosophy. Generic AI advice produces generic ideas. We don’t want generic ideas.

The best way to learn is to build. Every lesson produces something concrete. Reader replies and Latticework comments will sharpen the curriculum as we go, so use the comment function under each daily post to ask questions and share your experiences.

Bloomberg terminal not needed. The bootcamp uses two paid subscriptions (Claude and Perplexity) and (mostly) free APIs. Total cost: about $40 per month. (If you already have access to expensive data APIs, you can certainly use them.)

What you’ll build

Four phases:

Lessons 1 to 3, Foundations. How AI models actually think. Prompt patterns that outperform 90% of casual prompting. Setting up your stack.

Lessons 4 to 7, The data layer. Mastering EDGAR, FRED, and a data service. Where investors get clean, free, reliable data, and how to pull it on demand.

Lessons 8 to 11, Perplexity and Claude as research partners. Spaces, Projects, connectors, memory, sub-agents, scheduled research, and wide screening.

Lessons 12 to 16, Build and ship your idea engine. Using Claude Code (a terminal pair-programmer for non-coders) to build real screeners and analyzers in plain English. Design, build, schedule, refine.

Every lesson includes a “Make it yours” callout, i.e., how to flex the same machinery to fit your philosophy. High-ROE only? Owner-operator small caps? Special situations and spin-offs? Macro-driven cyclicals? The default examples are in the MOI tradition (value, quality, special situations), but the engine you build is yours.

What you’ll need

Two paid subscriptions (~$40/month total):

• Perplexity Pro (~$20/mo): access to Computer, Spaces, connectors

• Claude Pro (~$20/mo): includes Claude Code in the terminal

Both are month-to-month. If either one isn’t earning its keep in your workflow, cancel it. We’re recommending them because the free tiers don’t include Claude Code or Perplexity Computer in their full form, and we’d rather have you working with capable tools than bumping into rate limits.

Optional paid API: A financial data service.

Free accounts: GitHub, FRED, SEC EDGAR (no account needed).

Not required: Coding or statistics background.

The community

Discussion happens through Latticework comments and email replies. Most of the lasting value of any joint learning project is the people you do it with, and Latticework is where that conversation lives.

Privacy

Your screeners, write-ups, and capstone outputs are private by default.

How to join

This is a Latticework subscriber benefit.

If you are already a paid Latticework subscriber, you can begin with Lesson 1 immediately. If you are not yet a subscriber, you can subscribe here and then start the course.

A note on transparency: I share what worked and what didn’t as I built this system. Some lessons land cleanly; others required revision based on what we learned. By the end of the 16 lessons, you can have a working investment tool tailored to your philosophy.

See you in Lesson 1.

— John