AI Catalyst C3·Core Sessions - Week 5·2:08:13

Session 9: Introduction to Cursor & its principles

Dhir Trainer/mentor — deliberately unstructured problem-solving format ('in Catalyst you are here to solve problems'); works Claude Code, Codex, Cursor and Devin interchangeably; taught through a mild viral infection with voice breaks. Part 1 of a two-day Cursor arc: today the harness, tomorrow the build. · Niharika Cohort manager — open/close, CSAT poll (as heard; closing voice unnamed)

▶local recording · LMS lesson

Session map

The stanceBuilding the harnessRunning the pipeline

click a node — its card pops up (drag it anywhere, × to close)

Concept

The map reads left to right — the stance flow into building the harness, then into running the pipeline. Click any node to open that idea here; every timestamp jumps into the recording.

The short version

Not a Cursor advocacy session — a problem-solving framework wearing Cursor as its excuse: 'if you ask what tool I'm using, my answer in the heart is WHO CARES.' He rotates Claude Code, Codex, Cursor and Devin interchangeably, exhausting tokens on one before moving to the next; the transferable asset is the HARNESS.
The harness = instructions/rules + tools (MCPs, connectors) + skills — the structure that keeps the horse-cart under control, explained through the restaurant: rules are 'wash your hands, read the recipe,' tools are the knife/oven/wok, skills are the recipes — and an Italian kitchen's harness rightly differs from a Chinese kitchen's.
The live problem: build a 'Cursor for non-engineers' teaching website, by pipeline — INGEST (YouTube via free local YT-DLP, blogs/Substack via Parallel MCP, X + Reddit via Scrape Creators) → FILTER (agent reads all files and must 'discuss with me the rationale of what you're keeping and ignoring' before drafting) → BUILD (extract-design-system skill cloning codingformarketers.com, superpowers brainstorm, Next.js scaffold, Vercel deploy) — live URL shipped by session end.
Installation is agentic now: don't hand-edit MCP JSON — paste the tool's documentation into the agent and say 'install this MCP'; it configures, asks for the API key, and the settings panel's green dot confirms. Same trick for skills (skills.sh — superpowers as his universal core, extract-design-system for this build; evaluate skills by install counts).
The economics thread: YouTube scraping via paid actors costs $2-3/video while local YT-DLP is free; routing rules ('YT-DLP first, Scrape Creators only after') conserve credits; fresh agent per task conserves context; audio/video MCPs 'drink tokens like anything'; and the era's koan — 'when building becomes easy, WHAT to build is more important than HOW to build.'

The concepts

Tool-agnostic problem solving ('who cares')

0:07:09

He opened a Cursor session by refusing to sell Cursor — because the skill that survives the next model release is the problem-solving process, not the tool loyalty.

The argument has a practical core: capability parity has arrived among the frontier agentic platforms, so tool identity is a depreciating asset. What appreciates is the meta-skill — framing a problem, deciding what capabilities an agent needs, and assembling them (the harness) on whatever platform is currently reliable and has tokens left. His token-exhaustion rotation is the vivid version: the tools are interchangeable enough that he treats them as a pooled budget.

The one caveat worth keeping is architectural, not brand-level: sandboxed platforms (Claude Code) versus local-system platforms (Codex) genuinely behave differently for machine-level tasks like installing libraries — a distinction that matters for this session's YT-DLP install and nothing to do with which writes better code.

Worked example · from the session

His month's stack, stated plainly: Codex main, Claude Code fallback, Cursor for speed, Devin a little, Antigravity skipped ('very similar to Cursor — no point').

Why it matters

Cohort members keep asking 'should I switch tools?' — this concept is the standing answer, and it frames every remaining session: learn harnesses, rent tools.

People get this wrong

Mastering one tool deeply beats spreading across several.

Master the PROCESS deeply; keep tools shallow and swappable. The harness is the mastery — platforms churn monthly.

If somebody asks what tool are you using and why — with all humbleness, my answer in the heart is: who cares? My problem is I want to go and solve a problem.0:09:11

This idea elsewherebuilds onprinciples over tools — the dev edition

Go deeper

In one line: The session's stance, set before any teaching: Claude Code, Codex, Cursor, Devin, Antigravity are functionally interchangeable agentic platforms — 'what Claude Code can do, Codex can do' — differing mainly in marketing and reliability-of-the-week. His actual workflow: start on Claude Code, exhaust its tokens, continue on Codex, exhaust those, pick up on Cursor. Currently Codex is his main and Claude Code the fallback 'this month' — the ranking floats with reliability.

The pizza rule for tool debates: 'taste is personal' — the best-tool question has no transferable answer, so he refuses to advocate (2:06:59)

Reliability, not capability, drives his rotation: 'every other day Claude Code is going bonkers… Codex is relatively stable. If next month Claude Code becomes more reliable, it might shift' (0:37:46)

Everything in the session transfers: 'remove Cursor, add Claude Code, add Codex — a little bit of command syntax changes, but as such the thing does not change' (0:11:14)

One real platform difference flagged: Claude Code runs sandboxed while Codex works on your local system — so local-machine tasks behave differently (1:17:52)

▶ Watch this taught: 0:07:09

Check yourself

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

What actually differs between the frontier agentic platforms, per this session?

Reliability, marketing, and sandbox-vs-local architecture — not core capability. 'What Claude Code can do, Codex can do.'

What's his response to running out of tokens on one platform?

Move the same work to the next platform — the harness pattern transfers, so tokens across tools are effectively one budget.

The harness: instructions + tools + skills

0:13:15

'Harness' had become a buzzword the cohort kept hearing and couldn't define — so he spent the session's whole first hour building one and not a single product.

The three legs divide cleanly by function. Instructions are standing behavior: routing rules ('scrape YouTube with YT-DLP first'), coding standards, tone constraints — everything the agent should do without being reminded. Tools are capabilities: an agent can't search the web or scrape Reddit natively, so MCPs (Parallel, Scrape Creators) and local libraries (YT-DLP) extend its reach. Skills are procedures: packaged expertise like extract-design-system or superpowers that the agent loads when the task matches.

The two structural insights: the harness serves the agent, not you — you're provisioning a worker, not decorating a dashboard; and harnesses are problem-shaped, not universal — his website-building harness (scrapers + design skills) is the Italian kitchen, and tomorrow's app harness will be the Chinese one, sharing some tools but weighted completely differently. Hence the build order: problem first, capabilities derived from it, harness assembled leg by leg.

Worked example · from the session

The Avengers line as he installed the third scraper: 'I'm not directly going to war against Thanos. First I'm assembling the Avengers — then I go to war.'

Why it matters

This is the course's unifying abstraction for every agentic platform — Cursor rules/MCPs/skills, Claude Code CLAUDE.md/MCPs/skills, Codex equivalents — one mental model across all of them.

People get this wrong

The harness is a fancy word for your prompt.

The prompt is one leg (instructions). The harness is the whole standing system — rules + tools + skills — that makes the agent capable before any prompt arrives.

Instructions, tools, skills — the three straps holding the agent to the cart, and the kitchen analogy for each

Most of the time today is only setting up the harness. Because when I have a system that is built for me, it becomes a powerful system that can work for me irrespective of what I am doing.0:19:21

This idea elsewherebuilds onthe triad, now called a harness reappears inskills become one leg of the harness

Go deeper

In one line: The buzzword defined: a harness is the system you set up in any agentic platform, made of three parts — INSTRUCTIONS/rules (the prompts and standing constraints), TOOLS (connectors and MCP servers), and SKILLS. Named for the horse-cart harness: 'the structure holding the horses to the cart… the mechanism to keep it in control.' Crucially, the harness is built FOR THE AGENT — the instructions, tools and skills are what the agent consults to work.

The restaurant mapping: rules = 'be at your station at 7:59, wash hands, read the recipe'; tools = knife, oven, wok; skills = the recipes (0:17:17)

Harnesses are NOT universal — the Italian kitchen's harness (wood-fired oven, sourdough) differs from the Chinese kitchen's (wok, five-spice) even when the raw toolset overlaps (0:19:21)

'Most of the time today is only setting up the harness. I will not build a single thing' — the setup IS the leverage (0:19:21)

Build order: problem statement first → derive the capabilities the agent needs → add them one by one (1:19:53)

▶ Watch this taught: 0:13:15

Check yourself

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

Define the three harness legs with the kitchen analogy.

Instructions = house rules (wash hands, read the recipe); tools = knife/oven/wok (MCPs, connectors, libraries); skills = the recipes (packaged procedures).

Why isn't there one best universal harness?

Harnesses are problem-shaped: the Italian and Chinese kitchens share tools but weight them differently — capabilities derive from the specific problem statement.

The pipeline: ingest → filter → build

0:23:28

The homework wasn't 'learn Cursor' — it was 'read the website Cursor just built about itself,' because the pipeline that made it is the real lesson.

Each stage has a distinct discipline. Ingestion is capability work — the harness's scrapers pull transcripts, articles and threads into plain text files the agent can reference. Filtering is judgment work — raw scraped material is bloated and contradictory, so the agent must read everything and negotiate with you about what survives (his prompt forced a keep/ignore discussion before any drafting). Building is assembly work — the filtered tutorial content plus an extracted design system becomes a scaffolded, deployed site.

The generalization is the point: swap 'Cursor for non-engineers' for any topic you need to learn, and the same pipeline produces a personal, shareable learning resource. It's Session 6's factory idea — raw material transformed into something more valuable — aimed at knowledge instead of leads.

Worked example · from the session

The actual artifacts on screen: cursor-yt.txt (video transcript), cursor-blog.txt (Substack scrapes, paywalls noted), cursor-reddit/x reference file → cursor-for-beginners folder → the deployed site.

Why it matters

This is Paul's own pipeline, taught back: ingest transcripts, filter with judgment, build the teaching site — validation that the architecture is the industry pattern, not an idiosyncrasy.

People get this wrong

Scrape everything, dump it in, let the AI sort it out during generation.

Filtering is its own stage with the human in it — skipping the keep/ignore negotiation produces a website-shaped pile of unweighted scrapings.

Sources in, judgment in the middle, a live website out — the self-learning factory he built on stage

For your projects

This session is an independent rediscovery of Paul's course-KB architecture — ingest (recordings/transcripts) → filter (extraction with judgment) → build (the static site). Worth citing when explaining the KB to anyone from this cohort.

This idea elsewherebuilds onthe factory pattern, for learning resources

Go deeper

In one line: The session's problem — 'teach Cursor for non-engineers' — solved as a three-stage pipeline: INGEST from chosen sources (YouTube, Substack/blogs, Reddit, X), FILTER what deserves to survive (with the human in the loop), BUILD the artifact (a website) from the filtered material. The claim: this same system is how you should self-learn ANY new topic — build yourself the resource.

Source selection is deliberate: YouTube for depth, blogs/Substack for written craft, Reddit and X for practitioner advice — 'don't forget our good old friend X' (0:25:30)

The meta-move: the website teaching Cursor is built IN Cursor — the material and the demonstration are the same artifact (0:05:08)

Cost honesty up front: 'I am not considering cost optimization at this level. If I have to learn something exhaustively, I have to pay the cost' — but the tricks (YT-DLP, limits) cap it (0:29:36)

By session end the pipeline shipped: scraped txt files → filtered tutorial folder → designed website → live Vercel URL shared in chat (1:50:44)

▶ Watch this taught: 0:23:28

Check yourself

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

What discipline does each stage demand?

Ingest: capability (scrapers into text files). Filter: judgment (keep/ignore negotiated with the human). Build: assembly (filtered content + design system → deployed site).

What's the transferable use of this pipeline beyond Cursor?

Self-learning any topic: ingest the best sources, filter to a tutorial, build the resource — 'the system you build today… to build self-learning resources for yourself.'

Agentic MCP installation: paste the docs, ask the agent

how-to0:33:40

He announced 'a very complex process' — then pasted a URL and typed 'install this MCP.' The joke is the lesson: configuration died as a skill this year.

The old ritual — locate the JSON config, edit server entries, restart, debug path issues — is now the agent's job, because the agent can read documentation and operate its own settings. What remains yours is judgment: choosing the tool, sourcing the docs, deciding where the API key lives (a .env file in anything real), and verifying the green light. Even debugging is delegated — his error resolved by asking the agent to look at its own output.

The pattern generalizes past MCPs: local libraries (YT-DLP installed from a pasted GitHub repo), skills (pasted from skills.sh), anything with documentation. The harness assembles itself; you're the procurement department.

Worked example · from the session

Both installs end-to-end: Parallel (docs URL → 'install this MCP' → configured) and Scrape Creators (docs → key request → dashboard key named 'cursor session' → green after one self-debug).

Do it in this order

01Find the tool's MCP/API documentation page (plain Google search — 'this much work you have to do')
02Copy the docs URL; in a FRESH agent, prompt: 'install this MCP' + the link
03When asked for an API key: create one in the tool's dashboard (name it for the context, e.g. 'cursor session') and paste it
04Prefer a .env environment variable for the key in real projects — pasting it raw was 'for simplicity's sake' on stage
05Verify in settings → MCP: green means configured; on error, ask the agent 'why is X erroring' / 'show output' and let it self-repair
06Repeat per tool — one fresh agent per install to conserve context

Gotchas["Some tools ship an 'install in Cursor' button (Scrape Creators did) — the docs-paste route works even when they don't (0:41:51)", "His Scrape Creators install showed a red error first; one 'show output' prompt later it self-diagnosed to green (0:45:54)", "Skills install identically: paste the skills.sh entry, 'install this skill, if not already done' (1:02:14)"]

Why it matters

Install friction was the moat keeping non-engineers off these tools — agentic installation removes it, which is exactly why this session can be 'Cursor for non-technical people.'

People get this wrong

MCP setup requires understanding the config format.

The agent reads docs and writes its own config — your jobs are tool choice, key custody (.env), and verifying the green light.

This idea elsewherebuilds onMCP servers, now self-installing

Go deeper

In one line: The 'very complex process' punchline: to install any MCP, copy its documentation URL, paste it into the agent, and say 'install this MCP.' The agent reads the docs, writes the config, asks for what it needs (API keys), and the settings panel's green indicator confirms. No hand-editing MCP JSON — 'my Cursor is an agentic platform; it will figure it out and do it for me.'

The free-tier check rides along: post-install, the agent reported his 1,000 remaining Scrape Creators credits unprompted (0:45:54)

Claude Code's sandbox makes some local installs behave differently — use the terminal Claude Code, not Claude chat, for harness work (1:17:52, 1:56:49)

▶ Watch this taught: 0:33:40

Check yourself

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

What's the full install prompt-pattern, including failure handling?

Paste docs URL + 'install this MCP'; supply the API key when asked; check for green in settings; on red, 'show output / why is it erroring' and let the agent repair.

Where should the API key actually live, and why did he do otherwise?

In a .env environment variable; he pasted it raw purely for on-stage simplicity and said so twice.

The scraper army: Parallel, Scrape Creators, YT-DLP, Firecrawl

0:31:39

One scraper can't cover the internet: the searcher gets blocked on Reddit, the platform API charges $3 a video on YouTube — so he assembles a squad and writes routing orders.

The division of labor follows cost and access. Parallel searches — it's a retrieval engine for agents, cheap and broad, but platforms with login walls block it. Scrape Creators specializes in exactly those platforms, metered per call, spanning an absurd catalog (Truth Social to SoundCloud). YouTube gets its own lane because long videos make metered scraping ruinous — YT-DLP runs locally, pulls auto-captions as plain text, and costs nothing. Firecrawl covers arbitrary sites and doubles as redundancy: when the design-extraction skill stumbled, the agent reached for Firecrawl unprompted.

Two durable habits ride along: source your tools from practitioner complaint threads (the YT-DLP discovery pattern — Reddit gripes about credit burn point at the free alternative), and evaluate by adoption (174k GitHub stars did the vetting). And note what the artifacts must be: agent-readable text files, not chat-locked summaries — the NotebookLM contrast.

Worked example · from the session

The live routing: Substack articles → Parallel; Reddit + X advice → Scrape Creators; the 342k-view YouTube tutorial → YT-DLP to cursor-yt.txt; paywalled blogs partially scraped and accepted ('this much is sufficient').

Why it matters

Ingestion is the harness's supply chain — knowing which scraper owns which lane (and which lane is free) is the difference between a $60 experiment and a $0 one.

People get this wrong

Scraping YouTube means downloading video — expensive and heavy by nature.

The value is the TRANSCRIPT: YT-DLP pulls captions locally for free, even translating languages — the $2-3/video actor fee buys nothing the text file lacks.

Search, platforms, YouTube-for-free, blogs — four scrapers, each with a lane, routed by rule

I am not directly going to war against Thanos. First, I'm assembling the Avengers — set up my harness, and then I go into war and solve the problem.0:49:59

This idea elsewherecontrasts witha scraping waterfall, assembled by hand

Go deeper

In one line: Four tools, four niches. Parallel.ai: a search engine built FOR AGENTS (with a human/machine dual-mode website), free-tier generous — the harness's web-searcher; EXA and Tavily are peers. Scrape Creators: one umbrella API over TikTok/Instagram/YouTube/LinkedIn/Twitter/Reddit/Truth Social and more — the platform scraper. YT-DLP: a 174k-star open-source local library that pulls YouTube TRANSCRIPTS free (vs $2-3/video through paid actors). Firecrawl: blog/site scraping and the fallback that rescued his design extraction.

Parallel's machine-mode demo grounds a prediction: every website will ship human AND agent versions, and 'your agent will talk to Amazon's agent, bargain, and purchase' — within a year or less, he believes (0:33:40)

YT-DLP found via a Reddit complaint thread about Apify credit burn — 'somebody said, why don't you try this repo. One line.' Local install = zero credits per scrape (0:49:59)

YT-DLP scrapes transcripts, not videos — including cross-language: a Spanish tutorial scraped and understood in English (0:52:01)

NotebookLM contrast: it can chat about a video but the transcript isn't AVAILABLE TO YOUR AGENT — harnesses need agent-accessible artifacts (0:52:01)

Twitter is the hard nut: 'don't play games with Twitter — you'll get banned. Decently use their API' (via Scrape Creators) (0:47:55)

CAPTCHA reality (Q&A): plain scrapers hit walls; circumvention needs browser-driving agents (Claude in Chrome, Codex opening its own browser) (1:56:49)

▶ Watch this taught: 0:31:39

Check yourself

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

Route these: a Substack search, a Reddit thread, a 3-hour YouTube video.

Substack → Parallel MCP (web search/scrape); Reddit → Scrape Creators (platform API); YouTube → YT-DLP locally, transcript only, free.

Why does the NotebookLM comparison matter to harness design?

Harness artifacts must be available to the AGENT — NotebookLM's understanding is locked in its chat; YT-DLP's transcript is a text file any agent can read.

Rules: routing the scrapers, user vs project scope

0:56:09

The tools were installed but dumb about cost — one paragraph of routing rules made the agent frugal forever.

A rule converts a one-time decision into standing behavior. His routing logic — free local library before metered API, searcher for search, platform scraper for platforms — exists precisely once, in settings, and every future agent session inherits it. The proof came minutes later: asked to scrape a video with no tool named, the agent chose YT-DLP because the rule was in scope.

The scoping model is worth internalizing: user rules are your permanent operating doctrine (cost routing, tone, safety habits); project rules are local law (this repo's stack, this client's conventions). And the convergence note matters cross-platform — in Claude Code the same doctrine lives in CLAUDE.md, in Codex in its instruction files: same leg of the harness, different filing cabinet.

Worked example · from the session

The rule text composed on stage, dictated straight into settings — YT-DLP first for YouTube, Parallel for search, Scrape Creators for X/Reddit, 'conserve on the credits.'

Why it matters

Rules are where credit discipline stops depending on your memory — the harness enforces its own economics.

People get this wrong

Rules are guardrails against the agent misbehaving.

Mostly they're ROUTING — encoding which tool wins which job (and at what cost) so every future session starts with your economics built in.

Go deeper

In one line: With tools installed, the first rule writes itself: 'When asked to scrape a YouTube video, FIRST use YT-DLP, only then Scrape Creators — to conserve credits. For internet search, use Parallel MCP. For X and Reddit, use Scrape Creators.' Set in Cursor settings → Rules as a USER rule (applies everywhere) versus a PROJECT rule (this repo only) — and you can have the agent write the rule for you.

Rules are the instructions leg of the harness made standing — the agent picked YT-DLP unprompted on the next scrape request because the rule routed it (1:23:57)

Scope choice is deliberate: user-level because 'wherever I am doing the scraping, I will need this'; project rules for repo-specific standards (1:00:13)

Platform note: Codex and Claude Code fold rules into skills/prompt files — 'rules and skills are becoming one and the same'; Cursor keeps them separate for enforcing coding standards (0:58:12)

Meta-shortcut: 'you can go to the agent and tell it — I want to set up these rules — and they'll get set up' (1:00:13)

▶ Watch this taught: 0:56:09

Check yourself

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

User rule or project rule: 'always scrape YouTube with YT-DLP first'?

User rule — it applies to every project where scraping happens; project rules are for repo-specific conventions.

How did the rule prove itself in the demo?

The next scrape prompt named no tool; the agent chose YT-DLP on its own — the routing had become default behavior.

Skills from the marketplace: superpowers, extract-design-system

1:02:14

He didn't write a design system or a brainstorming procedure — he shopped for both, vetted them by install count, and had the agent install them like apps.

The marketplace changes what 'having a capability' means: expertise is packaged, ranked by adoption, and installable by prompt. His two picks bracket the range — superpowers is a general-purpose thinking upgrade he carries into every harness, while extract-design-system is problem-specific provisioning for this build (clone the look of a site you love instead of describing aesthetics in prompts). The adoption heuristic substitutes for evaluation you can't do yet: 124k installs is a code review performed by the crowd.

Note the quiet composition at build time: the agent chose to invoke superpowers before scaffolding — installed skills aren't menu items you trigger, they're capabilities the agent weaves in when the task matches. That's the harness working as designed.

Worked example · from the session

The design-extraction run: 'extract the design from codingformarketers.com' → the skill (with a Firecrawl assist) emitted a full design system with tokens and branding, ready to drive the site build.

Why it matters

The skills leg is where your harness inherits other people's mastery — the same compounding Harshit taught for email copy, now for design and reasoning.

People get this wrong

Installed skills sit idle until you explicitly invoke them.

The agent composes them in when tasks match — superpowers fired before the site scaffold without being named in the prompt.

This idea elsewherereappears inskills.sh again — the Humanizer's home

Go deeper

In one line: The skills leg gets provisioned from skills.sh: SUPERPOWERS — 'a core part of my harness always,' the universal brainstorming skill (a plugin, technically: skills + agents packaged together); and EXTRACT-DESIGN-SYSTEM — pulls a complete design system (tokens, branding, fonts) from any website you admire. Install like everything else: paste the entry, 'install this skill, if not already done.' Evaluate candidates by adoption: installs and stars, not descriptions.

Skill vs plugin defined: 'a plugin consists of skills, agents — packaging everything together. That's the only difference' (1:02:14)

Vetting heuristic: extract-design-system showed 124k installations — 'for beginners, always start with skills people are using a lot' (1:04:16)

Superpowers earned its keep invisibly: before scaffolding the site, the agent called it for a brainstorm pass unprompted (1:44:37)

Skills are cheap to carry: 'they only add a few tokens to the context' — hoarding installed skills is fine (1:58:51)

Q&A extensions: ElevenLabs MCP for audio, Higgsfield for video — but 'expect your token usage to shoot through the roof' (1:15:51)

▶ Watch this taught: 1:02:14

Check yourself

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

How do you vet an unknown skill before installing?

Adoption: install counts and repo stars — start with heavily-used skills; treat low-adoption ones as unverified.

What distinguishes a plugin from a skill?

Packaging: a plugin bundles skills plus agents together; a skill is the single procedure.

Fresh agent per task: context as a budget

0:52:01

He opened more agent windows than browser tabs — because in agentic platforms, the whiteboard you don't erase becomes the bug you can't find.

Context is a consumable with two failure modes: cost (every token of stale conversation is paid again each turn) and quality (models drift and hallucinate as context bloats — the Session 8 ICP incident was exactly this). The fresh-agent habit solves both structurally: tasks get clean rooms, and state that must persist lives in FILES the next agent @-references. That's why the pipeline's artifacts are .txt and .md files rather than chat memory — files are the durable, agent-legible medium between contexts.

The habit scales up into his modality budgeting: text-first workflows because voice and image multiply token burn, and skepticism toward token-hungry fashions (loop engineering) until proven. Frugality here isn't stinginess — it's the same engineering discipline as the YT-DLP routing rule.

Worked example · from the session

The rhythm on stage: install Parallel (agent 1), install Scrape Creators (agent 2), scrape (agent 3), filter with @-referenced files (agent 4), extract design (agent 5), build (agent 6).

Why it matters

This is the vibe-coder's equivalent of memory management — and the direct fix for the 'why did it suddenly get dumb?' experience everyone hits in long sessions.

People get this wrong

One long session helps the agent 'know the project' better.

Long sessions degrade and overbill; project knowledge belongs in files and rules the next fresh agent can load — erase the whiteboard, keep the documents.

Go deeper

In one line: The standing habit threaded through the whole demo: every new task — each MCP install, the filter step, the design extraction, the build — gets a NEW agent window. 'It's like erasing the whiteboard and starting afresh': installations don't need the scraping conversation's context, and long sessions degrade output. Claude hallucinating his ICP in Session 8 was this failure; here it's prevented structurally.

'Every installation I'm doing, I can open a new agent window… so that I can save up on the context usage' (0:54:03)

The @-reference bridges fresh contexts: a new agent can @cursor-blog.txt, @cursor-yt.txt — files, not chat history, carry state between agents (1:32:05)

Token-cost ladder from Q&A: text is cheapest, voice higher, image/video 'guzzles' — budget context AND modality (2:04:56)

The 'loop engineering' teaser declined for the same reason: 'it drinks tokens like anything' — not taught until he's confident it's worth the spend (2:02:53)

▶ Watch this taught: 0:52:01

Check yourself

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

How does state survive if every task gets a fresh agent?

Files: scraped txt files, the tutorial folder, the design system — @-referenced into each new context. Chat history is disposable; artifacts persist.

Name the two failure modes of bloated context.

Cost (stale tokens re-billed every turn) and quality (drift/hallucination — the Session 8 wrong-ICP incident).

The educator's eye: human curation and the keep/ignore negotiation

1:19:53

The most automated session of the course kept two jobs stubbornly human: choosing which videos deserve scraping, and arguing with the agent about what survives the cut.

Both checkpoints are placed where taste outperforms tokens. Source selection is upstream leverage — one educator-eye minute scanning YouTube results (recency, views, framing) beats fifty agent-scraped transcripts of mediocre tutorials, on both cost and quality. The keep/ignore negotiation is downstream control — forcing the agent to expose its editorial rationale BEFORE drafting converts a black-box summarization into a reviewable decision, and his one-line verdict ('audience is completely non-technical') redirected the whole artifact.

This is the intelligence loop's human station: the machine ingests and proposes; the human supplies audience judgment the scrape can't contain. Note it's cheap — two touchpoints, not constant supervision.

Worked example · from the session

The filter exchange verbatim: agent lists keeps/ignores per source file → he approves with an audience constraint → only then does the cursor-for-beginners folder get written.

Why it matters

The difference between 'AI-generated content' and a resource worth sharing is exactly these two checkpoints — the same reason Paul reviews extractions before commit.

People get this wrong

A good enough agent makes human curation a bottleneck to remove.

Curation is the highest-leverage tokens-per-minute in the pipeline — two human touchpoints steered everything, and removing them yields confident, unweighted mush.

This idea elsewherereappears incuration beats volume, again

Go deeper

In one line: Two deliberate human checkpoints in an otherwise agentic pipeline. Upstream: he shortlists YouTube URLs HIMSELF — 'I have the eye of an educator… I sample the video' (view counts as signal: the 342k-view tutorial made the cut). Downstream: the filter prompt forbids autonomous drafting — 'discuss with me the rationale of what you are keeping and what you are ignoring… we discuss everything before you write the final file.'

The agent's filter report came back structured: what it's keeping ('you are the senior dev, Cursor is the junior'; 'plan like a PM, not a magician'; the 12-lesson checklist) and what it's ignoring — then he ruled: 'my audience is completely non-technical, go with your preference' (1:36:16)

Bulk YouTube search by agent rejected on cost AND judgment grounds: too many videos, too much transcript, no taste (1:28:00)

Known-good sources skip search: bookmarked Twitter posts can be pasted directly for ingestion (1:28:00)

Paywalled Substack articles partially scraped and accepted — 'this much is sufficient': curation includes knowing when enough is enough (1:25:59)

▶ Watch this taught: 1:19:53

Check yourself

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

Where are the two human checkpoints and what does each contribute?

Source shortlisting (educator's taste — which videos deserve scraping) and the keep/ignore negotiation (audience judgment before any drafting).

Why did he refuse to let the agent search YouTube itself?

Cost (long transcripts × many videos) and judgment (view-count/framing taste the agent lacks) — bulk agent search is the telescope; his shortlist is the laser.

Extract a design you love, build, deploy

how-to1:38:19

Instead of describing a design in adjectives, he pointed at a website he loved and said 'extract that' — then the whole build inherited someone's proven taste.

Design-by-reference solves the non-designer's hardest problem: articulating aesthetics. The extract-design-system skill converts an admired site into machine-usable tokens — colors, type, spacing, branding — which then drive the scaffold, so consistency is structural rather than hoped-for. The build prompt's 'brainstorm or discuss where required' clause matters: it licenses the agent to stop and think (superpowers) instead of bulldozing, while 'it felt it was straightforward and went forward' shows the valve only opens when needed.

The deploy leg reprises Session 4's ramp from inside Cursor: offer accepted, auth allowed, production URL live — with the honest wobble ('something is happening with Vercel… I'll troubleshoot later') that real demos have. Total distance from scraped transcripts to shareable teaching site: one session, on stage, while ill.

Worked example · from the session

The three prompts of the whole build phase: 'extract the design from codingformarketers.com' → 'build the website with all the files using the extracted design' → 'deploy to Vercel.'

Do it in this order

01Choose a reference website whose look and feel you want — taste by example, not adjectives
02Fresh agent: 'extract the design from <site>' — the skill emits a design-system file (tokens, branding, fonts); Firecrawl fills gaps automatically
03Fresh agent: build prompt referencing the content folder + extracted design, with 'brainstorm or discuss where required' as the escape valve
04Let it scaffold (Next.js app → design tokens/global styles → layout components → pages) and verify the dev server runs
05Say yes when it offers Vercel: authenticate, allow, get the production URL
06Share/test the live URL — his went to the cohort chat in-session

Gotchas["Cursor's speed is a genuine differentiator here: 'the same thing on Opus 4.8 would take much more time'; Composer 2.5 (built on Kimi K2.5) is the default engine (1:36:16)", "Deploy hiccups happen live — a Vercel auth stumble resolved with one 'allow'; Netlify named as the beginner alternative (1:48:42)", 'Free-tier hosting has scale limits — heavy traffic needs auto-scaling, which Vercel handles better than raw free tiers (1:48:42)', "Browser-testing tooling: he uses Chrome DevTools MCP over Playwright ('Google's official one — same purpose') (1:42:33)"]

Why it matters

This is the payoff that justifies the hour of harness-building: with rules, tools and skills in place, the actual product took three sentences.

People get this wrong

Cloning a site's design system is stealing the site.

It extracts the SYSTEM — tokens, spacing, type discipline — not content or code; his site shares codingformarketers' feel with entirely different material. (Sell nothing you've cloned without checking rights.)

