AI Repository Client Offer Playbook

For: Life of Arjav resource guide
Compiled: 18 Aug 2026
Scope: A practical setup and execution guide for the 7 repositories shown in the carousel: Pipecat, Cline, Postiz, AnythingLLM, CrewAI, Browser Use, and Firecrawl.

Important: The dollar amounts from the carousel are positioning examples for packaging client projects. They are not guaranteed market rates. Price based on measurable client value, implementation complexity, support scope, and risk.

---

1. What this guide is for

The common theme across all 7 repositories is simple:

You use Claude as the reasoning layer, these repositories as the execution layer, and package the result as a client-ready business system.

The practical goal is not to sell “AI tools.” The goal is to sell outcomes:

---

2. Base setup before touching any repository

2.1 Install core tools

Install these once on your machine:

# macOS Homebrew, if not installed already
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Git
brew install git

# Node.js, useful for Cline, web apps, and SDKs
brew install node

# Python and uv, useful for Pipecat, CrewAI, Browser Use, Firecrawl
brew install python uv

# Docker, useful for Postiz and AnythingLLM
brew install --cask docker

For Windows, use WSL2 for the smoothest Python, Docker, and Claude Code workflow.

---

2.2 Install Claude Code

Claude Code is the control center. Use it to read docs, scaffold projects, write code, debug, test, and create repeatable skills.

# macOS, Linux, WSL
curl -fsSL https://claude.ai/install.sh | bash

# Confirm install
claude --version

# Start and authenticate
claude

Alternative installs:

# macOS Homebrew
brew install --cask claude-code

# Windows
winget install Anthropic.ClaudeCode

---

2.3 Set API keys

Create a root .env file for your project experiments:

mkdir -p ~/ai-client-systems
cd ~/ai-client-systems
nano .env

Use this template:

# Claude / Anthropic
ANTHROPIC_API_KEY=your_anthropic_key

# Optional providers used by specific projects
OPENAI_API_KEY=your_openai_key
GOOGLE_API_KEY=your_google_key
DEEPGRAM_API_KEY=your_deepgram_key
CARTESIA_API_KEY=your_cartesia_key
ELEVENLABS_API_KEY=your_elevenlabs_key
TWILIO_ACCOUNT_SID=your_twilio_sid
TWILIO_AUTH_TOKEN=your_twilio_token
SERPER_API_KEY=your_serper_key
FIRECRAWL_API_KEY=your_firecrawl_key
BROWSER_USE_API_KEY=your_browser_use_key

Load it in a shell session:

set -a
source .env
set +a

---

3. How to use Claude Skills with these repositories

Skills are reusable instructions that Claude can load when a task matches the skill. Use them when you keep repeating the same setup, scoping, QA, deployment, or documentation process.

Project skills live here:

mkdir -p .claude/skills

A skill is just a folder with a SKILL.md file:

mkdir -p .claude/skills/client-system-builder
nano .claude/skills/client-system-builder/SKILL.md

Use this starter skill:

---
name: client-system-builder
description: Use this when turning an open-source AI repository into a client-ready system, including setup, scoping, implementation, QA, handoff docs, and pricing logic.
---

# Client System Builder

When this skill is active, convert a repository into a commercial client system.

## Process

1. Identify the client pain and measurable business outcome.
2. Read the official docs and repository README before writing code.
3. Create a minimal working demo first.
4. Add guardrails, logging, error handling, and secrets handling.
5. Create a client-facing handoff document.
6. Create a maintenance checklist.
7. Separate what is demo-grade from what is production-grade.

## Required output

- Offer name
- Client ICP
- Setup steps
- MVP architecture
- Required APIs
- Demo script
- QA checklist
- Deployment checklist
- Pricing logic
- Risks and limitations

Invoke it inside Claude Code:

/client-system-builder Turn firecrawl/firecrawl into a lead generation system for boutique recruiting agencies. Build a working local MVP and document every setup step.

---

4. Recommended project folder structure

Use one folder per system:

mkdir -p ~/ai-client-systems/{phone-agent,website-builder,social-engine,company-ai,multi-agent-retainer,browser-automation,lead-machine}

Recommended structure inside each:

project-name/
├── .claude/
│   └── skills/
├── docs/
│   ├── client-brief.md
│   ├── implementation-plan.md
│   ├── qa-checklist.md
│   └── handoff.md
├── src/
├── scripts/
├── data/
├── outputs/
├── .env.example
├── README.md
└── CLAUDE.md

Add a CLAUDE.md file in each project:

# Project Instructions for Claude

You are helping build a production-oriented client system.

Rules:
- Read official docs before implementing.
- Never hardcode secrets.
- Use `.env.example` for required keys.
- Build the smallest working demo first.
- Add logs and clear error messages.
- Document setup, usage, failure modes, and handoff.
- Ask before deleting files or changing deployment configuration.
- Separate assumptions from verified facts.

---

Resource 1: pipecat-ai/pipecat

The offer

Carousel framing: The $8,000 phone agent.
Client outcome: A voice AI agent that answers calls, qualifies leads, books appointments, and logs the outcome.

Best-fit clients:

• Clinics
• Salons
• Local service businesses
• Real estate agencies
• Dental offices
• Home service companies
• Restaurants with reservation or catering calls

Good use cases:

• After-hours receptionist
• Lead qualification bot
• Appointment booking assistant
• FAQ and routing assistant
• Follow-up calling assistant

Avoid pitching this first to clients who need regulated medical, legal, financial, or emergency advice unless you have strict compliance, logging, escalation, and human takeover workflows.

---

What Pipecat does

Pipecat is a framework for real-time voice and multimodal AI agents. It connects the moving parts required for voice AI:

• Transport layer, such as web, phone, or video room
• Speech-to-text
• LLM reasoning
• Tool/function calls
• Text-to-speech
• Conversation state
• Interruption handling
• Session logging

---

Install and scaffold

cd ~/ai-client-systems/phone-agent

# Install Pipecat CLI
uv tool install "pipecat-ai[cli]"

# Verify
pipecat --version

# Initialize a project
pipecat init

During pipecat init, choose the setup closest to your target:

• Phone bot for receptionist, inbound calls, appointment booking
• Web bot for website demo or browser-based voice assistant
• Coding agent path if you want Claude Code to scaffold and edit the project

Pipecat can also install Context Hub for coding agents:

uv tool install "pipecat-ai[cli]" --with pipecat-ai-context-hub
pipecat context-hub install

This gives Claude Code local Pipecat docs and API context so it is less likely to hallucinate outdated imports.

---

Minimal MVP architecture

Caller
  -> Phone provider or browser transport
  -> Pipecat pipeline
  -> STT provider
  -> Claude as the reasoning layer
  -> Tool calls: calendar, CRM, FAQ, lead qualification
  -> TTS provider
  -> Caller hears response
  -> Call transcript and result stored

Suggested service options:

---

Claude prompt to build it

Use this inside the Pipecat project folder:

You are building a Pipecat-based AI receptionist MVP for a local service business.

Goal:
- Answer inbound calls.
- Ask what service the caller needs.
- Collect name, phone, email, preferred date/time, and urgency.
- Answer basic FAQ from docs/business_faq.md.
- If the caller wants to book, create a structured booking request in outputs/bookings.jsonl.
- If unsure, escalate to a human callback.

Rules:
- Read the existing Pipecat project files first.
- Use current Pipecat conventions from AGENTS.md, CLAUDE.md, and Context Hub if available.
- Keep the first version local and demo-friendly.
- Do not integrate live Twilio until the local voice/web demo works.
- Add .env.example with required variables.
- Add docs/handoff.md and docs/test-script.md.

---

Test script

Use these calls to test the agent:

1. "Hi, I need to book a cleaning for next Friday."
2. "How much do you charge?"
3. "Can you send someone today?"
4. "I am not sure what service I need."
5. "Can I speak to a person?"

Expected output:

{
  "caller_name": "...",
  "phone": "...",
  "email": "...",
  "service_needed": "...",
  "preferred_time": "...",
  "urgency": "...",
  "summary": "...",
  "human_follow_up_required": true
}

---

Client packaging

Sell the outcome, not Pipecat.

Suggested deliverables:

• AI receptionist demo trained on business FAQs
• Call qualification script
• Booking data capture
• Escalation rules
• Transcript logging
• Admin handoff guide
• 2 weeks of tuning

Pricing logic:

Monthly missed calls x average booking value x close rate = recoverable revenue

Example:

40 missed calls/month x $200 average value x 30% booking rate = $2,400/month recoverable revenue

A $3,000 to $8,000 setup becomes easier to justify if the system saves admin time and recovers missed revenue.

---

Resource 2: cline/cline

The offer

Carousel framing: The $5,000 website.
Client outcome: Build a client website, landing page, internal portal, or simple app with Claude doing the coding work through Cline.

Best-fit clients:

• Service businesses needing a conversion site
• Agencies needing microsites
• Consultants needing lead capture pages
• Internal teams needing dashboards
• Creators needing directories or tools

---

What Cline does

Cline is an autonomous coding agent available as an IDE extension, CLI, SDK, and related workflows. In practice:

• Claude plans and reasons
• Cline edits files
• Cline runs commands
• Cline reads errors
• Cline iterates until the project works

---

Install Cline

Option A: IDE extension

Use this if you work in VS Code, Cursor, Windsurf, VSCodium, Antigravity, or JetBrains.

Steps:

1. Open the Extensions panel.
2. Search for Cline.
3. Install it.
4. Open the Cline panel.
5. Add your provider key or authenticate with Cline.

Option B: CLI

# Requires Node.js 20+, Node 22 recommended
npm install -g cline

# Authenticate
cline auth

# Start interactive mode
cline

# Or send a task directly
cline "Create a Next.js landing page for a dental clinic with lead capture"

Option C: SDK

mkdir my-agent && cd my-agent
npm init -y
npm install @cline/sdk

---

Build a $5,000 website system

Use this stack for a clean client website:

cd ~/ai-client-systems/website-builder
npx create-next-app@latest client-site
cd client-site
npm run dev

Recommended choices:

• Next.js app router
• TypeScript
• Tailwind CSS
• Simple form handling first
• Later add Resend, Supabase, Airtable, or HubSpot

---

Claude/Cline build prompt

Build a conversion-focused website for a local service business.

Business type: [replace]
Offer: [replace]
Location: [replace]
Primary CTA: Book a consultation
Secondary CTA: Call now

Requirements:
- Next.js + TypeScript + Tailwind.
- Mobile-first design.
- Pages: Home, Services, About, FAQ, Contact.
- Components: hero, proof bar, services, process, testimonials placeholder, pricing/quote section, FAQ, final CTA.
- Add a lead capture form with fields: name, email, phone, service needed, message.
- Store submissions locally in a JSON file for MVP or create a placeholder server action with clear comments.
- Add SEO metadata.
- Add README with setup, deployment, and client editing instructions.
- Do not overengineer.
- Run the app and fix all errors.

---

Client handoff checklist

• Domain connected
• Analytics installed
• Form submission tested
• Mobile views checked
• SEO title and description added
• Legal pages added if needed
• Deployment on Vercel, Netlify, or client hosting
• Client edit guide recorded or documented
• Backup copy exported

---

Client packaging

Possible deliverables:

• 5-page website
• Copywriting assisted by Claude
• Lead capture form
• Basic SEO
• Analytics
• Deployment
• 30-day bug fix window

Pricing logic:

• Simple landing page: $800 to $2,000
• Full small-business site: $2,500 to $5,000
• Website plus CRM automation: $5,000+

The margin comes from speed, but the value comes from conversion and deployment quality.

---

Resource 3: gitroomhq/postiz-app

The offer

Carousel framing: The $2,000 social client.
Client outcome: A content scheduling and publishing system where Claude creates the content calendar and Postiz publishes it across channels.

Best-fit clients:

• Local businesses
• Founder-led SaaS companies
• Coaches and consultants
• Agencies
• Creators with multiple channels
• Brands posting across LinkedIn, X, Instagram, TikTok, YouTube, Reddit, Slack, Discord, and similar platforms

---

What Postiz does

Postiz is an open-source social media scheduling tool. It lets you connect channels, schedule posts, and use a public API for publishing workflows.

---

Self-host with Docker Compose

Recommended server baseline for small teams:

• 2 vCPU and 2 GB RAM minimum for light use
• 4 vCPU and 8 GB RAM recommended
• 20 GB disk minimum
• 50 GB+ disk recommended if you store uploads

Install:

cd ~/ai-client-systems/social-engine

git clone https://github.com/gitroomhq/postiz-docker-compose
cd postiz-docker-compose

