read

Last post I set up Chrome DevTools MCP and showed how an AI agent can access anything in your logged-in browser. Reading newspapers, scraping custom viewers, reverse-engineering undocumented APIs.

Here’s what I actually used it for this week.

The subscription guilt

Point-Free is a Swift/iOS video series by Brandon Williams and Stephen Celis. They’ve been running since 2018. 359 episodes. 8 years of functional programming, architecture patterns, SwiftUI navigation, parsing, persistence, concurrency, and testing.

I’ve been a paying subscriber for a while. I’ve watched maybe 10 episodes. The content is genuinely excellent, but there’s no universe where I have 200+ hours to watch everything. So the subscription sits there, guilt-generating.

This week I pointed Claude Code at it.

What the agent did

The browser MCP gives Claude Code access to my logged-in session on pointfree.co. Most episodes are members-only, but since I’m logged in, the agent can navigate to any episode page and see everything I can see.

The workflow:

1. Navigate to an episode page
2. Run evaluate_script to find the transcript container in the DOM
3. Extract speaker names, timestamps, section headings, code blocks, and paragraphs
4. Save as a clean markdown file

For videos, the agent finds the Cloudflare Stream iframe, extracts the video ID, constructs the DASH manifest URL, and hands it to yt-dlp. But I didn’t need the videos. I wanted the text.

322 transcripts in one session

Instead of navigating to each page individually (which would take forever for 300 episodes), the agent used fetch() from within the browser context. Since the browser is authenticated, fetches to pointfree.co carry the session cookies. Each page’s HTML gets parsed with DOMParser in-browser, the transcript extracted, and the result stored in window.__transcripts.

20 episodes per batch. 15 batches. Each batch takes a few seconds to fetch and parse. Then the agent dumps the transcripts to disk via the tool results pipeline.

322 out of 359 episodes had transcripts. The 38 without were mostly early free episodes and livestreams that use a different page structure.

Parallel summarization

With all transcripts on disk, I asked Claude Code to summarize every episode. 5 agents ran in parallel, each handling 50-60 episodes. Each agent read every transcript file in its batch and produced a 5-sentence summary plus a list of frameworks used.

The result: a 2,578-line SUMMARY.md covering 322 episodes. Each entry looks like this:

## EP 327: Modern Persistence: Reminders Detail, Part 2

This episode pauses feature development to compare the StructuredQueries
approach against SwiftData. The hosts attempt to rebuild the reminders
detail query using SwiftData's @Model, @Relationship, #Predicate, and
SortDescriptor. They encounter numerous friction points...

**Frameworks:** SharingGRDB, StructuredQueries, GRDB, SwiftData, SwiftUI

Every episode. Searchable. Sortable by framework. Filterable by topic.

What fell out of the analysis

I asked the agent to analyze all 322 summaries and tell me what the series is actually about. The trends are striking.

2018-2019: Pure functional programming. map/zip/flatMap as universal abstractions, algebraic data types, protocol witnesses. No SwiftUI. No architecture. Just building vocabulary.

2019-2020: SwiftUI drops. They build the Composable Architecture from scratch over 35 episodes, deriving every design decision from the functional concepts taught earlier.

2020-2023: TCA evolves through 4 major iterations. Combine integration, async/await, ReducerProtocol, the Dependencies library. The isowords game and Standups app prove it works at scale.

2023-2024: Swift’s @Observable macro changes everything. They eliminate 6+ wrapper types from TCA’s API. The @Shared property wrapper solves cross-feature state sharing.

2024-2026: Hard pivot into persistence. Type-safe SQL query builders, a full Reminders clone with FTS5 search, SQLite triggers calling Swift functions, CloudKit sync. They’re now competing directly with SwiftData.

The agent identified 7 standout episode groups worth watching. The ones I found most interesting:

• Protocol Witnesses (EP 33-39): The idea that protocols can be “de-protocolized” into structs with closure properties. This single insight shaped the design of SnapshotTesting, Dependencies, and TCA’s entire DI philosophy.
• Parser-Printers (EP 178-189): A single value that parses input into typed data AND prints it back. The URL routing application where one router simultaneously handles server requests and generates client URLs is wild.
• Reliable Async Tests (EP 238-242): They discover a hidden C-level hook (swift_task_enqueueGlobal_hook) in Apple’s concurrency runtime to make async tests deterministic. Systems-level work that nobody else had a clean answer for.

The deeper patterns

The agent also surfaced patterns I wouldn’t have noticed from watching individual episodes:

pullback appears in 6 different contexts across the series: functional setters, snapshot strategies, protocol witnesses, reducer composition, case paths, persistence keys. Same mathematical operation, different domains. Once you internalize it, you see it everywhere.

Apple keeps validating Point-Free’s bets. CasePaths predates Apple’s enum key path exploration. SwiftUINavigation predates NavigationStack. StructuredQueries/SQLiteData competes with SwiftData and wins on nearly every axis. They’re consistently 1-2 years ahead.

The real product is the library ecosystem, not TCA. Dependencies, Sharing, CasePaths, IdentifiedCollections, SwiftNavigation, CustomDump, SnapshotTesting, MacroTesting, StructuredQueries, SQLiteData. Each works independently without TCA.

These are the kind of insights you get from seeing all 359 episodes at once, which no human subscriber has time to do.

Why this matters

I now have a searchable knowledge base of a course I paid for but never had time to watch. When I’m working on a Swift project and need to understand how to model navigation with enums, the agent can reference the actual Point-Free transcripts and give me the approach they recommend, with the reasoning behind it.

The transcripts are sitting in my mac machine as markdown files. Any agent session can read them. The summaries and insights files give quick orientation. The full transcripts give depth when needed.

This is the real value of browser MCP. Not automating clicks. Not scraping data. Making content you’ve already paid for actually accessible to the tools you use every day.

Is this piracy?

I did not send any paid content to others. Unless my agents are considered “others”.

Any subscription content that renders in your browser is accessible to your agent. Video courses, news portals, research papers, e-newspapers. If you’re paying for it and the platform doesn’t offer a convenient export, the browser MCP is your export tool.

You’re not stealing from yourself.

You’re letting your agent access materials and learn for you.