This idea elsewherereappears inthe deploy ramp, from inside Cursor builds ondesign taste, mechanized

Go deeper

In one line: The build phase: pick a reference site whose feel you admire (codingformarketers.com), run extract-design-system on it (tokens, branding, fonts — with Firecrawl auto-assisting when extraction stumbled), then 'build me the cursor-for-beginners website with all the files… using the extracted design, brainstorm or discuss where required' — Next.js scaffold, layout components, pages for tutorial/prompts/checklist, dev-run verification, and a Vercel deploy to a live shared URL.

Superpowers fired a brainstorm pass before scaffolding, unprompted — installed skills compose themselves in (1:44:37)

No guardrails yet by design: 'I just brought everything together' — tomorrow's app session adds the controls (1:46:40)

Learner Syed shipped a parallel version live (cursor-for-beginners.vercel.app) — assigned as comparative homework (1:52:45)

▶ Watch this taught: 1:38:19

Check yourself

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

How does design-by-reference beat design-by-description for non-designers?

You point at proven taste instead of articulating it — the skill extracts tokens/branding from the admired site and the build inherits them structurally.

What did the hour of harness-setup buy at build time?

A three-prompt product: extract design → build from files → deploy. The capabilities (scrapers, skills, rules) were already standing.

Field notes from the Q&A: sandboxes, CAPTCHAs, token gravity

