Tool	Job
HeyGen (MCP · mcp.heygen.com/mcp/v1/)	Talking-head at scale, outreach VO — after trust exists
Higgsfield	Cinematic B-roll, character consistency
Recraft	Vectors, logos, thumbnails, brand assets
Replicate / fal	Pay-per-use model experiments, batch gen
Magnific	Upscale before client or feed
ElevenLabs	Narration / dubbing when voice consistency needed
HyperFrames + video-use	Motion / showreel passes
CapCut / Premiere / Resolve	Edit rhythm, captions, export ladder

Use	Credits / mo	Plan	Cash
Engine cadence (4× ~70s cut-downs + light retakes)	~560	Creator	$29
True daily full Avatar IV + retakes	~1,050	Pro	$49+
Right fit: ~25s face inserts + warm Instantly clips	~570	Creator	$29
All 62 catalog cut-downs end-to-end + retakes	~2,200	Pro over 2–3 mo	~$100–150
All 62 as face inserts only (~25s)	~550	Creator	~$29 once

Tier	Channel	Cadence	Job
1	Instagram Reels	4–5/week	Discovery + DM starts
1	LinkedIn native video	3–4/week	Buyer trust — Cluely’s admitted gap
1	YouTube Shorts	Same masters	Search compound (months of shelf life)
2	Stories + comment magnets	Most weekdays	DM qualify · reply STACK / FUNNEL
2	X / Twitter	1–2 clips + threads	Builder / tech reach
2	Carousel	1/week	Saves · checklists · frameworks
3	TikTok	Optional 3–5	Raw reach · weaker Clarity ICP
3	Instantly + Upwork	Daily parallel	Cash floor — not “viral”

	Cluely	LoopSuit
Fuel	Controversy + spectacle	Receipts + hire-signal proof
Primary surface	TikTok / IG / X	IG Reels + LinkedIn + Shorts
Weak channel	LinkedIn (admitted)	Your opportunity
Team	Creator swarm + VC	Solo under FSH + batch Sundays
Conversion	Consumer heat / sub	DM → Clarity Session → build

Metric	Role
Watch-through / avg watch time	Hook + retention quality	Track
Sends per reach	Non-follower distribution	Track
Saves	Long-tail educational value	Track
Profile visits	Curiosity → bio	Track
DM starts	Conversation funnel	North star
Booked Clarity / calls	Business outcome	North star
Follower count	Weak proxy	Vanity
Raw likes / raw views alone	Easy to misread	Vanity

Ship It Live · 01 / 10

Full production script · Ship It Live 01

A lead-magnet form that qualifies and follows up—without a Zapier maze.

This is not a “tell Cursor to build it” video. The product is the finished workflow; the lesson is how you direct AI through constraints, options, contracts, implementation, QA, and recovery without surrendering judgment.

YouTube · 12–16 min Cut-down · 60–75 sec Screen + face Next.js 15 · Supabase · Instantly · Vercel Difficulty · Intermediate

The packaging

Title AI Built a Lead Funnel That Follows Up by Itself

Title BStop Connecting Forms With Fragile Zapier Chains

Title CNext.js → Instantly: A Production Lead Funnel With AI

ThumbnailYour face + “FORM → QUALIFIED” + one green arrow

Viewer promiseA working architecture, the exact prompts, and the mistakes to avoid

CTAComment FUNNEL for the architecture and prompt sequence

Do not use the original $2k/mo claimUnless you have a real invoice or measured replacement cost, it weakens the proof. The stronger hook is the visible system changing a lead from “new” to “qualified” and placing it in the correct Instantly campaign.

What you need before recording

A clean demo repo or branch with no client secrets
A Supabase project with a throwaway demo table
An Instantly test campaign/list—not a production send
API keys already stored in local environment variables
A fake but realistic PDF lead magnet
Three test inboxes you control
OBS recording screen and camera separately
Cursor in Plan mode for the first act

The visible artifactStart with the finished form. Submit your own test address. Show the Supabase row, the qualification fields, and the lead appearing in Instantly. Then rewind to an empty branch. Nick’s strongest recurring move is showing the byproduct before explaining the machinery.

Consent and data ruleThis is an opt-in nurture workflow. The form states what the person will receive, records consent time/source, and provides unsubscribe handling. Do not present “put every form submit into a cold-email campaign” as a best practice.

The story spine

Act 1 · ProofShow the working outcome and name the operational leak

Act 2 · JudgmentMake the architecture decisions before code exists

Act 3 · BuildImplement one vertical slice, then harden it

Act 4 · FailureLet one real bug breathe; show your diagnosis prompt

Act 5 · ReceiptRun the full path, show logs, deploy, draw the map

Act 6 · TransferGive the viewer a reusable operating principle

Full run of show

Read the “Say” blocks as intent, not theatre. Keep the nouns and decisions exact; let the connective language stay natural.

0:00–0:22

Cold open: demonstrate the finished loop

Screen first. Your face is a small picture-in-picture. Type a test email, choose “Agency / 2–10 people / needs lead routing,” submit, then hard cut through Supabase and Instantly.

“This looks like a normal lead-magnet form. It isn’t. Watch the email. The guide gets delivered, consent is recorded, the lead gets classified, and only the right profile enters this nurture campaign. No spreadsheet handoff. No Zapier chain I’m scared to touch. I’m rebuilding the whole path from an empty branch—and I’ll show you the exact decisions I give the AI, not just the final prompt.”

0:22–0:55

State the problem as a system, not a feature

“Most tutorials start with the form. That’s already one layer too low. The actual job is: capture a person’s intent, store evidence of consent, deliver what they asked for, decide what happens next, and make every retry safe. The form is just the front door.”

Draw five boxes on screen: Capture → Validate → Store → Route → Observe. Keep this map visible in a corner through the build; highlight one box at a time.

0:55–2:10

Prompt 1: force reconnaissance before implementation

“I don’t start by asking for code. I make the model build a map of the repo and the decision space. If it can’t explain where the boundary belongs, it doesn’t get permission to write files.”

We are adding an opt-in lead-magnet workflow to this existing application. Do not edit files yet. First: 1. Inspect the repository structure, package manager, routing style, existing form components, validation library, server/API conventions, database client setup, environment-variable handling, tests, and deployment target. 2. State what you found with exact file paths. 3. Identify anything ambiguous or risky. 4. Ask me only the questions whose answers would materially change the architecture. The required outcome is: explicit opt-in → validated server-side submission → durable lead record → lead-magnet delivery → qualified leads added to an Instantly test campaign → observable status and safe retries. Constraints: - Next.js 15 + TypeScript - Supabase is the source of truth - Instantly credentials never reach the browser - duplicate submits must not create duplicate campaign members - consent source and timestamp must be stored - no production campaign sends during development - no fabricated success state: the UI confirms only after the durable write succeeds Return findings and questions. Stop before proposing code.

Pause on its repo findings. Verify two paths aloud. If it hallucinates a file, call it out and ask it to prove the path. That moment teaches more than a clean montage.

2:10–3:20

Prompt 2: ask for options and trade-offs

“Now I want alternatives. One-shot AI coding usually fails before the first line of code because the model silently picked an architecture for you.”

Based on the verified repo findings, propose three viable architectures for this workflow. For each option, show: - request and data flow - where validation happens - how the lead magnet is delivered - how Instantly synchronization is triggered - retry and idempotency strategy - observability - security and privacy trade-offs - smallest useful test surface Compare: A. synchronous route handler B. durable database write plus background worker/queue C. Supabase Edge Function/webhook Recommend one for this repo and current traffic level. Optimize for correctness and easy recovery, not cleverness. Do not implement yet.

“For a demo, synchronous looks fast. For production, I want the form submission to succeed even if Instantly is down. So Supabase records the intent first, and a separate sync step can retry without asking the user to submit again. That’s the decision. The AI gave options; I own the choice.”

3:20–4:35

Define the contract before the UI

Open a small schema diagram. Zoom into only the fields you discuss.

“Before pixels, I want a data contract. Email is not enough. We need normalized email, company, role, company size, problem, consent timestamp, source, status, and an idempotency key. We also need to distinguish ‘captured’ from ‘synced.’ Otherwise the UI says success while the operation is half-dead.”

Design the smallest production-safe data contract for this workflow. Give me: 1. The TypeScript/Zod submission schema. 2. The Supabase table fields and constraints. 3. A status state machine for captured → delivery_pending → delivered → sync_pending → synced, including failed states. 4. The idempotency rule for repeat submissions and retries. 5. The Instantly field mapping. 6. Which fields may be logged and which must be redacted. Use normalized email plus campaign/list identity to prevent duplicate external members. Do not store the lead-magnet file in the database. Explain every field that is not obvious. No implementation yet.

4:35–6:10

Implement one vertical slice—not the whole system

“Now it can write code, but only one slice: form to durable database row. Instantly stays disconnected until the capture path is tested.”

Implement phase 1 only: accessible form → server-side validation → durable Supabase lead record → honest success/error UI. Requirements: - reuse existing project components and tokens - preserve the repo's conventions - progressive enhancement where practical - explicit consent checkbox with plain-language copy - honeypot and basic server-side rate limiting - normalize email before persistence - database uniqueness/idempotency handling - never expose service-role or Instantly credentials client-side - pending, success, duplicate, validation, rate-limit, and server-error states - no Instantly call yet - focused tests for schema validation, duplicate submit, and server error Before editing, list the exact files you will touch and why. Then implement. Afterward run the relevant typecheck/tests and report failures without hiding them.

Use a brief time compression while files are written. Come back on the first meaningful diff. Read one server boundary and one client state aloud; do not scroll through generated boilerplate.

6:10–7:10

Review the AI like a senior—not a passenger

“I’m checking four things before I run it: where the secret lives, whether validation happens again on the server, whether duplicate submission is a database guarantee—not an if statement—and whether ‘success’ means the write actually committed.”

Put a four-item checklist on screen. Check each against the diff. If one fails, keep it in the edit.

Review your phase-1 diff as a skeptical senior engineer. Look specifically for: - browser exposure of privileged credentials - client-only validation - race conditions around duplicate email submissions - a success UI that can lie - missing rollback/retry behavior - PII in logs - inaccessible form/error states - framework or library APIs that may be outdated For every finding, cite the exact file and line, explain impact, and patch only confirmed issues. Then rerun the focused checks.

7:10–8:20

Run the first receipt

Open the app and submit: invalid email, no consent, valid lead, then the same valid lead again. Show the database after each.

“Invalid input never reaches the table. No consent, no submission. The valid lead becomes ‘captured.’ The duplicate gets the same friendly outcome without a second row. That means phase one is stable enough to connect outward.”

Don’t cut immediately. Say: “Good. This is why we test the contract before adding the integration. I expected one durable row; I got two.” Then use the diagnosis prompt below and keep the failure in the final edit if it teaches something real.

The observed behavior differs from the contract. Expected: [state the exact expected result] Observed: [state the exact result, including error text] Reproduction: [list the exact clicks/request] Do not patch yet. Trace the request across client, route/action, database call, and constraint. Give me the most likely causes ranked by evidence. Tell me what log, query, or test would falsify each cause. Then run the smallest diagnostic that distinguishes them.

8:20–10:05

Add Instantly as an adapter, not the foundation

“Instantly is downstream. If I swap it next month, the form and lead record survive. So we give it a narrow adapter with an explicit input and normalized result.”

Implement phase 2 as a narrow Instantly adapter and retryable sync operation. Requirements: - confirm the current Instantly API endpoint and payload shape from official docs before coding - server-only credential access - typed adapter input/output - map only approved fields - test campaign/list ID comes from environment configuration - do not enable or trigger production sending - idempotent external add/update behavior - capture provider request ID/status without logging raw secrets or unnecessary PII - bounded retry with backoff for transient failures - distinguish retryable failures from permanent validation failures - update the Supabase status machine atomically - unit-test the adapter with mocked provider responses First show the verified API contract and files to change. Wait for approval before implementation.

“Notice the last line: show me the contract and wait. External APIs drift. I don’t want confident code against a year-old endpoint.”

10:05–11:25

Automate QA in a visible browser

“Now I let the agent use the product—but I define what evidence counts. A green terminal is not proof that the browser flow works.”

Start the app and run a headed browser QA pass so I can watch. Test these scenarios with unique controlled addresses: 1. invalid email 2. consent unchecked 3. valid low-fit submission 4. valid qualified submission 5. duplicate qualified submission 6. simulated Instantly 429 7. simulated Instantly 500 followed by successful retry For each scenario: - interact through the real UI - capture a screenshot at the decisive state - verify the expected Supabase row/status - verify whether Instantly should or should not receive the lead - record observed vs expected Do not fix defects during the first pass. Produce a defect list with reproduction steps. After I review it, patch one defect at a time and rerun only the relevant scenario plus a final happy-path regression.

Borrow the strongest Nate pattern: let the headed browser visibly struggle, then inspect screenshots and evidence. Do not narrate dead waiting time—jump cuts are fine, hidden judgment is not.

11:25–12:40

Deploy with an operational check

“Local success is still rehearsal. Deployment changes origins, environment variables, database permissions, and network behavior. So the final prompt is not ‘deploy it.’ It’s a release checklist with a rollback.”

Prepare this workflow for a production deployment without deploying yet. Produce and execute the preflight checks you can safely run: - typecheck, lint, focused tests, and production build - environment-variable inventory with values redacted - database migration and rollback plan - RLS/policy verification - origin/CORS assumptions - rate-limit behavior - test campaign safety - post-deploy smoke test - observable failure signal and manual retry path Stop if any check fails. Do not bypass hooks or weaken checks. Summarize the release plan, exact deploy command, verification steps, and rollback trigger. Wait for approval.

12:40–13:35

Final proof and transferable lesson

Run one clean submission on the deployed URL. Split screen: browser, Supabase row, Instantly test campaign. Then return to face camera full frame.

“Form submitted. Durable row first. Delivery status recorded. Qualified lead synced exactly once. And if Instantly goes down, the lead doesn’t disappear—it waits. That’s the difference between AI generating a feature and you directing AI to build a system.”

“The reusable sequence is: inspect, compare options, define the contract, build one vertical slice, review the boundary, test the failure, then connect the vendor. Comment FUNNEL and I’ll send the architecture plus the prompt sequence. Build the workflow; don’t worship the tool.”

Natural lines while Cursor is working

These keep the build feeling live without falling back to “AI is doing magic.” Use only when the screen supports the point.

While it inspects

“I’m waiting for file paths, not confidence. If it can’t cite the repo, I don’t trust the plan.”

When it offers options

“Fastest isn’t automatically best. I care about what happens when Instantly is unavailable.”

Before accepting edits

“I’m checking the blast radius: exact files, migration, environment variables, and external calls.”

When code compiles

“Compilation proves syntax. It does not prove the lead landed once, consent was stored, or retries are safe.”

When the agent fails

“I’m not asking it to try again. I’m giving it evidence and making it discriminate between causes.”

At the result

“The model wrote most of the code. The value was choosing the boundary and defining what ‘done’ meant.”

The 60–75 second cut-down

0–3s

Receipt

“This form just qualified a lead and routed it—exactly once.”

3–12s

Reframe

“The mistake is asking AI to build the whole funnel. Start by defining the five jobs: capture, validate, store, route, observe.”

12–27s

Show prompt progression

“First I make Cursor inspect the repo. Then it gives me three architectures. I choose durable database write before external sync, because a vendor outage should never eat the lead.”

27–43s

Best-practice stack

“Server-side validation. Consent timestamp. Database uniqueness. Instantly key stays server-only. Failed syncs retry; duplicate submits don’t duplicate people.”

43–58s

Failure evidence

“Then I make it test seven cases in a visible browser—including 429s and retries—before deployment.”

58–72s

Payoff

“AI wrote the code. My job was defining the system and refusing fake success. Comment FUNNEL for the prompts.”

Edit and performance notes

Frame one: the submitted form and Instantly result, not your logo and not a talking-head greeting.
Camera rhythm: face for judgment; screen for evidence. Return to face whenever you make a choice the AI cannot own.
Cursor typing: show the first and most consequential line typed live. Paste the remainder, then zoom/highlight constraints.
Dead time: cut installs and generation waits. Preserve plans, errors, choices, diffs, tests, and results.
Captions: emphasize nouns—DURABLE WRITE, SERVER-ONLY KEY, IDEMPOTENT, RETRYABLE—not every spoken word.
Proof: blur email addresses and tokens. Never fake a provider response for the final receipt; label simulations clearly.
Music: restrained electronic pulse under setup; drop it completely during the real failure and final proof.

Format synthesis, not voice imitation: byproduct-first proof and input narration observed in Nick Saraev; fresh-project setup, exact prompts, headed-browser QA, and visible debugging observed in Nate Herk; context-rich “world building,” examples, and operator responsibility observed in Varun Mayya. LoopSuit’s proprietary layer is senior product judgment, production boundaries, and honest receipts.

Pre-publish truth check

Every result shown happened in the recorded build
Any simulated outage is labelled “simulated”
No private lead, client, token, or campaign data is visible
The lead magnet and CTA actually exist before publish
The final architecture map matches the code shipped
No replacement-cost or revenue claim lacks a receipt

Ship It Live · 02 / 10

Full production script · Ship It Live 02

Auth and checkout that survive production—not a demo login.

This video is about the money wall as a system: identity, entitlement, webhooks, and recovery. You will not say “just build auth.” You will make Cursor prove every boundary before a single customer can pay.

YouTube · 12–16 min Cut-down · 60–75 sec Screen + face Next.js 15 · Supabase Auth · Stripe · Vercel Difficulty · Intermediate

The packaging

Title AI Built Auth + Checkout That Won’t Embarrass You in Production

Title BStop Shipping Fake Paid Walls

Title CSupabase Auth → Stripe → Webhook: The Production Path

ThumbnailYour face + “AUTH → PAY” + green check

Viewer promiseWorking paid gate, webhook truth, and the prompts that force correctness

CTAComment WALL for the auth/checkout checklist

What you need before recording

Fresh demo branch with no client secrets
Supabase Auth enabled (email magic link or password)
Stripe test mode keys + webhook signing secret
One test product / price ID already created
Vercel project ready for preview deploy
Two test emails: one free user, one paid
OBS: screen + face tracks
Cursor Plan mode for Act 1

The story spine

Act 1 · ProofShow unpaid denied / paid allowed

Act 2 · MapIdentity vs entitlement vs payment events

Act 3 · BuildAuth → checkout session → webhook → gate

Act 4 · AttackReplay, missing webhook, race conditions

Act 5 · DeployPreview URL with real Stripe test flow

Act 6 · TransferNamed checklist the viewer can steal

Full run of show

Say blocks are intent, not theatre. Keep nouns and decisions exact; let connective language stay natural.

0:00–0:25

Cold open: paid wall receipt

Start on the live preview URL. Attempt protected route while logged out → denied. Log in unpaid → denied. Complete Stripe test checkout → refresh → allowed. Face PiP small.

“Three states. Logged out: blocked. Logged in free: blocked. Paid: open. That is a paid wall. Not a button that says Upgrade. I’m rebuilding it from an empty branch—and I’ll show the exact prompts that keep Stripe and Supabase from lying to each other.”

0:25–1:05

Name the system, not the feature

Three boxes on screen: Identity · Payment Event · Entitlement. Keep them visible.

“Auth is identity. Stripe is payment intent. Entitlement is a durable fact in your database. The bug that burns founders is treating a successful Checkout redirect as truth. The webhook is truth. Everything else is a hint.”

1:05–2:25

Prompt 1: inspect before inventing

“Same rule as every Ship It Live: reconnaissance first. If it can’t cite the repo, it doesn’t write files.”

We are adding production-safe authentication and a Stripe paid wall to this Next.js 15 app. Do not edit files yet. 1. Inspect routing, existing auth (if any), middleware/proxy patterns, server actions/route handlers, Supabase client setup, env handling, and deploy target. 2. Cite exact file paths. 3. List ambiguities that would change the architecture. 4. Ask only decision-critical questions. Required outcome: - Email auth (or existing auth provider if already present) - Protected routes/server checks for paid features - Stripe Checkout in test mode - Webhook that updates entitlement durably - Client never trusts redirect alone - No service-role keys in the browser Stop after findings + questions.

2:25–3:40

Prompt 2: force three architectures

“I want options. One-shot auth tutorials usually hide the entitlement model.”

Propose three architectures for paid access: A. Stripe Customer Portal + metadata only B. Supabase table as source of truth updated by webhook C. Stripe as source of truth queried on every request For each: data flow, failure modes, latency, security, and test surface. Recommend one for a solo SaaS with low traffic. Optimize for correctness and easy recovery. Do not implement yet.

“B wins for us. Stripe can be down; our app still needs to know who paid. Webhook writes entitlement. Portal is for management later—not the source of truth.”

3:40–5:00

Define the entitlement contract

“If status isn’t a state machine, you’ll invent boolean soup: isPaid, hasAccess, unlocked. One field. Explicit transitions.”

Design the entitlement contract before UI: 1. TypeScript/Zod types for session user + subscription state 2. Supabase tables/fields: user_id, stripe_customer_id, status, price_id, current_period_end, updated_at 3. Status state machine: inactive → checkout_started → active → past_due → canceled 4. Idempotency rule for webhook events (event id unique) 5. Which events we handle (checkout.session.completed, customer.subscription.updated/deleted, invoice.payment_failed) 6. What the client may know vs must revalidate server-side No implementation yet.

5:00–6:40

Implement auth + protected gate only

“Phase 1: identity and gate. No Stripe yet. Prove login and denial first.”

Implement phase 1 only: - Supabase auth signup/login matching repo conventions - Server-side session checks for protected routes - Clear unpaid/unauthorized UI states - No Stripe integration yet - Focused tests for unauthenticated and authenticated-but-unpaid access List files to touch, then implement. Run typecheck/tests. Report failures honestly.

6:40–8:20

Add Checkout + webhook as adapters

“Redirect success is a celebration animation. Webhook is the unlock. Say that on camera every time.”

Implement phase 2: - Create Checkout Session server-only with test price ID from env - Success/cancel URLs that do NOT grant access by themselves - Webhook route verifying Stripe signature - Idempotent entitlement upsert keyed by Stripe event id - Never log raw secrets or full card data - Simulate: missing signature, replayed event, subscription canceled Verify Stripe API shapes against current docs before coding. Show contract, wait for approval, then implement.

8:20–9:40

Attack the happy path

Run: unpaid access attempt, checkout abandon, successful test card, webhook replay, cancel subscription.

“I’m not looking for green builds. I’m looking for the system refusing to grant access when the webhook didn’t fire.”

Observed: access granted without a verified webhook entitlement write. Expected: unpaid until webhook upserts active status. Trace client redirect, success page, server gate, and webhook handler. Rank causes by evidence. Patch only the confirmed cause. Add a regression test.

If access unlocks without webhook, stop. Say: “That’s the exact production bug. Fixing it live.” Then paste the diagnosis prompt pattern from Ship It 01.

9:40–11:10

Deploy preview and smoke

“Local Stripe CLI is rehearsal. Preview URL with a real webhook endpoint is the exam.”

Prepare preview deploy checklist: - env vars inventory (redacted) - webhook endpoint URL for Stripe CLI or dashboard - RLS policies for entitlement table - production build + focused tests - smoke: unpaid deny → pay test → allow → cancel → deny Stop on any failure. Summarize deploy + rollback. Wait for approval.

11:10–12:20

Close with transferable rule

Face full frame. End card: WALL CTA.

“Identity. Payment event. Entitlement. Three layers. AI can write the boilerplate—you own the boundaries. Comment WALL and I’ll send the checklist. Don’t ship a button that lies.”

Natural lines while Cursor is working

While inspecting

“I’m waiting for paths to middleware and env usage—not a tutorial summary.”

On options

“Redirect-as-truth is the fastest path and the first lawsuit.”

On webhook

“If this handler isn’t idempotent, Stripe retries will double-grant chaos.”

On deploy

“Preview is where env typos show up. That’s why we smoke the paid path.”

The 60–75 second cut-down

0–3s

Receipt

“Unpaid blocked. Paid open. Watch.”

