Blog

Watch on YouTube: https://www.youtube.com/watch?v=coe4fmu5cE8

Channel: Pace Morby

Introduction

In the Pace Morby video titled “The “Arbitrage” Secret That Built a $100k/Month Business,” the host explains how a simple referral model turned a Craigslist lead into a recurring revenue stream. By acting as an estimator or middleman, Pace connected home‑service buyers with licensed providers, added a markup, and collected a finder’s fee without performing the work himself or holding a contractor license. The video walks through the original paint‑contract deal, the scaling process across multiple trades, and the practical steps anyone can follow to replicate the arbitrage approach.

What the Video Covers

The presentation is broken into several core sections:

• The origin story: how a $2,500 finder fee for 15 houses per week at $1 per sq ft with Tom from Luxor Paints grew into roughly $25,000 per month.
• The mechanics of service arbitrage: finding a buyer, referring the work to a provider, and retaining a fee or markup.
• How Pace expanded the model to other home‑services such as cabinet refinishing, carpet, roofing, plumbing, HVAC, and landscaping.
• Specific numbers he used for markups (flat $1,000‑$1,500 per job or per‑unit amounts like $25 per cabinet door).
• Why a contractor license is not required when you act as the estimator/middleman.
• The role of lead generation channels—Craigslist and Facebook Marketplace—and the importance of a “yes” mindset.
• How AI‑generated before/after images can improve ad performance for these services.
• Practical action items for launching and scaling an arbitrage‑based business.
• A hype check that contextualizes the $80‑$100k/month claim as personal experience rather than a guaranteed outcome.

Step‑by‑Step Walkthrough of the Arbitrage Model

1. Identify a service niche – Choose a home‑service that is easy to estimate (e.g., cabinet refinishing priced per door, exterior paint priced per sq ft, carpet priced per yardage, roofing).
2. Source a licensed provider – Use Craigslist, Facebook Marketplace, or local trade directories to find a contractor willing to work at a wholesale rate. Example: a cabinet refinisher charging $50 per door.
3. Negotiate the wholesale rate – Agree on a base price that the provider will accept for completing the work.
4. Determine your markup – Add either a flat fee (e.g., $1,000 per job) or a per‑unit fee (e.g., $25 per cabinet door) to the provider’s price. Pace’s example: provider $50/door + Pace $75/door = $125/door quoted to the customer.
5. Create a simple estimate – Count cabinet doors, measure square footage for paint, or measure yardage for carpet. No specialized training is required; basic arithmetic suffices.
6. Post free‑estimate ads – List the service on Craigslist and Facebook Marketplace, emphasizing a free estimate and quick turnaround.
7. Close the lead – When a prospect says yes, confirm the scope, collect payment upfront or set a milestone schedule, and forward the job to the provider.
8. Manage the job – Act as the point of contact, ensure the provider completes the work to the agreed standard, and handle any customer service issues.
9. Collect your fee – After the provider is paid, retain your markup as profit.
10. Repeat and scale – Replicate the process across additional niches, increase ad frequency, and aim for roughly one closed job per three estimates (≈30% close rate).

Tools, Numbers, and Resources Mentioned

• Initial deal: $2,500 finder fee; later $400 per job as a quality check.
• Luxor Paint contract revenue: ~$25,000/month.
• Scaled revenue range: $80,000–$100,000/month after adding multiple services.
• Paint pricing context: $1.00 per sq ft (historical deal), $2.15 per sq ft (two‑story exterior), $1.50 per sq ft (one‑story exterior), current market ~$2.50 per sq ft.
• Cabinet refinishing example: provider $50 per door, Pace markup $75 per door → $125 per door quoted.
• Flat markup examples: $1,000 per job or $1,500 per job.
• Lead platforms: Craigslist, Facebook Marketplace.
• Key contacts/meeting places: Bank of America (where Pace met Tom), Invitation Homes / American Homes for Rent, Dun Edwards paint store.
• AI usage: generate before/after images to boost ad credibility and response rate.

Caveats and Hype Check

Claims of earning $80‑100k/month are based on Pace’s personal experience and may not be typical; success depends on consistent lead generation, negotiation skill, and market conditions, and there is no guarantee of similar results.

The video emphasizes that the arbitrage model works best when you can reliably source leads, negotiate wholesale rates, and maintain a “yes” mindset—acting quickly when a prospect agrees. Payment risk is mitigated by collecting upfront or using milestone payments, especially important in home‑services where clients may otherwise delay or withhold payment.

Concrete Next Actions

• Post daily free‑estimate ads on Craigslist and Facebook Marketplace for services such as cabinet refinishing, exterior paint, carpet, or roofing.
• Identify a licensed provider for each chosen service and negotiate a wholesale rate (e.g., $50 per cabinet door).
• Add a markup—either a flat amount ($1,000‑$1,500 per job) or a per‑unit amount ($25 per door)—and present the total price to the customer.
• Perform simple estimates: count doors, measure square footage, or measure yardage; no specialized certification needed.
• Use AI tools to create before/after visuals for your ads to increase credibility and response rate.
• Track leads and aim for at least one closed job per three estimates (≈30% close rate).
• Collect payment upfront or establish a milestone schedule to reduce non‑payment risk.
• Reinforce the “yes” mindset: when a lead says yes, figure out how to deliver within 30 minutes.
• Consider building a simple lead‑capture website or landing page to automate inquiries.
• Review results regularly, refine your markup and lead sources, and add new service niches as confidence grows.