1:15:51

The Q&A read like a costs-and-casualties report: a hundred dollars gone to a voice app, tokens massacred by a YouTube-watching agent, and a trainer refusing to teach his own obsession until it stops drinking.

The architecture note is the most practically important: sandbox (Claude Code) versus local access (Codex) explains a whole class of 'why won't it install things' confusion — and 'Claude chat is not agentic; use terminal Claude Code' is the sharpest one-line diagnosis of beginner failure in the course. The CAPTCHA answer draws the scraping frontier honestly: text APIs end where interactive challenges begin, and only browser-embodied agents cross.

The token-gravity stories aggregate into a budgeting instinct: text is cheap, voice and video are heavy, always-on monitoring loops are heaviest — so his skepticism about loop engineering isn't conservatism, it's the same cost-routing discipline as the YT-DLP rule, applied to fashion. And the koan reframes the whole two-day arc: the harness makes HOW nearly free, which moves all the scarcity to WHAT."

Worked example · from the session

The diagnosis chain for a stuck scraper: using Claude chat? → not agentic. Terminal Claude Code sandbox blocking installs? → use Codex locally. Hitting CAPTCHA? → browser agent or don't.

Why it matters

These are the answers the cohort will need the week they go off-script — saved here so the KB answers them before the forum does.

People get this wrong