3–15s

Reframe

“A paid wall is three systems: identity, payment events, entitlement.”

15–35s

Method

“I make Cursor inspect, offer three architectures, then I choose database entitlement updated by webhook—not redirect.”

35–55s

Attack

“Then I try to break it: abandon checkout, replay webhook, cancel.”

55–70s

CTA

“Comment WALL for the checklist. Don’t ship a lying Upgrade button.”

Edit and performance notes

Frame one: denied → allowed transition, not your face saying hello.
Blur: customer IDs, emails, webhook secrets.
Label: Stripe test mode watermark if visible.
Cut: waiting for Stripe dashboard; keep signature verify + entitlement write.
Music: drop under webhook failure moment.

Format synthesis: byproduct-first (Nick Saraev); exact prompts + headed verification (Nate Herk); world-building constraints / examples (Varun); proof + named framework (Hormozi). LoopSuit layer: entitlement as product truth.

Pre-publish truth check

Checkout used test mode only
Webhook verification shown on camera
No access granted from redirect alone
No real customer data
CTA asset exists before publish

Ship It Live · 03 / 10

Full production script · Ship It Live 03

Stop refreshing dockets. Build the status ping that respects the law office.

Unglamorous automation is the trust play. This script is Court Tracker as an operator system: scrape carefully, detect change, notify humans, keep an audit trail—and never pretend a brittle selector is “AI magic.”

YouTube · 12–16 min Cut-down · 60–75 sec Screen + face Scraper · queue · Slack/email · audit log Difficulty · Intermediate–Advanced

The packaging

Title AI Automated Court Status Checks Without Spamming Anyone

Title BLegal Ops Hates Refreshing Dockets—Fixing That Live

Title CScrape → Diff → Notify: A Production Status Webhook

ThumbnailFace + “STATUS CHANGED” + Slack ping

Viewer promiseChange detection architecture + responsible scraping rules + prompts

CTAComment DOCKET for the change-detection checklist

What you need before recording

Demo repo or Court Tracker sandbox branch
One public/demo case source you are allowed to poll
Slack webhook or email sink for demos
Storage for last-seen status snapshots
Rate-limit and robots/ToS notes written before shoot
Redaction plan for case numbers / party names
Cursor Plan mode

The story spine

Act 1 · ProofShow a status change notification from a controlled flip

Act 2 · EthicsState scraping/ToS/rate-limit posture on camera

Act 3 · ContractSnapshot schema + change types

Act 4 · BuildPoller → diff → notify → audit

Act 5 · FailureSelector break, empty page, duplicate notify

Act 6 · TransferLegal-ops playbook viewers can reuse

Full run of show

Say blocks are intent, not theatre. Keep nouns and decisions exact; let connective language stay natural.

0:00–0:28

Cold open: notification receipt

Show Slack/email: “Status changed: Hearing set → Continued.” Then reveal the audit row. No case PII.

“Legal ops shouldn’t refresh a portal twelve times a day hoping something moved. Here’s a status change, a human-readable ping, and an audit row that proves what we saw. I’m rebuilding the path—and the nuance is what we refuse to automate.”

0:28–1:20

Ethics and scope on camera

On-screen slate: ALLOWED SOURCE · RATE LIMIT · HUMAN IN LOOP · REDACT.

“Before prompts: we only poll sources we’re allowed to poll, we rate-limit like a polite human, we store the minimum, we redact in content, and we notify humans—we don’t file anything automatically. If your use case needs counsel, pause. This is ops monitoring, not legal advice.”

1:20–2:40

Prompt 1: map existing automation surface

We are building a court/docket status change detector for an ops demo. Do not edit files yet. Inspect the repo for existing scrapers, schedulers, notification adapters, storage, and logging. Cite paths. Constraints you must respect in all later work: - Only use the approved demo source URL I provide - Strict rate limiting and backoff - No credentials in client code - Snapshot + diff architecture (not “AI read the page and guess”) - Human notification only (Slack/email) - Full audit trail of observed status text and timestamp - Idempotent notifications (same change must not spam) - Redaction helpers for names/case identifiers in logs shown on camera Ask decision-critical questions only. Stop.

2:40–3:50

Prompt 2: options for change detection

Propose three change-detection designs: A. Hash entire HTML B. Extract structured fields (status, date, location) then diff fields C. Screenshot + vision model classification Compare false positives, brittleness, cost, and auditability. Recommend one for a law-office ops tool where false alarms destroy trust. Do not implement yet.

“B. Structured fields. Hashing HTML screams on every timestamp. Vision is expensive and hard to audit. We extract what a human would write on a sticky note—then diff that.”

3:50–5:10

Schema before scraper cleverness

Design the data contract: 1. monitored_matter fields 2. status_snapshot fields (raw_excerpt redacted, normalized_status, observed_at, source_url, content_hash_of_extracted_fields) 3. change_event types: status_changed, date_changed, removed, parse_failed 4. notification outbox with delivery state 5. idempotency key for a change 6. retention policy recommendation No implementation yet.

5:10–6:40

Implement vertical slice: extract + snapshot

“Phase 1 doesn’t notify anyone. If extraction is wrong, notifications would just industrialize panic.”

Implement phase 1 only: - Fetch with rate limit - Extract structured fields with tests against saved HTML fixtures - Write snapshots - Detect changes in unit tests using fixture pairs - No Slack/email yet Use fixtures so CI doesn’t hit the live site. List files, implement, run tests.

6:40–8:00

Add notify + outbox

Implement phase 2: - Outbox table for notifications - Slack and/or email adapter - Idempotent send - parse_failed alerts to operator (not client spam) - Dry-run mode for recording Show adapter contract first. Then implement with mocked provider tests.

8:00–9:20

Break selectors on purpose

Feed a broken HTML fixture. Show parse_failed → operator alert, no client spam.

“When the portal changes markup, silent wrong status is worse than a loud failure. We fail closed and page a human.”

Fixture produces empty/ambiguous status. Expected: parse_failed event + operator alert + no client status-changed notification. Trace extractor → change detector → outbox. Patch and add regression fixture.

If it “succeeds” with empty status, stop and force a parse_failed path.

9:20–10:40

Live controlled flip

Two runs. Second run must not notify.

“Demo mode: I flip the fixture from Hearing set to Continued. Watch one notification, one audit row, second run silent.”

10:40–11:50

Close

“Automation that earns trust is boring: extract, diff, notify, audit. AI helps you build it faster—it does not get to invent the status. Comment DOCKET for the checklist.”

Natural lines while Cursor is working

Ethics beat

“If I can’t say the source rules out loud, I shouldn’t film the scraper.”

On AI temptation

“I’m not asking a model to ‘read this page and tell me if it’s urgent.’ That’s how you hallucinate a hearing.”

On failures

“Loud parse failure beats quiet wrongness in a law office.”

The 60–75 second cut-down

0–3s

Receipt

“Status changed. One Slack ping. Audit row.”

3–15s

Rule

“Don’t hash HTML. Extract the fields a human would write down—then diff.”

15–40s

Build

“Fixtures first, notify second, fail closed when markup breaks.”

40–60s

Nuance

“Second poll stays silent. Idempotency is the product.”

60–72s

CTA

“Comment DOCKET for the checklist.”

Edit and performance notes

Redact all party names and real case numbers.
Show rate-limit code or config on screen.
Keep the ethics slate—cuts that remove it make the video look reckless.
Proof must be fixture/demo source, labeled as such.

Format synthesis: unglamorous real-work proof (Nick/Hormozi document-while-delivering); exact prompts + fixture QA (Nate); operator responsibility (Varun). LoopSuit layer: Court Tracker as trust product.

Pre-publish truth check

Source permission/ToS posture stated
No real client matters shown
Parse failure path demonstrated
Idempotent second run shown
Not legal advice disclaimer present if needed

Ship It Live · 04 / 10

Full production script · Ship It Live 04

Aggregator rank is a system—not a vibe. Watch Rank Radar catch a drop.

QSR multi-unit buyers don’t want AI poetry. They want: where did we rank, when did it change, and what evidence do we have. This script teaches polling, normalization, competitor context, and plain-language alerts—using Biryani Blues as proof, not as the brand.

YouTube · 12–16 min Cut-down · 60–75 sec Screen + face Rank Radar · scrapers · charts · alerts Difficulty · Intermediate

The packaging

Title AI Built the System That Watches Swiggy Rank So Ops Doesn’t Have To

Title BBiryani Blues Shouldn’t Guess Aggregator Rank

Title CRank Drop → Plain-Language Alert in One Sitting

ThumbnailFace + “#20 → #6” + red/green rank chip

Viewer promisePolling architecture, normalization rules, and alert copy that operators read

CTAComment RADAR for the QSR visibility checklist

What you need before recording

Rank Radar demo environment or sanitized dataset
Permission to show Biryani Blues / anonymized outlet if needed
Sample scrape payloads for Swiggy/Zomato-like cards
Chart component already in design system if possible
Alert sink (email/Slack/Telegram)
Cursor Plan mode

The story spine

Act 1 · ProofShow a rank drop alert with screenshot receipt

Act 2 · ICPWho this is for: multi-outlet QSR ops

Act 3 · ContractOutlet · platform · keyword · rank · observed_at

Act 4 · BuildPoll → normalize → store → detect → explain

Act 5 · FailureMissing listing, blocked scrape, false volatility

Act 6 · TransferVisibility checklist for operators

Full run of show

Say blocks are intent, not theatre. Keep nouns and decisions exact; let connective language stay natural.

0:00–0:30

Cold open: drop + evidence

Alert card: Indiranagar #6 → #14. Open evidence screenshot. Chart sparkline.

“Ops doesn’t need another dashboard nobody opens. They need: you dropped, here’s when, here’s the receipt. That’s Rank Radar. I’m rebuilding a slice live—and the AI work is the boring reliability, not the chart skin.”

0:30–1:15

ICP and enemy

“Enemy isn’t Swiggy. Enemy is guessing from a phone screenshot at dinner rush. Multi-outlet teams need a poller, a normalizer, and an alert in language a shift manager understands.”

1:15–2:30

Prompt 1: inspect Rank Radar surface

We are implementing/enhancing a Rank Radar style visibility monitor for QSR aggregator ranks. Do not edit yet. Inspect existing polling, storage, UI, and alert code. Cite paths. Outcome: - Poll platform listing cards on a schedule - Normalize outlet + platform + query + rank - Store time series - Detect meaningful drops/rises - Emit plain-language alert with evidence reference - Never invent ranks Ask only decision-critical questions. Stop.

2:30–3:40

Options: what is a “meaningful” change?

Propose three alerting policies: A. Alert on any rank change B. Alert on threshold (e.g. ≥3 positions) with cooldown C. Alert on percentile volatility vs trailing 7-day baseline Compare noise vs usefulness for multi-outlet QSR. Recommend one default + how operators override per outlet. No implementation yet.

“B as default. Any-change alerts train people to ignore the system. Baseline is phase two once we have history.”

3:40–5:00

Data contract

“Missing listing is not rank 100. It’s unknown. If you coerce it, your charts lie.”

Design schema: - outlets, platforms, tracked_queries - observations: rank, share_of_voice optional, raw_evidence_id, observed_at - alerts: type, delta, copy, evidence_id, delivered_at - idempotency for identical observations - rules for missing listings (null rank vs rank 999—pick one and justify) No UI yet.

5:00–6:30

Phase 1: normalize + store from fixtures

Implement observation ingest from fixtures (not live scrape yet): - parser for sample payloads - normalization - insert observations - tests for missing listing and duplicate poll List files, implement, test.

6:30–8:00

Phase 2: detector + plain-language alert

“I don’t let the model freestyle alert text. Operators need predictable language.”

Implement detector + alert copy generator: - threshold policy - cooldown - copy template: "{outlet} dropped from #{from} to #{to} on {platform} for “{query}” at {time}." - attach evidence id - unit tests for drop, rise, ignored tiny move, cooldown No fluffy AI copy. Deterministic templates.

8:00–9:20

Optional live scrape adapter

If live polling is in scope for this recording: - implement adapter behind interface - rate limits - failure taxonomy: blocked, empty, parse_failed - do not mark rank changed on parse_failed Show risks on camera. Prefer fixtures if live is flaky.

If live scrape fails, switch to fixtures openly: “Reliability demo beats fake live heroics.”

9:20–10:40

UI receipt: chart + alert

Show outlet detail: sparkline, last observation, alert list.

“Product surface is the chart plus the sentence. Infra without the sentence is a hobby project.”

10:40–11:50

Close

“Poll. Normalize. Threshold. Explain. That’s aggregator visibility as a system. Comment RADAR for the checklist—and if you run multi-outlet QSR, that’s the conversation I want.”

Natural lines while Cursor is working

On noise

“If every one-rank wobble pages a manager, we’ve built a nuisance.”

On missing

“Unknown is a first-class state. Don’t invent a number.”

On AI

“AI helps me ship the poller. It does not get to invent tonight’s rank.”

The 60–75 second cut-down

0–3s

Receipt

“#6 to #14. Alert + evidence.”

3–18s

Reframe

“Guessing from dinner-rush screenshots isn’t ops.”

18–40s

Method

“Fixtures → normalize → threshold alerts with cooldown. Missing ≠ rank 100.”

40–58s

Product

“Chart plus one plain sentence. That’s the surface.”

58–72s

CTA

“Comment RADAR for the checklist.”

Edit and performance notes

Products as proof: Rank Radar / Biryani Blues support the lesson; LoopSuit is still the brand.
Don’t claim live competitor ranks you didn’t capture.
Show cooldown and missing-listing handling—that’s the save-worthy nuance.
CTA targets QSR operators, not generic AI fans.

Format synthesis: niche education magnet (Nick); levels/system demo (Nate); distribution to buyers not cosplayers (Hormozi/Varun). LoopSuit layer: Rank Radar receipts.

Pre-publish truth check

Ranks shown are from demo/fixtures or real captured polls
No fabricated competitor claims
Missing listing handled as unknown
Alert copy is template-based
CTA checklist ready

Ship It Live · 05 / 10

Full production script · Ship It Live 05

Personalized video at scale—without faking the relationship.

HeyGen is inventory after trust, not a cold-open proof. This script builds a CSV → template → render pipeline with consent, variable hygiene, human review, and a hard ban on pretending the avatar is a live call.

YouTube · 12–15 min Cut-down · 60–75 sec Screen + face HeyGen · CSV · template · review queue Difficulty · Intermediate

The packaging

Title AI Built Personalized Outreach Clips Without Faking a Relationship

Title BHeyGen at Scale: Template, Variables, Human Gate

Title CCSV → Avatar Clip → Review Queue (Live)

ThumbnailFace + “NOT A FAKE CALL” + clip frame

CTAComment CLIP for the variable + consent checklist

What you need before recording

HeyGen account + one approved look
CSV of fake leads you control
Template with {{first_name}} {{company}} {{one_observation}}
Folder for renders
Review spreadsheet: approve / rewrite / kill
Cursor + any thin Node/Python runner

The story spine

Act 1 · ProofShow 3 rendered clips + review board

Act 2 · StanceAvatar after trust; never cold-proof

Act 3 · ContractVariables, consent, kill criteria

Act 4 · BuildCSV validate → render → store → queue

Act 5 · FailureBad variable / weird lip-sync / overclaim

Act 6 · TransferWhen to use face vs avatar

Full run of show

Say blocks are intent. Keep nouns exact; stay natural between them.

0:00–0:25

Cold open: three clips + review board

Play 2–3 second of each clip. Hard cut to APPROVE / REWRITE / KILL columns.

“Personalized video can scale. Fake intimacy can’t. These three clips came from one template and a CSV—and none of them go out until a human gates them. I’m building that pipeline live.”

0:25–1:10

Stance before tooling

“Phase rule for LoopSuit: real face builds trust. Avatar productizes presence after that. Cold outreach with an avatar claiming ‘just hopped on a call’ is how you torch reply quality. We generate inventory. We do not fake presence.”

1:10–2:20

Prompt 1: inspect + constraints

“Notice the banned phrases. That’s product judgment living in the prompt.”

Build a HeyGen outreach clip pipeline for demos. Do not edit yet. Inspect any existing media/automation code. Cite paths. Constraints: - Template-driven scripts only (no freeform model inventing claims) - CSV columns: first_name, company, one_observation, consent_flag, offer_line - Reject rows without consent_flag=true - one_observation must be a matched fact the operator wrote—not AI-invented praise - Output: render job ids, local/remote URLs, review status - Never claim the avatar is a live conversation - Ban phrases: "just hopped on a call", "recording this quickly for you" if false Ask decision questions only. Stop.

2:20–3:30

Options: render orchestration

Propose three orchestration designs: A. Manual UI only B. CSV → script → HeyGen API batch → review sheet C. Full auto-send into Instantly after render Recommend one for trust-preserving outbound. Do not implement yet.

“B. C is how you automate embarrassment. Review is the product.”

3:30–5:00

Implement validator + script builder

Implement phase 1: - CSV schema with Zod/Pydantic - Reject missing consent or empty observation - Build script text from template with strict variable substitution - Unit tests for bad rows No HeyGen API calls yet. List files, implement, test.

5:00–6:40

HeyGen adapter + review queue

Implement phase 2: - Server-only HeyGen credentials - Create video from template/look id - Poll until complete - Write review queue rows: draft_url, script_used, status=pending - Dry-run mode that skips spend Verify current HeyGen API shapes from docs before coding. Show contract, wait, then implement.

If the API shape is unclear, stop and say so on camera—don’t guess endpoints.

6:40–8:00

Human gate ritual

Open three queue rows. Kill one for a weak observation. Approve one. Rewrite one.

“This is the part creators skip. If the observation is generic, the clip dies. Scale without taste is spam with better lighting.”

8:00–9:10

Close

“Template. Consent. Matched observation. Human gate. Avatar is inventory—not a fake relationship. Comment CLIP for the checklist.”

Natural lines while Cursor is working

On trust

“If I wouldn’t say it on a real Loom, the avatar doesn’t get to say it.”

On variables

“AI doesn’t invent the observation. I do. The pipeline only fills blanks.”

The 60–75 second cut-down

0–3s

Receipt

“Three clips. One review board. Nothing auto-sends.”

3–20s

Rule

“Avatar after trust. Never fake a live call.”

20–45s

Build

“CSV validates consent + observation → render → human gate.”

45–70s

CTA

“Comment CLIP for the checklist.”

Edit and performance notes

Show banned-phrase list on screen.
Blur any real lead names.
Label dry-run vs paid renders.

Format synthesis: show-then-teach (Nick); exact prompts (Nate); zero-AI-in-sales-conversation principle (Varun vault). LoopSuit: avatar = inventory after trust.

Pre-publish truth check

Consent required on every row
No auto-send to Instantly
Banned fake-intimacy lines shown
Human kill demonstrated

Ship It Live · 06 / 10

Full production script · Ship It Live 06

Intake to welcome email with zero human clicks—and zero double-sends.

Zero-touch onboarding is an idempotency problem wearing a workflow UI. This script builds n8n (or equivalent) as a visible canvas while teaching contracts, retries, and the ‘welcome once’ rule.

YouTube · 11–15 min Cut-down · 60–75 sec Screen + face n8n · webhook · CRM · email Difficulty · Intermediate

The packaging

Title AZero-Touch Onboarding Without Double Welcome Emails

Title BIntake → CRM → Welcome: The Idempotent Path

Title CI Built Client Onboarding That Survives Retries

Thumbnailn8n canvas + “SEND ONCE”

CTAComment ONBOARD for the workflow checklist

What you need before recording

n8n instance (cloud or local)
Test form/webhook
Fake CRM (Airtable/HubSpot sandbox)
Email provider test mode
Cursor for any helper functions

The story spine

Act 1 · ProofSubmit twice → one welcome

Act 2 · MapCapture → enrich → provision → welcome → notify ops

Act 3 · BuildCanvas with idempotency key

Act 4 · BreakRetry storm / partial failure

Act 5 · TransferAgency owners steal the pattern

Full run of show

Say blocks are intent. Keep nouns exact; stay natural between them.

0:00–0:25

Double-submit receipt

Submit intake twice quickly. Show one CRM row, one welcome email.

“Zero-touch isn’t ‘more nodes.’ It’s surviving retries without spamming the client. Watch: two submits, one welcome.”

0:25–1:15

Name the jobs

“Five jobs: capture, validate, create-or-update CRM, send welcome once, ping ops. If any step can run twice, design for twice.”

1:15–2:30

Prompt: design before canvas

“I design the contract in Cursor first so the canvas isn’t improvisation.”

Design an idempotent onboarding workflow for n8n. Do not build yet. Define: 1. webhook payload schema 2. idempotency key (email+offer or uuid) 3. CRM upsert rule 4. welcome email once semantics 5. failure branches (CRM down, email down) 6. ops alert copy 7. which steps are safe to retry Return a step list mapped to n8n node types. Stop.

2:30–4:20

Build canvas live

Build nodes on camera. Highlight Idempotency-Key / static data check.

“If your ‘welcome’ node can fire on every webhook retry, you don’t have onboarding—you have a spam cannon.”

Given this approved step list, generate: - exact n8n node configuration notes - expression snippets for idempotency checks - test cases: first submit, duplicate submit, CRM 500 then success Keep it implementable in the UI. No fake credentials.

4:20–5:40

Failure drill

“Partial success is normal. The crime is a second welcome after recovery.”

Kill email provider mid-flow. Show CRM upsert kept, welcome queued/retried once, no duplicate after recovery.

5:40–6:40

Close

“Zero clicks for the operator. One email for the client. Comment ONBOARD for the checklist.”

Natural lines while Cursor is working

While wiring

“I’m hunting for any node that assumes ‘this only runs once.’”

On agencies

“This is the difference between a demo automation and something you can sell.”

The 60–75 second cut-down

0–3s

Receipt

“Two submits. One welcome.”

3–20s

Rule

“Design for retries or you will spam.”

20–45s

Build

“Contract in Cursor → canvas → failure drill.”

45–70s

CTA

“Comment ONBOARD.”

Edit and performance notes

Keep n8n zoomed so node names are readable.
Show the idempotency check expression full-screen.

Format synthesis: boring money workflows (Nick); canvas demo (Nate/Varun n8n); give checklist CTA.

Pre-publish truth check

Double submit demonstrated
Partial failure recovered without duplicate welcome
No production client emails

Ship It Live · 07 / 10

Full production script · Ship It Live 07

Phone buzz when the signal fires—without alert spam.

Axiom-style alerts are a product of schema + dedupe + quiet hours, not ‘push notifications.’ This script wires Expo push behind a webhook with explicit alert contracts.

YouTube · 12–15 min Cut-down · 60–75 sec Screen + face + phone Expo · webhook · Axiom-style payload Difficulty · Intermediate

The packaging

Title AI Wired Trading Alerts to My Phone Without Spam

Title BExpo Push Done Right: Schema, Dedupe, Quiet Hours

Title CWhen Axiom Fires, the Phone Buzzes—Once

ThumbnailPhone lock screen + “SIGNAL”

CTAComment ALERT for the push schema

What you need before recording

Expo project + physical device or simulator
Push token registered
Webhook receiver (Next route)
Sample Axiom-like JSON fixtures
Cursor

The story spine

Act 1 · ProofPhone receives one alert

Act 2 · Contractalert_id, symbol, score, reason, fired_at

Act 3 · BuildWebhook → validate → dedupe → Expo

Act 4 · BreakDuplicate fire / invalid payload

Act 5 · TransferSchema card on screen

Full run of show

Say blocks are intent. Keep nouns exact; stay natural between them.

0:00–0:25

Phone receipt

Film the physical phone if possible. One banner.

“Signal fired. Phone buzzed once. That’s the product. Building the path that refuses to buzz twice.”

0:25–1:20

Why most push demos fail

“They send on every webhook. Markets restate. Retries happen. Without alert_id dedupe and quiet hours, you train yourself to ignore the phone—and then the real signal dies unread.”

1:20–2:40

Prompt: contract first

“Products as proof: Axiom can be the signal source. The lesson is the alert system.”

