← All sessionsHomeSearch
AI Catalyst C3·Core Session - Week 11·3:02:15

Session 21: Advanced Data Extraction from PDFs — Parsing, OCR, and the Token-Free Product

Harshith Vaddiparthy Trainer — Outskill; builds 'AuthReady', a healthcare document-intelligence dashboard (prior-authorization packet triage) live, on a deliberately LLM-free extraction core · Shivani Cohort manager — first session in the new POC role; intro, logistics, CSAT poll

Session map

THE ECONOMICSTHE BUILDTHE CRAFTParsing vs scrapingOCR and document intelligence as their…'I'm literally paying with my…the labeling economy from CAPTCHA to th…AuthReadythe AI-built product with no LLM in the…The OCR shelfDatalab, Tesseract, Baidu's open model…Foundation before themeshadcn blocks, TweakCN skins, and the v…PixPipescreenshot your context — the image-tok…
The economicsThe buildThe craft
click a node — its card pops up (drag it anywhere, × to close)
Concept

The map reads left to right — the economics flow into the build, then into the craft. Click any node to open that idea here; every timestamp jumps into the recording.

The short version

  1. The frame is PARSING vs SCRAPING: scraping fetches from the web (crawl/scrape/search endpoints, Firecrawl, Perplexity's Sonar); parsing is OCR over documents you already hold — and it's the doorway to healthcare, finance, legal, and education work where the documents are the business.
  2. The build thesis is the course's most contrarian: an AI-era product with NO LLM in the runtime path — 'once it's built, you don't really need tokens to run it.' Frontier models CAN read handwriting (a GPT-5.6 demo proves it) but burn tokens doing what a trained document-intelligence model or a deterministic pipeline does for free.
  3. AuthReady, the live build: prior-authorization packet triage for outpatient imaging — PDF Inspector classifies pages, native text extracts locally, scans queue for OCR, and a coordinator sees a cited readiness checklist ('the coordinator sees work, not the raw OCR'). Scope is fenced on camera: it does not diagnose, decide medical necessity, or submit to a payer; synthetic/CMS sample data for the MVP, HIPAA compliance named as the price of going to market.
  4. The data economy gets named while a toggle is clicked: Datalab's 25% discount in exchange for training on your documents — 'I'm literally paying with my data' — set beside CAPTCHA and Pokémon Go as the history of humans labeling data for free. This becomes Session 22's founding cautionary tale.
  5. License reality-checks live: Datalab's weights carry commercial restrictions (a cohort member hits the conflict mid-build), Firecrawl and Baidu's OCR are MIT — 'combine Baidu's OCR with Firecrawl and you can build something very, very powerful.' Architecture time is defended explicitly: 'do spend a lot of time on the architecture... the foundation is the most important.'
  6. PixPipe closes the night: because text token cost scales with length while image token cost is (as-heard) fixed, screenshotting long context and feeding it to Fable 5 — 'the best OCR' — cut his bill dramatically ('$20 becomes $4'). Not a skill, 'an architecture design.' Claims flagged as-heard; the direction (context-as-image compression) is real and worth testing.

The concepts

01

Parsing vs scraping: OCR and document intelligence as their own discipline

Scraping goes and GETS documents; parsing reads the ones you already have. Different verbs, different tools, different industries.

Scraping is the web-facing family — /crawl, /scrape, /search endpoints (Firecrawl), deep-search APIs (Perplexity Sonar). Parsing is Optical Character Recognition over a document: PDF in → tool → clean output (human-readable text, or token/structured forms an agent consumes). The key market fact: frontier LLMs DO have built-in OCR — his live demo hands a handwritten Declaration-of-Independence image to GPT-5.6 and it reads it correctly — but 'this is just by using a ton of tokens.' Models trained specifically on document intelligence (Datalab's family) or classic engines (Tesseract) do the same work cheaper, and often better on structure: tables, headers, H1s, images all TAGGED with positions.

Tagging is the bridge to the wider industry: what Datalab's playground shows is data labeling/annotation — 'there are companies like Scale AI... an entire company would just be doing data annotation.' Use cases stack up from the cohort itself: healthcare records, finance invoices, legal documents, contract management, manufacturing, teachers grading handwritten exams.

Worked example · from the session

The Berkshire Hathaway income statement and a patent diagram in Datalab's gallery — structure-heavy documents where 'just dumping the PDF into the AI agent... might just be gibberish to it.'

Why it matters

Choosing the wrong verb costs real money: LLM-OCR on a book-length scan is a token bonfire; a parsing engine is a fixed, tiny cost.

People get this wrong

Parsing is obsolete because modern LLMs read documents natively.

LLMs read documents EXPENSIVELY. Parsing engines do the extraction for near-zero marginal cost; the LLM belongs downstream, if anywhere.

Parsing vs scraping: two disciplines, one destination Scraping live web pages · HTML Tools Firecrawl · actors · proxies Parsing / OCR PDFs · scans · documents Tools Datalab · Tesseract · doc models Structured data what the agent actually eats Session 21: document intelligence is its own discipline — pick the OCR shelf by license, not hype
Two disciplines, one destination: structured data
For your projects

This session pairs with your own token discipline: the reason your wrap scripts are Python and not model calls is exactly the parsing-vs-LLM economics he teaches here.

Go deeper

In one line: Parsing = OCR-based extraction from held documents (PDF → tool → text/structured output), distinct from scraping (web retrieval); powered by document-intelligence models or classic OCR engines rather than general-purpose LLM vision, which works but scales in tokens.

LLMs come with their own OCR — capability isn't the question, unit economics are ()

Tagging output = classified regions with positions (header/H1/text/image) — data labeling as a product ()

Playgrounds before API keys: every tool in the category ships a free playground 'just like platform.openai.com' — test before spending ()

Education use case he keeps returning to: handwritten exam-sheet grading ()

▶ Watch this taught:

Check yourself

Answer from memory first — the recall attempt is what makes it stick. Then reveal.

When is LLM-vision OCR still the right call?

Low volume, messy one-offs, or when extraction must flow straight into reasoning anyway — the moment volume or repetition appears, a dedicated parser wins on cost and consistency.

02

'I'm literally paying with my data': the labeling economy from CAPTCHA to the 25% discount

A settings toggle offers 25% off if Datalab may train on his documents. He flips it on camera and names the transaction: 'That's literally me accepting to sell my data... I'm paying with my data right now.'

The session's most quotable riff connects three things people rarely connect: (1) the vendor discount-for-data toggle ('no confidentiality agreement... just a straight-up 25% discount for our data'); (2) CAPTCHA — 'it confirms you are a human, but honestly what it's just doing is data labeling. WE are the data labelers'; (3) Pokémon Go — players mapping stairs, trees, and paths for what became a data company's asset: 'humans were the product.' The punchline for builders: 'that's the goldmine we're digging into right now — the data goldmine.' Every enterprise parsing deal exists because organizations now understand their documents are that asset and won't hand them to a discount toggle.

Worked example · from the session

Rahul's Rahul-and-Sara chat exchange over hating CAPTCHAs — annoyance reframed as unpaid labor in one line.

Why it matters

It's the demand-side explanation for both this session's on-prem pitch and s22's entire enterprise-RAG architecture.

People get this wrong

Free AI tools are free.

Free tiers are frequently data acquisitions — the discount IS the purchase price of your documents.

That's literally me accepting to sell my data to Datalab in exchange for a discount... I'm literally paying with my data.
It confirms that you are a human, but honestly, what it's just doing is data labeling. We are the ones who are labeling those data.
For your projects

Belongs in your standing client-conversation kit alongside the DLP habits this project already enforces.

Go deeper

In one line: The labeling economy: training data is acquired from users via discounts, gatekeeping puzzles, and games; consequently enterprises with proprietary documents price that data high — creating the market for parsing/RAG systems that keep documents on their own servers.

Enterprise plans typically remove the data-training toggle — privacy is a paid tier ()

The toggle demo is deliberate teaching theater: he flips it, names the price, and moves on ()

Direct setup for s22: same trainer, next day, builds the no-data-leaves-the-building RAG citing this exact moment

▶ Watch this taught:

Check yourself

Answer from memory first — the recall attempt is what makes it stick. Then reveal.

What's the professional takeaway before uploading client documents to any free tool?

Find the retention/training toggle first; assume free tiers monetize your data unless the policy says otherwise — and price that into whether you upload at all.

03

AuthReady: the AI-built product with no LLM in the runtime path

'It's not gonna burn a single token. It doesn't have AI... it's just purely the codebase, and it just works.' Built BY an agent, running WITHOUT one.

The use case is chosen for realism: prior-authorization packets at outpatient imaging centers arrive as mixed PDFs — native text, scans, faxes, rotated pages. AuthReady triages them: PDF Inspector classifies every page ('fast triage and structure layer, NOT the OCR engine'), native-text pages extract locally, scanned pages queue for Tesseract, and the output is a cited readiness checklist — missing prior test report, unreadable signature page, member-ID conflicts across documents — that a human coordinator verifies against cited pages. 'The coordinator sees work, not the raw OCR.'

The scope fence is explicit and repeated: it does NOT diagnose, decide medical necessity, or submit to the payer; handwriting routes to manual review in v1 ('AI-suggested transcription with MANDATORY human confirmation'); testing uses synthetic and public CMS sample data because real patient data isn't — and shouldn't be — available; HIPAA compliance is named as the requirement for going to market. LLMs appear only as an optional later tier ('three or four agents can validate the extraction'). The business shape mirrors s22: build it into the client's own servers, sell 'packet readiness and operational visibility, not an AI approval,' monetize as B2B service or exposed endpoint.

Worked example · from the session

The live test arc: a random PDF extracts but matches nothing → Codex generates a synthetic clinical record → CMS public sample data lands → 'it found the match — ordering provider, patient relationship' — extraction working end-to-end with zero runtime tokens.

Why it matters

'Imagine how work was done pre-AI' — the deliberately provocative design question: use AI to BUILD tools that don't need AI to RUN.

People get this wrong

An AI product means an LLM answers at runtime.

Often the AI's whole job is construction; the shipped artifact can be deterministic, auditable, and free to run — which is precisely what regulated buyers want.

Once it's built, you don't really need tokens to run it.
The coordinator sees work, not the raw OCR.
Sell packet readiness and operational visibility, not an AI approval.
What if you build tools using AI, but the tools themselves don't burn that many tokens?
For your projects

The verification-not-generation posture matches your validate.py doctrine: the machine checks; humans decide.

Go deeper

In one line: No-LLM pipeline = agent-built deterministic product (classify → extract → route-to-OCR → structured checklist → human review) whose runtime consumes no model tokens; LLM tiers optional and downstream; scope fenced away from regulated judgments; synthetic data for MVP, compliance (HIPAA) as the go-to-market gate.

'Adapter' taught plainly: a thin connector the agent writes between dashboard and codebase — 'small now, replaceable later' is called 'the right middle ground' ()

Architecture time defended: 'we're spending a lot of time on architecture... once your architecture is ready, you can build anything properly' ()

Endpoint explained from scratch for the cohort: expose a link from your server so other applications can use your codebase ()

Human-in-the-loop on request (Vijay): random quality-check sampling accepted into the design ()

The Sayed moment: a cohort member clones the localhost-only demo into his own published dashboard mid-session — 'he scraped me... don't ask questions with answers you're not ready for' ()

▶ Watch this taught:

Check yourself

Answer from memory first — the recall attempt is what makes it stick. Then reveal.

Why route handwriting to manual review instead of shipping the best OCR guess?

Doctor handwriting on medication orders is a safety-critical, low-confidence extraction — the design puts a mandatory human between the model's guess and the record.

04

The OCR shelf: Datalab, Tesseract, Baidu's open model — chosen by license and hardware

A cohort member hits a license conflict mid-build; the answer is the lesson: 'Datalab's codebase is Apache with commercial restrictions on the weights — use Firecrawl, it's MIT, and use Baidu's OCR.'

The shelf, as toured: DATALAB — commercial document-intelligence lab (its open repos include Marker, Surya, Chandra as-heard), excellent but its model weights carry commercial restrictions, so it anchors the category rather than the build. TESSERACT — the classic free OCR engine ('by Google or maybe Microsoft' — he's unsure live; it's Google-maintained, HP-born), the default cheap layer. BAIDU'S OCR (as-heard 'Unlimited OCR', on Hugging Face) — the heavyweight: MIT-licensed, ~3B parameters, ~2.8M monthly downloads as-heard, strong on handwriting, wants a GPU (32GB RAM 'should work'; his 18GB MacBook is marginal) — 'literally everything that Datalab does, Baidu just completely open-sourced it.' FIRECRAWL's document repos (PDF Inspector, AnyDoc) — MIT, command-installable, the build's actual spine.

Selection procedure mirrors s22: constraint (lightweight MVP, no time sink), agent-verified model cards ('I'll verify the model card, open-source location, license, hardware'), benchmarking flagged as required before productizing anything safety-critical ('doctor handwriting is very critical'). And the meta-skill again: these are LEGO blocks — 'bits and pieces of these tools, fully open source, spread out... bring them along in such a way that you build a product that solves a real-life use case.'

Worked example · from the session

The Hugging Face detour: search 'OCR', sort by downloads, read the model card — the discovery motion for models, parallel to s22's awesome-lists for repos.

Why it matters

License + hardware are the two gates that decide what you may SELL and what you can RUN — checked before a line of integration code.

People get this wrong

Open source on GitHub means free to commercialize.

The LICENSE and the WEIGHTS can differ — Datalab's restrictions bit a cohort member live; MIT (Firecrawl, Baidu's model) is the do-anything tier.

Do spend a lot of time on the architecture... once your architecture is ready, you can build anything properly.
For your projects

Note the honest ASR hazard: 'Unlimited OCR', 'Surya', 'Chandra', download counts are as-heard — verify names against Hugging Face before citing them anywhere client-facing.

Go deeper

In one line: OCR stack selection = license gate (MIT/open weights for commercial reuse; Apache-with-restrictions anchors out) + hardware gate (parameter count vs available RAM/GPU) + benchmark gate for safety-critical extraction; assembled LEGO-style from open repos with thin adapters.

Datalab respected, not resented: shown as the commercial benchmark and the category teacher ()

Baidu-on-VPS as the endpoint play: self-host the model, expose your own API endpoint, connect any agent — 'your very own Datalab' ()

PyTorch already installed saved him a 5GB dependency pull — environment state changes install honesty ()

An installation guide for Baidu OCR into a Hermes agent was generated as a learner resource on request ()

▶ Watch this taught:

Check yourself

Answer from memory first — the recall attempt is what makes it stick. Then reveal.

Why did the build defer BOTH Tesseract and Baidu to later phases?

Each OCR engine needs an adapter, routing, and failure handling — integration cost, not install cost, is the real price; the MVP proved the pipeline with native-text extraction first.

05

Foundation before theme: shadcn blocks, TweakCN skins, and the visual-first build loop

'If there is no auth page, where is it gonna apply the theme? First the foundation, then the theme for your foundation.'

The two-layer UI recipe, now a course ritual: install a shadcn/ui dashboard BLOCK (the structure), then apply a TweakCN THEME (the skin — today 'Tangerine', white-and-orange, his 'new favorite'; TweakCN is 'tweak your shadcn' — 'a cool wordplay'). Vijay's question — why both? — gets the clean answer above. Then the working rules: phased, visual-first prompting ('I'm a visual learner... run the dashboard command locally FIRST, then work on the rest — I don't want you to just keep thinking and I see nothing'); prune scaffolding aggressively (the stock block ships projects/playground/docs sidebar noise — cut to three pages: authorization queue, review center, operations); simplify before building ('don't spend a lot of time on this').

Two monetization asides ride along: his own newsletter CMS dashboard (subscribers, opens, analytics — 'literally just a shadcn dashboard') proves the pattern's reuse; and the ThemeCN idea — people already PAY for shadcn skins (Magic UI, the 'Ale Arc' purchase that baffled him) because 'not everyone has the taste for design' — 50-100 gated dashboard themes is a sellable product.

Worked example · from the session

The theme demo on his live newsletter tool — the same block, re-skinned, running a real product.

Why it matters

It's the fastest route from zero to a credible product surface, and the discipline (structure → skin → prune → phases) is what keeps agent builds visible and steerable.

People get this wrong

Theme first, then build the pages to match.

Theme applies TO structure; without the block in place the skin has nothing to land on — foundation, then theme.

If there is no auth page, where is it gonna apply the theme? First the foundation, then theme for your foundation.
For your projects

The 'I want to see everything happening live' prompt language is a good template for your own agent briefs — it forces observable checkpoints.

Go deeper

In one line: UI recipe: shadcn block (structure) → TweakCN theme (skin) → prune to essential pages → phased visual-first prompts so every agent step renders locally before backend work begins.

Sidebar pruning as a prompt pattern: name what to REMOVE, cap the page count, demand the page list back before build ()

Browser-automation verification skipped deliberately — 'we already know what's in it' — agent effort spent only where it informs ()

The paid-skins market proof: Magic UI 'is literally just shadcn UI with pretty templates' and people pay for install convenience ()

▶ Watch this taught:

Check yourself

Answer from memory first — the recall attempt is what makes it stick. Then reveal.

Why does visual-first phasing make an agent build safer, not just nicer?

A rendered dashboard is a checkpoint a non-reader of code can verify — each phase produces evidence, so drift is caught in minutes instead of at the end.

06

PixPipe: screenshot your context — the image-token loophole (as-heard, verify before relying)

'Token cost for text scales with length. Token cost for images is fixed. The same context as a screenshot: $20 becomes $4.'

The claimed mechanism: expensive frontier models (his example: Fable 5) price text input by token count, while an image costs a (roughly) fixed amount regardless of how much legible text it contains. PixPipe operationalizes the arbitrage — convert long text context to images, feed the images, let the model's OCR read them back. It 'works best only with Fable 5' because, he claims, Fable's OCR is near-lossless on dense screenshots ('99% efficient') where other models degrade ('80%'). His personal result: ~30% off his Fable bill (elsewhere pitched as 60-70% for scraping/PDF workloads). Adoption is trivial: 'it's not a skill... it's an architecture design' — point your agent at the repo and let it install.

The caveats matter: the discovery is attributed to one researcher (as-heard 'Team Chong'), the numbers are stage numbers, and image-token pricing genuinely varies by model and by image size — the loophole can close in one pricing update. What's durable is the direction: context-as-image compression is a real research thread, and the only honest way to use this is to benchmark YOUR workload's cost both ways.

Worked example · from the session

His whiteboard demo: a long prompt priced at '$20' as text, screenshotted and re-fed for '$4' — same context, fifth of the cost, readable because the model's OCR is strong enough.

Why it matters

For anyone burning frontier-model credits on long documents — this cohort, this course, this very extraction project — a 30% swing is worth an afternoon of testing.

People get this wrong

A universal 5x saving on any LLM bill.

A pricing arbitrage specific to certain models' image pricing and OCR quality — real enough to test, unstable enough to never hard-code.

Token cost for text scales... token cost for images is fixed. The same thing on Fable 5 is gonna cost you about $4 instead of $20.
For your projects

He name-checks Fable 5's expense all night — the model rendering this record. If the pricing claim holds for your account, your burn legs get materially cheaper; worth a controlled test before the next big backfill.

Go deeper

In one line: PixPipe pattern: render long text context as images before sending to a strong-OCR frontier model, exploiting fixed-ish image token pricing vs length-scaled text pricing; benefit is model- and pricing-dependent, so benchmark per workload and expect the loophole to move.

Positioned as the session's bookend: the build avoids tokens at runtime; PixPipe shrinks the tokens you DO spend building (0:20:51 teaser, 2:52:17 payoff)

Model-dependence is the core constraint: weak OCR turns compression into data loss ()

Distribution insight repeated: it's an installable mechanism, not a prompt — agents adopt it once and it applies everywhere

▶ Watch this taught:

Check yourself

Answer from memory first — the recall attempt is what makes it stick. Then reveal.

What must be true for the screenshot trick to actually save money on your workload?

Image tokens for your rendered pages must cost less than the text they replace AND the model's OCR must read them near-losslessly — both checked empirically, per model, per pricing table.

Every concept, three clicks deep

The same concepts as a quick reference: the closed row is the glance, open is the study card, and every timestamp jumps into the recording.

01Parsing vs scraping: OCR and document intelligence as their own disciplineParsing = OCR-based extraction from held documents (PDF → tool → text/structured output), distinct from scr…

Parsing = OCR-based extraction from held documents (PDF → tool → text/structured output), distinct from scraping (web retrieval); powered by document-intelligence models or classic OCR engines rather than general-purpose LLM vision, which works but scales in tokens.

LLMs come with their own OCR — capability isn't the question, unit economics are ()

Tagging output = classified regions with positions (header/H1/text/image) — data labeling as a product ()

Playgrounds before API keys: every tool in the category ships a free playground 'just like platform.openai.com' — test before spending ()

Education use case he keeps returning to: handwritten exam-sheet grading ()

02'I'm literally paying with my data': the labeling economy from CAPTCHA to the 25% discountThe labeling economy: training data is acquired from users via discounts, gatekeeping puzzles, and games;

The labeling economy: training data is acquired from users via discounts, gatekeeping puzzles, and games; consequently enterprises with proprietary documents price that data high — creating the market for parsing/RAG systems that keep documents on their own servers.

Enterprise plans typically remove the data-training toggle — privacy is a paid tier ()

The toggle demo is deliberate teaching theater: he flips it, names the price, and moves on ()

Direct setup for s22: same trainer, next day, builds the no-data-leaves-the-building RAG citing this exact moment

03AuthReady: the AI-built product with no LLM in the runtime pathNo-LLM pipeline = agent-built deterministic product (classify → extract → route-to-OCR → structured checkli…

No-LLM pipeline = agent-built deterministic product (classify → extract → route-to-OCR → structured checklist → human review) whose runtime consumes no model tokens; LLM tiers optional and downstream; scope fenced away from regulated judgments; synthetic data for MVP, compliance (HIPAA) as the go-to-market gate.

'Adapter' taught plainly: a thin connector the agent writes between dashboard and codebase — 'small now, replaceable later' is called 'the right middle ground' ()

Architecture time defended: 'we're spending a lot of time on architecture... once your architecture is ready, you can build anything properly' ()

Endpoint explained from scratch for the cohort: expose a link from your server so other applications can use your codebase ()

Human-in-the-loop on request (Vijay): random quality-check sampling accepted into the design ()

The Sayed moment: a cohort member clones the localhost-only demo into his own published dashboard mid-session — 'he scraped me... don't ask questions with answers you're not ready for' ()

04The OCR shelf: Datalab, Tesseract, Baidu's open model — chosen by license and hardwareOCR stack selection = license gate (MIT/open weights for commercial reuse;

OCR stack selection = license gate (MIT/open weights for commercial reuse; Apache-with-restrictions anchors out) + hardware gate (parameter count vs available RAM/GPU) + benchmark gate for safety-critical extraction; assembled LEGO-style from open repos with thin adapters.

Datalab respected, not resented: shown as the commercial benchmark and the category teacher ()

Baidu-on-VPS as the endpoint play: self-host the model, expose your own API endpoint, connect any agent — 'your very own Datalab' ()

PyTorch already installed saved him a 5GB dependency pull — environment state changes install honesty ()

An installation guide for Baidu OCR into a Hermes agent was generated as a learner resource on request ()

05Foundation before theme: shadcn blocks, TweakCN skins, and the visual-first build loopUI recipe: shadcn block (structure) → TweakCN theme (skin) → prune to essential pages → phased visual-first…

UI recipe: shadcn block (structure) → TweakCN theme (skin) → prune to essential pages → phased visual-first prompts so every agent step renders locally before backend work begins.

Sidebar pruning as a prompt pattern: name what to REMOVE, cap the page count, demand the page list back before build ()

Browser-automation verification skipped deliberately — 'we already know what's in it' — agent effort spent only where it informs ()

The paid-skins market proof: Magic UI 'is literally just shadcn UI with pretty templates' and people pay for install convenience ()

06PixPipe: screenshot your context — the image-token loophole (as-heard, verify before relying)PixPipe pattern: render long text context as images before sending to a strong-OCR frontier model, exploiti…

PixPipe pattern: render long text context as images before sending to a strong-OCR frontier model, exploiting fixed-ish image token pricing vs length-scaled text pricing; benefit is model- and pricing-dependent, so benchmark per workload and expect the loophole to move.

Positioned as the session's bookend: the build avoids tokens at runtime; PixPipe shrinks the tokens you DO spend building (0:20:51 teaser, 2:52:17 payoff)

Model-dependence is the core constraint: weak OCR turns compression into data loss ()

Distribution insight repeated: it's an installable mechanism, not a prompt — agents adopt it once and it applies everywhere

Tools referenced

ToolCoverageMomentContext
Codex (OpenAI)demonstratedBuild agent: brainstorming skill, writing-plan skill, spec docs, thin adapter, three parallel chats by session's end
ChatGPTdemonstratedDesktop app hosting the AuthReady project; folder-tree visibility gap puzzled over live
FirecrawldemonstratedPDF Inspector + AnyDoc repos are the build's extraction spine; MIT licensing the deciding factor
PDF Inspector (Firecrawl)demonstrated'Fast triage and structure layer, not the OCR engine' — classifies pages, routes scans to OCR
DatalabdemonstratedCategory benchmark: playground run, tagging demo, the 25% data toggle; weights commercially restricted
Hugging FacedemonstratedModel discovery by downloads + model-card verification
Tailwind CSS + shadcn/uidemonstratedDashboard block; the foundation-before-theme lesson
TweakCNdemonstrated'Tangerine' theme — his new favorite; 'tweak your shadcn'
Next.jsdemonstratedDashboard scaffold under the shadcn block
GitHubdemonstratedAuthReady pushed public with README mid-session
AnyDoc (Firecrawl)explainedWord/PowerPoint/Excel → clean markdown; integrated as optional in the final architecture
Tesseract OCRexplainedThe classic free engine; deferred to a later phase because each engine needs adapter + routing + failure handling
Baidu Unlimited OCRexplainedAs-heard name; MIT, ~3B params on Hugging Face; the handwriting heavyweight, GPU-hungry; Hermes install guide generated for learners
PixPipeexplainedThe token-efficiency mechanism; claims as-heard, direction real
superpowersmentioned'A really cool codebase which genuinely gives superpowers to your ChatGPT' — credited for the spec-document behavior
PerplexitymentionedSonar API named on the scraping side of the divide
ClaudementionedReached for in the handwriting demo when ChatGPT upload stalled
Scale AImentionedNamed as the data-labeling giant behind the tagging economy

Session materials

Archived locally on V: — click to open. Companion pages link to the LMS.

Action items

Resources mentioned

Resources
  • docAuthReady Build Guide
  • docAuthReady: Safe Healthcare Document Intelligence — Complete Resource Guide
  • docConversation Journey & Prompt Library
  • docPixPipe Token-Efficiency Guide
  • docBaidu Unlimited OCR for Hermes — Installation Guide
  • docSynthetic Testing & Verification
  • doc20Guide
  • docAuthReady GitHub repository
  • docAll s21 local attachment files

Extraction notes

This page was built from an auto-generated transcript, which garbles product and people's names. Those were corrected silently in everything above and logged here for transparency. The warnings flag claims that were true on the recording day but change fast.

Transcript corrections applied

The transcript saysThe trainer actually means
Deseret OCR / Tesserac / Teesseract / test rack / DesRat / TeslaTesseract OCR
Unlimited OCR / Paidu / BairusBaidu's open OCR model (as-heard 'Unlimited OCR' — verify exact model name on Hugging Face)
Arczive / Akshayiv / Arczaib / ArchivearXiv (the research-paper repository, Cornell)
Pixpipe / Pix5 / fixed pipe / Pix pipePixPipe (P-X-P-I-P-E, spelled out in-session)
Fable 5 / Table 5 / Fabled / Payable 5Fable 5 (Anthropic frontier model)
Team Chongas-heard attribution for the image-token discovery — unverified
Surja / Suraja / SuryaSurya (Datalab OCR repo)
Lyft / liftas-heard Datalab repo name — unverified
SharedCN / SHADC / SHAshadcn/ui
tweak CN / tweaked CM / TweakCNTweakCN
Wakil GPTas-heard learner-shared legal-parsing tool — unverified
Ale Arcas-heard name of a paid shadcn-derived design library — unverified
RMS Agent / Ramesh agentHermes agent
Kleenex existing processthe clinic's existing process
codecsCodex

True on recording day — verify before relying