A stronger scraper eventually beats CAPTCHAs.

CAPTCHAs mark the end of API-land — only browser-driving agents (Claude in Chrome, Codex's own browser) legitimately cross, and platform ToS still applies.

Whenever we are in the era where building becomes easy, what to build is more important than how to build.2:04:56

This idea elsewherebuilds oncredit discipline, dev edition

Go deeper

In one line: The Q&A's durable nuggets: Claude Code runs SANDBOXED (virtual environment) while Codex operates on your local system — use terminal Claude Code, never Claude chat, for harness work. CAPTCHAs defeat plain scrapers; only browser-driving agents (Claude in Chrome, Codex's own browser) circumvent them. Ollama can host a harness only with serious local hardware. Audio/video MCPs (ElevenLabs, Higgsfield) and 'loop engineering' all share one property: they drink tokens.

The Hardik/Viber post-mortems: $100 burned on a voice-based app; a Hermes agent watching competitors' YouTube metrics 'killed the tokens' — modality and monitoring loops are the budget-eaters (2:02:53)

Copyright question answered pragmatically: personal-consumption learning resources are fine; selling scraped material is where issues start (1:54:46)

Curriculum reassurance: 'we are 6-7 sessions into the core… monetization, finding ideas, everything connects in a few weeks — trust us' (2:00:52)