Design a mobile alert pipeline for trading/ops signals. Do not implement yet. Define Zod schema for inbound webhook: - alert_id (idempotency) - symbol - score - reason (human string, max length) - fired_at - severity Define: - dedupe window - quiet hours behavior - Expo push message mapping - storage of delivery attempts - what happens on Expo 429 Stop after contract.

2:40–4:30

Implement webhook + Expo

Implement: - Next.js route validating schema - Dedupe by alert_id - Expo push server-only - Delivery log - Tests: valid, duplicate, invalid, quiet hours List files, implement, test. No real trading advice copy—use demo reasons.

4:30–5:40

Duplicate fire drill

POST same alert_id twice. Second is no-op.

“Second fire swallowed. That’s how you keep trust with your own nervous system.”

If two banners appear, stop and fix dedupe before continuing.

5:40–6:40

Close

“Schema. Dedupe. Quiet hours. Then Expo. Comment ALERT for the schema card.”

Natural lines while Cursor is working

On Axiom

“I’m not selling signals here—I’m showing the delivery system around them.”

On spam

“An ignored phone is a failed product.”

The 60–75 second cut-down

0–3s

Receipt

“One buzz. One banner.”

3–20s

Rule

“Dedupe by alert_id or you’ll hate your phone.”

20–50s

Build

“Validate → dedupe → Expo → log.”

50–70s

CTA

“Comment ALERT.”

Edit and performance notes

Prefer real device footage.
No live trading advice claims.
Show schema on screen at end.

Format synthesis: receipt-first (Nick); fixture/duplicate tests (Nate). LoopSuit: Axiom as proof, alert system as lesson.

Pre-publish truth check

Duplicate suppressed
No financial advice claims
Demo reasons only

Ship It Live · 08 / 10

Full production script · Ship It Live 08

Four subagents, one kernel—routing that you can explain.

Cortex / Loopsuit Brain is meta-proof of the solo stack. This script is about routing judgment: which agent gets the job, what context they receive, and how the kernel refuses silent wrong answers.

YouTube · 12–16 min Cut-down · 60–75 sec Screen + face Cortex · router · subagents · vaults Difficulty · Advanced

The packaging

Title AI Wired a Personal AI OS With Real Routing

Title BFour Subagents, One Kernel—Live

Title CStop Asking One Model to Do Every Job

ThumbnailRouter diagram + “KERNEL”

CTAComment KERNEL for the routing tree

What you need before recording

Cortex/Brain demo environment
At least 2–4 named agents/skills
Sample user tasks
Logging visible
Cursor

The story spine

Act 1 · ProofSame ask routed to different agents

Act 2 · MapRouter policy

Act 3 · BuildRoute + handoff + critique

Act 4 · FailureAmbiguous task / wrong route

Act 5 · TransferWhen not to multi-agent

Full run of show

Say blocks are intent. Keep nouns exact; stay natural between them.

0:00–0:30

Two routes, one kernel

Submit ‘summarize vault notes’ vs ‘draft Instantly line.’ Show different agents selected.

“One chat box. Two jobs. Two specialists. The product isn’t ‘more agents’—it’s a kernel that routes with reasons you can read.”

0:30–1:20

Anti-hype

“If you can’t explain why agent B got the task, you don’t have an OS—you have cosplay. Multi-agent without a router policy is just spend.”

1:20–2:40

Prompt: routing policy

“Outreach editor never auto-sends. Critic never invents facts. Those are kernel laws.”

Design a router policy for a personal AI OS with agents: - researcher (vault/RAG) - builder (code) - outreach_editor (email/DM copy, human-final) - critic (review) For each incoming task type, define: - primary agent - required context packs - tools allowed - stop conditions - when to escalate to human - logging fields: route_reason, agents_touched, tokens_est Do not implement yet. Return a decision tree.

2:40–4:30

Implement/wire router

Implement or refine the router: - classify task - attach only needed context - run primary agent - optional critic pass for high-risk outputs (outreach, code deploy) - persist route_reason in UI Tests: research task, code task, outreach task, ambiguous task → ask clarifying question. List files, implement, test.

4:30–5:40

Ambiguity drill

“Ambiguous input should ask—not guess a specialist. Silence is worse than a clarifying question.”

If it routes confidently on garbage input, force a clarify path.

5:40–6:50

Close

“Specialists are cheap. Judgment is the kernel. Comment KERNEL for the routing tree.”

Natural lines while Cursor is working

On spend

“Parallel agents are a tool, not a personality.”

On sales

“Copy agents draft. Humans send. Non-negotiable.”

The 60–75 second cut-down

0–3s

Receipt

“Two tasks. Two agents. One reason log.”

3–20s

Rule

“If you can’t read the route reason, it’s cosplay.”

20–50s

Build

“Policy → router → critic on high-risk.”

50–72s

CTA

“Comment KERNEL.”

Edit and performance notes

Show route_reason in UI large.
Don’t claim AGI. Claim operable routing.

Format synthesis: levels/system (Nate); DO separation of concerns (Nick). LoopSuit: Cortex as solo-stack proof.

Pre-publish truth check

Route reasons visible
Ambiguous path asks
No auto-send outreach

Ship It Live · 09 / 10

Full production script · Ship It Live 09

Gemini → structured meal plan → app—without mushy JSON.

The lesson is structured generation: schema first, model second, UI third. FitPro is the receipt that speed-to-ship can still be typed and validated.

YouTube · 10–14 min Cut-down · 60–75 sec Screen + face Gemini · Zod · FitPro UI Difficulty · Intermediate

The packaging

Title AI Forced Gemini Into a Schema the App Can Trust

Title BMeal Plans Without Mushy JSON

Title CPrompt + Zod + UI in One Sitting

ThumbnailZod schema + “VALID”

CTAComment SCHEMA for the prompt+Zod pack

What you need before recording

FitPro demo or mini Next app
Gemini API key in env
Zod
Cursor

The story spine

Act 1 · ProofValid plan renders in UI

Act 2 · ContractZod meal plan

Act 3 · BuildPrompt → parse → repair once → UI

Act 4 · BreakInvalid model output

Act 5 · TransferSchema pack

Full run of show

Say blocks are intent. Keep nouns exact; stay natural between them.

0:00–0:22

UI receipt

Show FitPro meal screen, then Zod schema.

“This plan didn’t come from hope. It came from a schema. Model output that fails validation never reaches the UI.”

0:22–1:10

Thesis

“99% of bad AI features are missing contracts. World-build the shape first—calories, meals, macros, constraints—then invite the model into that world.”

1:10–2:20

Prompt: schema + generation policy

“Examples in the prompt are Varun’s puzzle pieces. Schema is the lock.”

Design a FitPro meal-plan generation contract. 1. Zod schema for a 1-day plan (meals[], items[], macros, allergens, notes) 2. System/user prompt that includes examples of good/bad output 3. Repair policy: one repair attempt on validation failure, then user-visible error 4. Never display unvalidated JSON Do not implement yet.

2:20–4:00

Implement

Implement: - Zod schema - Gemini call server-side - parse + safe repair once - FitPro UI binding only after success - tests with fixture invalid JSON List files, implement, test.

4:00–5:10

Invalid output drill

Force a broken fixture through the path. Show repair then hard fail.

“The model can be wrong. The app must not be.”

If UI renders partial garbage, stop.

5:10–6:00

Close

“Schema. Prompt with examples. One repair. Then UI. Comment SCHEMA for the pack.”

Natural lines while Cursor is working

On speed

“Twenty-five minutes is real only if validation is part of the clock.”

On models

“Swap Gemini tomorrow—the schema stays.”

The 60–75 second cut-down

0–3s

Receipt

“Validated plan on screen.”

3–18s

Rule

“No schema, no feature.”

18–45s

Build

“Zod → prompt examples → one repair → UI.”

45–70s

CTA

“Comment SCHEMA.”

Edit and performance notes

Show failing JSON briefly—it’s the lesson.
No medical claims.

Format synthesis: world-building prompts (Varun); typed contracts (LoopSuit); show-then-teach.

Pre-publish truth check

Unvalidated JSON never shown
Repair-once demonstrated
No health claims

Ship It Live · 10 / 10

Full production script · Ship It Live 10

First response in under a minute—building the speed-to-lead pipe.

Local business buyers feel speed. This script builds form → CRM → SMS with SLA timing, business hours, and a human-sounding first reply that isn’t AI sludge.

YouTube · 11–15 min Cut-down · 60–75 sec Screen + face Form · CRM · SMS Difficulty · Intermediate

The packaging

Title AI Built a Sub-60-Second Lead Response Pipe

Title BSpeed-to-Lead Without Sounding Like a Bot

Title CForm → CRM → SMS in One Sitting

ThumbnailTimer 0:47 + SMS bubble

CTAComment SPEED for the speed-to-lead checklist

What you need before recording

Revive Air demo or sandbox form
CRM sandbox
SMS test number (Twilio/etc test)
Stopwatch
Cursor

The story spine

Act 1 · ProofStopwatch under 60s

Act 2 · CopyHuman first SMS

Act 3 · BuildPipe + SLA log

Act 4 · BreakAfter-hours / duplicate

Act 5 · TransferLocal biz checklist

Full run of show

Say blocks are intent. Keep nouns exact; stay natural between them.

0:00–0:30

Stopwatch cold open

Submit form on camera. Cut to SMS. Show elapsed.

“Forty-seven seconds from form to SMS. Local businesses lose jobs in the gap—not in the ad account. Building the pipe that closes the gap without sounding like a robot.”

0:30–1:20

Copy stance

“First SMS is human: name, what they asked for, one next step. No ‘just circling back.’ No AI stains. If AI drafts it, I rewrite before it can send.”

1:20–2:30

Prompt: SLA system

“I pick the human template on camera. That’s the judgment.”

Design a speed-to-lead pipeline: - form webhook - CRM upsert - SMS first response - SLA timer logging (received_at, first_touch_at) - business hours vs after-hours behavior - duplicate lead suppression - template with variables + banned phrases list Do not implement yet. Return architecture + SMS template options (3), mark the most human.

2:30–4:20

Implement

Implement the pipeline in this repo’s conventions: - validate intake - CRM upsert - SMS send server-only - SLA log - after-hours: acknowledge + schedule callback message (no fake ‘we’re available now’) - tests for duplicate and after-hours List files, implement, test.

4:20–5:30

After-hours drill

“Lying about being open destroys trust faster than a slow reply. After-hours gets an honest ack.”

If it claims a human is available when you set after-hours, fix copy immediately.

5:30–6:30

Close

“Speed is a system. Honesty is the copy. Comment SPEED for the checklist—local operators, this one’s for you.”

Natural lines while Cursor is working

On AI copy

“Draft with AI, ship with a human pass—especially line one.”

On Revive

“Product as proof of local-ops speed, not the brand subject.”

The 60–75 second cut-down

0–3s

Receipt

“Form → SMS in under a minute.”

3–18s

Rule

“Fast and human beats fast and fake.”

18–45s

Build

“CRM upsert + SLA log + honest after-hours.”

45–70s

CTA

“Comment SPEED.”

Edit and performance notes

Show stopwatch on screen.
Use test SMS numbers only.
Banned-phrase list on screen.

Format synthesis: niche ICP magnet (Nick); live stopwatch proof; erase AI stains (Varun). LoopSuit: Revive Air as proof.

Pre-publish truth check

Sub-60s on camera or honest miss
After-hours honest
No production leads

UX Autopsy · 01 / 10 · Script 11

Full production script · UX Autopsy 01

This order screen makes money—and still fails new users.

A hiring PM should watch this and think: he can diagnose density, protect power users, and ship a clearer path without dumbing the product down. Zerodha is the specimen; your rebuild is the proof you design and implement.

YouTube · 10–14 min Cut-down · 60–75 sec Annotated UI + rebuild Fintech · density · progressive disclosure Hire signal · Product designer who ships

On-camera hygiene (every autopsy)Never show API keys, tokens, .env, customer PII, account balances, or unredacted order tickets from a real account. Teach the pattern with annotated public UI or your own rebuild. If a secret flashes, cut it — the value is the framework, not the credential.

Hire signal this video must landA company watching should leave thinking: senior product judgment + AI-native execution in one person — not “another UI tip guy.” End with a tangible artifact (checklist/rebuild) that proves you design and ship.

The packaging

Title AWhy This Order Ticket Still Fails New Traders

Title BFintech Density Rules From a Real Order Screen

Title CI Rebuilt the Order Flow Without Killing Power Users

ThumbnailBlurred ticket + “TOO DENSE” → “CLEAR”

CTAComment DENSITY for the 7 density rules

What you need before recording

Public marketing screenshots or your own paper-trading UI — never a funded account
Figma or code rebuild of a simplified ticket
Redaction checklist: amounts, account IDs, names
Cursor for the rebuild slice
On-screen slate: 7 density rules

The story spine

Act 1 · DiagnosisAnnotate overload on the specimen

Act 2 · PrinciplesName the 7 rules

Act 3 · RebuildShip a clearer primary path in code/Figma

Act 4 · Power usersShow advanced still accessible

Act 5 · Hire closeOne sentence: design + build ownership

Full run of show

You are on camera as the person who would own this screen in a bank or fintech — designer and builder. Teach the key; never flash secrets.

0:00–0:25

Cold open: annotate, don’t gossip

Blur any balances. Circles on competing CTAs, stacked fields, weak hierarchy.

“This screen prints money for the platform. It still fails the first-time orderer. I’m not dunking on a brand—I’m showing how a senior product person reads density, then rebuilds the primary path without stripping power users.”

0:25–1:20

Credibility without résumé dump

“I’ve designed for regulated money products—the standard is: if a new user can lose money from confusion, the hierarchy failed. Power users can tolerate density. New users need a primary path that is impossible to miss.”

1:20–2:40

Teach the 7 density rules (value front)

Slate each rule full-screen. These are the save.

“Rule 1: one primary action. Rule 2: progressive disclosure for advanced. Rule 3: numbers need alignment and units. Rule 4: danger actions need friction, not camouflage. Rule 5: status must be readable at a glance. Rule 6: errors sit next to the field that failed. Rule 7: empty optional fields don’t outrank required ones. Steal these. They’re the product.”

2:40–3:40

Prompt: autopsy → rebuild brief

“I give the model redacted reality and a rule set. It doesn’t get secrets; the audience still gets the framework.”

You are helping me produce a UX autopsy rebuild of an order ticket (generic fintech, inspired by public brokerage UIs). Constraints: - Do not request or store any real account data, API keys, or credentials - Work only from redacted screenshots / my description - Output: (1) annotated issue list mapped to 7 density rules (2) proposed information architecture for a primary path + advanced drawer (3) component checklist for a Next.js/shadcn rebuild Do not invent competitor metrics or fake testimonials. Ask only if a UI detail is ambiguous. Then produce the brief.

3:40–5:40

Rebuild live (design + code)

Show Figma or Cursor implementing primary Buy/Sell, qty, product, confirm. Advanced collapsed.

“Primary path: product, side, quantity, review. Advanced: order type, validity, more—behind one control. I’m implementing it, not sliding a mock. That’s the hire signal: judgment and shipping in one seat.”

Implement a minimal order-ticket primary path in this repo using existing design tokens/components. Requirements: - Primary: instrument label (mock), side, quantity, review CTA - Advanced section collapsed by default (order type, validity) - Accessible labels, numeric input validation - Confirm step that restates the order in plain language - No real brokerage APIs, no secrets in env for this demo - Tests for validation + confirm copy List files, implement, run checks.

5:40–6:40

Power-user respect

“If advanced is buried forever, traders bounce. If advanced is always open, newcomers freeze. The craft is the default—not the component library.”

6:40–7:30

Close for buyers

“If you hire for fintech or SaaS: you want someone who can see this, name the rules, and ship the fix. Comment DENSITY—I’ll send the seven rules as a one-pager.”

Natural lines while working

While annotating

“I’m counting competing focal points. More than one primary CTA is already a bug.”

While coding

“The rebuild has to run. A Figma-only dunk doesn’t prove I can own the screen in production.”

The 60–75 second cut-down

0–3s

Hook

“Money screen. New user still fails.”

3–20s

Rules

“Seven density rules—steal these.”

20–45s

Rebuild

“Primary path shipped; advanced collapsed.”

45–70s

Hire

“Design judgment + build. Comment DENSITY.”

Edit and performance notes

Blur all personal financial data.
Do not claim ‘Zerodha hired me’ or fake access.
End card = rules one-pager, not a secret repo.

Positioning: senior product designer + implementer. Specimen for teaching; rebuild is your craft proof.

Pre-publish truth check

No real balances/account IDs
Rules stated explicitly
Working rebuild or interactive prototype shown
No fabricated insider claims

UX Autopsy · 02 / 10 · Script 12

Full production script · UX Autopsy 02

One of these pay confirms trust-signals harder. Guess which.

Payment confirmation is trust engineering. A company should see you can compare products coldly, extract a checklist, and apply it to their checkout—designer brain, builder hands, no fanboying.

YouTube · 9–13 min Cut-down · 55–70 sec Side-by-side UI Payments · trust · confirmation Hire signal · Product systems thinker

On-camera hygiene (every autopsy)Never show API keys, tokens, .env, customer PII, account balances, or unredacted order tickets from a real account. Teach the pattern with annotated public UI or your own rebuild. If a secret flashes, cut it — the value is the framework, not the credential.

Hire signal this video must landA company watching should leave thinking: senior product judgment + AI-native execution in one person — not “another UI tip guy.” End with a tangible artifact (checklist/rebuild) that proves you design and ship.

The packaging

Title APhonePe vs GPay: Who Wins Trust at Confirm?

Title BThe Payment Confirmation Checklist Pros Use

Title CI Side-by-Side’d Pay Confirm UX—Here’s the Winner Pattern

ThumbnailTwo phones + “TRUST?”

CTAComment CONFIRM for the trust checklist

What you need before recording

Two redacted/public confirm screens (or recreations)
Checklist slate: amount, payee, method, undo/window, receipt
No real UPI IDs or full phone numbers on camera

The story spine

Act 1 · GuessAudience picks before reveal

Act 2 · CriteriaTrust checklist

Act 3 · ScoreBoth against criteria

Act 4 · ApplyRebuild a generic confirm for a SaaS checkout

Act 5 · HireYou own money UX end-to-end

Full run of show

You are on camera as the person who would own this screen in a bank or fintech — designer and builder. Teach the key; never flash secrets.

0:00–0:30

Cold open: ask them to guess

Side-by-side, faces of UI only, PII blurred.

“Same job: confirm a payment. One of these makes people feel safer. Don’t scroll—guess in the comments. Then I’ll score both on a trust checklist I use when I design money flows.”

0:30–1:30

Value front: the checklist

“Trust confirm needs: unmistakable amount, unmistakable payee, method visible, last-chance edit, clear success state, receipt that can be found later, and failure that doesn’t strand you. That’s the product. Logos are decoration.”

1:30–3:00

Score both

Green/amber ticks on each criterion. Stay fair; no ragebait.

“I’m not here to crown a forever winner. I’m here to show how a product person decides. Where hierarchy is clearer, that’s the pattern you steal for your own checkout.”

3:00–4:00

Prompt: generic confirm component

“We translate public UX into a reusable pattern—without importing anyone’s private data.”

Design a payment confirmation step for a SaaS checkout (not UPI-specific). Must include: - amount + currency - recipient/product name - payment method last4 only (no full PAN) - edit + confirm actions - success and failure states - accessibility notes No real processor keys. Output IA + shadcn component outline. Then wait before code.

4:00–5:40

Ship a confirm step

Implement the approved confirmation step in this demo app. - Mock payment only - Never log full card numbers - Success/failure states - Tests for copy that restates amount + product List files, implement, test.

5:40–6:30

Close

“If you’re hiring: you want someone who can steal patterns ethically, write the checklist, and implement the state machine. Comment CONFIRM.”

Natural lines while working

On fairness

“If I dunk for views, buyers smell it. Criteria first, score second.”

On secrets

“Last four only. Always.”

The 60–75 second cut-down

0–3s

Hook

“Guess which confirm trusts harder.”

3–18s

Checklist

“Amount, payee, method, edit, receipt.”

18–45s

Apply

“Generic SaaS confirm shipped.”

45–65s

CTA

“Comment CONFIRM.”

Edit and performance notes

Blur UPI IDs and phones.
No ‘official partnership’ implication.

Positioning: comparative product judgment → shipped pattern.

Pre-publish truth check

PII redacted
Checklist explicit
Mock payment only

UX Autopsy · 03 / 10 · Script 13

Full production script · UX Autopsy 03

Empty states are where enterprise UX dies.

TD Bank design pedigree is the credibility—but the value is a reusable empty-state system. Companies should think: bank-grade product craft, AI-era shipping speed.

YouTube · 10–14 min Cut-down · 60–75 sec Before/after UI Enterprise · empty states · onboarding Hire signal · Bank-grade product designer

On-camera hygiene (every autopsy)Never show API keys, tokens, .env, customer PII, account balances, or unredacted order tickets from a real account. Teach the pattern with annotated public UI or your own rebuild. If a secret flashes, cut it — the value is the framework, not the credential.

Hire signal this video must landA company watching should leave thinking: senior product judgment + AI-native execution in one person — not “another UI tip guy.” End with a tangible artifact (checklist/rebuild) that proves you design and ship.

The packaging

Title AEmpty States Are Where Enterprise Products Die

Title BThe Empty-State Checklist From Regulated Product Work

Title CI Rebuilt a Dead Empty Screen Into an Operator Path

ThumbnailBlank screen → “NEXT ACTION”

CTAComment EMPTY for the empty-state checklist

What you need before recording

Example empty screens (SaaS or banking-like demo)
Do not show real customer accounts
Mention TD as prior design standard carefully—not as LoopSuit client
Rebuild in code

The story spine

Act 1 · Dead emptyShow useless blank

Act 2 · StandardWhy regulated products sweat this

Act 3 · Checklist5-part empty state

Act 4 · RebuildShip it

Act 5 · HireDesign systems thinking

Full run of show

You are on camera as the person who would own this screen in a bank or fintech — designer and builder. Teach the key; never flash secrets.

0:00–0:25

Dead empty cold open

Blank table / zero accounts state.

“This screen is empty—and that’s when users decide your product is broken. Enterprise UX doesn’t die on the happy path. It dies here.”

0:25–1:15

Cred, precise

“I’ve worked to a bank-grade mobile standard—prior design work on TD’s mobile banking, not a LoopSuit case study. That bar taught me: empty is still a designed state. Explanation, next action, escape hatch, education, and no shame.”

1:15–2:30

Value front checklist

“Five parts: (1) what this space is for (2) why it’s empty in plain language (3) one primary next action (4) secondary learn/link (5) what success will look like. Miss one and support tickets rise.”

2:30–3:30

Prompt

“I’m specifying a system—not a one-off illustration.”

Create an empty-state system for a B2B dashboard list view. Deliver: - content model for the five parts - do/don't copy examples (no AI sludge) - React/shadcn component API - analytics events: empty_viewed, empty_cta_clicked No customer data. No secrets.

3:30–5:20

Implement

Implement EmptyState for a demo ‘Accounts’ or ‘Matters’ list. - Five-part content - Primary + secondary CTA - Skeleton → empty → populated transitions - Tests for CTA presence No real bank APIs. List files, implement, test.

5:20–6:20

Close

“If you need someone who designs the boring states that keep enterprises calm—and can ship them—comment EMPTY.”

Natural lines while working

On TD

“Prior design standard—not ‘I run TD’s AI.’ Precision builds trust.”

On AI

“AI can draft empty copy. I still kill anything that sounds like a motivational poster.”

The 60–75 second cut-down

0–3s

Hook

“Empty is where enterprise UX dies.”

3–20s

Five parts

“What / why / next / learn / success.”

20–45s

Ship

“Component live in the demo.”

45–70s

CTA

“Comment EMPTY.”

Edit and performance notes

Clarify TD relationship verbally and on-screen if needed.
No real customer empties with PII.

Positioning: regulated-product craft + shipping speed.

Pre-publish truth check

TD framing accurate
Checklist explicit
Working empty state shipped

UX Autopsy · 04 / 10 · Script 14