# Review and configure environment variables before starting
cp .env.example .env 2>/dev/null || true
nano .env

# Start
docker compose up

If your system requires lowercase Docker command:

docker compose up

Open:

http://localhost:4007

Temporal UI, if enabled in the compose setup:

http://localhost:8080

---

Configure social channels

Inside Postiz:

1. Create an admin account.
2. Connect brand channels.
3. Create approval rules if client review is required.
4. Generate an API key if automating via API.
5. Test one draft post before scheduling a batch.

---

Use Claude to create the monthly content engine

Create a content brief:

# Client Content Brief

Business:
Audience:
Offer:
Tone:
Forbidden topics:
Proof points:
Content pillars:
Primary CTA:
Posting channels:
Posting cadence:

Claude prompt:

Create a 30-day content calendar for this client.

Inputs:
- Read docs/client-content-brief.md.
- Use 4 content pillars.
- Create 20 LinkedIn posts, 20 X posts, 8 Instagram captions, and 4 newsletter-style long posts.
- Each post must include hook, body, CTA, and asset suggestion.
- Avoid generic AI or marketing fluff.
- Output as CSV with columns: date, platform, post_type, hook, body, CTA, asset_needed, approval_status.

---

Automate scheduling

Start manually first:

1. Generate calendar with Claude.
2. Client approves CSV.
3. Upload/schedule manually in Postiz.
4. Track performance.

Then automate:

1. Use the Postiz API key in the Authorization header.
2. Generate payloads from approved content.
3. Schedule posts in batches.
4. Log success and errors.

Basic API pattern:

curl -H "Authorization: your-api-key" \
  http://localhost:4007/public/v1/integrations

For production use, read the current Postiz API docs for the exact create-post payload per platform, because each platform has its own settings schema.

---

Client packaging

Deliverables:

• Self-hosted or cloud scheduling workspace
• Connected channels
• 30-day content calendar
• Approval workflow
• Posting schedule
• Weekly analytics summary
• Content repurposing prompt library

Pricing logic:

• $500 to $1,000/month for basic scheduling and light content
• $1,500 to $2,500/month for strategy, repurposing, scheduling, and reporting
• $3,000+/month if tied to lead magnets, outbound, paid distribution, or founder brand growth

---

Resource 4: Mintplex-Labs/anything-llm

The offer

Carousel framing: The $3,500 AI setup.
Client outcome: A private AI workspace trained on a company’s documents, processes, FAQs, SOPs, product docs, sales docs, and internal knowledge.

Best-fit clients:

• Agencies
• SaaS teams
• Ops-heavy businesses
• Support teams
• Sales teams
• Internal knowledge teams
• Founder-led businesses with scattered docs

---

What AnythingLLM does

AnythingLLM is an all-in-one AI application for building a private ChatGPT-like workspace over company documents. It supports document chat, agents, multi-user use, model provider configuration, and self-hosted Docker deployment.

---

Run with Docker

cd ~/ai-client-systems/company-ai

export STORAGE_LOCATION=$HOME/anythingllm
mkdir -p $STORAGE_LOCATION
touch "$STORAGE_LOCATION/.env"

docker pull mintplexlabs/anythingllm

docker run -d --rm -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v ${STORAGE_LOCATION}:/app/server/storage \
  -v ${STORAGE_LOCATION}/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm

Open:

http://localhost:3001

If running on a remote server, expose the correct reachable IP or domain and secure it behind HTTPS and authentication.

---

Document preparation workflow

Before uploading to AnythingLLM, clean the client’s knowledge base.

Folder structure:

client-knowledge-base/
├── 01-company-overview/
├── 02-products-services/
├── 03-sales-objections/
├── 04-support-faq/
├── 05-sops/
├── 06-pricing/
├── 07-case-studies/
└── 08-policies/

Claude cleanup prompt:

Organize these client documents into a clean knowledge base for an internal AI assistant.

Tasks:
- Remove duplicates.
- Identify outdated docs.
- Create a source index.
- Convert messy docs into clean markdown.
- Flag contradictions.
- Create a top-level README explaining what each folder contains.
- Create questions the assistant should be able to answer after ingestion.

---

Configure AnythingLLM

Inside the UI:

1. Create a workspace for the client.
2. Choose the LLM provider.
3. Choose embeddings and vector database settings.
4. Upload cleaned documents.
5. Set workspace instructions.
6. Test retrieval quality with real questions.
7. Create role-specific workspace prompts.

Suggested workspace instruction:

You are the internal AI assistant for [Client].
Use only the uploaded documents unless the user explicitly asks for general advice.
When answering from company knowledge, cite the document name when possible.
If the answer is missing or unclear, say that the knowledge base does not contain enough information.
Do not invent pricing, policies, guarantees, legal terms, or technical claims.

---

Role-specific assistant ideas

---

Client packaging

Deliverables:

• Hosted AnythingLLM instance or configured local deployment
• Clean document library
• Workspace instructions
• Role-specific assistants
• Test question set
• Admin guide
• User guide
• 30-day improvement cycle

Pricing logic:

• $1,500 to $3,500 for a basic internal AI setup
• $5,000+ if document cleanup, user permissions, agent workflows, and ongoing support are included
• Monthly support retainer for doc updates and prompt tuning

---

Resource 5: crewAIInc/crewAI

The offer

Carousel framing: The $5,000 retainer.
Client outcome: A multi-agent workflow where each agent has a role and the system coordinates research, analysis, execution, QA, and reporting.

Best-fit clients:

• Agencies
• B2B service companies
• Research-heavy teams
• Ops teams
• GTM teams
• Recruiting and staffing companies
• Businesses with repetitive decision workflows

---

What CrewAI does

CrewAI is a Python framework for multi-agent workflows. It has two useful patterns:

• Crews: role-based agents collaborating on tasks
• Flows: event-driven workflows with more deterministic control

Use Crews for flexible reasoning. Use Flows for predictable business processes.

---

Install CrewAI

cd ~/ai-client-systems/multi-agent-retainer

# Create virtual environment
uv venv --python 3.12
source .venv/bin/activate

# Install CrewAI
uv pip install crewai

# Install tools extras if needed
uv pip install 'crewai[tools]'

Create a new crew:

crewai create crew client_ops_crew
cd client_ops_crew

Run:

crewai install
crewai run

---

Install official CrewAI skills in Claude Code

Inside Claude Code:

/plugin marketplace add crewAIInc/skills
/plugin install crewai-skills@crewai-plugins
/reload-plugins

This gives Claude Code CrewAI-specific setup and design guidance.

---

Example retainer system: outbound campaign crew

Agents:

Workflow:

Input client brief
  -> ICP Researcher creates target definition
  -> Lead Analyst enriches and scores accounts
  -> Offer Strategist creates angles
  -> Copywriter drafts sequences
  -> QA Reviewer flags problems
  -> Reporting Analyst creates client report

---

Claude prompt to build it

Use CrewAI to build a multi-agent workflow for a B2B outbound agency.

Goal:
Given a client brief and a CSV of prospects, produce:
- ICP scoring
- offer angle per segment
- 3 cold email sequence variants
- QA notes
- weekly client report

Implementation requirements:
- Use a CrewAI project structure.
- Define agents in agents.yaml.
- Define tasks in tasks.yaml.
- Use sequential process for MVP.
- Read input from data/prospects.csv and docs/client-brief.md.
- Save outputs to outputs/.
- Add .env.example.
- Add README with exact run steps.
- Keep first version local.

---

Client packaging

Deliverables:

• Multi-agent workflow
• Input templates
• Output templates
• QA rules
• Weekly report generation
• Human review checkpoints
• Maintenance and improvement cycle

Pricing logic:

Retainers work when the system runs every week and affects revenue, hiring, ops, or client delivery.

Possible packages:

• $1,500/month: one narrow workflow, manual triggering
• $3,000/month: weekly workflow with reporting and improvements
• $5,000+/month: multiple workflows, integrations, client calls, monitoring, and optimization

---

Resource 6: browser-use/browser-use

The offer

Carousel framing: The $1,200 automation.
Client outcome: Automate browser tasks that do not have clean APIs.

Best-fit clients:

• Ops teams
• Recruiters
• Agencies
• Back-office teams
• Local businesses with repetitive dashboards
• Teams that copy/paste between web portals

Good use cases:

• Fill forms
• Download reports
• Extract data from logged-in dashboards
• Submit routine applications
• Move data between web tools
• Check status pages
• Perform repetitive browser workflows