Watch on YouTube: https://www.youtube.com/watch?v=LP7bfT4vOlo

Channel: Nick Saraev

Introduction

The video from Nick Saraev’s channel explains a practical way to create a personal knowledge base—sometimes called a “second brain”—using the Claude family of models. Rather than loading every piece of information directly into the model’s context window, the approach keeps data external, indexes it with a lightweight search algorithm, and retrieves only the most relevant snippets before generating an answer. This retrieval‑augmented generation (RAG) setup aims to keep responses up‑to‑date while reducing the computational cost typically associated with vector‑database solutions.

What the video covers

The presenter outlines why large context windows (now able to hold the equivalent of 35‑50 books of tokens) can lead to stale answers when all stored data is given equal weight. He introduces recency‑weighted retrieval as a solution: each incoming item is timestamped, and the system biases retrieval toward newer entries. The video then walks through a complete pipeline that continuously pulls new data via connectors, summarizes and extracts key “atoms” with a cheap LLM, stores those summaries in a plain‑text BM25 index, and monitors connector health to maintain freshness.

Step‑by‑step walkthrough

• Identify the information sources you want to feed into the knowledge base (e.g., email, Slack, call transcripts, closed AI sessions).
• Build or adapt a connector script that queries each source for only new items since the last run, attaches the current timestamp to each record, and writes the raw text to a staging area.
• Schedule the connector to run on a regular cadence—such as every 15 minutes—using a cron job or similar scheduler, adjusting the frequency based on API limits and system capacity.
• Pass each newly captured item through a cost‑effective LLM (Claude Haiku 5.5) to generate two outputs: a concise summary and a list of atoms, which are discrete pieces of information like error messages, solutions, commands, or decisions.
• Store the summary and atom list as plain‑text entries in a BM25‑indexed collection; the index enables fast keyword‑based retrieval without the overhead of vector embeddings.
• Deploy a background monitoring script that checks connector health (API keys, permissions, network connectivity) and logs any failures, triggering alerts if the pipeline stalls.
• Periodically review the index to prune outdated or redundant entries, keeping the searchable corpus lean and ensuring that recency weighting remains effective.
• Test the end‑to‑end flow by asking Claude a question that should be answered using the knowledge base; verify that the returned answer cites recent, relevant summaries or atoms.
• Visit the Maker Zero repository (referenced in the video description) to copy the ready‑to‑use prompt for summarization/atom extraction and to join the community for updates and troubleshooting.

Tools and numbers mentioned

• Claude Haiku 5.5 – the inexpensive model used for summarizing incoming data and extracting atoms.
• Gmail API (read‑only) – example connector for pulling email messages.
• BM25 – the plain‑text search algorithm that powers the knowledge‑base index.
• Context window size – current consumer LLMs can hold roughly 35‑50 books worth of tokens.
• Scale of the presenter’s engram – about 35‑50 k records stored in the searchable index.
• Connector interval – every 15 minutes in the demonstrated setup.
• Cost and speed improvement – the BM25‑based RAG reduces inference time and maintenance cost by roughly 9/10ths compared with traditional vector‑DB‑driven RAG.
• Resources – prompts and starter code are available in the Maker Zero repository (second link in the video description).

Caveats and hype check

The video mentions that the presenter’s knowledge base powers a business that “generates a good income every month” and that “multi‑billion dollar companies” use similar systems, but it does not provide concrete revenue figures, case studies, or independent verification. These statements should be treated as anecdotal marketing claims rather than proven results. As the presenter notes, “Simple search is much more effective than all other methods,” yet the effectiveness will depend on the quality of the connectors, the relevance of the extracted atoms, and the frequency of updates.

> “It will answer with great confidence because to it, things are like, ‘Hey, there’s a text here, there’s a text there. I don’t know which one is correct. I’ll just give you the first one I find.’”

Concrete next actions

• List all data sources you wish to include (email, Slack, call transcripts, closed AI sessions, etc.) and note any API requirements.
• Write a connector script for each source that fetches only new items since the last run, timestamps them, and saves the raw text to a temporary folder.
• Set up a scheduler (cron, Windows Task Scheduler, or a cloud‑based trigger) to run each connector every 15 minutes or at a cadence that matches your usage patterns.
• Export closed AI chat sessions as plain‑text files and feed them into the same pipeline for long‑term reference.
• Configure a cheap LLM (Claude Haiku 5.5 or an equivalent model) to produce a summary and an atom list for each new item, using the prompt provided in the Maker Zero repository.
• Store the generated summaries and atoms in a BM25 index; many open‑source libraries (e.g., Whoosh, Elasticsearch with BM25 similarity) can be used for this purpose.
• Implement a monitoring script that pings each connector’s API, checks for authentication errors, and logs success/failure status to a file or monitoring service.
• Schedule a weekly maintenance job to review the index, remove entries older than a chosen threshold, and deduplicate similar atoms.
• Copy the summarization/atom‑extraction prompt from the Maker Zero repository and adapt it to your specific terminology if needed.
• Run a test query through Claude, asking a question that should be answered by your knowledge base, and confirm that the response cites recent, relevant information.