Full production script · UX Autopsy 04

Power users tolerate clutter. Your SaaS users won’t.

Translate pro-tool chrome into a SaaS chrome budget. Hire signal: you can learn from complex products without cargo-culting them into a startup dashboard.

YouTube · 9–13 min Cut-down · 55–70 sec Chrome audit Fintech · information architecture Hire signal · Product architect

On-camera hygiene (every autopsy)Never show API keys, tokens, .env, customer PII, account balances, or unredacted order tickets from a real account. Teach the pattern with annotated public UI or your own rebuild. If a secret flashes, cut it — the value is the framework, not the credential.

Hire signal this video must landA company watching should leave thinking: senior product judgment + AI-native execution in one person — not “another UI tip guy.” End with a tangible artifact (checklist/rebuild) that proves you design and ship.

The packaging

Title ATradingView Chrome vs Your SaaS Dashboard

Title BThe Chrome Budget Rule for Product Teams

Title CStop Copying Pro-Tool Clutter Into Startup UI

ThumbnailBusy chrome → “BUDGET”

CTAComment CHROME for the chrome budget sheet

What you need before recording

TradingView mobile screenshots (public)
Your SaaS dashboard demo
Chrome budget: persistent / contextual / buried

The story spine

Act 1 · AuditCount chrome regions

Act 2 · RuleChrome budget

Act 3 · TranslateSaaS before/after

Act 4 · ShipSimplify one screen

Act 5 · HireIA ownership

Full run of show

You are on camera as the person who would own this screen in a bank or fintech — designer and builder. Teach the key; never flash secrets.

0:00–0:25

Count the chrome

“I’m counting regions fighting the chart. Power users earned this clutter. Your SaaS buyer did not. If you copy pro-tool density into a startup dashboard, you’re cosplaying complexity.”

0:25–1:20

Chrome budget (value)

“Persistent chrome: only what you need every session. Contextual: appears in-task. Buried: settings and rare power. If everything is persistent, nothing is important.”

1:20–2:40

Translate to SaaS

Split: TradingView-like busy vs your cleaned dashboard.

“Axiom-style products can be dense for traders. Operator SaaS for QSR or clinics should not feel like a terminal unless the user is a terminal user.”

2:40–3:40

Prompt

Audit a dashboard layout description/screenshot (redacted). Classify each control as persistent, contextual, or buried. Propose a chrome budget that halves persistent controls without removing critical actions. Output a before/after IA. No secrets, no live trading advice.

3:40–5:20

Ship simplification

Refactor the demo dashboard shell: - Reduce top persistent actions to a budget of N (choose N and justify) - Move rare actions into overflow - Keep primary workflow CTA obvious - Preserve keyboard access List files, implement, screenshot before/after in notes.

5:20–6:10

Close

“Hire for taste under complexity—not for maximal buttons. Comment CHROME.”

Natural lines while working

On Axiom

“Products as proof of dense-finance craft—not the only aesthetic I ship.”

The 60–75 second cut-down

0–3s

Hook

“Pro clutter ≠ SaaS UI.”

3–18s

Budget

“Persistent / contextual / buried.”

18–45s

Ship

“Dashboard chrome cut.”

45–65s

CTA

“Comment CHROME.”

Edit and performance notes

No live account P&L.
Don’t insult TradingView users—respect the audience split.

Positioning: IA judgment across pro and operator products.

Pre-publish truth check

Chrome budget taught
Before/after shown
No financial advice

UX Autopsy · 05 / 10 · Script 15

Full production script · UX Autopsy 05

This UI trains you to sound desperate. Here’s the operator rewrite.

Flip the marketplace default into a senior operator proposal structure. Companies and founders should think: he sells outcomes, designs the narrative, and isn’t a ‘freelancer’ commodity.

YouTube · 9–13 min Cut-down · 60–75 sec UX + copy rewrite Positioning · proposals · offers Hire signal · Outcome-led operator

On-camera hygiene (every autopsy)Never show API keys, tokens, .env, customer PII, account balances, or unredacted order tickets from a real account. Teach the pattern with annotated public UI or your own rebuild. If a secret flashes, cut it — the value is the framework, not the credential.

Hire signal this video must landA company watching should leave thinking: senior product judgment + AI-native execution in one person — not “another UI tip guy.” End with a tangible artifact (checklist/rebuild) that proves you design and ship.

The packaging

Title AUpwork’s UI Trains You to Sound Desperate

Title BThe Operator Proposal Structure I Actually Use

Title CStop Writing Cover Letters for Project Work

Thumbnail‘Hire me’ → ‘Here’s the system’

CTAComment PROPOSAL for the structure

What you need before recording

Redacted Upwork-style composer mock (or public UI with no personal bids)
Your proposal template
Banned phrases list
Optional: Cursor to format a sample

The story spine

Act 1 · Problem UIHow the composer shapes weak copy

Act 2 · ReframeOperator vs applicant

Act 3 · Structure5-block proposal

Act 4 · Live rewriteBefore/after

Act 5 · HireYou want the operator

Full run of show

You are on camera as the person who would own this screen in a bank or fintech — designer and builder. Teach the key; never flash secrets.

0:00–0:25

Cold open

“This composer optimizes for ‘please pick me.’ That’s applicant energy. Operators lead with diagnosis, plan, proof, and boundaries. I’m rewriting the structure—and calling out the UI patterns that push you the wrong way.”

0:25–1:20

Bio stance

“I don’t pitch as a freelancer. I pitch as the person who designs and ships the system end-to-end—product, AI, code. The proposal has to sound like that, or the wrong buyers reply.”

1:20–2:40

Value front: 5 blocks

“Block 1: mirrored problem in their words. Block 2: proposed system in one paragraph. Block 3: proof artifacts (links, not adjectives). Block 4: first 7–14 day plan. Block 5: fit/boundaries—what you won’t do. Soft CTA. No life story.”

2:40–3:40

Prompt for rewrite assist

“AI drafts. I own truth. If a metric isn’t real, it dies.”

Rewrite this proposal draft into the 5-block operator structure. Rules: - No desperation openers ("I'd love the opportunity") - No AI sludge ("leverage", "robust synergy", "excited to") - No invented metrics or clients - Keep claims only if evidence URLs are provided in the draft - Preserve truthful constraints Return before/after with comments on what the UI was tempting me to do wrong.

3:40–5:20

Live before/after

Split screen. Highlight banned lines dying.

“Watch the adjectives leave and the plan arrive. That’s how a company reading my profile thinks ‘we can hire him to own the build’—not ‘we can hire a bidder.’”

5:20–6:20

Close

“If you’re a founder hiring: you want diagnosis and a system, not a cover letter. Comment PROPOSAL for the structure—I use this on Instantly and Upwork alike.”

Natural lines while working

On secrets

“No client names without permission. Proof links to public case studies only.”

On AI

“Zero AI in the actual sales call. Drafts are fine; the conversation stays human.”

The 60–75 second cut-down

0–3s

Hook

“UI trains desperation.”

3–20s

Five blocks

“Problem → system → proof → plan → boundaries.”

20–45s

Rewrite

“Before/after on screen.”

45–70s

CTA

“Comment PROPOSAL.”

Edit and performance notes

Redact bid amounts if any.
Public proof only.
Banned phrase list on screen.

Positioning: outcome operator / AI-native builder — never ‘freelancer’ commodity.

Pre-publish truth check

No invented ROI
5-block structure explicit
Human voice, no sludge

UX Autopsy · 06 / 10 · Script 16

Full production script · UX Autopsy 06

Meta shows vanity first. Here’s the metric map that actually steers content.

Product autopsy of Insights as information architecture. Teach which numbers are decisions—then redesign a metrics surface a company would hire you to own.

YouTube · 11–15 min Cut-down · 60–75 sec Redacted Insights + decision board Metrics · IA · creator ops Hire signal · Product + growth systems

On-camera hygieneNo .env, API keys, Stripe live keys, customer emails, clinic patient data, or unredacted private Insights. Teach frameworks with redacted screens and your rebuild. Value = the map; never the credential.

Hire signalA company should finish thinking: he diagnoses product systems, designs the fix, and can implement it — AI-native product designer + builder.

Steal-this value (teach before the build)

Watch-through

Did the first 1.5s earn the rest? Change hooks, not hashtags.

Sends/reach

Is this travel content? Design explicit send-to-[role] moments.

Saves

Is this reference material? Checklists/tutorials live here.

Profile→DM

Did curiosity become conversation? Bio/CTA alignment.

Calls

North star. Everything else is upstream instrumentation.

The packaging

Title AInstagram Insights Hides the Metrics That Matter

Title BThe Only Metric Map I Use for Reels

Title CI Redesigned How You Should Read Insights

ThumbnailInsights blur + VANITY → DECISIONS

CTAComment METRICS for the decision map

What you need before recording

Redacted Insights screenshots
On-screen metric map slate
No OAuth demos that expose tokens

The story spine

Act 1Show vanity hierarchy

Act 2Decision stack

Act 3Weekly ritual

Act 4Ship decision board

Act 5Hire close

Full run of show

Depth first. Every beat teaches a reusable rule or ships proof. No secret-flexing.

0:00–0:30

Wrong hierarchy

Blur identity. Circle vanity prominence.

“Insights is a product. It leads with what’s easy to feel—not what’s useful to decide. I’m mapping which metrics change next week’s content.”

0:30–2:00

Decision stack

“Top to bottom: watch-through — did the hook hold? Sends per reach — did it travel? Saves — will it resurface? Profile visits → DMs — curiosity to conversation? Booked calls — business. Likes and raw views are weather, not steering.”

2:00–3:10

Why UI misleads

“Platforms optimize engagement loops. Your business optimizes buyer conversations. When they diverge, a senior product person builds a translation layer.”

3:10–4:20

Prompt: decision map

Design a one-page Content Decision Map for Reels operators. Columns: metric · decision it informs · how to capture weekly · what to ignore. No fabricated benchmarks. No login credentials. Educational only. Also return a 5-step Tuesday ritual.

4:20–6:00

Ship decision board

“I’m shipping operator IA—not scraping Meta.”

Build a demo Reels Decision Board: - Cards: watch-through, sends/reach, saves, profile→DM, calls - Each: definition, decision question, weekly note field - Vanity section (likes/views) collapsed - Local state only, no OAuth/tokens Use existing design tokens. List files, implement.

6:00–7:00

Close

“Five numbers, one kill, one double-down. Comment METRICS.”

Natural lines

On ego

“200k views with zero DMs is a costume party.”

On hire

“Redesign the measurement surface—don’t worship the vendor default.”

The 60–75 second cut-down

0–3s

Hook

“Insights leads with vanity.”

3–25s

Stack

“Watch-through → sends → saves → DM → calls.”

25–50s

Ship

“Decision board live.”

50–70s

CTA

Comment METRICS.

Edit notes

Redact account identity.
No fake algorithm secrets.

Depth: IA critique + operator system + shipped translation UI.

Pre-publish truth check

Account redacted
No credentials
Decision map explicit
Board has no OAuth

UX Autopsy · 07 / 10 · Script 17

Full production script · UX Autopsy 07

Billing UX that doesn’t make people cancel out of spite.

Customer Portal is retention product. Show configuration + copy decisions that preserve dignity—and wire test-mode Portal without ever flashing secrets.

YouTube · 12–16 min Cut-down · 60–75 sec Stripe test mode only Billing · retention · SaaS Hire signal · Full-stack product owner

On-camera hygieneNo .env, API keys, Stripe live keys, customer emails, clinic patient data, or unredacted private Insights. Teach frameworks with redacted screens and your rebuild. Value = the map; never the credential.

Hire signalA company should finish thinking: he diagnoses product systems, designs the fix, and can implement it — AI-native product designer + builder.

Steal-this value (teach before the build)

Spite cancel

Confusion, hidden invoices, impossible card update, guilt UI.

Portal ≠ truth

Webhooks update entitlement; Portal is the cockpit.

Server sessions

Created with secret key—never from the browser.

Copy tone

Inform, don’t hostage.

Support cost

Missing self-serve = tickets + trust leak.

The packaging

Title AStripe Customer Portal: Stop Spite Cancels

Title BBilling UX Checklist Before Portal Goes Live

Title CI Configured Portal Like Retention Product

ThumbnailPortal + no spite cancel

CTAComment BILLING for the checklist

What you need before recording

Stripe TEST keys in env only—never show values
Test customer + subscription
Blur account IDs in Dashboard

The story spine

Act 1Spite cancel

Act 27-point checklist

Act 3Configure

Act 4portal.sessions server-only

Act 5Failure if key leaks

Full run of show

Depth first. Every beat teaches a reusable rule or ships proof. No secret-flexing.

0:00–0:30

Cold open

“People cancel because billing made them feel trapped—not only because the product failed. Portal is where that happens. I’m tearing down the decisions, then wiring test-mode correctly.”

0:30–2:10

Retention checklist

“(1) cancel reasons without hostage flows (2) clear renewal date + plan name (3) invoices findable (4) payment method update without a ticket (5) pause/downgrade if you offer it—don’t hide it (6) copy that doesn’t guilt-trip (7) webhooks remain entitlement source of truth—Portal UI is not your database.”

2:10–3:20

Config on camera

Dashboard portal settings; blur secrets.

“Every checkbox is a support-cost decision.”

3:20–4:30

Safe portal session prompt

Implement Stripe Customer Portal session route. Hard constraints: TEST MODE only; secret key server-only; never log secrets; create session for authenticated user's stripe_customer_id; return_url /billing; clear error if missing customer id; comment the Dashboard config checklist. Verify current Stripe API from docs. Mocked tests. List files, implement.

4:30–6:10

Live test

Manage billing → Portal test mode.

“Dignity in self-serve. Support should be the exception.”

If a key appears in client bundle or network tab, stop and fix out loud.

6:10–7:10

Close

“Checkout, portal, entitlement—one product. Comment BILLING.”

Natural lines

On keys

“If you can read my key on camera, I failed the video.”

On cancel

“Trap friction becomes a public screenshot.”

The 60–75 second cut-down

0–3s

Hook

“Spite cancels are UX.”

3–25s

Checklist

“Seven dignity rules.”

25–50s

Ship

“Server-only portal session.”

50–70s

CTA

Comment BILLING.

Edit notes

Test mode only.
Cross-link auth+Stripe ship script mentally.

Depth: retention psychology + Stripe config + secure implementation.

Pre-publish truth check

Test mode
No key visible
Checklist taught
Server-side session

UX Autopsy · 08 / 10 · Script 18

Full production script · UX Autopsy 08

Blank-box AI UX is lazy. Here’s the starter system that makes models useful.

Empty prompt boxes are product failures. Teach starters, examples, constraints, repair—then ship the pattern companies hire AI product designer-engineers to build.

YouTube · 10–14 min Cut-down · 60–75 sec AI UX pattern Prompt UX · empty states Hire signal · AI product designer-engineer

On-camera hygieneNo .env, API keys, Stripe live keys, customer emails, clinic patient data, or unredacted private Insights. Teach frameworks with redacted screens and your rebuild. Value = the map; never the credential.

Hire signalA company should finish thinking: he diagnoses product systems, designs the fix, and can implement it — AI-native product designer + builder.

Steal-this value (teach before the build)

Starters

Job-shaped beats feature-shaped.

Example

One output teaches the world faster than help text.

Constraints

Tone/length/format as UI.

Repair

Too long / more specific beats blind regenerate.

Analytics

Weak starter conversion = product bug.

The packaging

Title ABlank AI Boxes Are Lazy Product Design

Title BThe Prompt Starter Pattern I Ship

Title CI Rebuilt an Empty Prompt Into a System

ThumbnailEmpty → STARTERS

CTAComment STARTERS for the kit

What you need before recording

Public AI-empty UI screenshots
Demo AiComposer component

The story spine

Act 1Blank failure

Act 2Four-layer system

Act 3Taxonomy

Act 4Ship composer

Act 5Hire

Full run of show

Depth first. Every beat teaches a reusable rule or ships proof. No secret-flexing.

0:00–0:25

Cold open

“A blinking cursor is not a product. Most AI features fail here—not in the model.”

0:25–2:00

Four layers

“(1) job-based starters—Rewrite for clarity, Extract action items—not Try AI (2) one example output (3) visible constraints—tone, length, format (4) repair path. World-build in the UI or you get sludge.”

2:00–3:00

Autopsy

“Weak starters mean only power users win. Fine for a side feature—deadly if AI is the product.”

3:00–4:10

Prompt

Design an AI input empty-state for a B2B app. Deliver: 8 job-based starters; example chip; constraint controls; React component API; analytics starter_clicked / prompt_submitted / repair_clicked. No model API keys in client.

4:10–5:50

Implement

Implement AiComposer empty state: - starter chips hydrate template with cursor on variable - example preview - constraint selects - server stub may mock generation Tests for hydration. List files, implement.

5:50–6:40

Close

“Hire the person who designs the empty state—not only who wires the model. Comment STARTERS.”

Natural lines

On sludge

“Job language is the product.”

The 60–75 second cut-down

0–3s

Hook

“Blank box = lazy.”

3–22s

System

“Starters, example, constraints, repair.”

22–50s

Ship

“Composer live.”

50–70s

CTA

Comment STARTERS.

Edit notes

Your rebuild is the hero—not dunking for sport.

Depth: AI UX theory + taxonomy + shipped composer.

Pre-publish truth check

No third-party creds
Pattern taught
Component shipped

UX Autopsy · 09 / 10 · Script 19

Full production script · UX Autopsy 09

Clinic booking funnels leak money between Booked and Paid.

Rebound is proof. The lesson is a conversion leak map clinic and health-SaaS teams hire you to close—design + systems.

YouTube · 12–16 min Cut-down · 60–75 sec Booking autopsy Health/local · conversion Hire signal · Revenue systems designer

On-camera hygieneNo .env, API keys, Stripe live keys, customer emails, clinic patient data, or unredacted private Insights. Teach frameworks with redacted screens and your rebuild. Value = the map; never the credential.

Hire signalA company should finish thinking: he diagnoses product systems, designs the fix, and can implement it — AI-native product designer + builder.

Steal-this value (teach before the build)

Booked≠Paid

Events aren’t cash without deposit/policy.

Price early

Late sticker shock is designed abandonment.

Deposit

Commitment device—clear and ethical.

Confirmation

Expectations checklist beats vague see-you-then.

Follow-up

SMS chaos is a product opportunity—human tone.

The packaging

Title AWhy Booked Clinics Still Lose Revenue

Title BThe Clinic Funnel Leak Map

Title CI Autopsied a Med Spa Booking Flow

ThumbnailBooked ≠ Paid

CTAComment CLINIC for the leak map

What you need before recording

Public booking UIs or wires
Never PHI
Leak map slate

The story spine

Act 1Booked≠Paid

Act 27 leaks

Act 3Score a flow

Act 4Ship primary path

Act 5Hire

Full run of show

Depth first. Every beat teaches a reusable rule or ships proof. No secret-flexing.

0:00–0:30

Cold open

“Calendar says booked. Bank disagrees. That gap is the bleed. Rebound exists because of this—today you get the leak map.”

0:30–2:20

Seven leaks

“(1) vague service (2) late price surprise (3) no deposit (4) weak confirmation expectations (5) no reminders (6) invisible no-show policy (7) post-consult follow-up dies in SMS chaos. Rank for your clinic—don’t boil the ocean.”

2:20–3:30

Autopsy

Constructive, not cruel.

“Money falls out in the boring middle—not the homepage hero.”

3:30–4:40

Prompt

Create a clinic booking leak-map worksheet for 7 leaks: user moment · business cost · UX fix · ops/automation fix · metric. No medical advice, no PHI, no invented ROI %.

4:40–6:20

Ship demo path

“Design commitment, then automate follow-up.”

Demo booking path: clear service + price range early; mock deposit; expectations checklist; reminder preference. No real payments, no patient data. List files, implement.

6:20–7:10

Close

“Comment CLINIC. Hire the person who sees revenue as a designed system.”

Natural lines

On Rebound

“Proof I build money systems—not the whole channel identity.”

On ethics

“Patterns only. No patient stories.”

The 60–75 second cut-down

0–3s

Hook

“Booked ≠ paid.”

3–25s

Map

“Seven leaks.”

25–50s

Ship

“Deposit + expectations path.”

50–72s

CTA

Comment CLINIC.

Edit notes

No PHI.
No fake revenue numbers.

Depth: revenue architecture + UX + automation.

Pre-publish truth check

No PHI
No invented ROI
Leak map explicit

UX Autopsy · 10 / 10 · Script 20

Full production script · UX Autopsy 10

Your menu photo is losing the click. Aggregator cards are a product surface.

QSR multi-unit buyers should feel seen. Connect card UX to visibility monitoring—design eye + ops instrumentation.

YouTube · 11–15 min Cut-down · 60–75 sec Card autopsy QSR · aggregators · visibility Hire signal · Industry product operator

On-camera hygieneNo .env, API keys, Stripe live keys, customer emails, clinic patient data, or unredacted private Insights. Teach frameworks with redacted screens and your rebuild. Value = the map; never the credential.

Hire signalA company should finish thinking: he diagnoses product systems, designs the fix, and can implement it — AI-native product designer + builder.

Steal-this value (teach before the build)

Card=product

Feed real estate is the storefront.

Thumbnail read

Fail at 120px = fail.

Menu accuracy

Wrong items are UX bugs with food cost.

Rank only

Documents losing if the card is bad.

Creative only

Pretty photos in position 28 still starve.

The packaging

Title AYour Aggregator Card Is Losing the Click

Title BQSR Visibility Checklist

Title CI Autopsied a Restaurant Card Like a Product

ThumbnailMenu photo + losing clicks

CTAComment RADAR for the checklist

What you need before recording

Public aggregator-style cards
Rank Radar as monitoring proof
Checklist slate

The story spine

Act 1Card=product

Act 2Checklist

Act 3Score

Act 4Monitoring bridge

Act 5Hire

Full run of show

Depth first. Every beat teaches a reusable rule or ships proof. No secret-flexing.

0:00–0:28

Cold open

“On aggregators your restaurant is a card in a feed. If the card fails, the kitchen never gets the order.”

0:28–2:10

Card checklist

“Visual: food readable at thumbnail size. Info: name, cuisine, honest rating. Offer: time/fee without surprise. Ops: menu accurate tonight? Rank: visible for head terms? Design without monitoring is vibes.”

2:10–3:20

Score a card

“Most failures are content ops—not ‘we need a rebrand.’”

3:20–4:30

Prompt

Create a QSR aggregator card & visibility checklist: creative · information scent · offer clarity · menu accuracy · rank monitoring · weekly owner ritual. No fake ranks. No ToS-hostile scrape steps. Educational only.

4:30–6:00

Bridge to Rank Radar

“Checklist = creative/ops. Rank Radar = instrumentation. Together = a system. Comment RADAR.”

Draft a printable QSR Visibility One-Pager: 10 creative checks + monitoring alerts that matter + what NOT to obsess daily. No credentials. No invented case metrics.

6:00–6:50

Close

“Multi-outlet QSR wants design and data as one loop. That’s the hire.”

Natural lines

On dunking

“Scoreboard for ops—not roasting restaurants.”

On ToS

“Checklist + monitoring concept—no scrape heroics here.”

The 60–75 second cut-down

0–3s

Hook

“The card is the product.”

3–25s

Checklist

“Creative + info + offer + accuracy + rank.”

25–50s

System

“Checklist + monitoring.”

50–70s

CTA

Comment RADAR.

Edit notes

No invented ranks.
Products as proof: Rank Radar.

Depth: marketplace card UX + ops instrumentation.

Pre-publish truth check

No fake ranks
Checklist explicit
Rank Radar as proof

Solo Stack · 1 / 10 · Script 21

Full production script · Solo Stack 01

This is the five-person agency, compacted.

Show the operating system: rules, agents, MCP, folder layout. Companies should see a repeatable AI-native build practice—not vibes.

12–15 min Screen + face Cursor · rules · MCP Hire · AI-native builder OS

On-camera hygieneNever show .env values, OAuth client secrets, access tokens, or private vault contents. Show file names, redacted configs, and the decision framework. If a secret appears, cut it.