Loop engineering teased and deferred twice: his current obsession, unproven, token-hungry — 'I'll come to it when I'm confident it is helpful' (2:02:53)

The era's koan, closing the session: 'when building becomes easy, WHAT to build is more important than HOW to build' (2:04:56)

▶ Watch this taught: 1:15:51

Check yourself

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

Why does 'use terminal Claude Code, not Claude chat' matter for harness work?

Chat isn't agentic — no tools, no file system, no installs. The harness needs an agentic runtime; and even there, Claude Code's sandbox differs from Codex's local access.

What's the common property of voice apps, video MCPs, and loop engineering?

Token gravity — modality and always-on loops multiply burn (the $100 voice app, the Hermes YouTube watcher). Budget before adopting.

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.

01Tool-agnostic problem solving ('who cares')The session's stance, set before any teaching: Claude Code, Codex, Cursor, Devin, Antigravity are functiona…0:07:09›

The session's stance, set before any teaching: Claude Code, Codex, Cursor, Devin, Antigravity are functionally interchangeable agentic platforms — 'what Claude Code can do, Codex can do' — differing mainly in marketing and reliability-of-the-week. His actual workflow: start on Claude Code, exhaust its tokens, continue on Codex, exhaust those, pick up on Cursor. Currently Codex is his main and Claude Code the fallback 'this month' — the ranking floats with reliability.

