AI Catalyst C3·Core Sessions - Week 5·2:34:37

Session 10: Building on Cursor & connect with AI workflows

Dhir Trainer/mentor — part 2 of the Cursor arc, taught through a worsening fever ('my energy will be a little low'). End-to-end agentic build: what-to-build framework → brainstormed PRD → Duolingo-style freemium app (AI Edge) with auth, payments and database — ~1 million tokens consumed on stage. · Niharika Cohort manager — open/close (as heard)

▶local recording · LMS lesson

Session map

What to buildDesigning the machineBuilding & shipping

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

Concept

The map reads left to right — what to build flow into designing the machine, then into building & shipping. Click any node to open that idea here; every timestamp jumps into the recording.

The short version

WHAT to build, before any building: ideas live at the intersection of your domain expertise and a customer need ('founder problem fit') — and 'somebody already built it' is no disqualifier (Swiggy after Zomato, Lyft after Uber, Zepto from a WhatsApp group's insights). His edge: 15 years teaching working professionals → build in education.
The ideation itself ran on Session 9's harness: two YouTube framework videos scraped to transcripts → merged into a product-ideation framework file → the framework RUN by the agent against his stated edge → market tree → micro-niches → the chosen product: AI Edge, a Duolingo-style freemium app teaching AI to professionals, with a paid implementation/consulting layer behind a qualification gate.
The Rick Rubin doctrine governs the whole flow: AI's outputs are SEEDS, not decisions — 'in this age of AI, the one skill to hone is human judgment.' Corollaries: audit the PRD, never take the framework's idea verbatim, and never let agents make irreversible decisions (AI reads anything; writes — trades, payments, sends — stay human).
The build was agentic coding, not vibe coding: superpowers-driven brainstorm interview → spec (PRD) → implementation plan (~20 tasks) → parallel sub-agents (curriculum scraper + PRD brainstormer, independent contexts) → Duolingo clone repo (MIT license) as the UX skeleton → stack decisions (Convex/Neon, Clerk auth for qualification data, Razorpay test mode, Context7 for hallucination-free docs) → Sentry security-review skill → live demo with honest bugs.
The product's real design problem wasn't features — it was the QUALIFICATION LOGIC: subtly collect ~15-20 data points (onboarding wizard, level-3 pain popup, optional LinkedIn enrichment), reveal the upsell only to qualified users, pay-first-then-book with a refundable deposit. 'The core monetization logic of your product' comes before course content, UI, everything.

At a glance, three clicks deep

Skim here first: the closed row is the glance, open is the study card with the key points and timestamps, and the ↓ link drops to that concept's full write-up below.

01What to build: expertise × customer needThe idea filter that precedes all building: your product should sit at the intersection of your DOMAIN EXPE…0:13:17›

The idea filter that precedes all building: your product should sit at the intersection of your DOMAIN EXPERTISE and a CUSTOMER NEED — 'founder problem fit,' which comes before product-market fit. Competition is not disqualifying: Zomato predated Swiggy, Uber predated Lyft, Zepto entered a crowded delivery market armed with pain-point insights from running a WhatsApp delivery group — 'somebody else built it' fails only when you bring no unique point of view.

His own application, stated with receipts: education for working professionals — '15 years… I know insights others don't.' Everything he builds starts there (0:15:18)

The supply-chain test: 20 years in supply chain → build/consult in supply chain with AI — the edge IS the moat (0:17:20)

Execution and distribution beat priority: the incumbents' existence proves the market; your insight defines the wedge (0:13:17)

↓ Full write-up of this concept

02Mining frameworks from YouTube (with yesterday's harness)Rather than inventing an ideation process, he mined one: searched YouTube for 'how to find ideas for good p…0:17:20›

Rather than inventing an ideation process, he mined one: searched YouTube for 'how to find ideas for good products,' picked two well-viewed videos ('how to use AI to find a million-dollar idea,' micro-SaaS ideas), scraped their transcripts with the Session 9 harness (YT-DLP, with Scrape Creators auto-falling-back when it failed), and had the agent merge them into a combined product-ideation framework file — a 5-phase pipeline: pick market → validate demand → research pain points → synthesize + prototype → ship + learn.

View count as the quality filter again: 'if it has got only a few views, that is not what we are looking at' (0:54:40)

The harness paid off immediately: YT-DLP failed mid-scrape and the agent fell back to Scrape Creators unprompted — the routing rules working (0:23:35)

NotebookLM ruled out for agentic work on architectural grounds: no API/CLI exposed, so Cursor and NotebookLM can't talk — 'whatever you're building must talk to each other' (0:27:58)

The framework file is shared in resources — reusable for any product hunt (0:25:56)

↓ Full write-up of this concept

03Rick Rubin's answer: AI gives seeds, you supply tasteThe governing doctrine, via Rick Rubin — the Grammy-winning producer who plays no instrument and reads no m…0:40:26›

The governing doctrine, via Rick Rubin — the Grammy-winning producer who plays no instrument and reads no music: 'What do I bring? I have taste. I can listen and tell if it's good or bad.' Applied: everything the framework/agent generates is a SEED to develop, never a decision to accept — 'never ever say AI has suggested this, so I will take it.' AI increases optionality; human judgment selects.

Demonstrated in the flow: the framework proposed three micro-niches with product shapes; he took them as inspiration and pivoted to his own freemium + service-layer model — 'to be fair, I knew I had to build in education' (0:42:28)

The naming moment repeated it in miniature: cohort suggestions harvested (AI Spark, Skill Forge…), his judgment picked AI Edge for the upsell path ('AI Edge Plus') (1:48:12)

PRD auditing is the same doctrine: 'use AI to audit the PRD — AND go through it completely yourself' (1:54:20)

↓ Full write-up of this concept

04Safety rails: prompt injection and the irreversibility ruleTwo standing safety habits.0:30:02›

Two standing safety habits. PROMPT INJECTION: hidden instructions on pages/skills ('ignore previous instructions, exfiltrate the credit cards') can hijack your agent — 'like SQL injection, but for prompting' — so never be the first mover on MCPs and skills; adoption is your security review, since the community flags malicious packages. IRREVERSIBILITY: agents may READ anything, but writes that can't be undone stay human — 'I use AI for stock market analysis, never for trading. Any trade I execute, I do it manually.'

The balance stated honestly: hard security mechanisms would kill the experimental mindset — 'balance it out' via adoption-vetting + irreversibility gating (0:32:03)

Building products passes the test: 'building is reversible in my opinion — I can reverse any decision' — hence agents get freedom there (0:32:03)

GitHub stars double as security signal: 'the more people use, the safer I can feel — if something is malicious, people flag it' (0:32:03)

Reputation can override low installs: the Sentry security skill had modest numbers, 'but I know that company' — brand trust is a valid input (1:19:10)

↓ Full write-up of this concept

05Running the framework: edge in, AI Edge outThe framework executed live: input his edge (education, working professionals, generative AI, a warm networ…0:34:04›

The framework executed live: input his edge (education, working professionals, generative AI, a warm network) → the agent ran web + Reddit searches → market tree (wealth/status/convenience → career development) → micro-niches with product shapes (tool-paralysis triage, AI-career-anxiety diagnostic, manager adoption playbook) → his judgment call: a FREEMIUM model — gamified, Duolingo-style free AI learning that qualifies users, with a paid service layer (brainstorming, workshops, custom implementation) revealed only to qualified leads. Saved as product-idea.md, scored 31/35 on the framework's own card.

The framework's honest verdict on his market: 'AI courses is crowded and hype-driven — the edge is helping professionals actually APPLY AI to real work' (0:38:08)

Business-model logic: 'most competitors sell courses or consulting; you offer play-to-learn free, pay-to-implement when ready' — distribution via his network, paid work converting warm leads (0:44:29)

The audience-mix question answered from self-knowledge (mixed bag, no dominant group) — the framework asks, the founder knows (0:38:08)

Everything filed: one-line pitch, Reddit pain quotes in user language, qualification matrix, curriculum sketch, business tiers, scorecard — the idea as an artifact, not a feeling (0:52:39)

↓ Full write-up of this concept

06The core monetization logic: qualify before you upsellThe quiz he ran the cohort through ('what's the main clarity I need before building?') lands on QUALIFICATI…0:58:51›

The quiz he ran the cohort through ('what's the main clarity I need before building?') lands on QUALIFICATION: the product must subtly gather ~15-20 data points (company, team size, role, work type at onboarding; a pain-point popup after level 3; optional LinkedIn URL for later enrichment) to identify which learners can become implementation clients — then reveal the upsell only to them, at the right moment. Design decisions: pay-FIRST-then-book (refundable ₹1000 deposit so people show up), payment in-app + booking on a separate URL, manual refunds for the MVP.

The priority order stated flat: 'this clarity has to come first — THEN course content, then everything else. It's the core monetization logic of your product' (1:02:56)

Subtlety is a design requirement: users won't fill a 20-field form — the wizard collects a little, level content seeds qualification questions, LinkedIn enrichment happens in the back end via Scrape Creators (1:33:58)

Solo users get a different level-3 question than team users — segmentation inside the gate (1:33:58)

Auth exists FOR qualification, not gatekeeping: 'my main concern is my business logic' — Clerk stores user identity so activity can accumulate against it (1:13:07)

The deposit psychology: refundable payment before booking filters tire-kickers and guarantees show-ups — refund after the call, manually for now (1:36:02)

↓ Full write-up of this concept

07The stack menu: database, auth, payments, docsThe app's four layers — frontend (UI/UX), backend (database), business logic, payments — each with a menu a…1:06:59›

The app's four layers — frontend (UI/UX), backend (database), business logic, payments — each with a menu and a 'don't agonize' verdict. Databases: Convex (open-source, reactive; his pick), Supabase, Turso (cloud SQLite — best local-to-cloud migration), MongoDB (unstructured/social data), Neon Postgres (what the agent actually chose, Duolingo-style). Auth: Clerk (500 free sessions, pairs well with Convex). Payments: Razorpay test mode now, Stripe later. Plus CONTEXT7: the MCP serving up-to-date library docs 'so my agent will not hallucinate while writing code.'

The database verdict: 'at the level we are, any database would suffice… spend time on your business logic instead' — relational (tables) → Supabase/Turso/Neon; unstructured → MongoDB (1:13:07)

Context7 is the anti-hallucination layer: agents write against the LATEST documentation instead of stale training data; the Clerk MCP serves the same role for Clerk's own libraries (1:09:01)

Payment gateways gate on live sites: Razorpay/Stripe review your website before granting production keys — test mode is the MVP path (2:10:05)

The .env discipline returns: keys (Clerk, Razorpay test, Neon connection string) go in a .env file, which he pointedly declined to open on stream (2:08:04)

OTP-less/third-party auth flavors exist (OTPless named); the accessibility rule got added live: front-end must be WCAG 2.2 compliant (1:09:01, 1:17:09)

↓ Full write-up of this concept

08Sub-agents: parallel work, independent contexts'Spin up 2 sub-agents in parallel: the first goes through my product idea and scrapes Substack/Reddit for c…1:23:32›

'Spin up 2 sub-agents in parallel: the first goes through my product idea and scrapes Substack/Reddit for curriculum content; the second brainstorms the business logic with me for the PRD.' Each sub-agent runs an INDEPENDENT context reporting to the main agent — parallelism for time, isolation for context hygiene. Available everywhere: 'Claude Code has sub-agents, Codex has sub-agents — every application has the same features.'

The two tracks genuinely didn't interact: curriculum research (scraping) and PRD brainstorming (interviewing him) — perfect parallelization candidates (1:25:35)

The build phase itself did NOT parallelize: '20 tasks… one thing has to be built after another' — dependencies force sequence; only independent work forks (1:56:23)

Context inheritance answered later (the Lizan question): agent-to-agent handoff works by pointing the NEW agent at the spec plan — 'look at what has been done and take it forward' — files as the relay baton again (2:18:17)

Session 9's promise kept: sub-agents were the deferred topic, delivered here in practice (1:23:32)

↓ Full write-up of this concept

09Agentic coding: brainstorm → spec → implementation plan → build'I will not call what I'm doing vibe coding — this is agentic coding': a deliberate document chain where th…1:29:49›

'I will not call what I'm doing vibe coding — this is agentic coding': a deliberate document chain where the superpowers skill interviews YOU (qualification gates, popup timing, payment flow, refund triggers), the answers crystallize into a SPEC (the PRD: onboarding flow, business rules, UX system, what's changed from the clone), the spec begets an IMPLEMENTATION PLAN (user stories, file structure, schema, ~20 ordered tasks), and only then does building start — with 'good to go, start building' as the human sign-off.

The interview surfaced questions he hadn't considered (solo vs team level-3 questions, refund triggers, popup UX options) — the skill as a co-designer, not a stenographer (1:31:57)

Model strategy: strongest model for planning, fast model for implementation — plan quality compounds, implementation speed compounds differently (1:54:20)

His Fable aside while praising planning models: 'everybody who worked with Fable in those little days — oh my god, it is game-changing. It gets me' (0:46:33)

↓ Full write-up of this concept

10Piggyback on proven UX: the Duolingo clone and licenses'Red means stop' — users carry learned behavior, so don't fight it: a food app should feel like DoorDash/Sw…1:40:06›

'Red means stop' — users carry learned behavior, so don't fight it: a food app should feel like DoorDash/Swiggy; a gamified learning app should feel like Duolingo. Implementation: find an open-source Duolingo CLONE on GitHub (decent stars/forks), check the LICENSE (MIT = commercial use OK; CC4 = no commercialization; GPL and others — read them), and instruct the agent to adopt its patterns while differentiating: keep the 3D tactile buttons, zigzag level path, confetti, mascot speech bubbles; swap the owl for a geometric AI coach, crowns for XP, add indigo to the palette, drop the leaderboard.

The justification is user-cost, not laziness: 'Duolingo has solved user journey and retention — I don't want to break my head on UI/UX decisions' (1:44:09)

License literacy in one pass: MIT (easiest, commercial OK — this clone's license, checked on stage), CC4 (reuse yes, commercialize no), GPL/others (read before touching) (1:44:09)

Differentiation is explicit in the prompt: 'piggyback on that design language through and through' but 'doesn't look like a direct clone' — patterns adopted, identity changed (1:46:11)

Having the clone's CODE beat design extraction here: 'I have the complete code anyway — I don't need to extract' (1:46:11)

↓ Full write-up of this concept

11Vibe security: review skills, Semgrep, and the coming waveSecurity as a harness leg: the Sentry security-review skill installed (low installs, but 'I know that compa…1:17:09›

Security as a harness leg: the Sentry security-review skill installed (low installs, but 'I know that company — reputed'), run post-build to surface vulnerabilities ('I can ask it to implement the fixes'). For heavier needs: Semgrep — the scanning service Replit and Lovable themselves use on vibe-coded apps, with its own MCP for continuous scanning. His forecast: 'vibe security will become very popular in the coming months.'

Placement in the flow: security review runs AFTER the build, BEFORE shipping — a gate, not an afterthought and not a blocker during creation (2:05:53)

GDPR/PII pragmatism: pharma-adjacent MVPs need it day one; consumer apps can chase traction first and harden after (2:16:14)

Trust calculus for low-install skills: vendor reputation (Sentry, 830 GitHub stars) can stand in for adoption numbers (1:19:10)

Production checklist from the Q&A: cross-browser testing (Playwright MCP), mobile browsers specifically, edge-case test cases written and run (2:26:25)

↓ Full write-up of this concept

12The endgame: keys, breakage, honest bugsThe unglamorous last mile, shown honestly: rename env.example to .env and fill the keys (Clerk secret, Razo…2:08:04›

The unglamorous last mile, shown honestly: rename env.example to .env and fill the keys (Clerk secret, Razorpay TEST keys, Neon connection string — 'I will not open this .env file' on stream); Clerk broke ('some problem is happening') → pragmatic bypass: 'spin up the basic app WITHOUT authentication so I can check it out — I'll fix this later'; the demo worked with visible bugs (a repeating question, a missed popup, off UI) — 'how do I fix bugs? Patiently going through each one.' Marketing plan: build in public on LinkedIn for the first 5-10 users.

The bypass is a technique, not a failure: isolate the broken subsystem (auth), demo the core loop, schedule the fix — momentum preserved (2:22:21)

Payment reality: gateways review your LIVE site before production keys — Razorpay test mode is the sanctioned MVP path, Stripe added later for global (2:10:05)

Debugging doctrine in one line: 'this part is not working, I go back and tell it — fix it completely. Then keep fixing step by step' — specific reports, iterative passes (2:30:40)

The demo's honest ledger: lessons rendered, answers checked, confetti fired; question-repeat bug, missed popup, UI misalignment — 'I'll fix it over the next few days and share the Vercel link' (2:26:25)

When stuck on any service setup: paste 'I am trying to do X, I am stuck here' into Perplexity/any engine — the unstick move (2:12:11)

↓ Full write-up of this concept

The concepts in full

What to build: expertise × customer need

0:13:17

'Someone already built it' killed more good products than competition ever did — Swiggy, Lyft and Zepto all launched into 'taken' markets and won on insight.

The intersection does two jobs. Expertise supplies the unique insight — the pain points, vocabulary and buying behavior you know that generic founders don't (Zepto's founders literally ran the WhatsApp group where the pains were typed out daily). Customer need supplies the market — without it, expertise produces hobbies. Founder problem fit asks the pre-market question: are you deeply, durably suited to THIS problem? Because product iterations will burn months, and only founder-level fit survives them.

The competitive-market reframe follows: incumbents validate demand and teach you the baseline; your expertise tells you what they're missing. The failure mode isn't building in a crowded market — it's building in one where you have no differentiated view.

Worked example · from the session

His live choice: not 'what's hot' but 'where do I have 15 years of insight' — education, narrowed to working professionals, narrowed to AI skills, before any framework ran.

Why it matters

This is the first gate of the session's whole pipeline — the framework, PRD and app all inherit their quality from whether this intersection was honest.

People get this wrong

A truly original idea is the prerequisite — if it exists, move on.

Original insight, not original idea: most winners entered existing markets with a differentiated view. No unique point of view is the real disqualifier.

Expertise × customer need — the intersection where ideas survive, with the crowded-market counterexamples

This idea elsewherebuilds onniche-picking, now for products

Check yourself

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

What two components define founder problem fit, and which comes first?

Domain expertise × customer need — and it precedes product-market fit: are you the right person for this problem, before is this the right product for the market.

How does Zepto answer 'it's already been built'?

They entered a crowded market with unique pain-point insight (from running the WhatsApp delivery group) — incumbents validate demand; your insight is the wedge.

Mining frameworks from YouTube (with yesterday's harness)

0:17:20

He needed an ideation framework, so he did to YouTube what Session 9 did to Cursor tutorials — scraped the experts and made their process executable.

The move generalizes Session 9's pipeline from content to PROCESS: frameworks are knowledge too, and two creators' methods merged into one file become an executable asset the agent can run. The harness handles mechanics (transcripts via the free local scraper, fallback routing on failure); the human curates (view counts, educator's eye); and the output isn't notes — it's a framework file that the next prompt can execute against your inputs.

The NotebookLM aside carries the architectural lesson: agentic systems require components that expose interfaces (APIs, CLIs, files). A tool whose intelligence is locked behind a chat UI is a cul-de-sac in any pipeline — the same reason Session 9 preferred yt-dlp's text files over NotebookLM's conversations.

Worked example · from the session

The two-video merge on stage: both transcripts scraped, then 'work on a framework to find new product ideas' — yielding the 5-phase pipeline saved to a file.

Why it matters

This turns every 'how do the pros do X' video into an executable process — the cheapest way to acquire someone's methodology is a transcript and a merge prompt.

People get this wrong

Frameworks are things you read and internalize.

In an agentic workflow, frameworks are FILES you scrape, merge, and run — the agent executes the methodology while you supply the inputs and judgment.

This idea elsewherebuilds onthe pipeline, reused for ideation

Check yourself

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

What made the scraped framework EXECUTABLE rather than just notes?

It was saved as a file the agent can run against inputs — the next prompt was literally 'run the product idea framework using the available skills and tools.'

Why is NotebookLM wrong for this pipeline despite understanding videos well?

No exposed API/CLI — the agent can't talk to it, so its understanding is locked in chat. Agentic components must interoperate.

Rick Rubin's answer: AI gives seeds, you supply taste

0:40:26

The most decorated producer in music can't play a note — his entire job is judgment. That's the human role in every agentic pipeline this course builds.

The Rubin frame resolves the anxiety underneath 'AI can do everything now': generation was never the scarce resource — selection was. An agent running a good framework produces plausible micro-niches, business models, names, PRDs — optionality. What it cannot supply is the taste that knows which option fits your edge, your network, your risk appetite. His behavior modeled it consistently: accept the framework's structure, override its conclusions with domain knowledge, harvest the crowd's names but make the call, let AI draft the PRD but read every line.

This is also why the session's title skill is 'agentic coding,' not automation: the human stays in the loop precisely at the judgment joints — idea selection, business logic, PRD approval, security review — and delegates everything between them.

Worked example · from the session

The interview answer retold in full: no instruments, no sheet music, shelves of Grammys — 'I have taste.'

Why it matters

Every remaining session assumes this division of labor — and it's the durable career answer to 'what's left for humans': the joints where judgment lives.

People get this wrong

Better prompts will eventually make the AI's first suggestion the right one.

Suggestions are seeds by design — the framework maximizes optionality, and taste (your edge, your context) does the selecting. That division is permanent, not a model limitation.

Rick Rubin says: I have taste. I can listen and tell if it is good or bad. In this age of AI, if there is one skill you have to hone very well, it is your human judgment.0:42:28

Whatever ideas you are getting from AI, those are seeds which should inspire your own. Never ever say — AI has suggested me this, so I will take it.0:40:26

Check yourself

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

What did he DO with the framework's three product suggestions?

Treated them as seeds: absorbed the structure, then substituted his own freemium-learning + paid-implementation model rooted in his education edge.

Where does judgment re-enter after generation, per this session?

At the joints: idea selection, business-logic decisions, PRD audit (AI-assisted AND personal read-through), security review, and every irreversible action.

Safety rails: prompt injection and the irreversibility rule

0:30:02

One hidden sentence on a webpage can turn your agent against you — and his whole defense fits in two habits, not a security stack.

Prompt injection works because agents read everything as potential instructions: a scraped page or an installed skill.md can carry hidden directives that override yours. The practical defense for non-security-engineers is herd immunity — heavily-adopted MCPs and skills have been effectively audited by their user base, so 'don't be the first mover' converts popularity into protection (with the refinement that a known-reputable vendor can compensate for low adoption).

The irreversibility rule is the deeper design principle: partition every workflow into reads (analysis, scraping, drafting — delegate freely) and irreversible writes (trades, payments, sends, deletes — human-executed, always). It's the same razor Harshit's human-in-the-loop agents and Akhil's certainty principle expressed, stated at its most portable: the agent may know everything; it may not DO the undoable.

Worked example · from the session

His stock-market partition: AI runs all the analysis; every actual trade is placed by hand — 'I don't trust it well,' and the mistrust is load-bearing.

Why it matters

These two habits are the entire security posture the course asks of non-engineers — cheap, memorable, and they compose with everything else.

People get this wrong

Security for agentic work means locking the agent down.

Lockdown kills experimentation. The working posture is two-fold: crowd-vetted components in, human hands on every irreversible action out.

Anything reading, I can easily do with AI. Anything writing, I hold back. Wherever there is an irreversible decision, that's where I intervene.0:32:03

This idea elsewherebuilds onadoption-vetting, now security-framed

Check yourself

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

Describe prompt injection and the everyday defense.

Hidden instructions in content the agent reads (pages, skills) that override yours — defended by adoption-vetting: use MCPs/skills with real user bases, never be first.

Apply the irreversibility rule to an outreach campaign.

Agent drafts, enriches, analyzes (reads/reversible); the human approves sends and any payment/refund actions (irreversible writes) — same partition as his stock trading.

Running the framework: edge in, AI Edge out

0:34:04

He typed four sentences about his own edge, and twenty minutes later held a scored, filed, Reddit-validated product blueprint — the framework did the legwork, his taste did the steering.

Watch the division of labor. The agent executed the framework's phases mechanically: expanded his edge into a market tree, pulled demand signals from live web/Reddit searches, drafted micro-niches with product shapes attached. He intervened exactly where judgment lives: choosing the mixed-audience path, rejecting the suggested shapes for his own freemium + service-layer model (seeded by his stated intention to build in education), and answering the buyer question (both individuals and teams). The 31/35 scorecard and the saved product-idea.md convert vibes into an auditable artifact the next phase (PRD) consumes.

The freemium design is worth studying on its own: the free tier isn't generosity — it's a qualification machine, teaching AI while collecting the signals that route the right users toward the paid implementation layer. That insight becomes the next concept's whole subject.

Worked example · from the session

The market tree on screen: career development under wealth/status → non-technical professionals learning genAI → four micro-segments — then his pivot: 'forget the landing page copy, I have a clear idea in my mind.'

Why it matters

This is the reusable template: your edge + the framework file + the harness = a filed, scored product idea in one sitting — repeatable for every idea you'll ever evaluate.

People get this wrong

The framework's output is the product decision.

The framework produced seeds and evidence; the chosen model (freemium + service layer) came from his edge and didn't appear in the suggestions — inputs to judgment, not substitutes.

This idea elsewherebuilds onthe harness executing a framework

Check yourself

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

What did the agent contribute vs the founder in the ideation run?

Agent: market tree, live demand signals, micro-niche drafts, scoring, filing. Founder: the edge statement, audience call, business-model pivot, final selection — the judgment joints.

Why is the free tier strategically 'free'?

It's a qualification machine: gamified learning collects the data and warms the leads that the paid implementation layer converts — education as top-of-funnel.

The core monetization logic: qualify before you upsell

0:58:51

The cohort guessed features, pricing, architecture — the answer was none of them: before anything else, design HOW the product learns who's worth selling to.

The insight inverts how beginners spec products. Features, curriculum and UI all serve a routing engine: every interaction either teaches the user or teaches YOU about the user, and the monetization moment fires only when enough signal has accumulated. Hence the architecture: authentication first (identity to accumulate signal against), a light onboarding wizard (role, company, team size — enough to segment, not enough to scare), content-embedded qualification (the level-3 'is this a team pain?' popup reads as curriculum, works as scoring), and enrichment deferred to the back end where it costs no UX.

The conversion mechanics inherit Session 8's click-minimization with a twist: pay-first-then-book uses a refundable deposit as a commitment filter — the inverse of low-friction CTAs, deployed deliberately because a booked implementation call with a no-show costs more than a lost maybe."

Worked example · from the session

The gate options weighed live with the superpowers interview: single gate after level 3 vs split gates vs store-and-wait — he chose the single level-3 gate with different questions for solo vs team users.

Why it matters

This is the difference between an app that teaches and a business that converts — and it's the design work AI can't do for you, because it encodes YOUR sales motion.

People get this wrong

Build the learning product; add monetization when there are users.

The monetization logic IS the architecture — data points, gates and reveal timing shape auth, onboarding, content and popups. Bolting it on later means rebuilding.

Onboarding wizard → levels 1-3 → pain popup → qualified? → pay (refundable) → book — the free tier as a lead-scoring machine

This idea elsewherebuilds onconversion design, now in-product

Check yourself

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

Why does authentication exist in this product?

Qualification, not security: identity is the key that user data and activity accumulate against, so the routing engine can score and segment learners.

Defend pay-first-then-book against 'lower the friction.'

The refundable deposit is a deliberate commitment filter: implementation calls are expensive, no-shows are worse than lost maybes — friction placed exactly where it selects.

The stack menu: database, auth, payments, docs

1:06:59

The cohort wanted THE database answer; he gave them a menu and a shrug — because at MVP scale the brand doesn't matter, and the hour you'd spend choosing belongs to your qualification logic.

The menu has real distinctions worth exactly one paragraph: relational databases (Supabase, Neon, Turso, Convex) fit table-shaped data — users, lessons, progress; MongoDB fits unstructured/graph-ish data — social feeds, networks. Turso's niche is migration (cloud SQLite for local-first builds); Convex is open-source and pairs sweetly with Clerk; Neon is what the agent picked by following the Duolingo clone's conventions — and he let it, because the choice is reversible and the business logic isn't waiting.

Context7 deserves its own beat: code-writing agents hallucinate against stale API memory, and a docs-MCP grounds every generated call in current documentation — the single cheapest quality upgrade for agentic coding. The keys discipline (.env, never on screen, payment gateways in test mode until the live site passes review) rounds out the professional posture."

Worked example · from the session

The live sequence: Convex intended → agent chose Neon via the clone's conventions → 'will this architecture work on Vercel?' → yes → proceed. No agonizing.

Why it matters

Stack paralysis is where beginner builds die; the menu-plus-verdict format is the antidote — reversible choices made fast, judgment saved for the logic that pays.

People get this wrong

Stack choice is the make-or-break architecture decision.

At MVP scale it's reversible and nearly fungible — the make-or-break decision is the business logic. He let the agent pick the database and audited the logic instead.

Four layers, a menu per layer, and one verdict: agonize over business logic, not database brands

This idea elsewherebuilds onplatform choices, one layer deeper

Check yourself

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

When does MongoDB beat the relational menu?

Unstructured/social/network-shaped data. Tables (users, lessons, progress) → Supabase/Neon/Turso/Convex — and at MVP scale, any of them.

What problem does Context7 solve mechanically?

Agents hallucinate APIs from stale training data; Context7 serves current library docs via MCP so generated code targets real, latest interfaces.

Sub-agents: parallel work, independent contexts

1:23:32

While one agent interviewed him about payment gates, another was off scraping Reddit for curriculum — two independent contexts, one shared clock.

Sub-agents extend fresh-agent hygiene into parallelism: each gets a clean, task-scoped context (no cross-contamination between curriculum scraping and business-logic interviewing) plus a reporting line to the main agent. The decision rule for forking is dependency analysis — research tracks that don't consume each other's outputs can run simultaneously; build tasks with sequential dependencies (schema before components before pages) cannot, which is why his implementation ran single-file.

The handoff pattern completes the architecture: when any agent's context ends (or dies), continuity lives in FILES — the spec and implementation plan — and the successor agent is pointed at them: 'look at what's been done, take it forward.' Contexts are disposable; the plan is the institution."

Worked example · from the session

The screen with both windows live: sub-agent 1 churning Scrape Creators/parallel-search calls for curriculum, sub-agent 2 running the superpowers interview about qualification gates.

Why it matters

This is how agentic builds scale past one attention span — and the dependency rule (fork research, serialize builds) transfers to every platform's version of the feature.

People get this wrong

More sub-agents = faster everything.

Parallelism follows dependencies: research forks, builds serialize. Sub-agents buy time only where tasks don't consume each other's outputs.

This idea elsewherebuilds onfresh contexts, now in parallel

Check yourself

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

What forks and what serializes, per the session?

Independent research tracks fork (curriculum scraping ∥ PRD brainstorm); dependent build tasks serialize (the 20-task implementation ran in order).

How does work survive an agent's context ending?

Files as the baton: the new agent reads the spec/implementation plan, checks what's built, and continues — the plan, not the chat, is the institution.

Agentic coding: brainstorm → spec → implementation plan → build

how-to1:29:49

Vibe coding says 'build me an app' and prays; agentic coding spends an hour being interviewed by a skill before a single file exists — and ships with fewer bugs because of it.

The document chain is error-prevention economics: a wrong decision costs a sentence to fix in the brainstorm, a paragraph in the spec, a refactor in the plan, and a debugging session in the code. So the process front-loads decisions where they're cheapest — the superpowers interview forcing every business-logic ambiguity to the surface (when's the gate? who pays first? what happens on an abandoned popup?) before anything compiles. The spec freezes those answers; the implementation plan sequences them; the build executes them with earned autonomy.

The model-tiering advice operationalizes it: planning is where quality compounds (a better PRD improves every downstream task), so spend your strongest model there; implementation is where speed compounds, so let Composer sprint. And both documents get audited — by AI for coverage, by you for judgment — before 'start building' unlocks the run."

Worked example · from the session

The interview's texture: 'single gate after L3, split gate after L2, or store-no-offer?' … 'which timing model do you want the product to FEEL like?' — product design conducted as dialogue.

Do it in this order

01Open the PRD conversation with the superpowers skill: 'use the brainstorming skill… I want to go deeper on onboarding data, qualification, upsell reveal' — answer its interview honestly
02Make the judgment calls it surfaces: gate timing (single gate after level 3), payment order (pay-first-then-book), refund trigger (manual for MVP), popup placement (in-app payment, separate booking URL)
03Have it write the SPEC file — review personally AND with AI ('use AI to audit the PRD; also go through it completely')
04Optionally upgrade models for planning: 'switch to Opus 4.8 in planning mode to build the PRD; implementation can be done with Composer 2.5'
05Ask for the IMPLEMENTATION PLAN: file structure, database schema, components, ordered tasks
06Sign off ('good to go, start building') and let it run the task list — intervene only at judgment joints

Gotchas["The brainstorm is where errors get cheap: 'this will reduce the number of errors when building… do this BEFORE the PRD' (1:40:06)", 'Spec ≠ implementation plan: the spec is decisions and flows; the plan is user stories, schema and build order — two documents, two audits (1:52:15)', "Freedom is earned: 'I have given complete freedom to Cursor because I did a lot of work questioning everything' — autonomy follows interrogation, not vice versa (1:56:23)", "Token honesty: the build consumed ~1M tokens ('200k here, 100k, 100k…') — agentic coding is thorough, not cheap (2:16:14)"]

Why it matters

This is the session's transferable spine: on any platform, the brainstorm→spec→plan→build chain converts AI coding from gambling into engineering.

People get this wrong

Agentic coding means the agent codes while you watch.

It means the agent interviews, documents and sequences BEFORE coding — the human decides at every judgment joint, then grants earned autonomy for the run.

Brainstorm → spec → implementation plan → build — decisions made where they're cheapest, autonomy granted where it's earned

I will not call what I am doing vibe coding. This is more like agentic coding.1:50:14

This idea elsewherecontrasts withvibe coding vs agentic coding

Check yourself

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

Why is the brainstorm the cheapest place in the chain?

Error-cost gradient: a decision reversed there costs a sentence; in the spec a paragraph; in the plan a refactor; in code a debugging session. Front-load the ambiguity.

Where do the strong and fast models each go, and why?

Strong (Opus-class) on planning — PRD quality compounds downstream; fast (Composer) on implementation — execution speed compounds there. Plan rich, build quick.

Piggyback on proven UX: the Duolingo clone and licenses

1:40:06

He didn't design a learning app — he adopted the muscle memory of the 500-million-download one, legally, and changed the mascot.

The principle is conservatism about learned behavior: every UX convention users already know (red stops, swipes dismiss, streaks motivate, zigzag paths progress) is free training you'd otherwise have to fight or teach. Cloning the interaction grammar of the category leader means your novelty budget gets spent where it differentiates (content, the AI coach, the qualification layer) instead of re-teaching navigation.

The legal literacy is the professional edge: open-source ≠ free-for-anything. MIT permits commercial use (hence this clone); CC4 blocks commercialization; GPL carries copyleft obligations. Thirty seconds reading a LICENSE file on stage modeled the habit. And note the tactic's relationship to Session 9's design extraction: when a good clone repo exists, the CODE is a richer artifact than extracted tokens — patterns, components and interactions come along."

Worked example · from the session

The adopt/change ledger the agent produced: keeping 3D buttons, lesson bubbles, zigzag path, confetti; changing owl→geometric coach, crowns→XP, green→indigo+lime, no leaderboard in MVP.

Why it matters

UX novelty is a tax users pay; this is how a solo builder ships category-standard usability in an afternoon while spending taste where it differentiates.

People get this wrong

Distinctive products need distinctive UX from scratch.

Distinctiveness belongs in identity and value; interaction grammar should be boring and borrowed — fighting learned behavior (orange for stop) just burns users.

This idea elsewherebuilds onclone by repo, not just extraction

Check yourself

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

MIT vs CC4 in one line each.

MIT: use, modify, commercialize freely (easiest). CC4: reuse allowed, commercialization not — read every license before building on a repo.

What got kept and what got changed from the clone, and by what rule?

Kept: the behavioral grammar (buttons, path, confetti, bubbles). Changed: identity (mascot, palette, XP, no leaderboard). Rule: adopt learned behavior, differentiate identity.

Vibe security: review skills, Semgrep, and the coming wave

1:17:09

The app compiled, the confetti fired — and the next prompt wasn't 'ship it,' it was 'run the security review skill.'

Vibe-coded apps have a characteristic vulnerability profile: generated code that works but leaks — exposed keys, missing validation, permissive routes. The economic answer mirrors the rest of the course: packaged expertise (a security-review skill) run at the right gate, surfacing vulnerabilities with fix suggestions the same agent can implement. For apps with real stakes, Semgrep is the industrial version — continuous scanning, trusted enough that Replit and Lovable run it on their own users' output.

The rollout wisdom is risk-tiered: data-sensitive domains (pharma, finance) need compliance posture from day one; consumer MVPs may ethically chase traction first and harden at the first sign of real users. And the trust calculus for security TOOLING itself inverts slightly — for a security skill, vendor reputation (Sentry) can outweigh install counts, because the vendor's whole business is trust."

Worked example · from the session

The live run: 'run the security review skill' → basic vulnerabilities listed → fixes deferred deliberately ('I'll keep it as is for now') — reviewed, triaged, scheduled.

Why it matters

Security is the gap between demo and product — and 'vibe security' is his named prediction for the next tooling wave; early literacy here is a consulting edge.

People get this wrong

Security is the platform's job — Vercel/Replit handle it.

Platforms secure infrastructure; YOUR generated code's leaks are yours. Review skills and Semgrep exist precisely because vibe-coded app logic is the new attack surface.

Check yourself

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

Where does the security review sit in the build chain?

Post-build, pre-ship: a gate after creation — run the skill, triage findings, implement or schedule fixes before deployment.

When does GDPR/PII rigor apply from day one?

Data-sensitive domains (pharma, health, finance) — consumer MVPs can prioritize traction and harden once real users arrive.

The endgame: keys, breakage, honest bugs

2:08:04

The most valuable minutes of the demo were the broken ones: Clerk died, and instead of panic came a bypass prompt, a working demo, and a scheduled fix.

The last mile has its own skills. Key management: .env files filled from each service's dashboard, never displayed, with test-mode keys wherever gateways gate on live-site review. Failure triage: when a subsystem breaks mid-flow, the move is isolation — disable it, demo the core, fix async — because momentum and morale are project resources too. Bug practice: run the app like a user, log each break specifically ('this exact part is not working'), and feed the agent one precise report at a time rather than 'it's buggy.'

The build-in-public close ties to distribution: announce on LinkedIn, narrate progress, convert the first handful of users from your network — the marketing chapter arriving in later sessions, seeded here. And the meta-lesson of the whole session: ~1M tokens, real breakage, visible bugs — and a working freemium app with auth, payments and a qualification engine, in one sitting, while sick."

Worked example · from the session

The honest demo reel: 'what is a large language model?' answered, confetti earned, then the same question repeating — bug noted aloud, fix scheduled, session closed with the ledger open.

Why it matters

Every real build ends like this — keys, breakage, bug lists. Seeing the professional posture (bypass, isolate, iterate) is worth more than a flawless demo.

People get this wrong

A demo with bugs means the process failed.

The process shipped a working app with a known bug ledger in one session — bugs are scheduled work, and the bypass/isolate/iterate posture is the skill being taught.

This idea elsewherereappears inthe last mile, with real breakage

Check yourself

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

Clerk breaks mid-demo — reconstruct his exact move.

Isolate: 'spin up the basic app without authentication so I can check it out' — demo the core loop, schedule the auth fix. Momentum over completeness.

Why test-mode payment keys for the MVP?

Razorpay/Stripe grant production keys only after reviewing your live site — test mode is the sanctioned path until the site exists to review.

Tools referenced

Tool	Coverage	Moment	Context
Cursor	demonstrated	0:19:21	The build platform end-to-end: sub-agents, superpowers interviews, ~1M tokens across the session; Composer 2.5 implementing, Opus 4.8 suggested for planning mode
Context7	demonstrated	1:09:01	Up-to-date library docs via MCP 'so my agent will not hallucinate while writing code' — the anti-stale-API layer
Convex	demonstrated	1:11:06	His intended open-source reactive database (pairs well with Clerk); the agent ultimately chose Neon via the clone's conventions
Neon	demonstrated	2:12:11	The Postgres the app actually shipped on (Duolingo-clone convention); free at project scale
Clerk	demonstrated	1:13:07	Auth for QUALIFICATION (500 free sessions); its MCP installed for docs; broke during the demo → bypassed, fix scheduled
Razorpay	demonstrated	1:36:02	Payments in TEST mode (gateways review live sites before production keys); refundable ₹1000 booking deposit; Stripe planned for global
Sentry (security-review skill)	demonstrated	1:19:10	Post-build vulnerability review; low installs outweighed by vendor reputation (830 stars)
skills.sh	demonstrated	1:19:10	Source of the security-review skill; superpowers reused from Session 9 for the PRD interview
GitHub	demonstrated	1:42:07	The Duolingo clone repo (MIT license, checked on stage) as the UX skeleton
Supabase	mentioned	1:11:06	The beginner-friendly database alternative (also handles auth)
Turso	mentioned	1:11:06	Cloud SQLite — 'the best way' to migrate local SQLite builds to cloud
MongoDB	mentioned	1:13:07	The unstructured/social-data lane of the database menu
Semgrep	mentioned	2:20:18	The industrial vibe-security scanner — used by Replit and Lovable on user apps; has its own MCP
OTPless	mentioned	1:17:09	Third-party OTP auth service (India-first; equivalents exist elsewhere)
Replit	mentioned	2:03:51	His mobile-app starter recommendation — store-submission friction is the hard part, and Replit eases it
Playwright	mentioned	2:26:25	Browser/edge-case testing MCP for the production checklist (he personally uses Chrome DevTools MCP)
Perplexity	mentioned	2:12:11	The unstick move for any service setup: 'I am trying to do X, I am stuck here'

Session materials

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

vtt

GMT20260628-140140_Recording.transcript (1).vtt

132 KB

idea-validation-scorecard.md

3 KB

PRODUCT-IDEA-FRAMEWORK.md

10 KB

product-idea.md

12 KB

Action items

Write your own founder-problem-fit statement: your expertise × a customer need you've personally observed — before touching any tool (0:13:17)
Scrape 2-3 well-viewed 'how to find product ideas' videos into a framework file with your harness, then RUN it against your edge (0:17:20)
Design your qualification logic before features: what 15-20 data points, collected how subtly, gating what upsell, revealed when (0:58:51)
Adopt the document chain: superpowers brainstorm → spec → implementation plan → sign-off — and audit the PRD yourself plus with AI (1:29:49)
Find your category's open-source UX clone; check the LICENSE (MIT yes, CC4 no commercialization) before building on it (1:42:07)
Install Context7 and a security-review skill; run the review post-build, pre-ship (1:09:01)
Apply the irreversibility rule to your own workflows: list which actions are reads (delegate) vs irreversible writes (keep human) (0:32:03)

Resources mentioned

Resources

docThe combined product-ideation framework file (scraped from the two YouTube videos) — shared in resources 0:25:56
docproduct-idea.md — AI Edge blueprint: pitch, qualification matrix, curriculum sketch, business tiers, 31/35 scorecard 0:52:39
docThe spec (PRD) and implementation plan files for AI Edge — the agentic-coding document chain 1:52:15
docDuolingo open-source clone repo (MIT) — the UX skeleton 1:42:07
docHis digitized session notes (promised: 'I will try to digitize these notes') 1:04:58

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
hardness	harness (throughout, as in Session 9)
gimme k 2.5 / Kimi k 2.5	Kimi K2.5 (under Cursor's Composer 2.5)
plot code / cloud code / CloudCore	Claude Code
codecs	Codex
super bass / SuperBase	Supabase
Tarso / Tarsow / Tarso DB	Turso (cloud SQLite)
mion dot tech	neon.tech (Neon Postgres)
Recruven / Rick Rubin	Rick Rubin (record producer; 'Anderson Cooper' interview, CNN — as heard)
Charge GBT	ChatGPT
5.6, Terra and Sol	unresolved garble in the Sam Altman announcement aside (as heard)
Claude Maitre's Claude Fable / Cloud Meters / Mitos	Anthropic's Claude Fable (the model this KB runs on; 'Mitos' likely Mythos)
WAC AG 2.2 / WCAG 2.2	WCAG 2.2 (web accessibility standard)
wipe coding / white coding	vibe coding
Swiggy / Zomato / Zepto	the Indian delivery-market examples (correct as heard)
razor pay	Razorpay
OTP less	OTPless (auth service)
get sentry / GetCentury	Sentry (getsentry — the security-review skill's vendor)
semgrep / s e m g r e b	Semgrep
21st data	21st.dev (likely — front-end component library, in the closing Q&A)
Versal / Wersal / Purcell	Vercel
neon postgres	Neon (serverless Postgres)
AI Roach	a cohort product-name suggestion (as heard, likely 'AI Coach')
the morning	unresolved garble ('background terminals started by…')
speakers is hitting me	likely 'the sickness is hitting me' (closing, through fever)
BST	unresolved (in 'Claude Mythos could break even BST — one of the most secure things')
Dileep	learner name (product-name suggestions round)

True on recording day — verify before relying

Model/platform claims are of-the-day (June 2026): Composer 2.5 on Kimi K2.5, Opus 4.8 for planning, the Sam Altman announcement aside, and another Fable lament ('it gets me') — all as heard.
Free tiers quoted: Clerk 500 user sessions, Neon free at project scale, Razorpay/Stripe live-site review requirements — verify at build time.
AI Edge shipped with known bugs (question repeat, missed popup) and auth bypassed; he promised the fixed Vercel link 'in the next few days' — the artifact may exist by now.
His 'vibe security will become very popular in the coming months' is a dated prediction; Semgrep's Replit/Lovable usage as stated.
Hermes deep-dive promised as a future masterclass; 'loop engineering' still deferred.
Trainer taught through fever, worse than the prior day — pacing and Q&A depth reflect it.