Hire signalThis pillar sells the operating system of one AI-native product designer/builder — judgment, structure, and boundaries — not tool cosplay.

Steal-this value

Rules > chat

Project rules beat clever one-off prompts.

Separate concerns

Directives / skills / app code — don’t mush them.

MCP is power+risk

Only enable what you can explain.

Demo repo

Tour a clean template, not a secret-laden client repo.

The packaging

Title AMy Solo Stack: The Five-Person Agency Compacted

Title BCursor Setup That Actually Ships Client Work

CTAComment STACK for the folder layout

Prep

Clean demo repo
Redacted mcp.json showing structure only
Rules file examples without secrets

Story spine

1Tour layout

2Rules philosophy

3Agent/skills

4MCP boundaries

5Hire close

Full run of show

0:00–0:25

Open on layout

File tree full screen.

“This isn’t ‘I use Cursor.’ This is how one operator replaces a relay of vendors—with structure.”

0:25–1:40

Value: layers

“Layer 1: repo conventions. Layer 2: Cursor rules that encode taste and safety. Layer 3: skills/agents for repeatable jobs. Layer 4: MCP tools with least privilege. Chat is the steering wheel—not the brain.”

1:40–3:00

Rules live

“I show what I ban: inventing APIs, skipping RLS, committing secrets, AI sludge in user copy.”

Draft a .cursor/rules set for a Next.js 15 + Supabase + Stripe app. Include: stacking order, security bans, design-token rules, PRD-before-code rule, no-secret-logging. Output markdown only. No real keys.

3:00–4:30

MCP boundary

“If I can’t say what an MCP can touch, it stays off. Avatar tools after trust—never as cold proof.”

Write an MCP enablement checklist: - purpose - data it can access - blast radius if compromised - redact/test plan - when NOT to enable No OAuth secrets in the output.

4:30–5:40

Close

“Hire the person with an OS—not a prompt notebook. Comment STACK.”

Natural lines

On client repos

“I never screen-share a live client .env. Ever.”

60–75s cut-down

0–3s

Hook

“Five-person agency. One seat.”

3–25s

Layers

“Rules → skills → MCP → chat.”

25–50s

Proof

“Layout + bans on screen.”

50–70s

CTA

Comment STACK.

Edit notes

Blur any tokens.
Use demo repo only.

Solo-stack OS as the hire magnet.

Truth check

No secrets shown
Layers taught
Demo repo only

Solo Stack · 2 / 10 · Script 22

Full production script · Solo Stack 02

Missing spec is the bottleneck—not missing skill.

Teach the self-brief that makes AI useful. Hire signal: product thinking before code.

10–14 min PRD → tickets Hire · product-minded builder

On-camera hygieneNever show .env values, OAuth client secrets, access tokens, or private vault contents. Show file names, redacted configs, and the decision framework. If a secret appears, cut it.

Hire signalThis pillar sells the operating system of one AI-native product designer/builder — judgment, structure, and boundaries — not tool cosplay.

Steal-this value

Outcome first

What done looks like in one sentence.

Non-goals

What we refuse this week.

Contract

Data shapes before UI.

Acceptance

Tests/checks that prove done.

Blast radius

Files/systems allowed to change.

The packaging

Title AThe Brief I Write Before I Let AI Code

Title BSpec Is the Bottleneck

CTAComment BRIEF for the template

Prep

Blank brief template on screen
One real anonymized example

Story spine

1Bad brief fail

2Template

3Fill live

4Hand to Cursor

5Close

Full run of show

0:00–0:25

Fail cold open

“‘Build auth’ is how you get a demo that can’t survive production. The bottleneck was never typing speed.”

0:25–2:00

Template

“Outcome · users · non-goals · data contract · happy path · failure path · acceptance checks · blast radius · open questions. That’s the brief. AI fills code inside it.”

2:00–3:20

Fill live

Convert this rough idea into an operator brief using the 9-section template. Idea: [paste] Ban invented metrics. List open questions instead of guessing.

3:20–4:40

Hand to Cursor

“Now the first prompt is ‘inspect repo against this brief—don’t code yet.’”

Using this brief, inspect the repo and list mismatches/risks. Do not edit files yet.

4:40–5:30

Close

“Companies hire judgment. Comment BRIEF.”

Natural lines

On AI

“Without a brief, the model improvises your product.”

60–75s cut-down

0–3s

Hook

“Spec is the bottleneck.”

3–25s

Template

“Nine sections.”

25–50s

Live

“Brief → inspect, don’t code.”

50–70s

CTA

Comment BRIEF.

Edit notes

Anonymize client details.

PRD discipline as moat.

Truth check

Template explicit
No invented claims

Solo Stack · 3 / 10 · Script 23

Full production script · Solo Stack 03

Wire HeyGen from Cursor—without turning OAuth into a circus.

MCP wiring as a security + product lesson. Show structure, redact secrets, teach when avatar tools belong.

11–15 min MCP config Hire · systems integrator with taste

On-camera hygieneNever show .env values, OAuth client secrets, access tokens, or private vault contents. Show file names, redacted configs, and the decision framework. If a secret appears, cut it.

Hire signalThis pillar sells the operating system of one AI-native product designer/builder — judgment, structure, and boundaries — not tool cosplay.

Steal-this value

Least privilege

Only tools you need.

Redact forever

Tokens never on camera.

Trust phase

Avatar after face-trust exists.

Fail closed

If auth is messy, stop—don’t paste secrets into chat.

The packaging

Title AHeyGen MCP From Cursor—The Safe Way

Title BOAuth/MCP Checklist Before You Enable Anything

CTAComment MCP for the safety checklist

Prep

HeyGen MCP docs
Redacted config skeleton
Dry-run plan

Story spine

1Why MCP

2Safety checklist

3Config skeleton

4Dry-run call

5Close

Full run of show

0:00–0:25

Open

“MCP makes Cursor a control plane. That’s power. Power without a checklist is how keys leak on YouTube.”

0:25–1:50

Checklist

“Purpose · scopes · secret storage · who can invoke · blast radius · rotate plan · when not to enable.”

1:50–3:20

Skeleton only

Show JSON with SECRET_REDACTED.

Produce a redacted MCP server config skeleton for a video tool integration. Use placeholders only. Include comments for required env vars and a preflight checklist. No real credentials.

3:20–4:40

Dry-run

“List tools, don’t render paid jobs until the boundary is clear.”

If the UI shows a live token, cut and rotate immediately—say so.

4:40–5:30

Close

“Integrations are product decisions. Comment MCP.”

Natural lines

On avatar

“Inventory after trust—never cold ‘proof.’”

60–75s cut-down

0–3s

Hook

“MCP is power+risk.”

3–25s

Checklist

“Purpose → rotate plan.”

25–50s

Skeleton

“Redacted config.”

50–70s

CTA

Comment MCP.

Edit notes

Never show OAuth client secret.
Rotate if exposed.

Safe integration craft.

Truth check

All secrets redacted
Checklist taught

Solo Stack · 4 / 10 · Script 24

Full production script · Solo Stack 04

Full-time commitment + shipping products—here’s the cut list.

Honest capacity under FSH. Hire signal: operator who protects deep work and still ships.

9–13 min Calendar Hire · reliable operator

On-camera hygieneNever show .env values, OAuth client secrets, access tokens, or private vault contents. Show file names, redacted configs, and the decision framework. If a secret appears, cut it.

Hire signalThis pillar sells the operating system of one AI-native product designer/builder — judgment, structure, and boundaries — not tool cosplay.

Steal-this value

Non-negotiables

Sleep, FSH commitments, deep build blocks.

Content is capture

Document while delivering—don’t invent a second job.

Kill list

What you stop doing to ship.

Batching

Sunday shoot / weekday ship cadence.

The packaging

Title AHow I Ship Products With a Full-Time Day Job

Title BThe Cut List That Makes Solo Possible

CTAComment CAPACITY for the weekly blocks

Prep

Anonymized calendar
Cut list slate

Story spine

1Constraint

2Blocks

3Kill list

4Content rule

5Close

Full run of show

0:00–0:25

Open

“I’m not a full-time creator. I ship under load. Here’s the cut list—because without one, the stack is cosplay.”

0:25–2:00

Weekly blocks

“Deep build · client/comms · content capture · admin. If content isn’t capture, it dies first.”

2:00–3:20

Kill list

Help me write a capacity cut list for a builder with a full-time job. Categories: stop doing / batch / delegate / automate. No hustle-porn. Practical weekly hours only.

3:20–4:20

Content rule

“Screen-record the build. Editing is the job. Topic invention is optional.”

4:20–5:10

Close

“Hire reliability under constraint. Comment CAPACITY.”

Natural lines

On honesty

“If I pretend I have 60 free hours, buyers won’t trust the rest.”

60–75s cut-down

0–3s

Hook

“Ship under load.”

3–25s

Blocks

“Build / comms / capture / admin.”

25–50s

Kill

“Cut list on screen.”

50–70s

CTA

Comment CAPACITY.

Edit notes

Don’t trash employer. Professional tone.

Capacity as craft.

Truth check

No employer secrets
Cut list explicit

Solo Stack · 5 / 10 · Script 25

Full production script · Solo Stack 05

286 pages from 30 videos—without becoming a librarian.

Vault ingest as a system: schema, summaries, links. Cortex/Brain as proof of personal AI OS.

12–16 min Vault UI Hire · knowledge systems builder

On-camera hygieneNever show .env values, OAuth client secrets, access tokens, or private vault contents. Show file names, redacted configs, and the decision framework. If a secret appears, cut it.

Hire signalThis pillar sells the operating system of one AI-native product designer/builder — judgment, structure, and boundaries — not tool cosplay.

Steal-this value

Atomic notes

One idea per page.

Provenance

Always link source video/id.

Schema

People / concepts / techniques.

Don’t boil

Ingest for decisions, not completionism.

The packaging

Title AHow I Turn Transcripts Into an Agent Wiki

Title BIngest Schema So You Don’t Drown

CTAComment WIKI for the schema

Prep

Demo vault with public transcripts only
Schema diagram

Story spine

1Problem

2Schema

3Ingest prompt

4Query proof

5Close

Full run of show

0:00–0:25

Open

“Raw transcripts aren’t knowledge. Without a schema you become a librarian with worse search.”

0:25–2:00

Schema

“Source → claims → concepts → people → reusable templates. Provenance on everything.”

2:00–3:30

Ingest

Design an ingest schema for YouTube transcripts into a personal wiki. Fields for source, claims, concepts, quotes (short), links. Output folder conventions + a single ingest prompt. No copyrighted full-transcript dumps in the answer—structure only.

3:30–4:40

Query

“Ask the vault a decision question—show the cited note, not a vibes answer.”

4:40–5:30

Close

“Personal AI OS is a product. Comment WIKI.”

Natural lines

On Brain

“Meta-proof of the solo stack—not the channel subject.”

60–75s cut-down

0–3s

Hook

“Transcripts ≠ knowledge.”

3–25s

Schema

“Source → claims → concepts.”

25–50s

Proof

“Cited answer.”

50–70s

CTA

Comment WIKI.

Edit notes

Public sources only on camera.

Knowledge system craft.

Truth check

Schema explicit
Citations shown

Solo Stack · 6 / 10 · Script 26

Full production script · Solo Stack 06

I skip the agency ping-pong.

Tokens → component → PR in one seat. Hire signal: designer who ships.

11–15 min Tokens → UI Hire · product designer-engineer

On-camera hygieneNever show .env values, OAuth client secrets, access tokens, or private vault contents. Show file names, redacted configs, and the decision framework. If a secret appears, cut it.

Hire signalThis pillar sells the operating system of one AI-native product designer/builder — judgment, structure, and boundaries — not tool cosplay.

Steal-this value

Tokens

Color/type/space before screens.

One composition

Hero rules still apply.

Implement

Same person ships.

Review

Accessibility + states.

The packaging

Title ADesign to Code With No Handoff

Title BTokens First, Then Components

CTAComment HANDOFF for the checklist

Prep

Design tokens file
One component to build

Story spine

1Anti-handoff

2Token pass

3Build

4States

5Close

Full run of show

0:00–0:25

Open

“Handoff is where quality dies. I design and ship—so the intent doesn’t leak between vendors.”

0:25–1:40

Tokens

“If tokens aren’t real, ‘design’ is a screenshot.”

1:40–3:40

Build

Implement a UI section from this token set and brief. Preserve existing design system. Include hover/focus/empty states. No new dependency sprawl. List files, implement, lint.

3:40–4:40

States

“Empty, loading, error—enterprise craft.”

4:40–5:20

Close

“Hire one owner. Comment HANDOFF.”

Natural lines

On Figma

“Optional artifact—not a relay baton.”

60–75s cut-down

0–3s

Hook

“No ping-pong.”

3–20s

Tokens

“Design is code-adjacent.”

20–50s

Ship

“Component with states.”

50–70s

CTA

Comment HANDOFF.

Edit notes

Show working UI.

Designer-builder identity.

Truth check

Working component
States covered

Solo Stack · 7 / 10 · Script 27

Full production script · Solo Stack 07

Auth that won’t embarrass you in production.

RLS + Stripe entitlement mindset in a tight lesson. Secrets stay redacted.

12–15 min Policies Hire · production-minded full-stack

On-camera hygieneNever show .env values, OAuth client secrets, access tokens, or private vault contents. Show file names, redacted configs, and the decision framework. If a secret appears, cut it.

Hire signalThis pillar sells the operating system of one AI-native product designer/builder — judgment, structure, and boundaries — not tool cosplay.

Steal-this value

Default deny

Policies are allowlists.

User-scoped rows

auth.uid() patterns.

Service role

Server only.

Entitlement

Paid flags from webhooks, not UI.

The packaging

Title ASupabase RLS in 12 Minutes (The Parts That Matter)

Title BStop Shipping Apps That Trust the Client

CTAComment RLS for the checklist

Prep

Demo Supabase project
Policy SQL on screen
No production data

Story spine

1Threat

2Checklist

3Write policies

4Test negative

5Close

Full run of show

0:00–0:25

Open

“If the client can read everyone’s rows, you don’t have an app—you have a breach waiting.”

0:25–1:50

Checklist

“Default deny · user scope · no service role in browser · test as two users · Stripe entitlement separate.”

1:50–3:30

Implement

Draft RLS policies for tables: profiles, projects, project_members. Assume Supabase auth. Explain each policy. Include a negative test plan. No real project URLs or keys.

3:30–4:40

Negative test

“User B must not see User A. Show the fail.”

If it leaks, fix before ending—don’t ship the thumbnail of a green build.

4:40–5:30

Close

“Production taste is the hire. Comment RLS.”

Natural lines

On speed

“Fast and open is not a flex.”

60–75s cut-down

0–3s

Hook

“Client trust is a bug.”

3–20s

Rules

“Default deny.”

20–50s

Test

“User B denied.”

50–70s

CTA

Comment RLS.

Edit notes

Test data only.
Never show service role key.

Security as product craft.

Truth check

Negative test shown
No keys

Solo Stack · 8 / 10 · Script 28

Full production script · Solo Stack 08

Zero AI on the sales call—here’s why.

Boundaries make the brand trustworthy. Automate drafts; never the close.

9–13 min Rubric Hire · trustworthy operator

On-camera hygieneNever show .env values, OAuth client secrets, access tokens, or private vault contents. Show file names, redacted configs, and the decision framework. If a secret appears, cut it.

Hire signalThis pillar sells the operating system of one AI-native product designer/builder — judgment, structure, and boundaries — not tool cosplay.

Steal-this value

Draft ≠ send

AI may draft; human sends.

Discovery calls

Live judgment only.

Pricing

Human owns numbers.

Apologies/legal

Human.

Fake presence

No avatar pretending to be a call.

The packaging

Title AWhat I Refuse to Automate

Title BZero AI on the Sales Call

CTAComment HUMAN for the boundary list

Prep

Boundary slate
Call rubric

Story spine

1Burn story

2Boundary list

3Rubric

4Where AI helps

5Close

Full run of show

0:00–0:25

Open

“Buyers who smell a bot feel tricked. That kills close energy faster than a polished draft helps.”

0:25–2:00

Boundaries

“I automate research, drafting, scheduling logistics. I refuse: live sales conversation, final Instantly personalization without review, fake ‘I recorded this for you’ avatars cold.”

2:00–3:20

Call rubric

Create a 20-minute discovery-call rubric: goals, questions, disqualify signals, next-step options. No manipulative tactics. Straight operator tone.

3:20–4:20

AI lane

“AI prepares the brief. I run the call.”

4:20–5:10

Close

“Trust is the product. Comment HUMAN.”

Natural lines

On Instantly

“Human pass on line one—always.”

60–75s cut-down

0–3s

Hook

“Zero AI on the call.”

3–25s

List

“Draft ≠ send.”

25–50s

Rubric

“Discovery structure.”

50–70s

CTA

Comment HUMAN.

Edit notes

No client call recordings without permission.

Varun/LoopSuit zero-AI-in-sales principle.

Truth check

Boundaries explicit
Rubric shipped

Solo Stack · 9 / 10 · Script 29

Full production script · Solo Stack 09

The stack you’re paying for—and the leaks.

Whiteboard the multi-vendor tax. This is LoopSuit’s character thesis as a teachable artifact.

10–14 min Whiteboard Hire · systems thinker / studio lead

On-camera hygieneNever show .env values, OAuth client secrets, access tokens, or private vault contents. Show file names, redacted configs, and the decision framework. If a secret appears, cut it.

Hire signalThis pillar sells the operating system of one AI-native product designer/builder — judgment, structure, and boundaries — not tool cosplay.

Steal-this value

Vendor tax

Strategy → design → build → QA → launch.

Leak types

Intent, time, quality, blame.

One owner

Design+build collapses leaks.

Not anti-people

Anti-relay structure.

The packaging

Title AOne Operator vs Five Vendors: The Cost Map

Title BHandoff Is Where Your Budget Goes to Die

CTAComment HANDOFFCOST for the table

Prep

Whiteboard or FigJam
Cost table template

Story spine

1Map vendors

2Leak types

3Fill table

4Solo alternative

5Close

Full run of show

0:00–0:25

Open

“You’re not paying for five talents. You’re paying for four handoffs.”

0:25–2:00

Leak types

“Intent leak · calendar leak · quality leak · accountability leak. Name them or you can’t kill them.”

2:00–3:30

Table

Create a one-page cost map table: stage · typical vendor · handoff artifact · failure mode · cost signal · solo-stack alternative. No fake dollar claims—use qualitative + ‘measure your own rate’ guidance.

3:30–4:30

Solo alternative

“One operator who designs and ships. That’s the offer.”

4:30–5:20

Close

“Comment HANDOFFCOST. Hire the collapse.”

Natural lines

On tone

“Not dunking on freelancers—dunking on relay structure.”

60–75s cut-down

0–3s

Hook

“Four handoffs.”

3–25s

Leaks

“Intent/time/quality/blame.”

25–50s

Table

“Map on screen.”

50–70s

CTA

Comment HANDOFFCOST.

Edit notes

No fabricated agency invoices.

Core LoopSuit thesis content.

Truth check

Table explicit
No fake $

Solo Stack · 10 / 10 · Script 30

Full production script · Solo Stack 10

Don’t customize everything. Customize this.

Opinionated shadcn allowlist. Taste + speed for product teams.

9–13 min Components Hire · product designer with code taste

On-camera hygieneNever show .env values, OAuth client secrets, access tokens, or private vault contents. Show file names, redacted configs, and the decision framework. If a secret appears, cut it.

Hire signalThis pillar sells the operating system of one AI-native product designer/builder — judgment, structure, and boundaries — not tool cosplay.

Steal-this value

Compose not theme-spam

Tokens > endless variants.

Allowlist

Button, Input, Dialog, Sheet, Table, Form, Toast…

Denylist

Novelty components that fight the system.

Accessibility

Focus states non-negotiable.

The packaging

Title Ashadcn Decisions That Actually Matter

Title BMy Allowlist / Denylist for Components

CTAComment SHADCN for the allowlist

Prep

Storybook or demo app
Allowlist slate

Story spine

1Problem

2Allowlist

3Live picks

4Customize rules

5Close

Full run of show

0:00–0:25

Open

“Most teams don’t have a design system problem. They have a decision problem.”

0:25–2:00

Allowlist

“Customize: brand tokens, button hierarchy, form patterns, empty states. Don’t customize: every radius and shadow for sport.”

2:00–3:30

Live

Produce an opinionated shadcn allowlist/denylist for a B2B SaaS. For each allow: when to use. For each deny: what to use instead. Assume Tailwind + existing tokens.

3:30–4:20

Rule

“If removing a card doesn’t hurt understanding, delete the card.”

4:20–5:10

Close

“Taste is a hireable skill. Comment SHADCN.”

Natural lines

On Inter

“Defaults without choice read as no designer.”

60–75s cut-down

0–3s

Hook

“Decision problem.”

3–25s

Allowlist

“Customize the few.”

25–50s

Live

“List on screen.”

50–70s

CTA

Comment SHADCN.

Edit notes

Show real components.

Design-system judgment.

Truth check

Allowlist explicit
Working UI

Money Machines · 01 · Script 31

Full production script · Money Machines · 01 · Script 31

This level flipped three times—here’s the logic.

Teach a readable rule for color-flip / level logic without selling tips. Product proof: you can explain market systems and encode them.

12–15 min TradingView + Pine Not advice · systems lesson Hire · fintech systems thinker

On-camera hygiene · Money MachinesNot financial advice. No live account sizes, API keys, broker logins, or unverifiable ROI. Show logic, failure modes, and product systems. Blur P&L if it appears. Axiom/TradingView are proof of systems thinking—not tip-selling.

Hire signalA fintech/ops buyer should think: he can model risk, explain systems without hype, and ship the product surface around money workflows.

Steal-this value

Rule > vibe

Define flip conditions in plain language.

Encode it

Show the Pine/condition—not mystique.

Failure mode

When the rule does not apply.

Product angle

This is how you’d expose a rule in a UI.

Packaging

Title AWhy This Gold Level Flipped Three Times

Title BColor-Flip Logic Without the Guru Voice

CTAComment FLIP for the rule card

Prep

Chart replay with no account balance
Rule card slate
Disclaimer slate

Spine

1Receipt

2Rule

3Encode

4Fail case

5Close

Full run of show

0:00–0:25

Receipt

Replay three flips. No P&L.

“Same level. Three flips. I’m not giving you a trade—I’m showing how a system defines a flip so a product can explain it.”

0:25–2:00

Rule card

“A flip needs: prior acceptance, break condition, retest behavior, invalidation. If you can’t write those four, you don’t have a rule—you have a story.”

2:00–3:40

Encode

Help me write a plain-language rule card + pseudocode for a 'level color flip' concept for education. Include: inputs, flip condition, invalidation, what NOT to claim. Not financial advice. No guaranteed outcomes. No broker API keys.

3:40–4:40

Fail case

“Here’s a bar that looks like a flip and isn’t—because invalidation hit. Honesty is the product.”

4:40–5:30

Close

“Systems, not tips. Comment FLIP. Hire the person who can explain and encode.”

Natural lines

On advice

“If it sounds like ‘buy now,’ cut it.”

60–75s cut

0–3s

Hook

“Three flips. One rule.”

3–25s

Four parts

“Accept, break, retest, invalidate.”

25–50s

Encode

“Pseudocode on screen.”

50–70s

CTA

Comment FLIP.

Edit notes

Not advice slate.
No live orders.

Axiom-adjacent education; products as proof.

Truth check

Disclaimer present
No P&L flex
Rule explicit

Money Machines · 02 · Script 32

Full production script · Money Machines · 02 · Script 32

A 0–100 score isn’t a crystal ball—it’s a stack of models.

Demystify composite scores. Hire signal: you design explainable fintech UX, not magic numbers.

11–15 min Score UI Explainability Hire · product + quant taste

On-camera hygiene · Money MachinesNot financial advice. No live account sizes, API keys, broker logins, or unverifiable ROI. Show logic, failure modes, and product systems. Blur P&L if it appears. Axiom/TradingView are proof of systems thinking—not tip-selling.