The pizza rule for tool debates: 'taste is personal' — the best-tool question has no transferable answer, so he refuses to advocate (2:06:59)

Everything in the session transfers: 'remove Cursor, add Claude Code, add Codex — a little bit of command syntax changes, but as such the thing does not change' (0:11:14)

One real platform difference flagged: Claude Code runs sandboxed while Codex works on your local system — so local-machine tasks behave differently (1:17:52)

02The harness: instructions + tools + skillsThe buzzword defined: a harness is the system you set up in any agentic platform, made of three parts — INS…0:13:15›

The buzzword defined: a harness is the system you set up in any agentic platform, made of three parts — INSTRUCTIONS/rules (the prompts and standing constraints), TOOLS (connectors and MCP servers), and SKILLS. Named for the horse-cart harness: 'the structure holding the horses to the cart… the mechanism to keep it in control.' Crucially, the harness is built FOR THE AGENT — the instructions, tools and skills are what the agent consults to work.

The restaurant mapping: rules = 'be at your station at 7:59, wash hands, read the recipe'; tools = knife, oven, wok; skills = the recipes (0:17:17)

Harnesses are NOT universal — the Italian kitchen's harness (wood-fired oven, sourdough) differs from the Chinese kitchen's (wok, five-spice) even when the raw toolset overlaps (0:19:21)

'Most of the time today is only setting up the harness. I will not build a single thing' — the setup IS the leverage (0:19:21)

Build order: problem statement first → derive the capabilities the agent needs → add them one by one (1:19:53)

03The pipeline: ingest → filter → buildThe session's problem — 'teach Cursor for non-engineers' — solved as a three-stage pipeline: INGEST from ch…0:23:28›

The session's problem — 'teach Cursor for non-engineers' — solved as a three-stage pipeline: INGEST from chosen sources (YouTube, Substack/blogs, Reddit, X), FILTER what deserves to survive (with the human in the loop), BUILD the artifact (a website) from the filtered material. The claim: this same system is how you should self-learn ANY new topic — build yourself the resource.

Source selection is deliberate: YouTube for depth, blogs/Substack for written craft, Reddit and X for practitioner advice — 'don't forget our good old friend X' (0:25:30)

The meta-move: the website teaching Cursor is built IN Cursor — the material and the demonstration are the same artifact (0:05:08)

Cost honesty up front: 'I am not considering cost optimization at this level. If I have to learn something exhaustively, I have to pay the cost' — but the tricks (YT-DLP, limits) cap it (0:29:36)

By session end the pipeline shipped: scraped txt files → filtered tutorial folder → designed website → live Vercel URL shared in chat (1:50:44)

04Agentic MCP installation: paste the docs, ask the agentThe 'very complex process' punchline: to install any MCP, copy its documentation URL, paste it into the age…0:33:40›

The 'very complex process' punchline: to install any MCP, copy its documentation URL, paste it into the agent, and say 'install this MCP.' The agent reads the docs, writes the config, asks for what it needs (API keys), and the settings panel's green indicator confirms. No hand-editing MCP JSON — 'my Cursor is an agentic platform; it will figure it out and do it for me.'

The free-tier check rides along: post-install, the agent reported his 1,000 remaining Scrape Creators credits unprompted (0:45:54)

Claude Code's sandbox makes some local installs behave differently — use the terminal Claude Code, not Claude chat, for harness work (1:17:52, 1:56:49)

05The scraper army: Parallel, Scrape Creators, YT-DLP, FirecrawlFour tools, four niches.0:31:39›