Watch on YouTube: https://www.youtube.com/watch?v=mOy7JQjTYwE

Channel: Moritz | AI Systems

Introduction

The video from Moritz | AI Systems shows how to give Claude the ability to “watch” YouTube videos without relying on its native text‑only processing. By installing an open‑source skill called eyes, Claude can index a video’s frames, transcript, on‑screen text, timestamps, and audio/color data. Once indexed, the model can answer detailed questions about the video quickly and consistently, at a cost of only a few cents per video.

What the Video Covers

The presentation walks through the limitations of Claude’s built‑in capabilities, explains how the eyes skill works, demonstrates its core features, provides cost estimates, and outlines practical use cases. Key points include:

• Claude cannot natively process video; it only handles text and static images.
• The eyes skill extracts frames, transcript, on‑screen text, timestamps, and audio/color data to create a local index.
• Indexed data enables fast, repeatable queries for search, burst analysis, layout detection, and video DNA comparison.
• Costs range from approximately 1 cent for a short clip using a cheap model to about 30 cents for a 20‑minute video processed with the top model.
• Installation is performed via a GitHub repository; after setup, the agent invokes the skill with the command /eyes <YouTube‑URL>.
• Use cases highlighted are tutorial step extraction, competitor video analysis, clipping, style copying, and edit validation.
• The tool improves consistency compared with Claude’s ad‑hoc FFMPEG approach, which can vary depending on the prompt.

Step‑by‑Step Walkthrough

1. Install the eyes skill – Copy the GitHub repository link from the video description and instruct your agent to install it. This step sets up the necessary dependencies and makes the /eyes command available.
2. Index a video – Run /eyes <YouTube‑URL> pointing to the target YouTube video. The skill will:
   • Extract frames at a configurable rate (the demo mentions bursts of 8 frames per second).
   • Download the transcript and any on‑screen text.
   • Capture audio and color information for later analysis.
   • Store all extracted data locally so subsequent queries are fast and consistent.
3. Run queries – Once indexing is complete, you can ask Claude specific questions. Examples from the video include:
   • Searching for on‑screen text or keywords.
   • Using the burst feature to capture a rapid series of screenshots from an interesting segment.
   • Applying the measure command to generate an editing DNA report (e.g., cuts per minute, percentage of shots under one second).
   • Comparing two videos by analyzing their DNA reports to spot similarities or differences in editing style.
   • Cropping or extracting specific frames for further use.
4. Apply insights – The DNA report can be used to:
   • Edit a raw clip to match the pacing and style of a reference video.
   • Validate your own edits before publishing by checking against reference metrics such as layout changes or shot length distribution.

Tools, Numbers, and Technical Details

The video provides concrete figures that help estimate the expense of using the eyes skill:

• ≈ 1 cent for a 45‑second video processed with a cheap model.
• ≈ 2 cents for the same length with a mid‑tier model.
• ≈ 10 cents for a 45‑second video using the top model.
• ≈ 20 cents for a 2‑minute video with the top model.
• ≈ 30 cents for a 20‑minute video with the top model.

Other technical mentions include:

• The skill relies on FFMPEG for frame extraction when used ad‑hoc, but the eyes tool provides a consistent, repeatable alternative.
• Burst mode captures approximately 8 frames per second.
• The measure feature can report metrics such as 70 cuts per minute and T7% of shots lasting under one second.
• Installation source is the public GitHub repository linked in the video description.

Caveats and Hype Check

“Claude can’t actually watch videos. It will kind of rebuild everything from scratch.”

The presenter emphasizes that the tool is free and open‑source, with no affiliate promotions or hidden revenue claims. Cost estimates are approximate and depend on the model selected; the core functionality is presented as genuinely accessible without upsells. However, users should note that:

• Initial indexing requires processing time proportional to video length and the chosen model’s speed.
• Local storage is needed to hold the indexed frames, transcript, and audio data.
• While the skill improves consistency over ad‑hoc FFMPEG prompts, the quality of on‑screen text extraction depends on the underlying OCR capabilities.

Concrete Next Actions

To start using the eyes skill with Claude, consider the following steps:

• Obtain the GitHub repository URL from the video description and run the installation command via your agent.
• Test the skill on a short YouTube clip (e.g., a 45‑second tutorial) using /eyes <URL> to verify indexing and query response times.
• Experiment with the burst feature on a segment containing fast motion or animation to see how many frames are captured per second.
• Generate a measure report for two competing videos and compare their editing DNA (cuts per minute, shot length distribution) to identify stylistic differences.
• Search your indexed library for specific on‑screen text or keywords relevant to a research task.
• Apply the DNA report to edit a raw clip, aiming to match the reference video’s pacing and layout changes.
• Before publishing any edited video, run a validation check against the reference metrics to ensure consistency.