Hire signalA fintech/ops buyer should think: he can model risk, explain systems without hype, and ship the product surface around money workflows.

Steal-this value

Decompose

List contributing factors.

Weights

Say what’s heavier—and why.

Uncertainty

Show when score is weak.

UI

Explainability panel > naked number.

Packaging

Title AWhat’s Inside a 0–100 Trading Score

Title BExplainable Scores Beat Magic Numbers

CTAComment SCORE for the anatomy card

Prep

Axiom-like score UI (demo/sample)
Anatomy slate

Spine

1Naked number problem

2Anatomy

3UI pattern

4Ship explainer

5Close

Full run of show

0:00–0:25

Open

“A big number without anatomy is a slot machine. Here’s how I’d explain a composite score so a desk can trust—or reject—it.”

0:25–2:10

Anatomy

“Factors · weights · agreement · disagreement · data freshness · ‘do not treat as advice.’ If any of those are missing, the product is lying by omission.”

2:10–3:30

Prompt

Design an explainability panel for a 0–100 composite score in a fintech UI. Include: factor list, weight visualization, disagreement state, stale-data state, disclaimer copy. No fabricated backtest returns. Educational product UX only.

3:30–5:00

Ship

Implement a demo ScoreExplain panel in this repo with mock factors. Accessible, clear hierarchy, disclaimer visible. List files, implement.

5:00–5:50

Close

“Explainability is the hire. Comment SCORE.”

Natural lines

On hype

“If I can’t open the hood, I don’t post the number.”

60–75s cut

0–3s

Hook

“Not a crystal ball.”

3–25s

Anatomy

“Factors, weights, disagreement.”

25–50s

Ship

“Explain panel.”

50–70s

CTA

Comment SCORE.

Edit notes

Mock data OK.

VeritasGuard-adjacent explainability craft.

Truth check

Disclaimer
No fake returns
Panel shipped

Money Machines · 03 · Script 33

Full production script · Money Machines · 03 · Script 33

I shipped a look-ahead bug. Catching it on camera.

Mistake content with a technical checklist. Hire signal: you debug honestly and protect users from false edges.

10–14 min Pine diff Integrity Hire · trustworthy builder

On-camera hygiene · Money MachinesNot financial advice. No live account sizes, API keys, broker logins, or unverifiable ROI. Show logic, failure modes, and product systems. Blur P&L if it appears. Axiom/TradingView are proof of systems thinking—not tip-selling.

Hire signalA fintech/ops buyer should think: he can model risk, explain systems without hype, and ship the product surface around money workflows.

Steal-this value

Future leak

Using data not available at bar close.

Repaint

Visuals that change history.

Test

Bar replay + print debugging.

Product duty

Don’t ship false confidence.

Packaging

Title AThe Look-Ahead Bug That Cost Me a Session

Title BPine Checklist: Stop Lying to Yourself

CTAComment LOOKAHEAD for the checklist

Prep

Before/after script
Replay

Spine

1Confession

2Mechanics

3Fix

4Checklist

5Close

Full run of show

0:00–0:25

Confession

“I shipped a look-ahead bug. The chart looked genius. The live session didn’t. Here’s the diff.”

0:25–2:00

Mechanics

“If your series peeks at future bars—or repaints—your backtest is fan fiction.”

2:00–3:30

Fix

Explain look-ahead / repaint risks in Pine-like logic and produce a defensive checklist for indicator authors. Educational. No ‘guaranteed strategy.’ Include how to verify with replay.

3:30–4:30

Checklist on screen

“Steal this. Tape it above the monitor.”

4:30–5:20

Close

“Integrity is a product feature. Comment LOOKAHEAD.”

Natural lines

On ego

“The win that needs a lie isn’t a win.”

60–75s cut

0–3s

Hook

“Look-ahead cost a session.”

3–25s

Why

“Future leak / repaint.”

25–50s

Fix

“Checklist.”

50–70s

CTA

Comment LOOKAHEAD.

Edit notes

Show the bug humbly.

Mistake → trust content.

Truth check

Bug explained
Checklist explicit

Money Machines · 04 · Script 34

Full production script · Money Machines · 04 · Script 34

London hours only—why the rest is noise for this system.

Session filters as product logic. Constraint is a feature.

9–13 min Session overlay Systems Hire · productized trading systems

On-camera hygiene · Money MachinesNot financial advice. No live account sizes, API keys, broker logins, or unverifiable ROI. Show logic, failure modes, and product systems. Blur P&L if it appears. Axiom/TradingView are proof of systems thinking—not tip-selling.

Hire signalA fintech/ops buyer should think: he can model risk, explain systems without hype, and ship the product surface around money workflows.

Steal-this value

Define session

TZ + window explicit.

Why

Liquidity/behavior hypothesis—labeled as such.

UI

Show ‘outside window’ state.

Honesty

Not ‘markets are closed to opportunity’—‘this system doesn’t trade it.’

Packaging

Title AWhy This Gold System Ignores Half the Day

Title BKillzones as Product Constraints

CTAComment SESSION for the filter rules

Prep

Session overlay
Rule slate

Spine

1Noise

2Define

3Encode

4UI state

5Close

Full run of show

0:00–0:25

Open

“If your system is session-specific, say it. Pretending 24h edge is how you burn trust.”

0:25–1:50

Define

“Window · timezone · what happens outside · why we chose it (hypothesis, not prophecy).”

1:50–3:20

Encode

Write session-filter rules for an educational gold system UI: fields, outside-window UX copy, logging. Not financial advice. No promises.

3:20–4:20

UI

“Outside killzone should look disabled—not silently wrong.”

4:20–5:10

Close

“Constraints are product. Comment SESSION.”

Natural lines

On FOMO

“Sitting out is a feature.”

60–75s cut

0–3s

Hook

“Half the day ignored—on purpose.”

3–25s

Define

“Window + TZ.”

25–50s

UI

“Disabled outside.”

50–70s

CTA

Comment SESSION.

Edit notes

Label hypothesis vs fact.

Product constraints.

Truth check

Window explicit
No advice

Money Machines · 05 · Script 35

Full production script · Money Machines · 05 · Script 35

Signal without staring at screens.

Alert pipeline architecture—dedupe, schema, quiet hours. Cross-link Expo alerts Ship It.

11–15 min Webhook → Telegram Architecture Hire · full-stack systems

On-camera hygiene · Money MachinesNot financial advice. No live account sizes, API keys, broker logins, or unverifiable ROI. Show logic, failure modes, and product systems. Blur P&L if it appears. Axiom/TradingView are proof of systems thinking—not tip-selling.

Hire signalA fintech/ops buyer should think: he can model risk, explain systems without hype, and ship the product surface around money workflows.

Steal-this value

Schema

alert_id, symbol, reason, time.

Dedupe

Same id once.

Transport

Bot token server-only.

Human copy

Deterministic templates.

Packaging

Title AChart to Telegram Without Alert Spam

Title BThe Alert Architecture I’d Ship

CTAComment ALERTARCH for the diagram

Prep

Test bot
Redacted token
Fixture payload

Spine

1Receipt

2Arch

3Build

4Dedupe

5Close

Full run of show

0:00–0:25

Buzz

Phone/Telegram receipt.

“One alert. Not twelve. Architecture did that.”

0:25–1:40

Diagram

“Signal → validate → dedupe → template → send → log.”

1:40–3:30

Build

Design a chart→Telegram alert path: Zod schema, idempotency, server-only secrets, template copy, failure taxonomy. No live trading advice. Placeholders for tokens only.

3:30–4:30

Dedupe drill

“Same payload twice → one message.”

If two messages, fix before ending.

4:30–5:20

Close

“Delivery systems are the product. Comment ALERTARCH.”

Natural lines

On tokens

“Bot token never on camera.”

60–75s cut

0–3s

Hook

“One buzz.”

3–20s

Arch

“Validate→dedupe→send.”

20–50s

Drill

“No spam.”

50–70s

CTA

Comment ALERTARCH.

Edit notes

Test channel only.

Same craft as Expo alerts Ship It.

Truth check

Token redacted
Dedupe shown

Money Machines · 06 · Script 36

Full production script · Money Machines · 06 · Script 36

GC vs XAUUSD—stop mixing them in your head.

Instrument literacy as product UX. Clear comparison UI.

9–13 min Comparison UI Education Hire · fintech UX clarity

On-camera hygiene · Money MachinesNot financial advice. No live account sizes, API keys, broker logins, or unverifiable ROI. Show logic, failure modes, and product systems. Blur P&L if it appears. Axiom/TradingView are proof of systems thinking—not tip-selling.

Hire signalA fintech/ops buyer should think: he can model risk, explain systems without hype, and ship the product surface around money workflows.

Steal-this value

Different instruments

Contract vs spot CFD/FX-like.

UI duty

Label venue, unit, session.

DM pattern

Beginners confuse symbols—design for that.

No tip

Clarity ≠ signal.

Packaging

Title AGC vs XAUUSD: What Your Product Must Make Obvious

Title BStop Mixing Futures and Spot in the UI

CTAComment INSTRUMENT for the map

Prep

Comparison table
Demo UI

Spine

1Confusion

2Map

3UI

4Ship

5Close

Full run of show

0:00–0:25

Open

“If your product shows both and doesn’t explain the difference, you created support tickets and bad decisions.”

0:25–2:00

Map

“Symbol · venue · unit · typical session · what a ‘point’ means · what your score refers to.”

2:00–3:30

Ship

Design a comparison component: GC vs XAUUSD for an educational fintech UI. Fields above. Disclaimer. No trade recommendations.

3:30–4:30

Implement

Implement InstrumentCompare demo with mock data and clear labels. List files, implement.

4:30–5:20

Close

“Clarity is kindness. Comment INSTRUMENT.”

Natural lines

On DMs

“Most confused DMs are product failures.”

60–75s cut

0–3s

Hook

“Stop mixing them.”

3–25s

Map

“Symbol/venue/unit.”

25–50s

UI

“Compare component.”

50–70s

CTA

Comment INSTRUMENT.

Edit notes

Educational only.

Product clarity.

Truth check

Map explicit
No advice

Money Machines · 07 · Script 37

Full production script · Money Machines · 07 · Script 37

If I can’t show the failure modes, I don’t post the win.

Honesty rubric for any performance content. Trust magnet for serious buyers.

10–14 min Losing week Integrity Hire · credible systems person

On-camera hygiene · Money MachinesNot financial advice. No live account sizes, API keys, broker logins, or unverifiable ROI. Show logic, failure modes, and product systems. Blur P&L if it appears. Axiom/TradingView are proof of systems thinking—not tip-selling.

Hire signalA fintech/ops buyer should think: he can model risk, explain systems without hype, and ship the product surface around money workflows.

Steal-this value

Show losers

Or don’t show winners.

Costs

Fees/slippage assumptions stated.

Sample

Small samples aren’t strategy.

Look-ahead

Banned.

Audience

Serious buyers punish fakery.

Packaging

Title ABacktest Honesty Rules I Won’t Break

Title BShow the Losing Week or Don’t Post

CTAComment HONEST for the rubric

Prep

Losing period chart
Rubric slate

Spine

1Win culture fail

2Rubric

3Apply

4Content rule

5Close

Full run of show

0:00–0:25

Open

Show a losing stretch first.

“If the channel only posts green, it’s marketing—not education.”

0:25–2:10

Rubric

“Disclose sample · costs · regime · failure modes · what would falsify the claim. Miss one → don’t publish.”

2:10–3:30

Prompt

Create a Backtest/Performance Honesty Rubric for creators and fintech PMs. Checklist + red flags + publish/no-publish gate. No fabricated stats.

3:30–4:30

Apply

“I’m running today’s example through the gate on camera.”

4:30–5:20

Close

“Credibility compounds. Comment HONEST.”

Natural lines

On vanity

“Green screenshots are carbs.”

60–75s cut

0–3s

Hook

“Losing week first.”

3–25s

Rubric

“Disclose or don’t post.”

25–50s

Gate

“Publish/no-publish.”

50–70s

CTA

Comment HONEST.

Edit notes

Real-looking demo OK if labeled.

Anti-fake-proof brand rule.

Truth check

Rubric explicit
Loser shown

Money Machines · 08 · Script 38

Full production script · Money Machines · 08 · Script 38

Money content pulls intent—if you show systems, not tips.

Meta content strategy: why fintech proof attracts hiring buyers. Bridge Money Machines → LoopSuit offer.

9–13 min Comments/DMs redacted Strategy Hire · positioning clarity

On-camera hygiene · Money MachinesNot financial advice. No live account sizes, API keys, broker logins, or unverifiable ROI. Show logic, failure modes, and product systems. Blur P&L if it appears. Axiom/TradingView are proof of systems thinking—not tip-selling.

Hire signalA fintech/ops buyer should think: he can model risk, explain systems without hype, and ship the product surface around money workflows.

Steal-this value

Tips attract tip-seekers

Wrong avatar.

Systems attract operators

Right avatar.

Proof stack

UI + logic + honesty.

CTA

Clarity Session / build—not ‘signals club.’

Packaging

Title AWhy Fintech Content Attracts Real Buyers

Title BSystems Content vs Tip Content

CTAComment INTENT for the content map

Prep

Redacted comment screenshots
Map slate

Spine

1Wrong audience

2Right proof

3Map

4CTA design

5Close

Full run of show

0:00–0:25

Open

“If you teach entries, you get entry junkies. If you show systems, you get people who buy systems.”

0:25–2:00

Proof types

“Explainable score · alert architecture · instrument clarity · honesty rubric. That’s buyer bait.”

2:00–3:20

Map

Create a content→buyer map for a productized AI studio using fintech proof: content type · viewer · desired buyer action · CTA. No fake engagement stats.

3:20–4:20

CTA

“Soft teach five times. Then Clarity Session. Never ‘join my signals.’”

4:20–5:10

Close

“Comment INTENT. Products as proof—LoopSuit as the hire.”

Natural lines

On brand

“Axiom is proof. LoopSuit is the company.”

60–75s cut

0–3s

Hook

“Systems, not tips.”

3–25s

Proof

“Explainability + architecture.”

25–50s

Map

“Content→buyer.”

50–70s

CTA

Comment INTENT.

Edit notes

Redact people in comments.

Pillar thesis closer.

Truth check

Map explicit
No tip-selling

Client Work · 01 · Script 39

Full production script · Client Work · 01 · Script 39

They asked for ‘just a small change.’ It wasn’t.

Scope control as senior commercial craft. Anonymized. Template the audience can steal.

10–14 min Redacted email Commercial Hire · operator who protects delivery

On-camera hygiene · Client WorkAnonymize names, amounts, and identifying details. No screenshots of private threads without redaction. Teach the template; don’t dunk on a client for sport.

Hire signalA founder should think: he runs commercial conversations like a senior operator—scope, pricing, boundaries—not a desperate bidder.

Steal-this value

Name the delta

Old vs new outcome.

Impact

Design/eng/test/risk.

Options

Absorb / change order / defer.

Tone

Calm, firm, helpful.

Write it once

Template > improvising angry.

Packaging

Title AThe Scope Fight Reply I Actually Send

Title B‘Small Change’ Is How Projects Die

CTAComment SCOPE for the reply template

Prep

Fully redacted thread
Template slate

Spine

1Incident

2Diagnosis

3Template

4Live rewrite

5Close

Full run of show

0:00–0:25

Open

Redacted email.

“‘Tiny tweak.’ It changed the data model. Here’s the reply that saved the relationship and the timeline.”

0:25–2:00

Diagnosis

“Scope fights are usually undefined acceptance criteria—not evil clients.”

2:00–3:30

Template

Write a scope-change reply template with: mirror request · impact · options (absorb/CO/defer) · question for decision · tone guidelines. No threats. Senior operator voice.

3:30–4:40

Rewrite live

“Watch adjectives leave. Watch options arrive.”

4:40–5:30

Close

“Hire people who can hold scope without drama. Comment SCOPE.”

Natural lines

On dunking

“Teach the system—don’t ratio a client.”

60–75s cut

0–3s

Hook

“Not a small change.”

3–25s

Options

“Absorb / CO / defer.”

25–50s

Template

“Reply on screen.”

50–70s

CTA

Comment SCOPE.

Edit notes

Heavy redaction.

Commercial maturity.

Truth check

Anonymized
Template explicit

Client Work · 02 · Script 40

Full production script · Client Work · 02 · Script 40

Paid diagnosis beats free calls that go nowhere.

AI Clarity Session as lead offer—pricing psychology + packaging. Exact published price OK if on site.

10–14 min Offer page Packaging Hire · offer designer / closer

On-camera hygiene · Client WorkAnonymize names, amounts, and identifying details. No screenshots of private threads without redaction. Teach the template; don’t dunk on a client for sport.

Hire signalA founder should think: he runs commercial conversations like a senior operator—scope, pricing, boundaries—not a desperate bidder.

Steal-this value

Paid filters

Serious buyers self-select.

Deliverable

Ranked opportunities—even if they don’t hire you.

Guarantee framing

Only state what’s true on site.

Free calls

Train tire-kickers.

Content bridge

Teach → paid diagnostic.

Packaging

Title AWhy I Charge for the Diagnosis

Title BPaid Clarity Session Packaging

CTAComment CLARITY for the offer map

Prep

loopsuitai.com offer copy (public)
Offer map slate

Spine

1Free-call trap

2Offer anatomy

3Page teardown

4Objection handling

5Close

Full run of show

0:00–0:25

Open

“Free calls filled with ‘just exploring’ are a tax on builders. Paid diagnosis is the filter and the product.”

0:25–2:10

Anatomy

“Promise · who it’s for · what they leave with · price · refund/guarantee only if real · next step. Don’t hide the price if it’s published.”

2:10–3:30

Prompt

Create an offer-map one-pager for a paid AI Clarity Session style diagnostic. Include ICP, deliverables, agenda outline, disqualify list, FAQ objections. Use only claims that are generally true for paid diagnostics; mark placeholders for price/guarantee to be filled from the live site.

3:30–4:30

Objections

“‘Why pay if I might not hire you?’ Because you leave with a ranked map either way.”

4:30–5:20

Close

“Comment CLARITY. Soft content, hard offer when earned.”

Natural lines

On price

“Say the real number from the site—don’t invent discounts on camera.”

60–75s cut

0–3s

Hook

“Paid diagnosis.”

3–25s

Anatomy

“Promise → deliverable → price.”

25–50s

Map

“Offer one-pager.”

50–70s

CTA

Comment CLARITY.

Edit notes

Match live site claims.

Lead offer packaging.

Truth check

No fake guarantees
Offer map explicit

Client Work · 03 · Script 41

Full production script · Client Work · 03 · Script 41

What I changed in contracts after a mid-build ghost.

Kill-fee / pause language as productized commercial hygiene. Anonymized story → stealable clause map—not revenge content.

10–14 min Redacted clause Commercial Hire · operator who protects cashflow

On-camera hygiene · Client WorkAnonymize names, amounts, and identifying details. No screenshots of private threads without redaction. Teach the template; don’t dunk on a client for sport.

Hire signalA founder should think: he runs commercial conversations like a senior operator—scope, pricing, boundaries—not a desperate bidder.

Steal-this value

Define pause

What counts as silence / non-response.

Kill vs pause

Refundable work vs earned fees.

Artifacts

What you hand over if engagement ends.

Tone

Protect both parties; no courtroom voice on camera.

Write once

Clause map > improvising after panic.

Packaging

Title AThe Clause I Added After a Client Ghosted

Title BKill-Fee Language Without the Drama

CTAComment KILLFEE for the clause map

Prep

Fully anonymized timeline slate
Clause map (no live contract scan with names)
Disclaimer: not legal advice

Spine

1Incident

2What broke

3Clause map

4Live rewrite

5Close

Full run of show

0:00–0:25

Incident

Timeline only—no names.

“Mid-build silence. I had momentum and no decision. Here’s what I changed in the commercial system after that—not the rant.”

0:25–2:00

Diagnosis

“Ghosting is usually unclear decision rights + no pause protocol. If your SOW has no silence rule, you volunteered for free anxiety.”

2:00–3:40

Clause map

Draft a plain-language kill-fee / pause clause MAP for productized build work (not a jurisdiction-specific legal contract). Include: definition of non-response, pause trigger, earned fees, deliverable freeze, restart fee, soft tone guidelines. Label clearly: NOT legal advice — have counsel review. No client names.

3:40–4:40

Rewrite

“Watch fear leave the sentence. Watch options arrive: pause · kill · restart.”

4:40–5:30

Close

“Hire people who protect delivery and cashflow without becoming the villain. Comment KILLFEE. Not legal advice—steal the structure.”

Natural lines

On revenge

“If the video needs a villain, you’re making content—not systems.”

On counsel

“Structure here. Lawyer for the jurisdiction.”

60–75s cut

0–3s

Hook

“Ghosted mid-build.”

3–25s

Gap

“No silence protocol.”

25–50s

Map

“Pause / kill / restart.”

50–70s

CTA

Comment KILLFEE.

Edit notes

Heavy anonymization.
On-screen ‘not legal advice’ slate.

Commercial systems after failure.

Truth check

Anonymized
Not legal advice stated
Clause map explicit

Client Work · 04 · Script 42

Full production script · Client Work · 04 · Script 42

Cheap clients need more updates, not fewer.

Daily status as trust infrastructure. Silence looks like progress to you and abandonment to them.

9–13 min Status template Ops Hire · delivery lead energy

On-camera hygiene · Client WorkAnonymize names, amounts, and identifying details. No screenshots of private threads without redaction. Teach the template; don’t dunk on a client for sport.

Hire signalA founder should think: he runs commercial conversations like a senior operator—scope, pricing, boundaries—not a desperate bidder.

Steal-this value

Cadence

What ships every day / week.

Format

Done · blocked · next · decision needed.

Channel

Where it lives (email/Slack/Notion)—pick one.

Cheap ≠ less care

Lower budget often = higher anxiety.

Async default

Status reduces meetings.

Packaging

Title ADaily Status Beats Silent Genius

Title BThe Cadence That Saved My Client Relationships

CTAComment STATUS for the template

Prep

Blank status template slate
Redacted sample day
Timer optional

Spine

1Silent genius myth

2Anxiety math

3Template

4Live fill

5Close

Full run of show

0:00–0:25

Open

“I used to go dark when I was deep in build. They assumed I vanished. Daily status fixed more relationships than prettier demos.”

0:25–1:50

Anxiety math

“Uncertainty compounds faster than bugs. If budget is tight, they need more signal—not less.”

1:50–3:20

Template

Write a daily client status template for productized AI/build work. Sections: shipped today · in progress · blocked · decision needed (owner + due) · tomorrow plan · risks. Keep it under 120 words when filled. Calm operator tone. No filler praise.

3:20–4:30

Live fill

Fill with fake anonymized day.

“Watch how decisions surface. That’s the point—not the diary.”

4:30–5:15

Close

“Silent genius is a junior flex. Comment STATUS.”

Natural lines

On oversharing

“Status is decisions and risk—not a novel.”

60–75s cut

0–3s

Hook

“More updates, not fewer.”

3–25s

Why

“Anxiety compounds.”

25–50s

Template

“Done / blocked / decide.”

50–70s

CTA

Comment STATUS.

Edit notes

Keep sample anonymized.
Show filled vs blank.

Delivery trust systems.

Truth check

Template explicit
No client dunk

Client Work · 05 · Script 43

Full production script · Client Work · 05 · Script 43

How a platform gig became a retained system.

Upsell path from marketplace job → productized retainer. Teach the ladder; anonymize the client.

11–15 min Timeline slate GTM Hire · commercial product thinker

On-camera hygiene · Client WorkAnonymize names, amounts, and identifying details. No screenshots of private threads without redaction. Teach the template; don’t dunk on a client for sport.

Hire signalA founder should think: he runs commercial conversations like a senior operator—scope, pricing, boundaries—not a desperate bidder.

Steal-this value

Proof first

Ship a vertical slice they can feel.

Name the system

Turn tasks into a named operating loop.

Retain the outcome

Sell cadence + ownership, not hours.

Exit platform risk

Move communication off-platform when allowed.