Avoid using this for anything that violates a site’s terms, bypasses access controls, scrapes private data without permission, or handles sensitive actions without human approval.

---

What Browser Use does

Browser Use gives AI agents browser control. Claude can reason through a task while Browser Use handles page navigation, clicks, fields, screenshots, and extraction.

---

Install Browser Use

cd ~/ai-client-systems/browser-automation

uv venv --python 3.12
source .venv/bin/activate

uv pip install browser-use
uvx browser-use install

Create .env:

touch .env
nano .env

Add one or more keys:

BROWSER_USE_API_KEY=your_browser_use_key
ANTHROPIC_API_KEY=your_anthropic_key
OPENAI_API_KEY=your_openai_key
GOOGLE_API_KEY=your_google_key

Browser Use also supports installing a skill for coding agents:

browser-use skill install

If using Claude Code, you can ask:

Install or upgrade browser-use to the latest stable version with uv using Python 3.12, run browser-use skill install to register the skill, and connect it to my browser. If setup or connection fails, inspect the official browser-use setup docs and fix the environment.

---

Minimal Python agent

import asyncio
from browser_use import Agent, ChatBrowserUse

async def main():
    agent = Agent(
        task="Open example.com, summarize the page, and return the title.",
        llm=ChatBrowserUse(model="openai/gpt-5.5"),
    )
    history = await agent.run()
    print(history)

if __name__ == "__main__":
    asyncio.run(main())

For Claude-specific usage, use a current supported Anthropic/Claude model from the Browser Use docs or configure the LLM wrapper recommended by the current package version.

---

Client automation discovery template

Ask the client:

1. What browser task do you repeat every day or week?
2. What website or dashboard is involved?
3. Does it require login?
4. What data goes in?
5. What data comes out?
6. What mistakes happen when humans do it?
7. What is the value of saving this time or avoiding this error?
8. What action should always require human approval?

---

Claude prompt to build a browser automation

Build a Browser Use automation for this task:
[describe task]

Rules:
- Use a test account or sandbox first.
- Do not store credentials in code.
- Read credentials from environment variables.
- Add allowed domain restrictions if the library supports it in the current version.
- Take screenshots at each major step for debugging.
- Log extracted data to outputs/results.csv.
- Stop before any irreversible action unless APPROVE_FINAL_ACTION=true.
- Add docs/runbook.md with exact steps and known failure cases.

---

Client packaging

Deliverables:

• Workflow mapping
• Browser automation script
• Login and secrets setup
• Test mode
• Human approval step
• Output file or webhook
• Error screenshots
• Runbook

Pricing logic:

hours saved per month x hourly cost + error reduction + speed value = monthly value

A $1,200 job is defensible when it saves 10 to 30 hours/month or removes a recurring operational bottleneck.

---

Resource 7: firecrawl/firecrawl

The offer

Carousel framing: The $5,000 lead machine.
Client outcome: Turn websites into clean data, feed the data into Claude, and produce qualified lead lists, summaries, or research outputs.

Best-fit clients:

• B2B agencies
• Recruiters
• Sales teams
• Market research teams
• Investors
• Local lead generation businesses
• E-commerce research teams

---

What Firecrawl does

Firecrawl provides API endpoints for search, scrape, interact, crawl, map, and batch scrape workflows. The practical value is converting web pages into LLM-ready markdown or structured data.

---

Install Firecrawl SDK

cd ~/ai-client-systems/lead-machine

uv venv --python 3.12
source .venv/bin/activate

pip install firecrawl-py

Create .env:

FIRECRAWL_API_KEY=fc-YOUR-API-KEY
ANTHROPIC_API_KEY=your_anthropic_key

Load keys:

set -a
source .env
set +a

---

Basic search

from firecrawl import Firecrawl

app = Firecrawl(api_key="fc-YOUR-API-KEY")
results = app.search("outplacement firms United States", limit=5)

for result in results.web:
    print(result.title, result.url)

---

Basic scrape

from firecrawl import Firecrawl

app = Firecrawl()
result = app.scrape("https://example.com")
print(result.markdown)

---

Lead machine architecture

Search query
  -> Firecrawl search
  -> Firecrawl scrape relevant pages
  -> Claude extracts structured fields
  -> Deduplicate by domain
  -> Score ICP fit
  -> Export CSV
  -> Optional enrichment
  -> Optional outreach sequence