Four tools, four niches. Parallel.ai: a search engine built FOR AGENTS (with a human/machine dual-mode website), free-tier generous — the harness's web-searcher; EXA and Tavily are peers. Scrape Creators: one umbrella API over TikTok/Instagram/YouTube/LinkedIn/Twitter/Reddit/Truth Social and more — the platform scraper. YT-DLP: a 174k-star open-source local library that pulls YouTube TRANSCRIPTS free (vs $2-3/video through paid actors). Firecrawl: blog/site scraping and the fallback that rescued his design extraction.

YT-DLP found via a Reddit complaint thread about Apify credit burn — 'somebody said, why don't you try this repo. One line.' Local install = zero credits per scrape (0:49:59)

YT-DLP scrapes transcripts, not videos — including cross-language: a Spanish tutorial scraped and understood in English (0:52:01)

NotebookLM contrast: it can chat about a video but the transcript isn't AVAILABLE TO YOUR AGENT — harnesses need agent-accessible artifacts (0:52:01)

Twitter is the hard nut: 'don't play games with Twitter — you'll get banned. Decently use their API' (via Scrape Creators) (0:47:55)

CAPTCHA reality (Q&A): plain scrapers hit walls; circumvention needs browser-driving agents (Claude in Chrome, Codex opening its own browser) (1:56:49)

06Rules: routing the scrapers, user vs project scopeWith tools installed, the first rule writes itself: 'When asked to scrape a YouTube video, FIRST use YT-DLP…0:56:09›

With tools installed, the first rule writes itself: 'When asked to scrape a YouTube video, FIRST use YT-DLP, only then Scrape Creators — to conserve credits. For internet search, use Parallel MCP. For X and Reddit, use Scrape Creators.' Set in Cursor settings → Rules as a USER rule (applies everywhere) versus a PROJECT rule (this repo only) — and you can have the agent write the rule for you.

Rules are the instructions leg of the harness made standing — the agent picked YT-DLP unprompted on the next scrape request because the rule routed it (1:23:57)

Scope choice is deliberate: user-level because 'wherever I am doing the scraping, I will need this'; project rules for repo-specific standards (1:00:13)

Platform note: Codex and Claude Code fold rules into skills/prompt files — 'rules and skills are becoming one and the same'; Cursor keeps them separate for enforcing coding standards (0:58:12)

Meta-shortcut: 'you can go to the agent and tell it — I want to set up these rules — and they'll get set up' (1:00:13)

07Skills from the marketplace: superpowers, extract-design-systemThe skills leg gets provisioned from skills.sh: SUPERPOWERS — 'a core part of my harness always,' the unive…1:02:14›

The skills leg gets provisioned from skills.sh: SUPERPOWERS — 'a core part of my harness always,' the universal brainstorming skill (a plugin, technically: skills + agents packaged together); and EXTRACT-DESIGN-SYSTEM — pulls a complete design system (tokens, branding, fonts) from any website you admire. Install like everything else: paste the entry, 'install this skill, if not already done.' Evaluate candidates by adoption: installs and stars, not descriptions.

Skill vs plugin defined: 'a plugin consists of skills, agents — packaging everything together. That's the only difference' (1:02:14)

Vetting heuristic: extract-design-system showed 124k installations — 'for beginners, always start with skills people are using a lot' (1:04:16)

Superpowers earned its keep invisibly: before scaffolding the site, the agent called it for a brainstorm pass unprompted (1:44:37)

Skills are cheap to carry: 'they only add a few tokens to the context' — hoarding installed skills is fine (1:58:51)

Q&A extensions: ElevenLabs MCP for audio, Higgsfield for video — but 'expect your token usage to shoot through the roof' (1:15:51)

08Fresh agent per task: context as a budgetThe standing habit threaded through the whole demo: every new task — each MCP install, the filter step, the…0:52:01›

The standing habit threaded through the whole demo: every new task — each MCP install, the filter step, the design extraction, the build — gets a NEW agent window. 'It's like erasing the whiteboard and starting afresh': installations don't need the scraping conversation's context, and long sessions degrade output. Claude hallucinating his ICP in Session 8 was this failure; here it's prevented structurally.

'Every installation I'm doing, I can open a new agent window… so that I can save up on the context usage' (0:54:03)

The @-reference bridges fresh contexts: a new agent can @cursor-blog.txt, @cursor-yt.txt — files, not chat history, carry state between agents (1:32:05)

Token-cost ladder from Q&A: text is cheapest, voice higher, image/video 'guzzles' — budget context AND modality (2:04:56)

The 'loop engineering' teaser declined for the same reason: 'it drinks tokens like anything' — not taught until he's confident it's worth the spend (2:02:53)

09The educator's eye: human curation and the keep/ignore negotiationTwo deliberate human checkpoints in an otherwise agentic pipeline.1:19:53›

Two deliberate human checkpoints in an otherwise agentic pipeline. Upstream: he shortlists YouTube URLs HIMSELF — 'I have the eye of an educator… I sample the video' (view counts as signal: the 342k-view tutorial made the cut). Downstream: the filter prompt forbids autonomous drafting — 'discuss with me the rationale of what you are keeping and what you are ignoring… we discuss everything before you write the final file.'

Bulk YouTube search by agent rejected on cost AND judgment grounds: too many videos, too much transcript, no taste (1:28:00)

Known-good sources skip search: bookmarked Twitter posts can be pasted directly for ingestion (1:28:00)

Paywalled Substack articles partially scraped and accepted — 'this much is sufficient': curation includes knowing when enough is enough (1:25:59)

10Extract a design you love, build, deployThe build phase: pick a reference site whose feel you admire (codingformarketers.com), run extract-design-s…1:38:19›

The build phase: pick a reference site whose feel you admire (codingformarketers.com), run extract-design-system on it (tokens, branding, fonts — with Firecrawl auto-assisting when extraction stumbled), then 'build me the cursor-for-beginners website with all the files… using the extracted design, brainstorm or discuss where required' — Next.js scaffold, layout components, pages for tutorial/prompts/checklist, dev-run verification, and a Vercel deploy to a live shared URL.

Superpowers fired a brainstorm pass before scaffolding, unprompted — installed skills compose themselves in (1:44:37)

No guardrails yet by design: 'I just brought everything together' — tomorrow's app session adds the controls (1:46:40)

Learner Syed shipped a parallel version live (cursor-for-beginners.vercel.app) — assigned as comparative homework (1:52:45)

11Field notes from the Q&A: sandboxes, CAPTCHAs, token gravityThe Q&A's durable nuggets: Claude Code runs SANDBOXED (virtual environment) while Codex operates on your lo…1:15:51›

The Q&A's durable nuggets: Claude Code runs SANDBOXED (virtual environment) while Codex operates on your local system — use terminal Claude Code, never Claude chat, for harness work. CAPTCHAs defeat plain scrapers; only browser-driving agents (Claude in Chrome, Codex's own browser) circumvent them. Ollama can host a harness only with serious local hardware. Audio/video MCPs (ElevenLabs, Higgsfield) and 'loop engineering' all share one property: they drink tokens.