Boundary

Don’t trash Upwork—show the graduation path.

Packaging

Title AUpwork → Retained Without Looking Desperate

Title BThe Ladder Out of Marketplace Work

CTAComment LADDER for the upsell path

Prep

Anonymized timeline (week 1 → retained)
Offer ladder slate
Public portfolio only

Spine

1Receipt

2Ladder

3Scripts

4Risks

5Close

Full run of show

0:00–0:25

Receipt

“Started as a scoped gig. Became a retained system. Here’s the ladder—not the flex screenshot with earnings.”

0:25–2:10

Ladder

“Slice → named system → weekly operating rhythm → retain outcome. If you can’t name the system, you’re stuck selling tasks.”

2:10–3:40

Path map

Create an Upwork→retained upsell path one-pager for an AI-native product designer/builder. Stages: first win · system name · retainer packaging · off-platform transition notes (high-level, policy-safe) · disqualify signs. No fake earnings. No client names. Calm commercial tone.

3:40–4:40

Risks

“Don’t pitch retainers before trust. Don’t ghost platform rules. Don’t underprice the first slice as bait then bait-and-switch.”

4:40–5:30

Close

“Marketplace is a channel. Productized systems are the business. Comment LADDER.”

Natural lines

On earnings porn

“No dollar screenshots. Path only.”

60–75s cut

0–3s

Hook

“Gig became a system.”

3–25s

Ladder

“Slice → name → retain.”

25–50s

Map

“One-pager.”

50–70s

CTA

Comment LADDER.

Edit notes

No earnings UI.
Anonymize industry if needed.

Commercial graduation path.

Truth check

No earnings flex
Path explicit
Anonymized

Client Work · 06 · Script 44

Full production script · Client Work · 06 · Script 44

Cold email isn’t dead—lazy personalization is.

Show a before/after first line + bridge that feels observed, not generated. Teach the quality bar used in LoopSuit outreach.

10–14 min Before/after lines GTM Hire · GTM systems + taste

On-camera hygiene · Client WorkAnonymize names, amounts, and identifying details. No screenshots of private threads without redaction. Teach the template; don’t dunk on a client for sport.

Hire signalA founder should think: he runs commercial conversations like a senior operator—scope, pricing, boundaries—not a desperate bidder.

Steal-this value

Observation

Specific, checkable, non-creepy.

Bridge

Why it matters to their job—not your pitch.

Ban list

Compliments, weather, ‘I love your energy.’

QA pass

Read aloud; if you’d cringe receiving it, rewrite.

Hire signal

You build outbound systems with taste.

Packaging

Title AThe Instantly Line That Felt Human

Title BStop Shipping Robot Personalization

CTAComment HUMAN for the line rules

Prep

Two fake-but-realistic before lines
After lines (no real lead PII)
Rules slate

Spine

1Lazy sample

2Rules

3Rewrite live

4Bridge

5Close

Full run of show

0:00–0:25

Open

Show bad line on screen.

“‘Loved your recent post about innovation.’ That’s not personalization—that’s spam with manners. Here’s the bar.”

0:25–2:00

Rules

“Matched observation · one job-relevant bridge · no fake intimacy · no secrets or scraped private data. Instantly is the pipe. Taste is the product.”

2:00–3:40

Rewrite

Rewrite these two cold first-lines to be human without being creepy. Rules: specific observable public fact; no flattery fluff; one bridge to a systems/ops pain; under 25 words each. Output: before → after → why. Do not invent private facts. Do not include real emails/phones.

3:40–4:40

Bridge

“Observation without bridge is stalking cosplay. Bridge without observation is a brochure.”

4:40–5:20

Close

“Comment HUMAN. Hire the person who refuses robot lines.”

Natural lines

On scraping

“Public pages only. No private CRM dumps on camera.”

60–75s cut

0–3s

Hook

“Lazy personalization.”

3–25s

Rules

“Observe → bridge.”

25–50s

Rewrite

“Before/after.”

50–70s

CTA

Comment HUMAN.

Edit notes

Use fictional company names.
Never show real lead CSVs.

LoopSuit personalization craft (public-facing).

Truth check

No real PII
Rules explicit
Before/after shown

Client Work · 07 · Script 45

Full production script · Client Work · 07 · Script 45

Rebound isn’t for everyone—and that’s the point.

Disqualify list as product craft. Saying no protects delivery quality and brand. Anonymize the clinic story.

9–13 min ICP filter slate Offer design Hire · productized offer owner

On-camera hygiene · Client WorkAnonymize names, amounts, and identifying details. No screenshots of private threads without redaction. Teach the template; don’t dunk on a client for sport.

Hire signalA founder should think: he runs commercial conversations like a senior operator—scope, pricing, boundaries—not a desperate bidder.

Steal-this value

ICP positive

Who it’s for—in one line.

Hard nos

Conditions that break the product.

Soft nos

Possible later with different packaging.

Script the no

Helpful redirect, not ghosting.

Brand

Selectivity is a feature.

Packaging

Title AHow I Say No to a Bad-Fit Clinic

Title BThe Disqualify List That Saves Projects

CTAComment NOPE for the filter

Prep

Anonymized ‘almost signed’ story
Disqualify list slate
Public Rebound positioning only

Spine

1Almost-yes

2Why no

3Filter

4No script

5Close

Full run of show

0:00–0:25

Open

“They wanted Rebound energy with a workflow that breaks Rebound. I said no. Here’s the filter I use so ‘no’ is a system—not a mood.”

0:25–1:50

Why no

“Bad fit usually means: no ops owner, impossible data access, or they want magic without process change. Shipping anyway creates a case study you can’t show.”

1:50–3:20

Filter

Create a disqualify / ICP filter one-pager for a productized clinic follow-up / speed-to-lead style offer (Rebound-like). Include: must-haves, hard nos, soft nos, polite decline email skeleton, alternative referral note. No client names. No medical claims. No PHI examples.

3:20–4:20

No script

“Thank them. Name the mismatch. Offer a smaller diagnostic or a referral. Don’t leave them in silence.”

4:20–5:10

Close

“Selectivity is how productized offers stay productized. Comment NOPE.”

Natural lines

On dunking

“Teach the filter. Don’t roast a clinic on the internet.”

60–75s cut

0–3s

Hook

“I said no.”

3–25s

Why

“Fit breaks the product.”

25–50s

Filter

“Hard nos on screen.”

50–70s

CTA

Comment NOPE.

Edit notes

No PHI.
Anonymize geography if needed.

Offer boundary craft.

Truth check

No PHI
Filter explicit
Anonymized

Client Work · 08 · Script 46

Full production script · Client Work · 08 · Script 46

Close rate is the bottleneck—not followers.

Post-mortem a bad discovery call into a rubric you can run next time. Operators who blame top-of-funnel need this.

11–15 min Call rubric Sales craft Hire · founder who can close

On-camera hygiene · Client WorkAnonymize names, amounts, and identifying details. No screenshots of private threads without redaction. Teach the template; don’t dunk on a client for sport.

Hire signalA founder should think: he runs commercial conversations like a senior operator—scope, pricing, boundaries—not a desperate bidder.

Steal-this value

Agenda

Minute-by-minute control.

Diagnosis questions

Force specifics over vibes.

Next step

Always leave with a dated decision.

Self-score

Record (with consent) or notes → grade.

Funnel truth

More leads won’t fix a soft close.

Packaging

Title AI Bombed a Discovery Call—Here’s the Rubric

Title BFix Close Rate Before You Buy More Leads

CTAComment RUBRIC for the call scorecard

Prep

Anonymized call notes (fake composite OK)
Rubric slate
Timer

Spine

1Confession

2What failed

3Rubric

4Rehearse

5Close

Full run of show

0:00–0:25

Confession

“Bad discovery call. Soft close. I blamed the lead quality for a week. Then I scored the call. I was the bottleneck.”

0:25–2:00

Failure modes

“Talked features too early. Didn’t quantify cost of status quo. Left without a next step date. Those are skill bugs—not Instagram bugs.”

2:00–3:40

Rubric

Build a discovery-call scorecard for productized AI build / Clarity Session style sales. Categories (0–2 each): agenda control, problem quantification, decision process, budget/authority clarity, next-step commitment, talk-listen balance. Include: red-flag list and a 60-second recovery script when the call goes vague. No fake close-rate stats.

3:40–4:40

Rehearse

“Run the recovery script out loud once on camera. Awkward is fine. Soft closes are worse.”

4:40–5:30

Close

“Followers don’t close. Rubrics do. Comment RUBRIC.”

Natural lines

On blame

“If you didn’t ask for the next step, the lead didn’t ghost—you did.”

60–75s cut

0–3s

Hook

“I was the bottleneck.”

3–25s

Fails

“No next-step date.”

25–50s

Rubric

“Scorecard.”

50–70s

CTA

Comment RUBRIC.

Edit notes

Composite anonymized story OK.
No real call recordings with PII.

Sales craft as product skill.

Truth check

Rubric explicit
No fake stats
Anonymized

Tool Speedruns · 01 · Script 47

Full production script · Tool Speedruns · 01 · Script 47

Skip the hype thread. Here’s the 45-second test.

Same prompt, two models, scored grid. Teach evaluation as a senior builder habit—not influencer FOMO.

8–12 min Split screen Eval Hire · AI-native product lead

On-camera hygiene · Tool SpeedrunsNo API keys, tokens, billing screens with account IDs, or unpaid stock that isn’t cleared. Show the workflow and the eval—not the hype thread. Prefer free/public demos or your own assets.

Hire signalA founder/PM should think: he evaluates tools like a product lead—tests, cost, failure modes—then ships with taste.

Steal-this value

Fixed prompt

Don’t change the ask mid-test.

Axes

Correctness · taste · tool-use · refusal quality · speed/cost.

Failure case

Include one adversarial prompt.

Ship decision

Adopt / watch / ignore—with reason.

No key leak

Blur account UI.

Packaging

Title ANew Model Drop—What Actually Changed

Title BMy 45-Second Model Eval Grid

CTAComment EVAL for the grid

Prep

Two model tabs ready
Eval grid slate
One real shipping prompt from your work (sanitized)

Spine

1Hype kill

2Protocol

3Live compare

4Decision

5Close

Full run of show

0:00–0:20

Open

Hype headline vs your grid.

“New model. Skip the thread. Same prompt. Score it. Forty-five seconds of truth beats an hour of takes.”

0:20–1:40

Protocol

“Fixed prompt · fixed rubric · one failure case · decide adopt/watch/ignore. If you can’t decide, you didn’t test—you vibed.”

1:40–3:20

Live

Create a one-page model eval grid for comparing two LLMs on a product-building task. Columns: model A/B. Rows: correctness, UI taste, tool-use reliability, hallucination risk, latency/cost note, ship decision. Include a sample shipping prompt placeholder (auth+Stripe style) and an adversarial prompt. No API keys. No fabricated benchmark numbers.

3:20–4:20

Decision

“Say the decision on camera. ‘It’s cool’ is not a decision.”

4:20–5:00

Close

“Comment EVAL. Hire people who test like PMs.”

Natural lines

On FOMO

“If it doesn’t change how you ship this week, it’s entertainment.”

60–75s cut

0–3s

Hook

“Skip the hype.”

3–25s

Protocol

“Same prompt, score.”

25–50s

Grid

“Adopt / watch / ignore.”

50–70s

CTA

Comment EVAL.

Edit notes

Blur billing.
Don’t name-drop unverifiable scores.

Builder evaluation craft.

Truth check

No keys
Grid explicit
Decision stated

Tool Speedruns · 02 · Script 48

Full production script · Tool Speedruns · 02 · Script 48

Pay-per-use image runs without a new subscription.

Batch generate via fal/Replicate-style APIs. Cost-aware builder workflow—keys hidden, loop shown.

9–13 min API loop (redacted) Cost Hire · pragmatic systems builder

On-camera hygiene · Tool SpeedrunsNo API keys, tokens, billing screens with account IDs, or unpaid stock that isn’t cleared. Show the workflow and the eval—not the hype thread. Prefer free/public demos or your own assets.

Hire signalA founder/PM should think: he evaluates tools like a product lead—tests, cost, failure modes—then ships with taste.

Steal-this value

When pay-per-use wins

Spiky volume, experiments.

Batch contract

Inputs, idempotency, failure retry.

Cost ceiling

Hard stop before runaway spend.

QA

Spot-check outputs before client send.

Hygiene

Env vars off-screen.

Packaging

Title ABatch Images Without Another Subscription

Title Bfal/Replicate Loop for Cost-Sensitive Builds

CTAComment BATCH for the loop checklist

Prep

Sanitized script/notebook
Cost ceiling slate
Sample outputs you own

Spine

1Cost problem

2Loop shape

3Implement

4Failure modes

5Close

Full run of show

0:00–0:25

Open

“Another monthly seat for occasional image runs is how solos go broke. Here’s a pay-per-use batch loop—keys stay hidden.”

0:25–1:50

Shape

“Input CSV/list → submit jobs → poll/webhook → store URLs → QA sample → cost log. If any step is vibes, you’ll overspend.”

1:50–3:30

Prompt

Design a safe batch image-generation loop outline for fal or Replicate style APIs. Include: input schema, rate limits, retries, cost ceiling, secrets handling (.env never printed), QA sampling, failure report. Pseudocode OK. No real API keys. No scraping illegal content.

3:30–4:20

Fails

“Timeouts, content policy rejects, silent partial batches. Show the failure report pattern.”

If live API flaky: walk the checklist on a slate and show cached sample outputs.

4:20–5:10

Close

“Comment BATCH. Cost ceilings are a product feature.”

Natural lines

On keys

“If a key appears for one frame, the take is dead.”

60–75s cut

0–3s

Hook

“No new subscription.”

3–25s

Loop

“Submit → poll → QA.”

25–50s

Ceiling

“Hard stop spend.”

50–70s

CTA

Comment BATCH.

Edit notes

Blur dashboards with balances.
Own the sample assets.

Cost-aware generative ops.

Truth check

No keys
Ceiling explicit
QA step shown

Tool Speedruns · 03 · Script 49

Full production script · Tool Speedruns · 03 · Script 49

Never ship soft pixels to a client.

Upscale/export checklist before send. Taste + process—show before/after on assets you own.

7–11 min Before/after Delivery QA Hire · design-led finisher

On-camera hygiene · Tool SpeedrunsNo API keys, tokens, billing screens with account IDs, or unpaid stock that isn’t cleared. Show the workflow and the eval—not the hype thread. Prefer free/public demos or your own assets.

Hire signalA founder/PM should think: he evaluates tools like a product lead—tests, cost, failure modes—then ships with taste.

Steal-this value

When to upscale

Hero frames, print, big screens.

When not to

Already crisp vectors / UI screenshots.

Artifacts

Watch for plastic skin / fake detail.

Export pack

Formats, color, naming.

Client trust

Soft pixels read as careless.

Packaging

Title AMagnific Before Client Send

Title BThe Export Checklist That Saves Reputation

CTAComment SHARP for the checklist

Prep

Owned before asset
After upscale
Checklist slate

Spine

1Soft pixel sin

2Protocol

3Live pass

4Checklist

5Close

Full run of show

0:00–0:20

Open

Soft vs sharp side-by-side.

“If the hero is soft, the whole brand feels soft. Here’s the pass I run before anything leaves.”

0:20–1:30

Protocol

“Source quality → upscale only if needed → artifact check → color → export naming → attach notes. Magnific is a tool; the checklist is the product.”

1:30–3:00

Checklist

Create a pre-client-send image export checklist for AI-assisted marketing/product visuals. Include: when to upscale, artifact red flags, color/export settings reminders, file naming, ‘do not upscale’ cases. No brand secrets. No scraped client confidential comps.

3:00–4:00

Live

“Before / after. Call out one artifact you’d reject.”

4:00–4:50

Close

“Finishing is a hire signal. Comment SHARP.”

Natural lines

On over-sharpen

“Fake detail is worse than soft—reject it.”

60–75s cut

0–3s

Hook

“Never ship soft.”

3–25s

Protocol

“Upscale only if needed.”

25–50s

Check

“Artifact reject.”

50–70s

CTA

Comment SHARP.

Edit notes

Use owned assets.
Don’t imply Magnific is mandatory—protocol is.

Delivery finishing craft.

Truth check

Owned assets
Checklist explicit

Tool Speedruns · 04 · Script 50

Full production script · Tool Speedruns · 04 · Script 50

Vectors that don’t fall apart at favicon size.

Recraft-style logo lockup in three variants. Founder DIY branding with constraints—not infinite generations.

9–13 min Recraft/vector UI Brand Hire · brand-aware product designer

On-camera hygiene · Tool SpeedrunsNo API keys, tokens, billing screens with account IDs, or unpaid stock that isn’t cleared. Show the workflow and the eval—not the hype thread. Prefer free/public demos or your own assets.

Hire signalA founder/PM should think: he evaluates tools like a product lead—tests, cost, failure modes—then ships with taste.

Steal-this value

Constraints first

Name, industry, must-nots.

Three variants

Wordmark · icon · stacked.

Size test

16px / 32px / social avatar.

Vector export

SVG sanity.

Stop generating

Pick with a rubric.

Packaging

Title ALogo Lockup in 3 Variants—Fast

Title BFavicon-Proof Vectors Without the Agency Bill

CTAComment LOCKUP for the variant brief

Prep

Brief slate
Three outputs
Size test grid

Spine

1Brief

2Generate under constraints

3Size test

4Pick rubric

5Close

Full run of show

0:00–0:25

Open

“Founders generate fifty logos and pick none. Here’s three variants with a size test—so the mark survives favicon hell.”

0:25–1:40

Brief

“Name · one-line promise · must-not list · where it lives (app icon, nav, invoice). Without that, Recraft is a slot machine.”

1:40–3:20

Variant brief

Write a Recraft/logo lockup brief for a fictional productized AI studio brand (not copying LoopSuit marks). Require 3 variants: wordmark, icon mark, stacked lockup. Include: negative constraints, favicon test checklist, SVG export notes, pick rubric (clarity at 16px, uniqueness, legal-safe abstract shapes). No trademarked lookalikes.

3:20–4:20

Size test

Show 16px row.

“If it dies at 16px, it dies in the tab. Kill it.”

4:20–5:10

Close

“Comment LOCKUP. Constraints beat infinite gens.”

Natural lines

On copying

“Don’t recreate living brands. Invent under constraints.”

60–75s cut

0–3s

Hook

“Favicon-proof.”

3–25s

Brief

“Constraints first.”

25–50s

Test

“16px kill.”

50–70s

CTA

Comment LOCKUP.

Edit notes

Fictional brand OK.
Don’t claim trademark clearance.

DIY brand systems craft.

Truth check

Constraints explicit
Size test shown
No copycat marks

Tool Speedruns · 05 · Script 51

Full production script · Tool Speedruns · 05 · Script 51

Voice consistency when my throat’s shot.

ElevenLabs (or similar) VO preset for Reel B-roll: settings you can reuse, not random voices every post.

8–12 min Voice settings Content ops Hire · production systems thinker

On-camera hygiene · Tool SpeedrunsNo API keys, tokens, billing screens with account IDs, or unpaid stock that isn’t cleared. Show the workflow and the eval—not the hype thread. Prefer free/public demos or your own assets.

Hire signalA founder/PM should think: he evaluates tools like a product lead—tests, cost, failure modes—then ships with taste.

Steal-this value

Lock identity

One voice profile for the brand lane.

Settings card

Stability/clarity/style—write them down.

Script hygiene

Short lines; no AI-stained filler.

When not to

Trust-critical face-out still wins.

Consent/ethics

Your clone/own rights only.

Packaging

Title AMy ElevenLabs Preset for Reel B-roll

Title BVoice Consistency When You Can’t Record

CTAComment VOICE for the preset card

Prep

Preset slate
Sample B-roll edit
Blur account/billing

Spine

1Problem

2Preset

3Generate

4Mix

5Close

Full run of show

0:00–0:20

Open

“Throat’s shot. Deadlines aren’t. Here’s the VO preset I use for B-roll—so the brand still sounds like one person.”

0:20–1:40

Preset

“Voice ID · stability · clarity · style · speed. If it isn’t written down, you’ll drift every week.”

1:40–3:10

Card

Create a reusable VO preset card for short-form Reel B-roll narration. Include: when to use AI VO vs real face-cam, script line-length rules, ban-list for AI diction, mix notes (duck under SFX), ethics note (own voice / licensed only). No API keys. No unpaid celebrity clones.

3:10–4:10

Mix

“Generate → trim breaths → duck under UI SFX → never let VO fight on-screen text.”

4:10–4:55

Close

“Preset is the product. Comment VOICE.”

Natural lines

On faking you

“B-roll backup ≠ replacing face-out trust forever.”

60–75s cut

0–3s

Hook

“Throat’s shot.”

3–25s

Preset

“Write the settings.”

25–50s

Mix

“Duck under SFX.”

50–70s

CTA

Comment VOICE.

Edit notes

Blur keys/billing.
Disclose AI VO if platform norms require.

Content ops continuity.

Truth check

No keys
Preset explicit
Ethics noted

Tool Speedruns · 06 · Script 52

Full production script · Tool Speedruns · 06 · Script 52

Lock the face once—stop regenerating strangers.

Character sheet → scene workflow. Consistency as a system, not luck.

9–13 min Sheet → scene Gen video Hire · brand systems designer

On-camera hygiene · Tool SpeedrunsNo API keys, tokens, billing screens with account IDs, or unpaid stock that isn’t cleared. Show the workflow and the eval—not the hype thread. Prefer free/public demos or your own assets.

Hire signalA founder/PM should think: he evaluates tools like a product lead—tests, cost, failure modes—then ships with taste.

Steal-this value

Sheet first

Angles, wardrobe, lighting notes.

Reference pack

What you attach every run.

Drift checks

Eyes, hairline, wardrobe breaks.

Scene brief

Action + camera—not ‘make cool video.’

Rights

Own likeness / cleared talent only.

Packaging

Title ACharacter Sheet Before You Generate

Title BStop Regenerating Strangers

CTAComment SHEET for the consistency checklist

Prep

Sample sheet (you or fictional)
One scene gen
Drift reject examples

Spine

1Stranger problem

2Sheet

3Scene brief

4QA

5Close

Full run of show

0:00–0:25

Open

Two mismatched faces.

“If every take is a new person, you don’t have a brand—you have a slot machine. Lock the sheet first.”

0:25–1:50

Sheet

“Face refs · wardrobe · palette · do-nots. Higgsfield (or any consistent gen stack) is only as good as the sheet.”

1:50–3:20

Checklist

Write a character-sheet → scene consistency checklist for short-form gen video. Include: required references, scene brief fields, drift QA list, regenerate rules, rights/consent reminder. No real private photos of non-consenting people. No API keys.

3:20–4:20

QA

“Reject on drift. Don’t ‘fix’ a stranger into your brand.”

4:20–5:10

Close

“Consistency is design ops. Comment SHEET.”

Natural lines

On consent

“Your face or cleared talent—period.”

60–75s cut

0–3s

Hook

“Stop regenerating strangers.”

3–25s

Sheet

“Refs + do-nots.”

25–50s

QA

“Reject drift.”

50–70s

CTA

Comment SHEET.

Edit notes

Prefer your own likeness/consent.
Fictional character OK for demo.

Gen-video brand consistency.

Truth check

Consent noted
Checklist explicit

Tool Speedruns · 07 · Script 53

Full production script · Tool Speedruns · 07 · Script 53

Train it on how you wrote before ChatGPT existed.

Claude Projects (or equivalent) with a pre-AI writing corpus + erase-AI-stains ban list. Voice as a system.

10–14 min Project files Voice Hire · brand/voice systems owner

On-camera hygiene · Tool SpeedrunsNo API keys, tokens, billing screens with account IDs, or unpaid stock that isn’t cleared. Show the workflow and the eval—not the hype thread. Prefer free/public demos or your own assets.

Hire signalA founder/PM should think: he evaluates tools like a product lead—tests, cost, failure modes—then ships with taste.

Steal-this value

Corpus pick

Emails, decks, posts from before ChatGPT.

What to exclude