---

Lead CSV schema

company_name,domain,industry,location,source_url,description,services,target_buyers,signals,fit_score,reason,email_status,notes

---

Claude extraction prompt

Extract structured lead data from the markdown below.

Return strict JSON with:
- company_name
- domain
- industry
- location
- services
- target_buyers
- buying_signals
- disqualifiers
- summary
- fit_score from 1 to 5
- fit_reason

Rules:
- Do not invent missing fields.
- Use null where unavailable.
- Prefer exact website language when summarizing services.
- Keep fit_reason under 30 words.

Markdown:
[PASTE MARKDOWN]

---

Python skeleton for search, scrape, and export

import csv
import os
from firecrawl import Firecrawl

FIRECRAWL_API_KEY = os.getenv("FIRECRAWL_API_KEY")
app = Firecrawl(api_key=FIRECRAWL_API_KEY)

query = "outplacement firms United States"
search_results = app.search(query, limit=10)

rows = []
for item in search_results.web:
    url = item.url
    try:
        page = app.scrape(url)
        rows.append({
            "company_name": item.title,
            "domain": url,
            "source_url": url,
            "raw_markdown_preview": page.markdown[:1000] if page.markdown else "",
        })
    except Exception as e:
        rows.append({
            "company_name": item.title,
            "domain": url,
            "source_url": url,
            "raw_markdown_preview": "",
            "error": str(e),
        })

