The original AI Bootcamp launch video follows:

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 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