Anything confidential / client-secret.

Ban list

Words/rhythms that scream LLM.

Project instructions

How to use the corpus.

QA

Read aloud test.

Packaging

Title AMy Pre-AI Writing Corpus in Claude Projects

Title BErase AI Stains—Ban List Included

CTAComment CORPUS for the ban list

Prep

Anonymized sample files list
Ban list slate
Before/after paragraph

Spine

1Stain problem

2Corpus rules

3Ban list

4Live rewrite

5Close

Full run of show

0:00–0:25

Open

“If every caption sounds like ChatGPT, buyers feel it. I load a pre-AI corpus so the model has to sound like me—not like the internet.”

0:25–1:50

Corpus

“Old proposals, founder notes, emails you actually sent. Strip secrets. Keep rhythm.”

1:50–3:30

Ban list

Create an 'erase AI stains' ban list + Claude Project instruction block for a productized AI studio founder voice. Include: banned openers, banned adjectives, rhythm rules, how to use uploaded pre-AI samples, confidentiality rule (never paste client secrets). Output: ban list + project instruction markdown.

3:30–4:30

Rewrite

“Paste a stained paragraph. Force the ban list. Hear the difference.”

4:30–5:20

Close

“Voice is infrastructure. Comment CORPUS.”

Natural lines

On secrets

“Corpus ≠ dumping client Notion into the cloud.”

60–75s cut

0–3s

Hook

“Pre-AI corpus.”

3–25s

Rules

“Strip secrets.”

25–50s

Ban

“Stains list.”

50–70s

CTA

Comment CORPUS.

Edit notes

Show fake/sanitized samples only.
No client confidential uploads on camera.

Voice systems craft.

Truth check

No secrets
Ban list explicit

Tool Speedruns · 08 · Script 54

Full production script · Tool Speedruns · 08 · Script 54

Showreel motion without After Effects debt.

video-use / HyperFrames-style motion pass: intentional motion jobs, not decorative spam.

9–13 min Timeline Motion Hire · design-led motion craft

On-camera hygiene · Tool SpeedrunsNo API keys, tokens, billing screens with account IDs, or unpaid stock that isn’t cleared. Show the workflow and the eval—not the hype thread. Prefer free/public demos or your own assets.

Hire signalA founder/PM should think: he evaluates tools like a product lead—tests, cost, failure modes—then ships with taste.

Steal-this value

Jobs only

Entrance, emphasis, transition—max 2–3.

Timing

Readable beats > flashy.

Brand link

Motion matches product personality.

Export

Platform-safe lengths.

Stop criterion

If it doesn’t clarify, cut it.

Packaging

Title AShowreel Motion Without AE Debt

Title BA Motion Pass With Three Jobs

CTAComment MOTIONPASS for the job list

Prep

Short clip + timeline
Job list slate
Before/after cut

Spine

1AE debt myth

2Job list

3Pass

4Kill test

5Close

Full run of show

0:00–0:25

Open

“You don’t need a week in After Effects for a showreel beat. You need three motions with jobs—and a kill test.”

0:25–1:40

Jobs

“Reveal brand · emphasize claim · bridge scenes. Everything else is noise.”

1:40–3:20

Pass brief

Write a motion-pass brief for a 20–30s product showreel using a modern AI/video timeline tool (video-use / HyperFrames style). Specify: 2–3 motion jobs, timing notes, what to avoid (bouncy junk, endless fades), export checklist. No stolen footage. No client confidential UI without permission.

3:20–4:20

Kill test

“Mute it. If motion still helps hierarchy, keep it. If it’s just vibes, delete.”

4:20–5:10

Close

“Comment MOTIONPASS. Intention beats plugins.”

Natural lines

On tool names

“Tool is a vehicle. Jobs are the craft.”

60–75s cut

0–3s

Hook

“No AE debt.”

3–25s

Jobs

“Three motions.”

25–50s

Kill

“Mute test.”

50–70s

CTA

Comment MOTIONPASS.

Edit notes

Use owned footage.
Keep cuts tight.

Motion craft for founders.

Truth check

Jobs explicit
Kill test shown

Design Eye · 01 · Script 55

Full production script · Design Eye · 01 · Script 55

Remove the nav—whose site is this?

Brand-first hero test. If the first viewport could belong to anyone, branding failed.

9–13 min Hero teardown Brand Hire · senior product designer

On-camera hygiene · Design EyeCritique patterns, not people. Prefer anonymized or public screenshots you have rights to show. Don’t dox a competitor’s private staging. Teach the rule; don’t farm dunks.

Hire signalA product team should think: he has senior design taste and can encode it into product—brand, type, density, motion, explainability—not moodboard tourism.

Steal-this value

Brand signal

Name/mark as hero-level, not eyebrow.

One composition

Not a dashboard collage.

Budget

Brand · one claim · one line · one CTA · one visual.

No overlays

No floating badge spam.

Fix path

What to cut first.

Packaging

Title AWhy This SaaS Hero Fails the Brand Test

Title BRemove the Nav—Whose Site Is This?

CTAComment BRANDTEST for the checklist

Prep

Public SaaS hero (fair use critique) or anonymized mock
Checklist slate

Spine

1Brand test

2Failures

3Checklist

4Rebuild brief

5Close

Full run of show

0:00–0:25

Test

Crop nav out.

“Nav gone. Whose site is this? If you can’t tell, the hero failed—and so did the brand.”

0:25–1:50

Failures

“Inter-default type · purple glow · five CTAs · card grid in the fold · brand as tiny logo. That’s everyone.”

1:50–3:20

Checklist

Create a brand-first hero checklist for B2B/SaaS landing pages. Include: brand test (nav removed), hero budget, forbidden patterns, fix order. Tone: senior designer, not dunk-account. No doxxing private staging.

3:20–4:20

Rebuild

“One composition. Brand loud. Claim quiet enough to support—not overpower—the brand.”

4:20–5:10

Close

“Comment BRANDTEST. Hire taste you can ship.”

Natural lines

On dunking

“Critique the pattern. Don’t farm hate on a founder.”

60–75s cut

0–3s

Hook

“Whose site is this?”

3–25s

Fails

“Default stack.”

25–50s

Checklist

“Hero budget.”

50–70s

CTA

Comment BRANDTEST.

Edit notes

Prefer anonymized/composited fails if needed.
Fair-use public pages OK with restraint.

LoopSuit design rules → content.

Truth check

Checklist explicit
No personal attack

Design Eye · 02 · Script 56

Full production script · Design Eye · 02 · Script 56

Inter is the default of people who didn’t choose.

Type pairing in ~20 seconds: display + body with intent. Show a live swap.

7–11 min Font swap Typography Hire · design systems taste

On-camera hygiene · Design EyeCritique patterns, not people. Prefer anonymized or public screenshots you have rights to show. Don’t dox a competitor’s private staging. Teach the rule; don’t farm dunks.

Hire signalA product team should think: he has senior design taste and can encode it into product—brand, type, density, motion, explainability—not moodboard tourism.

Steal-this value

Choose on purpose

Default stacks = no brand.

Roles

Display vs body vs mono.

Contrast

Weight/structure—not just size.

Avoid cluster

Don’t copy the AI-design cliché pairings.

Ship test

Read a real paragraph.

Packaging

Title AType Pairing in 20 Seconds

Title BStop Defaulting to Inter

CTAComment TYPE for the pairing rules

Prep

Landing mock with Inter
Swap fonts live
Rules slate

Spine

1Default sin

2Roles

3Live swap

4Rules

5Close

Full run of show

0:00–0:20

Open

“Inter isn’t evil. Unchosen Inter is. Twenty seconds—pick a pair with a job.”

0:20–1:20

Roles

“Display carries brand. Body carries trust. Mono carries systems. If all three are the same, you didn’t design.”

1:20–2:50

Rules

Write a 20-second type-pairing rubric for product marketing pages. Include: role definitions, contrast checks, 3 example pair directions (not Inter+Inter), anti-patterns (AI cliché stacks), accessibility note. No piracy—assume licensed/Google fonts.

2:50–3:50

Swap

Live CSS/font change.

“Same layout. New voice. That’s the point.”

3:50–4:40

Close

“Comment TYPE. Choice is the craft.”

Natural lines

On snobbery

“Inter is fine when chosen. Defaults aren’t a personality.”

60–75s cut

0–3s

Hook

“Unchosen Inter.”

3–25s

Roles

“Display / body / mono.”

25–50s

Swap

“Live change.”

50–70s

CTA

Comment TYPE.

Edit notes

Use licensed fonts.
Keep swap snappy.

Typography as brand signal.

Truth check

Rubric explicit
Live swap

Design Eye · 03 · Script 57

Full production script · Design Eye · 03 · Script 57

One face, one claim, one contrast.

Thumbnail grid system: three variants, pick with a mute test.

8–12 min 3 variants Packaging Hire · content design lead

On-camera hygiene · Design EyeCritique patterns, not people. Prefer anonymized or public screenshots you have rights to show. Don’t dox a competitor’s private staging. Teach the rule; don’t farm dunks.

Hire signalA product team should think: he has senior design taste and can encode it into product—brand, type, density, motion, explainability—not moodboard tourism.

Steal-this value

Mute test

Readable with sound off.

One claim

≤6–8 words on cover.

Face/UI dominance

Don’t split attention.

Contrast

Subject vs background separation.

Variant logic

A/B/C with one changed variable.

Packaging

Title AThumbnails That Stop Thumbs

Title BOne Face, One Claim, One Contrast

CTAComment THUMB for the grid

Prep

Three thumbnail drafts
Grid slate
Phone preview

Spine

1Scroll reality

2Rules

3Three variants

4Pick

5Close

Full run of show

0:00–0:20

Open

“Thumbnails aren’t decoration—they’re the ad. One face, one claim, one contrast.”

0:20–1:30

Rules

“Mute test · claim length · no badge spam · tint matches pillar. If you need a legend, you lost.”

1:30–3:10

Grid

Create a thumbnail grid system for a multi-pillar creator/product brand. Include: composition rules, text limits, pillar tint guidance (cool/neutral—avoid error-red), 3-variant test method, mute-test checklist. Assume face-out + UI proof mix.

3:10–4:10

Pick

“Change one variable per variant. Pick with the mute test—not vibes.”

4:10–4:55

Close

“Comment THUMB. Packaging is product.”

Natural lines

On clickbait

“Contrast ≠ lying. Claims must match the video.”

60–75s cut

0–3s

Hook

“One claim.”

3–25s

Rules

“Mute test.”

25–50s

Variants

“Change one thing.”

50–70s

CTA

Comment THUMB.

Edit notes

Use your face/UI.
Match LoopSuit tint system.

Content packaging craft.

Truth check

Grid explicit
Mute test

Design Eye · 04 · Script 58

Full production script · Design Eye · 04 · Script 58

If removing the card doesn’t hurt, delete the card.

Cards vs composition teardown. Cards only when they hold interaction—otherwise they’re visual debt.

9–13 min Landing teardown Layout Hire · product designer who ships

On-camera hygiene · Design EyeCritique patterns, not people. Prefer anonymized or public screenshots you have rights to show. Don’t dox a competitor’s private staging. Teach the rule; don’t farm dunks.

Hire signalA product team should think: he has senior design taste and can encode it into product—brand, type, density, motion, explainability—not moodboard tourism.

Steal-this value

Interaction test

Card must earn its container.

Hero ban

No card grids in the first viewport.

Alternatives

Type, space, rules, imagery.

When cards win

Selectable items, dashboards, feeds.

Teardown order

Remove → see if meaning survives.

Packaging

Title ACards vs Composition

Title BDelete the Card If It Does Nothing

CTAComment CARDS for the teardown rules

Prep

Landing section before/after
Rules slate

Spine

1Card addiction

2Test

3Teardown

4Rebuild

5Close

Full run of show

0:00–0:25

Open

“If removing the border, shadow, and radius doesn’t hurt understanding, it wasn’t a component—it was fear of empty space.”

0:25–1:40

Test

“Ask: is the user choosing/acting inside this box? No? Delete the card.”

1:40–3:20

Rules

Write a cards-vs-composition teardown rubric for marketing + product pages. Include: hero rules, when cards are allowed, replacement patterns, before/after checklist. Senior, practical, no aesthetic snobbery without reasons.

3:20–4:20

Rebuild

Show deleted cards.

“Watch hierarchy get clearer when boxes leave.”

4:20–5:10

Close

“Comment CARDS. Composition is courage.”

Natural lines

On dashboards

“Feeds and pickers can keep cards. Heroes usually shouldn’t.”

60–75s cut

0–3s

Hook

“Delete the card.”

3–25s

Test

“Does it hold action?”

25–50s

Rebuild

“Boxes leave.”

50–70s

CTA

Comment CARDS.

Edit notes

Prefer your own landing mocks.
Keep teardown kind.

Layout craft from design rules.

Truth check

Rubric explicit
Before/after

Design Eye · 05 · Script 59

Full production script · Design Eye · 05 · Script 59

Near-black needs warm air—here’s the recipe.

Dark UI tokens that aren’t muddy: elevation, hairlines, accent discipline.

8–12 min Token slate Color Hire · UI systems designer

On-camera hygiene · Design EyeCritique patterns, not people. Prefer anonymized or public screenshots you have rights to show. Don’t dox a competitor’s private staging. Teach the rule; don’t farm dunks.

Hire signalA product team should think: he has senior design taste and can encode it into product—brand, type, density, motion, explainability—not moodboard tourism.

Steal-this value

Not pure #000 only

Layered surfaces.

Warm air

Subtle temperature in neutrals.

Hairlines

Borders that separate without glowing.

Accent budget

One signal color, used sparingly.

Contrast a11y

Text/icon checks.

Packaging

Title ADark UI That Isn’t Muddy

Title BNear-Black Needs Warm Air

CTAComment DARK for the token recipe

Prep

Muddy vs clean side-by-side
Token list
Component sample

Spine

1Mud problem

2Recipe

3Tokens

4Apply

5Close

Full run of show

0:00–0:20

Open

“Muddy dark UI is just black with blue glow. Here’s a recipe: surfaces, warm air, hairlines, one accent.”

0:20–1:40

Recipe

“Elevation steps · neutral temperature · border strategy · accent discipline · focus states. Purple glow is not a system.”

1:40–3:10

Tokens

Design a compact dark UI token recipe for a productized studio / fintech-adjacent app. Include: 4–5 surface levels, text tiers, border tokens, one accent + on-accent, do-not list (glow spam, pure black everything). Output as a short token table. Accessibility notes included.

3:10–4:10

Apply

“Same card, muddy vs recipe. Watch edges reappear.”

4:10–4:55

Close

“Comment DARK. Systems beat vibes.”

Natural lines

On purple

“If the accent is default AI purple, choose again.”

60–75s cut

0–3s

Hook

“Warm air.”

3–25s

Recipe

“Surfaces + hairlines.”

25–50s

Tokens

“Table on screen.”

50–70s

CTA

Comment DARK.

Edit notes

Match LoopSuit green accent if demoing brand.
Show contrast carefully.

Dark theme systems craft.

Truth check

Token table explicit
A11y noted

Design Eye · 06 · Script 60

Full production script · Design Eye · 06 · Script 60

2–3 intentional motions beat 20 decorative ones.

Motion with a job—for Reels and product UI alike. Edit-led demonstration.

8–12 min Reel cuts Motion Hire · motion-aware product designer

On-camera hygiene · Design EyeCritique patterns, not people. Prefer anonymized or public screenshots you have rights to show. Don’t dox a competitor’s private staging. Teach the rule; don’t farm dunks.

Hire signalA product team should think: he has senior design taste and can encode it into product—brand, type, density, motion, explainability—not moodboard tourism.

Steal-this value

Job list

Hierarchy, continuity, feedback.

Budget

2–3 per piece.

Timing

Readable, not twitchy.

Mute test

Still helps without audio.

Cut ruthlessly

Decorative = delete.

Packaging

Title AMotion With a Job

Title BThree Motions Max

CTAComment JOBS for the motion map

Prep

Reel with noisy motion
Cleaned cut
Job map slate

Spine

1Noise

2Jobs

3Rebuild

4Map

5Close

Full run of show

0:00–0:20

Open

“Twenty micro-animations isn’t premium—it’s anxiety. Two or three motions with jobs win.”

0:20–1:30

Jobs

“Guide the eye · connect cuts · confirm action. If it doesn’t do one of those, it’s cosplay.”

1:30–3:00

Map

Create a motion-job map for short-form product Reels and simple product UI microinteractions. Include: allowed jobs, budget (2–3), timing ranges, kill criteria, examples of decorative noise to delete. Practical. No After Effects flex.

3:00–4:00

Rebuild

Before/after edit.

“Watch clarity jump when noise leaves.”

4:00–4:50

Close

“Comment JOBS. Intention is the brand.”

Natural lines

On UI motion

“Feedback > floaty logos.”

60–75s cut

0–3s

Hook

“Three motions max.”

3–25s

Jobs

“Guide / connect / confirm.”

25–50s

Cut

“Noise out.”

50–70s

CTA

Comment JOBS.

Edit notes

Show your own edits.
Keep before brutal, after clean.

Motion craft companion to Tool Speedrun.

Truth check

Map explicit
Before/after

Design Eye · 07 · Script 61

Full production script · Design Eye · 07 · Script 61

Technical users can handle density—not confusion.

i2G / data-UI density rules: hierarchy, scan paths, progressive disclosure—not empty ‘clean’ at the cost of power.

10–14 min Data UI Density Hire · complex-product designer

On-camera hygiene · Design EyeCritique patterns, not people. Prefer anonymized or public screenshots you have rights to show. Don’t dox a competitor’s private staging. Teach the rule; don’t farm dunks.

Hire signalA product team should think: he has senior design taste and can encode it into product—brand, type, density, motion, explainability—not moodboard tourism.

Steal-this value

Scan path

Where the eye goes first.

Grouping

Related controls travel together.

Disclosure

Advanced behind clear doors.

Not sparse

Whitespace ≠ clarity.

Finance/tech

Respect expert users.

Packaging

Title ADensity Done Right

Title BPower Users Hate Fake Minimalism

CTAComment DENSITY for the hierarchy rules

Prep

Dense UI mock (Axiom/i2G-like or anonymized)
Annotated scan path
Rules slate

Spine

1Fake clean

2Rules

3Annotate

4Fix

5Close

Full run of show

0:00–0:25

Open

“Technical users can handle density. They can’t handle confusion. Here’s the difference.”

0:25–1:50

Rules

“Primary action obvious · secondary grouped · numbers aligned · labels consistent · advanced folded with a name—not hidden forever.”

1:50–3:30

Hierarchy

Write hierarchy rules for dense fintech / ops data UI (i2G-like). Include: scan-path checklist, grouping rules, typography scale for numbers, progressive disclosure patterns, anti-patterns (mystery meat icons, uneven columns). Educational product UX. No live account data.

3:30–4:30

Annotate

Draw scan path on screen.

“If I can’t narrate the path in five seconds, redesign.”

4:30–5:20

Close

“Comment DENSITY. Expert UI is a craft.”

Natural lines

On empty

“Deleting controls isn’t simplicity—it’s amputating power.”

60–75s cut

0–3s

Hook

“Density ≠ confusion.”

3–25s

Rules

“Scan path.”

25–50s

Annotate

“Five-second narrate.”

50–70s

CTA

Comment DENSITY.

Edit notes

Mock/demo data only.
Blur any real balances.

Complex product UX craft.

Truth check

No live PII/P&L
Rules explicit

Design Eye · 08 · Script 62

Full production script · Design Eye · 08 · Script 62

Compliance UI that doesn’t hide the why.

VeritasGuard-style explainability / HITL: show rationale, uncertainty, and human action without burying trust.

11–15 min HITL case UI Explainability Hire · trust & safety product designer

On-camera hygiene · Design EyeCritique patterns, not people. Prefer anonymized or public screenshots you have rights to show. Don’t dox a competitor’s private staging. Teach the rule; don’t farm dunks.

Hire signalA product team should think: he has senior design taste and can encode it into product—brand, type, density, motion, explainability—not moodboard tourism.

Steal-this value

Why visible

Rationale next to the decision.

Uncertainty

Don’t fake certainty.

HITL actions

Approve / override / escalate—clear.

Audit trail

What a human changed.

Tone

Calm, precise—not scary red theater.

Packaging

Title AExplainability UX That Builds Trust

Title BCompliance UI That Shows the Why

CTAComment WHY for the HITL pattern

Prep

Demo HITL case (synthetic)
Pattern slate
Disclaimer: illustrative

Spine

1Hidden why

2Pattern

3Build brief

4Edge cases

5Close

Full run of show

0:00–0:25

Open

“If compliance UI hides the why, operators stop trusting—and then they stop using it. Here’s the pattern.”

0:25–2:00

Pattern

“Decision · evidence · model rationale · confidence · human action · log. Miss one and you’ve built a black box with a pretty coat.”

2:00–3:40

Brief

Design an explainability + HITL case panel for a compliance / risk review product (VeritasGuard-like). Include: layout hierarchy, rationale blocks, uncertainty state, override flow, audit snippet, copy tone guidelines. Synthetic data only. No real PHI/PII. No fake legal guarantees.

3:40–4:40

Edges

“Stale evidence · conflicting signals · override without reason (block it). Those states are the product.”

4:40–5:30

Close

“Trust UI is how you get hired for serious systems. Comment WHY. Library complete—now go film.”

Natural lines

On theater

“Red banners aren’t explainability.”

On library

“62 scripts. Ship one this week.”

60–75s cut

0–3s

Hook

“Show the why.”

3–25s

Pattern

“Decision → rationale → HITL.”

25–50s

Edges

“Conflict states.”

50–70s

CTA

Comment WHY.

Edit notes

Synthetic case only.
No real regulated data.

Library closer · trust UX craft.

Truth check

Synthetic only
Pattern explicit
No fake legal claims

The Thesis

Creators without receipts

Builder with a face

What content is (and isn’t)

Distribution can be designed on purpose

Mechanics

Spectacle brand

Positioning & The Character

One-sentence identity (bio)

Stances you defend (repeatable)

The enemy (makes the brand legible)

Tone

Content Pillars

Lead magnet form → Instantly in 40 min

Supabase auth + Stripe checkout

Court Tracker status webhook

Rank Radar competitor scrape

HeyGen outreach clip generator

n8n onboarding zero-touch

Expo push for trading alerts

Cortex agent route in public

FitPro meal plan API glue

Revive Air speed-to-lead

Zerodha order ticket density

PhonePe vs GPay pay confirm

Banking app empty states

TradingView mobile chart chrome

Upwork proposal composer

Instagram Insights as product UX

Stripe Customer Portal

Notion AI empty prompt

Med spa booking flows

Aggregator restaurant pages

Cursor + Claude Code setup tour

How I brief myself before a build

MCP: HeyGen OAuth live

FSH day, content night

Agent wiki ingest (brain-varun style)

Design → code without Figma handoff

Stripe + Supabase RLS in 12 minutes

What I refuse to automate

One operator vs five vendors cost map

shadcn decisions that matter

XAUUSD 15m color-flip levels

Axiom score explained without hype

Pine Script bug that cost a session

Killzone filter for gold

From chart → Telegram alert

Futures vs spot — what the product shows

Backtest honesty rules

Why fintech content attracts buyers

The scope fight (anonymized)

Pricing the Clarity Session

When the client ghosted mid-build

Daily status > silent genius

Upwork → retained

Instantly reply that felt human

Saying no to a bad-fit clinic

Fix after a bad discovery call

New model drop — what actually changed

fal / Replicate batch

Magnific before client send

Recraft logo lockup in 3 variants

ElevenLabs VO for Reel B-roll

Higgsfield character sheet

Claude Projects with pre-AI corpus

video-use / HyperFrames motion pass

Why this SaaS hero fails

Type pairing in 20 seconds

Thumbnail that stops thumbs

Cards vs composition

Dark UI that isn’t muddy

Motion with a job

i2G density done right

VeritasGuard explainability UX

The Script System

The 0–3 second rule (really ~0–1.5s)

Hook taxonomy

Beat structures

Hook → demo → payoff