with open("outputs/leads_raw.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=rows[0].keys())
    writer.writeheader()
    writer.writerows(rows)

Then use Claude to convert the raw markdown previews into a clean structured CSV.

---

Client packaging

Deliverables:

• Lead source strategy
• Search query list
• Scrape pipeline
• Claude extraction prompt
• Deduplication logic
• CSV export
• Fit scoring
• Optional outbound angles
• Weekly refresh

Pricing logic:

A $5,000/month lead machine needs recurring value. Package it as:

• Weekly lead list refresh
• ICP scoring
• New buying signals
• Outreach-ready CSV
• Campaign angle suggestions
• Data QA and deduplication

---

8. Combining the repositories into higher-value systems

The strongest offers come from combining tools.

8.1 Lead generation engine

Firecrawl
  -> scrape and structure lead data
Claude
  -> score ICP fit and write angles
CrewAI
  -> split research, scoring, copy, QA, reporting
Postiz or outbound tool
  -> distribute content or outreach assets

Sell as:

Weekly qualified lead intelligence and campaign asset system

---

8.2 AI business operating system

AnythingLLM
  -> company knowledge base
CrewAI
  -> multi-agent workflows
Browser Use
  -> handles web portals with no API
Claude Skills
  -> repeatable SOPs and QA

Sell as:

Internal AI operations system for teams drowning in repetitive admin work

---

8.3 Receptionist plus booking system

Pipecat
  -> voice agent
Claude
  -> reasoning and conversation handling
Browser Use or API integration
  -> books into calendar or dashboard
AnythingLLM
  -> answers from business docs

Sell as:

AI receptionist that answers, qualifies, and prepares bookings for staff approval

---

8.4 Content agency system

Claude
  -> content strategy and copy
Postiz
  -> scheduling
Firecrawl
  -> source research
CrewAI
  -> research, writing, editing, QA agents

Sell as:

Founder-led content engine with research, scheduling, and reporting

---

9. Commercial validation workflow

Before building a heavy system, validate with this sequence:

Step 1: Pick one painful workflow

Bad:

I build AI agents.

Better:

I help dental clinics answer missed calls and turn them into booked appointments.

Step 2: Build a narrow demo

A demo should show one job done end-to-end:

• One call answered
• One website generated
• One month of posts scheduled
• One company knowledge base queried
• One lead list generated
• One repetitive browser workflow completed

Step 3: Sell the demo, not the architecture

Client framing:

I built a small demo showing how this could work for your team. It handles [specific task], produces [specific output], and saves [specific time or cost]. Want me to adapt it to your process?

Step 4: Scope production separately

Always separate:

---

10. Client discovery questions

Use these before quoting:

1. What exact task do you want automated or improved?
2. Who does it today?
3. How often does it happen?
4. How long does it take each time?
5. What tools are involved?
6. What data goes in?
7. What output is expected?
8. What happens if the system makes a mistake?
9. What actions require human approval?
10. What would make this project a clear win after 30 days?

---

11. Pricing logic

Use value-based pricing, but keep the scope real.

One-time setup pricing

Monthly retainer pricing

---

12. QA checklist for every system

• Runs locally from clean install instructions
• .env.example includes every required variable
• No secrets are committed
• Logs are readable
• Failure cases are documented
• Client can understand the output
• Human approval exists before irreversible actions
• Data storage location is documented
• System has a rollback or manual fallback
• Client handoff guide exists

---

13. Production readiness checklist

Use this before charging serious money:

• Authentication configured
• HTTPS enabled
• Secrets stored securely
• Database or file persistence confirmed
• Backups configured if data matters
• Monitoring or error alerts added
• Rate limits understood
• Terms of service checked for browser automation or scraping
• Client data handling documented
• Clear ownership and maintenance terms agreed

---

14. Copy-paste Claude master prompt

Use this with any repository:

I want to turn this open-source repository into a client-ready AI system.

Repository: [repo]
Client type: [client type]
Outcome: [business outcome]
Offer price target: [price]

Your job:
1. Read the official docs and README.
2. Explain the simplest MVP architecture.
3. Create a local setup plan.
4. Create the required file structure.
5. Implement the minimum working version.
6. Add .env.example.
7. Add logs and error handling.
8. Add a QA checklist.
9. Add client handoff docs.
10. Create a demo script I can record or show on a call.

Rules:
- Do not overengineer the first version.
- Do not hardcode secrets.
- Ask before using paid APIs heavily.
- Separate demo-grade from production-grade.
- Tell me exactly what to test after each milestone.

---

15. Suggested build order

Do not start with the hardest system.

Recommended order:

1. Cline website: easiest to demo, fastest to ship.
2. AnythingLLM AI setup: strong for internal teams and straightforward to explain.
3. Firecrawl lead machine: useful for GTM, research, outbound, and agency workflows.
4. Browser Use automation: good once you find a repetitive browser task.
5. Postiz content engine: good for recurring content clients.
6. CrewAI retainer: best after you understand the client workflow deeply.
7. Pipecat phone agent: highest perceived value, but highest risk and QA burden.

---

16. Official sources used

• Claude Code quickstart: https://code.claude.com/docs/en/quickstart
• Claude Code skills: https://code.claude.com/docs/en/slash-commands
• Anthropic Agent Skills repository: https://github.com/anthropics/skills
• Claude API quickstart: https://platform.claude.com/docs/en/get-started
• Cline install docs: https://docs.cline.bot/getting-started/installing-cline
• Pipecat docs: https://docs.pipecat.ai/pipecat/get-started/introduction
• Pipecat project scaffolding: https://docs.pipecat.ai/pipecat/get-started/build-your-next-bot
• Postiz Docker Compose docs: https://docs.postiz.com/self-host/installation/docker-compose
• Postiz system requirements: https://docs.postiz.com/self-host/installation/system-requirements
• Postiz API overview: https://docs.postiz.com/public-api/introduction
• AnythingLLM Docker guide: https://github.com/Mintplex-Labs/anything-llm/blob/master/docker/HOW_TO_USE_DOCKER.md
• CrewAI docs: https://docs.crewai.com/
• CrewAI README: https://github.com/crewAIInc/crewAI
• Browser Use quickstart: https://docs.browser-use.com/open-source/quickstart
• Browser Use README: https://github.com/browser-use/browser-use
• Firecrawl Python quickstart: https://docs.firecrawl.dev/quickstarts/python
• Firecrawl README: https://github.com/firecrawl/firecrawl

---

17. Final practical recommendation

If the goal is to make this useful fast, start with one of these three:

Fastest to sell

Cline website build for a local business

Why:

• Easy demo
• Easy before/after
• Low technical risk
• Clear deliverable

Best for B2B operators

Firecrawl lead machine for a niche outbound campaign

Why:

• Fits GTM and outbound workflows
• Easy to show CSV output
• Can become recurring

Best premium internal setup

AnythingLLM company AI workspace

Why:

• Easy for clients to understand
• Uses their existing docs
• Good setup fee plus maintenance

After those, graduate into Browser Use, CrewAI, and Pipecat when you have a clear workflow and a client willing to pay for reliability.