Copyright question answered pragmatically: personal-consumption learning resources are fine; selling scraped material is where issues start (1:54:46)

Curriculum reassurance: 'we are 6-7 sessions into the core… monetization, finding ideas, everything connects in a few weeks — trust us' (2:00:52)

Loop engineering teased and deferred twice: his current obsession, unproven, token-hungry — 'I'll come to it when I'm confident it is helpful' (2:02:53)

The era's koan, closing the session: 'when building becomes easy, WHAT to build is more important than HOW to build' (2:04:56)

Tools referenced

Tool	Coverage	Moment	Context
Cursor	demonstrated	0:33:40	The session's platform: Composer 2.5 default model (built on Kimi K2.5), settings → rules/skills/MCP, fresh-agent workflow, @-file references — 'super fast' at build time; SpaceX/X acquisition news relayed
Parallel.ai	demonstrated	0:31:39	Agent-native search engine (human/machine dual-mode site); installed as MCP from pasted docs; generous free limits; EXA and Tavily named as peers
Scrape Creators	demonstrated	0:41:51	Umbrella scraping API (TikTok → Truth Social); API-key flow, 1,000 free credits, one self-debugged error to green
YT-DLP	demonstrated	0:47:55	174k-star open-source local YouTube transcript scraper — free vs $2-3/video via paid actors; found in a Reddit complaint thread; cross-language transcripts
Firecrawl	demonstrated	1:17:52	Blog/site scraper MCP; auto-invoked by the agent to rescue the design extraction
skills.sh	demonstrated	1:02:14	Skill marketplace: superpowers (his universal core; a plugin technically) and extract-design-system (124k installs) both installed by prompt
Vercel	demonstrated	1:46:40	One-prompt deploy from Cursor to a live production URL; auth wobble resolved live; Netlify named as beginner alternative
Chrome DevTools MCP	mentioned	1:42:33	His browser-testing pick over Playwright — 'Google's official one, same purpose'
Claude Code	mentioned	0:37:46	This month's fallback to Codex; sandboxed architecture explained; 'use terminal Claude Code, not Claude chat'
Codex	mentioned	0:37:46	This month's main; local-system access (no sandbox); can open its own browser past CAPTCHAs
Devin	mentioned	0:07:09	Used 'very less' but part of the interchangeable rotation; Antigravity dismissed as Cursor-like
NotebookLM	mentioned	0:52:01	Contrast case: can chat about a video but its transcript isn't available to your agent — harness artifacts must be agent-readable
ElevenLabs	mentioned	1:15:51	The audio-skills MCP answer — with a token-cost warning
Higgsfield	mentioned	1:15:51	The video-skills MCP answer — 'token usage will shoot through the roof'
Ollama	mentioned	1:17:52	Possible harness host only with serious local hardware — 'it will guzzle system power'
Apify	mentioned	0:49:59	The credit-burner whose Reddit complaint thread led him to YT-DLP

Session materials

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

vtt

GMT20260627-140018_Recording.transcript.vtt

118 KB

Action items

Read the cursor-for-beginners site end-to-end (his and Syed's) — that's the homework before tomorrow's build session (1:52:45)
Set up your own harness: install Parallel MCP + Scrape Creators + YT-DLP by pasting docs into your agent; store keys in .env (0:33:40)
Write your routing rule (user-level): YT-DLP first for YouTube, Parallel for search, Scrape Creators for X/Reddit — conserve credits (0:56:09)
Install superpowers + extract-design-system from skills.sh; vet any other skill by install count (1:02:14)
Adopt fresh-agent-per-task with files as the state carrier (@-references) — stop running marathon sessions (0:52:01)
Run the pipeline on a topic YOU want to learn: shortlist sources yourself, force the keep/ignore discussion, build the resource (0:23:28)

Resources mentioned

Resources

docThe live artifact: his 'Cursor for beginners' website (Vercel URL shared in chat) — assigned as homework reading 1:50:44
docLearner Syed's parallel build: cursor-for-beginners.vercel.app — comparative homework 1:52:45
doccodingformarketers.com — the design reference whose system was extracted 1:38:19
docYT-DLP GitHub repo (link shared in chat — 'this one is not so well known') 0:49:59

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 says	The trainer actually means
Dhir / Delete (in 'Delete taught cursor') / Dheer	the trainer's name (per the closing 'Thank you, Dhir'; spelling unverified — needs registry entry)
hardness / hardscot / harnass	harness (the session's central term; 'hardscot' = horse-cart)
plot code / cloud code / CloudCore / blood code	Claude Code
codecs / code x	Codex
anti gravity	Antigravity (Google's agentic IDE, as heard)
Devon	Devin
kimikay 2.5 / kimik 2.5	Kimi K2.5 (open-source model under Cursor's Composer 2.5, as stated)
Gerson	Cursor (likely, in the token-rotation list)
Abbify / AP 5	Apify
Tavilly	Tavily
EXA	Exa (agent search engine)
YTDLP / YT DLP / mighty library / YTTLP	yt-dlp (the YouTube download library)
scrap creators	Scrape Creators
Oprah Super Pass	the 'superpowers' skill/plugin (as heard — garbled)
coding for marketers dot com	codingformarketers.com (design reference)
Versal / Purcell / Wartsen / vessel dot app / Versa	Vercel / .vercel.app
Higgs Field	Higgsfield (video MCP)
11 Labs	ElevenLabs
Shaizuan spice	Sichuan spice (the Chinese-kitchen analogy)
human comma dot machine	Parallel.ai's human/machine website toggle (as heard)
x has or SpaceX has acquired Cursor	the acquisition claim as stated in-session (see freshnessNotes)
Winsoft / Windsurf	Windsurf (learner question)
t h t / t sec / TXT	.txt files (cursor-yt.txt, cursor-blog.txt, reference.txt)
Viber	a colleague's name (as heard) — the Hermes YouTube-agent token story
loop engineering	his current research obsession (deferred; token-hungry)
CSAT poll... Thank you, Dhir	closing handoff (cohort-manager voice unnamed in this transcript)

True on recording day — verify before relying

The SpaceX/X-acquires-Cursor claim, 'Grok will power Cursor going ahead,' and Composer 2.5-on-Kimi-K2.5 are all as-stated in-session (June 2026) — verify before citing; the KB records the claim, not the fact.
His tool rotation is explicitly month-stamped: Codex main, Claude Code fallback 'this month' due to reliability — expect drift.
Free-tier numbers are of-the-day: Scrape Creators 1,000 credits, Parallel's 'very good limits,' extract-design-system's 124k installs, yt-dlp's 174k stars.
Loop engineering deferred as unproven and token-hungry — a likely future-session topic if it matures.
Session 2 of the Cursor arc (next session) promises: the app-building harness, sub-agents, .env walkthrough, debugging/test skills, what-to-build framework.
Trainer taught through a viral infection with planned voice breaks — session pacing reflects it.