AI Skills — Comprehensive Review

Compiled 2026-07-25  ·  26 YouTube transcripts, 288 techniques → 5 syntheses  ·  plus the Anthropic / Microsoft / Databricks skill blueprints. Operating rule: learn a current skill → find the matching Upwork job → integrate it & over-deliver.

How to read thisGlossaryBlueprintsSynthesesAgentic EngineeringTechnical / dev workflowMonetizationStartup strategy & positioningMarket intelligence & contentAll 26 videos

How to read this document

This is the distilled signal from everything we analyzed — not raw transcripts.

• Glossary — plain-English definitions of every key term, so nothing below is jargon.
• Part 1: Blueprints — what Anthropic, Microsoft and Databricks consider the professional skillset. We mine the material; we don't sit the exams.
• Part 2: Syntheses — the cross-video consensus (things many creators independently agree on = high conviction), plus the concrete actions, tools, and Upwork angles to actually do.
• Part 3: All videos — per-source detail: a summary and every technique with "what it is" + "how we apply it."

Each technique is tagged durable (a lasting principle) or decaying (a tool-of-the-week). Anything a creator claimed but we haven't verified is flagged ⚠ — verify before quoting it to a client.

Glossary — the key concepts in plain English

AgentAn LLM given tools (functions it can call) and a loop, so instead of just answering it can take actions — query a database, call an API, send an email — observe the result, and decide the next step.
RAG (Retrieval-Augmented Generation)Instead of relying on what the model memorized, you retrieve the relevant documents/records at question-time and feed them into the prompt, so answers are grounded in the client's real data and can cite sources.
Semantic / context layerA curated translation layer between the LLM and a messy database: it says which tables matter, defines business terms ('last quarter' = fiscal), and gives per-field hints — so the model writes correct queries instead of guessing. This is the 'data-layer moat' Abdi sells.
MCP (Model Context Protocol)An open standard for exposing a data source or set of tools to an AI agent through one secured boundary. Build one MCP server over a client's Postgres/APIs and many agents can plug into it.
Skill (Claude Code)A reusable folder of packaged know-how: a description (so Claude knows when to use it), step-by-step instructions, and real tool scripts. Only its name+description load until it's needed (cheap), then the full body loads on demand.
Sub-agentA separate agent spun up to handle a piece of work in its own context. Powerful for parallel batch jobs, but overusing them ('agent fleets') creates flaky, hard-to-debug systems — default to ONE agent first.
Eval / eval harnessAn automated test suite for non-deterministic AI: a fixed set of questions with expected behavior, scored each run (often by an 'LLM-as-judge') so you can prove quality and catch regressions. This is what turns a demo into something a client trusts.
Golden datasetA set of real historical examples with known-correct answers, used as the eval's answer key.
LLM-as-judgeUsing a second LLM call, with a rubric, to score whether an output is good — so quality checking scales without a human reading every run.
Loop (agent loop)trigger + goal: the agent reasons → acts → observes → checks a done-criterion → repeats until the goal is met. The magic '1-shot' results are usually loops with built-in verification. Best for verifiable maintenance, bad for greenfield features, and token-expensive.
Done-criterionThe objective, checkable stop condition for a loop ('until tests pass' / 'until every row validates'), plus a max-iterations cap so cost can't run away. Vague criteria ('until satisfied') cause endless or low-quality runs.
HarnessEverything around the model — the tools, the injected context, the loop, the guardrails. As base models plateau, the harness increasingly decides output quality. Competing on the harness (not the model) IS the 'owns the data layer' positioning.
Structured output (JSON schema)Forcing the model to return data in a fixed shape (not freeform text) so it plugs straight into other systems and can be validated + retried on failure.
Prompt cachingReusing a large static chunk of prompt (a big system prompt or fixed document) across calls at a fraction of the token cost — a margin lever on fixed-price jobs.
Human-in-the-loop / approval gateLetting the agent act autonomously right up to a consequential action (spending money, sending an email, a prod deploy), then pausing for a human yes/no. This is what makes autonomous agents sellable — it removes client liability fear.
Context window / the ~70% ceilingThe amount of text a model can hold at once. Quality degrades as it fills (roughly past 70-80%); good design prunes/summarizes and offloads static knowledge to retrieval or skills.
Durable vs decaying (our tag)Durable = a lasting principle that will still be true next year. Decaying = a tool-of-the-week that will churn. We prioritize durable and treat decaying as replaceable.
FDE (Forward-Deployed Engineer)An engineer who embeds with a client, maps their real workflow, and ships a working solution against it — a high-value ($150k-$1M) role model for how to scope and sell agent work.

Part 1 — Certification / exam skill blueprints

We do NOT sit these exams. We mine them as the definitive, current list of "what a professional AI/data engineer should be able to do," and we implement those skills in Upwork deliverables. Full detail lives in memory (reference-claude-skill-blueprint, reference-microsoft-databricks-skill-blueprints, reference-anthropic-claude-certification).

Anthropic Claude — the "Architect Foundations" blueprint = our build checklist

The 5 skill domains
Agentic Architecture (27%) · Claude Code Configuration (20%) · Prompt & Structured Output (20%) · Tool Design & MCP (18%) · Context & Reliability (15%). Treat these five as a checklist on every Claude build.
6 exam scenarios = Upwork job archetypes
Customer Support Agent · Code Generation · Multi-Agent Research · Developer Productivity · CI/CD · Structured Data Extraction. Each is a showroom piece / job type to build toward.
Free Anthropic Academy (20 courses — the material to mine)
Highest value: Building with the Claude API (tool use, RAG, MCP, agents) · MCP intro + advanced · Agent Skills · Subagents · Claude Code in Action · Claude with Bedrock / Vertex AI.

Microsoft & Databricks — the data-layer + GenAI blueprint

Microsoft AI path (AI-102 retiring → AI-103 + Applied Skills)
Current hands-on path = free Applied Skills incl. "Integrate MCP tools with agents in Foundry", "Develop generative AI apps in Azure AI Foundry (RAG agent on your own data)", "Create an AI agent", "Secure AI solutions." Maps 1:1 to our Claude+MCP+RAG+agents stack on the Azure side.
Microsoft Fabric — the data layer (= KalEdge Job C)
DP-700 (Fabric Data Engineer): ingest/transform data, SQL/PySpark/KQL, lakehouse/warehouse, pipelines, governance. DP-600 (Fabric Analytics Engineer): semantic models, DAX, data prep.
Databricks GenAI Engineer Associate — the modern RAG/agent stack
RAG, Vector Search, prompt engineering, MLflow 3 (tracing/scoring), Mosaic AI Agent Framework, MCP servers, eval judges, inference logging. Vendor-neutral enough to apply on our Azure/FastAPI builds.
AZ-305 — Azure Solutions Architect Expert (the architecture tier)
Design the WHOLE Azure solution, not just a build: identity/governance/monitoring (25–30%), data storage design (20–25%), business continuity / DR (15–20%), infrastructure design (30–35%) — all against the Azure Well-Architected Framework + Cloud Adoption Framework. The architect tier above AZ-204 (developer). Upgrades how we scope + de-risk larger/enterprise engagements: sell "solution architecture."
"AI Architect" = a triad (there is no single dedicated Microsoft AI-architect exam)
The AI-solution-architect skillset for our stack = Anthropic Claude Certified Architect (agentic system design, CCAR-F/CCAR-P) + AZ-305 (Azure infrastructure design) + AI-103 (Foundry AI apps + agents). Mine all three for the "I architect your whole AI solution" positioning. Secondary, other clouds: AWS Machine Learning – Specialty, Google Cloud Professional ML Engineer.
Other clouds (AWS / Google) — mine the concepts, build on OUR stack
AWS Certified Machine Learning Engineer – Associate (MLA-C01) (the older ML Specialty MLS-C01 retired Mar 2026; an MLA-C02 update lands Sep 2026) — roughly half the exam is production ML: deploy, monitor, secure, and build on managed services + foundation models. Google Cloud Professional Machine Learning Engineer — design / build / deploy / monitor / maintain ML solutions. The rule for this entire document holds here: we mine the transferable, cross-cloud architecture concepts (MLOps, model monitoring & drift, vector search, evals, responsible AI, cost/latency, solution design) and implement them on our designated stack — Claude + Azure + FastAPI + Postgres. We do NOT adopt AWS or GCP as platforms; we touch their tooling only when a specific client is already on that cloud.
Stack-mapped roster to mine (priority order)
Anthropic Claude (Engineer + Architect) · Databricks GenAI · Fabric DP-700/600 · AI-103 + Foundry Applied Skills · AZ-204 (FastAPI deploy) · AZ-305 (Azure architecture) · DP-100 (Job B ML) · GitHub Actions (CI/CD) · secondary/concept-only: AWS MLA-C01, Google PMLE. — Everything maps back to Claude + Azure + FastAPI + Postgres; no new platforms.

Part 2 — Syntheses (the playbook)

Agentic Engineering — the core build checklist

How to build AI agents that actually work in production. This is the craft: how to make an agent reliable, debuggable, and trustworthy enough that a client pays for it. Every item here goes on the checklist for any Claude/agent build.

Consensus techniques (11)

Self-verifying loop with an objective done-criterion + failure-feedback patchingseen in 03, 06, 09, 11, 12
Why it mattersThe single strongest cross-video signal. Quality comes from the agent iterating against a checkable stop condition and folding each failure back in, not from one-shot prompting. This is what turns a flaky demo into a deliverable a client can trust, and it maps 1:1 onto Abdi's mandated 5-6x iteration/hardening process.
How we use itWrap every non-trivial deliverable in generate -> validate -> compare-to-spec -> fix -> repeat with a MEASURABLE gate (schema validates, tests green, eval score >= threshold, 100% rows parse) and a hard max-iterations cap so client cost can't run away. On error, surface the exact error to the agent, patch behavior, then update the skill/definition so the same failure never recurs. Sell the iteration as a hardening cycle where reliability visibly climbs each round.
Consolidate the brain — single agent first, add sub-agents only when a real boundary justifies itseen in 03, 06, 09, 11
Why it mattersEvery video that touches architecture warns against reflexive multi-agent fleets. Splitting the brain (planner that doesn't know the sub-agent's limits) creates a whole class of flaky failures; collapsing back to one agent removed them and, per Browser Use, gave ~10x faster dev cycles. Fewer moving parts = cheaper to run, easier to debug, easier to hand off to a non-technical client.
How we use itDefault client architecture to ONE well-verified agent with the tools it needs, plus access to its own logs/trace/code to self-diagnose. Only separate into sub-agents where there's a genuine productivity boundary (e.g. a dedicated eval'd scorer, or batch fan-out). Never ship a multi-agent showpiece for its own sake — protects margins and reliability.
Localized / on-demand context over one monolithic always-on promptseen in 03, 11, 12
Why it mattersContext engineering consensus: attach context to the specific thing it describes (field-local metadata; skills that load only name+description until relevant) instead of stuffing a giant system prompt. Directly improves answer quality AND lowers per-turn token cost (= lower client API bills), and keeps the agent out of the degraded high-context band.
How we use itStore per-field/per-table AI context inline in the semantic metadata, not a mega-prompt. Architect client agents as a lean system layer + a library of on-demand Claude Skills rather than one bloated CLAUDE.md/agent.md. Actively manage the working window (prune, summarize/compact, offload static knowledge to retrieval/skills) and treat ~70% utilization as a budget ceiling.
Trade tokens for deterministic code; let the model emit native forms, not a bespoke DSLseen in 03, 09, 12
Why it mattersRecurring 'the harness/tools are the leverage' point. Claude already knows SQL (favors CTEs, one-shots what took 3-4 chained queries); saving repeatable steps as committed scripts is cheaper, faster, reproducible. Browser Use's self-modifying harness is the extreme version — the agent writes its own tool when one is missing.
How we use itPrefer having the model generate the native query language (SQL) with a validation/parse guardrail over teaching a proprietary JSON query form. Freeze repeatable pipeline steps (chunk/embed, SQL report gen, data cleaning, PDF/slide styling) into committed Python scripts referenced by a skill's tool layer. Invest in the tools layer (typed params, docstrings) more than polishing prose instructions.
Traces + evals as the primary observability, backed by an LLM-as-judge scorerseen in 03, 06, 09
Why it mattersReading raw agent traces ('blobotomies') found root causes that aggregate scores hid (the split-brain bug). A separate, eval'd scorer agent (maker-checker) gives trustworthy quality gates. This is a sellable reliability differentiator, not just internal hygiene.
How we use itInstrument every agent build to persist full step-by-step traces (prompts, tool calls, tool results); when a client reports a bad output, read the trace instead of guessing. Ship an eval harness with a fixed question set, stored expected behavior, and an LLM judge scoring runs to catch regressions. Package both as deliverable features / upsell.
Codify skills/definitions from a PROVEN live run, then compound them every sessionseen in 03, 11, 12
Why it mattersTwo videos independently say: don't hand-write or AI-generate a skill up front — walk the agent through a real workflow to success, then have it write the skill so it inherits real API shapes/data/decision rules. After each run, decide one-time-fix vs live-forever and fold corrections back in. Day-30 agent should beat day-1. Turns the paid iteration process into cumulative asset value.
How we use itCo-pilot the agent through the client's ACTUAL workflow first, capture the successful trace, then 'review what you just did and create the skill.' After each iteration, feed the chat back: 'enhance the skill so this mistake can't recur.' Log every user query + correction and periodically fold them into the semantic metadata / sample queries — a self-improving deliverable the client keeps paying to maintain.
Human approval gate before irreversible actions (permission-gated skills)seen in 09, 12
Why it mattersBoth harness videos land on the same guardrail: the agent can act autonomously right up to the point of consequence (money, external messages, prod deploy), then pauses for a yes/no. This is what makes autonomous agents SELLABLE — it kills client liability fear.
How we use itBake a confirm-before-commit step into every automation that spends money or emails third parties — return a preview and wait. Implement as a pending-action row in Postgres + a notification. Gate dangerous actions behind human-only skills (disable-model-invocation) while keeping low-level data tools agent-only/hidden. Pitch it as safety/guardrail engineering.
Rich, instructive error messages + an explicit recovery budgetseen in 03, 11, 09
Why it mattersOne of the largest quality jumps Omni reported came purely from descriptive error messages plus telling the agent how to recover and giving it a retry budget. Ross Mike's failure-feedback loop is the same idea from the operator side. Cheap, high-ROI robustness.
How we use itIn FastAPI tool layers, return instructive error strings ('what went wrong + how to fix'), never raw stack traces, back into the agent loop. Prompt an explicit retry/recovery policy with a token/step budget. Trivial to add, disproportionate reliability gain on any agent deliverable.
The harness / data layer matters as much as the modelseen in 09, 11, 03
Why it mattersExplicitly stated across videos: as base models plateau at 'good enough,' the surrounding harness, tools, and injected context increasingly determine output quality (benchmark differences across Cursor/Claude Code/Codex on similar models). This IS Abdi's positioning.
How we use itCompete on context assembly, tool wiring, and workflow codification around whichever frontier model — not on the model choice. Model client agent UX on tools you actually use daily; treat structured client data/config like a codebase the agent navigates. Reinforce the 'owns the data layer' pitch in every proposal.
Sub-agent fan-out over a shared skill for batch scaleseen in 12, 09
Why it mattersThe ONE sanctioned use of many agents (consistent with 'single-agent-first'): once a capability is a proven skill, run N sub-agents invoking it in parallel to process volumes a single session can't (10 agents scanning 10,000+ domains). Turns a slow serial job into a priceable batch deliverable.
How we use itAfter proving a single-agent ingestion/enrichment/QA skill, parallelize it across sub-agents for bulk client datasets (document classification, lead enrichment, mass record validation). Price by volume.
Give autonomous agents their own scoped identity/mailbox, not the client's real credentialsseen in 11, 09
Why it mattersSecurity consensus: dedicated email/accounts limit attack surface for agents that touch inboxes; downloaded third-party skills are an attack vector AND lack context of a real run. Pairs cleanly with Abdi's per-project hello@<domain> mailbox standard.
How we use itProvision dedicated scoped identities/mailboxes per client agent instead of primary credentials; forward only what's needed. Never ship marketplace/third-party skills — build bespoke per client and sell 'no untrusted third-party code in your agent' as a security selling point.

Top actions to implement

  1. Curated semantic/context layer between the LLM and the client's data (per-field AI context, sample queries, sample values) — the data-layer moat Abdi sells; never point the model at raw schema
  2. Self-verifying loop with an objective, measurable done-criterion + max-iterations cap + failure-feedback patching — wrap every deliverable in it
  3. Codify bespoke Claude Skills from a PROVEN run on the client's real data, then compound them each iteration (turns the 5-6x paid iteration process into cumulative asset value)
  4. Ship a trace + eval harness (LLM-judge, fixed question set, stored expected behavior) as a deliverable feature and reliability upsell
  5. Human approval gate / permission-gated skills before any money/email/prod action — pending-action row in Postgres + notification (kills client liability fear, makes autonomous agents sellable)
  6. Single-agent-first architecture; add sub-agents only for a real boundary or batch fan-out
  7. Rich instructive error messages + explicit recovery budget in FastAPI tool layers
  8. Trade tokens for deterministic committed scripts (chunk/embed, SQL report gen, cleaning) referenced by skills — lowers client API bills, reproducible output
  9. Proactive 'agency' loop (AI prompts you): Azure cron/worker runs Claude over inbox/CRM/tickets, drafts next-actions, one-click approve — a differentiated product, not another chatbot
  10. Per-client 'database skill' artifact (schema + RLS + naming + migration policy) so any agent/dev makes safe first-try changes

Tools to try

  • Claude Skills (.claude/skills folders — description/instructions/tools, progressive disclosure, user-invocable & disable-model-invocation flags)
  • LLM-as-judge eval harness (fixed question set + stored expected behavior + scorer sub-agent)
  • Supabase agent skills (one-command install: schema + RLS + docs into agent context; enforce RLS, security-invoker views, no orphaned migrations)
  • Browser Use / Browser Harness over Chrome DevTools Protocol (CDP) — drive a real authenticated browser for login-only portals with no API
  • Codex /goal-style long-running objective with verifiable end-states for large unattended builds
  • OpenAI Tokenizer (or equivalent) to measure and budget context utilization toward the ~70% ceiling
  • Playwright / screenshot verification wired in as the agent's self-check tool for UI deliverables
  • Telegram/WhatsApp/Slack as the agent front-end for SMB clients (ship fast, skip building a UI, swap to web app later)
  • Postgres preferences/feedback table as durable agent memory (reach for this before a vector DB)
  • Editable workbook / table+filter+chart UI that agent outputs drop into (AI-to-build-UI to validate, not LLM-as-only-interface)

Upwork / business angles

  • 'Chat with your data' / text-to-SQL analytics agent built on a curated semantic layer (not raw schema) — pitch the semantic/context layer as the moat and the reason answers are correct and repeatable
  • Proactive AI assistant (AI-prompts-you) over a client's inbox/CRM/tickets that drafts next-actions for one-click approval — a differentiated product on the FastAPI+Azure+Postgres+Claude stack, explicitly 'not another chatbot'
  • Reliability/observability package as a standalone deliverable or upsell: full agent traces + an eval harness with LLM judge that demonstrates same-answer-every-time and catches regressions
  • Per-client 'database skill' artifact (Postgres schema + RLS policies + naming conventions + migration rules) so their agents and next dev make safe first-try changes — directly on-brand for 'owns the data layer'
  • Automate a login-only web portal that has no API, via CDP real-browser automation — the practical unlock for 'automate this thing we log into daily' jobs
  • Deliver a bespoke Claude Skills library committed in the client's repo (/ingest-docs, /run-evals, /draft-report) so their own team runs a reusable system, not a chat transcript
  • Bulk batch processing via sub-agent fan-out over one proven skill (document classification, lead enrichment, mass record validation) — priced by volume
  • Self-hardening automation sold as a 5-6x iteration hardening cycle: each round captures failures and folds them back into the skill so the system gets more reliable with use
  • Safe autonomous agents with human approval gates before any money/email/prod action — sell the guardrail engineering as a liability-reduction feature (fits the labor-marketplace 'insulated from liability' goal)

⚠ Claims to verify before quoting a client

Technical / dev workflow

The engineering discipline around agents: evals as proof of quality, MCP as the data boundary, deterministic-first design, cost control, and the day-to-day coding workflow (Matt Pocock / FDE).

Consensus techniques (9)

Evals + golden datasets as the RAG/agent quality proofseen in 01, 05, 07, 14
Why it mattersEvery serious builder frames evals (auto-generated scenarios, golden sets from client history, pass/fail rubrics, regression suites) as the thing that turns non-deterministic LLM output into evidence a client will pay for. It's the single most repeated high-value idea and maps 1:1 to Abdi's 'accurate response with sources' RAG work.
How we use itShip an eval/regression harness as a formal, named deliverable on every RAG/agent build: pull client historical examples to build a golden set, deliver a pass/fail + failure-category report (e.g. '41/50 passed, 5 missing-data, 4 wrong-record'), and add a human-in-the-loop feedback mechanism that keeps improving the harness post-delivery — which justifies a retainer. Package it as a 'RAG-quality guarantee.'
MCP as the shared data-layer boundary (own-the-data-layer, made concrete)seen in 14, 17
Why it mattersTwo independent stacks (Anthropic/Claude and Microsoft Agent Framework) converge on the same pattern: expose a client's DB/APIs once behind a single secured MCP boundary, then let many agents/tools discover and query it at runtime. This is Abdi's 'owns the data layer' positioning turned into a reusable, defensible, sellable artifact.
How we use itSell one MCP server per client that fronts their Postgres/APIs, built on his Claude+FastAPI stack. Multiple agents plug into it; decouple the vector store (shared pgvector/Azure AI Search index) from the agents so it's reused, not rebuilt. Note MCP is provider-agnostic, widening where he can sell it.
Human-in-the-loop approval gates on destructive/costly actionsseen in 05, 17, 01
Why it mattersRecurs as the cheapest, highest-perceived-value trust feature: let the agent run autonomously but pause on destructive or expensive tools (DB writes, deletes, sends, refunds) for a yes/no human callback. It directly counters client fear of runaway agents.
How we use itGate every destructive/costly tool behind an approval callback plus a per-agent allowed-tools allowlist; name it explicitly in the security section of proposals as the reason a client can trust an autonomous agent. Low effort, big risk-perception reduction.
Audit trail / observability so clients trust the agentseen in 01, 05, 17
Why it matters'If you can't show the client what the agent is doing, they'll never trust you.' Logging every trace, tool call and decision shows up as a trust differentiator (05), a maintenance loop that adds missing log coverage then sweeps prod errors (01), and three-tier middleware interception for logging/guardrails/tracing (17). Aligns with Abdi's python-observability practice and progress-tracker standard.
How we use itBuild a reusable middleware/observability harness once (structured logging + trace dashboard + PII redaction + guardrails) and reuse across every client agent. Present the traces during handoff; pair with the client-branded progress tracker. Then offer a scheduled 'self-healing' loop that reviews prod logs, root-causes, fixes, opens a PR and pings Slack/email.
Deterministic-first architecture; put intelligence only where judgment is neededseen in 01, 05
Why it mattersBoth the FDE playbook (05) and the loops video (01) warn against 'token-maxing' / looping on greenfield features: best solutions are mostly deterministic software + selective LLM calls + human approval, and loops belong only on verifiable maintenance goals, never feature delivery. Cheaper, lower-risk, higher-accuracy — a differentiator vs 'slap an agent on it' competitors.
How we use itFor each client workflow, classify every step deterministic-software / agent / human-approval and pitch the mostly-deterministic architecture as the design. Scope autonomous loops only for verifiable goals (metrics, tests pass, error-count=0) with stop-conditions and token budgets so a loop can't run for days.
Structured JSON-schema output as the integration + reliability primitiveseen in 05, 17
Why it mattersForcing schema-constrained output (not freeform text) is both the exception-handling backbone (05: JSON schema validation, defined failure modes, retries) and the intake-automation money pattern (17: chat → extract structured data → auto-fill form / book calendar / write row).
How we use itEnforce JSON-schema/tool-use output on every agent, validate it, define failure modes and add retry logic — sell the exception coverage as the reason the build survives production. Package the 'chat → structured data → downstream system' flow as a buyable intake-automation offer.
Cost control via prompt caching and cheap-model routingseen in 14, 05, 07, 17
Why it mattersMargin/pricing lever recurring across sources: prompt caching for large static context (14), 'sommelier of agents' matching model to task and benchmarking cheaper tiers like Gemini Flash/Haiku (05), Sonnet-for-implementation / Opus-for-review (07), and model-direct agents to dodge managed Agent Service surcharges (17).
How we use itEnable prompt caching on builds with big system prompts / fixed document context; route non-frontier steps to cheaper models; default to model-direct agents unless managed persistence is needed. Bank these as explicit proposal line items ('runs on raw model tokens, caches static context') to improve margin on fixed-bid jobs. Verify current caching pricing/params against live Anthropic docs before quoting.
Fresh-context discipline: smart zone, /clear, review in a clean contextseen in 07, 01
Why it mattersCoding quality craters around ~100k tokens regardless of window size; compacting leaves lossy 'sediment' and an implementer reviewing its own code reviews from the 'dumb zone.' The loops video independently uses fresh clean runs each iteration (Ralph) — same principle.
How we use itCap each coding task under ~100k tokens, /clear between self-contained tasks instead of compacting, and always run a separate reviewer pass on a clean context (Opus) before human QA. Treat needing to compact as a signal the task was scoped too big.
Own your stack / owned editable skills, not opaque proprietary frameworksseen in 07, 01, 05
Why it mattersRepeated caution against depending on frameworks you can't debug: prefer small owned markdown skills over spec-kit/task-master (07), own the loop on your own cron/GitHub Actions rather than Codex's proprietary /goal (01), integrate on top of client systems rather than forcing migration (05). Matches Abdi's portability + data-layer positioning.
How we use itKeep grill/PRD/issues/review loops as owned, per-client-tunable markdown skills; run autonomous loops on his own FastAPI + cron/GitHub Actions stack; position every proposal as 'build on top of your existing tools' with connectors, deployed shadow-mode → ramped autonomy, never rip-and-replace.

Top actions to implement

  1. Productize an 'AI Opportunity Sprint' (audit-first, renamed to avoid the tax-audit connotation) as the first deliverable on every Upwork engagement: map the REAL workflow with all exceptions, hand back an operating map + ROI matrix in the 3 business buckets (revenue uplift / risk mitigation / cost savings). Do the first 1-3 cheap/free to farm reviews, then charge and land-and-expand.
  2. Build a reusable eval + golden-dataset harness as a named deliverable for RAG/agent jobs: auto-generate scenarios, grade answer quality + source accuracy against client historical data, ship a pass/fail + failure-category report, and add human-in-the-loop feedback that justifies a retainer ('RAG-quality guarantee').
  3. Build one MCP server per client that fronts their Postgres/APIs as the single secured data-layer boundary, with a decoupled shared vector store (pgvector / Azure AI Search) multiple agents reuse — the concrete embodiment of his 'own the data layer' positioning.
  4. Build a reusable observability + safety middleware harness once (structured logging, trace dashboard, guardrails, PII redaction, per-agent tool allowlist, human-in-the-loop approval on destructive tools) and reuse it across every client agent; present traces at handoff as the enterprise trust differentiator.
  5. Offer a scheduled 'self-healing app' retainer: verifiable maintenance loops (nightly prod-log root-cause→fix→PR→Slack/email ping, docs-freshness sweep, performance SLA loop with a fixed benchmark harness, weekly SEO/GEO visibility loop) — verifiable goals only, with token budgets and stop-conditions, priced for token cost.
  6. Adopt Matt Pocock's owned coding workflow as his default delivery process: grill-me alignment skill → PRD (with explicit out-of-scope) → vertical-slice Kanban DAG → AFK Ralph-style implementation loops → separate fresh-context reviewer pass → manual QA; keep every task in the <100k smart zone and /clear between tasks.
  7. Standardize cost levers as proposal line items: prompt caching for static context, cheap-model routing for non-frontier steps, model-direct agents to avoid managed-service surcharges — improving margin on fixed-bid jobs (verify caching pricing/params against live Anthropic docs first).
  8. Block a weekend for the free Anthropic Academy builder path (skip Claude 101 / overlapping prompt-eng sections) to formalize prompt caching, extended thinking, MCP, Claude Code + GitHub Actions, and agent skills — then lift the patterns straight into deliverables.
  9. Build the next showroom piece as an FDE-style proof: pick one real back-office workflow, ship a fully instrumented agent (looping, tool use, guardrails, memory, audit trail, exception handling for the unhappy path) with an eval report + ROI numbers, and package it as a buyable Project Catalog offering.
  10. Enforce structured JSON-schema output + retry logic on every agent, and sell the intake-automation pattern (chat → extract structured data → auto-fill form / book calendar / write DB row) as a discrete offer.

Tools to try

  • Claude Agent SDK (standardize on one agent-building platform and go deep before diversifying)
  • MCP server (Claude-native) fronting client Postgres/APIs as the shared data-layer boundary
  • Claude Code /goal + owned cron/GitHub Actions loops (prefer owning the loop over Codex's proprietary /goal)
  • Ralph-style AFK bash loop over a markdown backlog on the FastAPI/Postgres stack
  • Sandcastle (sandboxed parallel agent loops via git worktrees + Docker)
  • Anthropic Academy free builder path (Building with the Claude API, Intro/Advanced MCP, Claude Code in Action, Agent Skills)
  • Prompt caching + extended thinking (Claude-native cost/quality levers — verify current pricing/params)
  • pgvector / Azure AI Search as a shared, agent-agnostic vector store reused across agents
  • Custom owned skills: grill-me, write-a-PRD, prd-to-issues, red-green-refactor, improve-code-base-architecture
  • Cheap-model tiers (Haiku / Gemini Flash) for non-frontier workflow steps to cut client cost
  • Playwright MCP + throwaway prototype routes for choosing front-end variants (don't expect unaided production UI)
  • FastAPI middleware/dependency pattern for a reusable guardrails + audit-log + PII-redaction layer

Upwork / business angles

  • 'AI Opportunity Sprint' audit-as-wedge: fixed-price discovery that maps the real workflow + ROI matrix, de-risks the sale, surfaces use cases the client never considered, and land-and-expands into the build (adjacent upstream/downstream workflows become the next engagement).
  • Sell to the human's incentive: frame every deliverable in the 3 business buckets (hours saved/week, error-rate reduction, revenue impact) so the client contact can point to it at their performance review — that's what actually closes the deal.
  • 'Self-healing app' retainer: nightly verifiable maintenance loops (error sweep → PR → Slack/email ping, docs-freshness, performance SLA, weekly SEO/GEO) — recurring revenue, and dovetails with his standing email-notification + progress-tracker standards.
  • RAG-quality guarantee: deliver an eval harness + golden set + pass/fail report as the credible differentiator vs prompt-and-pray freelancers; the human-in-the-loop feedback loop becomes an ongoing retainer.
  • Enterprise-trust packaging: audit-trail dashboards, tool allowlists, human-in-the-loop approval gates, prompt-injection/MCP-surface hardening — sell as the security section that lets wary clients trust an autonomous agent and pay more.
  • Integrate-on-top, never migrate: position as 'I'll make your existing NetSuite/Salesforce/Postgres stack better' with connectors, deployed shadow-mode → ramped autonomy — de-risks the sale and matches the data-layer positioning.
  • Intake-automation offer: chat → structured JSON → auto-fill form / book calendar / write row, as a discrete buyable Project Catalog listing.
  • AI-visibility (SEO + GEO) recurring service for the showroom sites (Ayuvara, KalEdge, abdialamir.com) and clients, using the fixed-crawl-then-rerun reliability pattern.
  • Pitch autonomous maintenance loops as a productized add-on/retainer line on every delivered system — but scope them only for verifiable goals with token budgets, never as the feature-delivery mechanism.
  • FDE-style 30-day showroom build (instrumented back-office agent + eval report + ROI numbers) as portfolio proof to win the first paid FDE-style engagement at higher rates.

⚠ Claims to verify before quoting a client

Monetization — how AI freelancers actually make money

Pricing, packaging, and go-to-market. This is the cluster that moves Abdi off $45/hr: price on outcome not hours, sell a flat recurring 'AI employee', demo on the client's own data, land low and expand.

Consensus techniques (11)

Price on outcome / human-equivalent value, never on tokens or hoursseen in 10, 13, 16, 19
Why it mattersEvery successful operator anchors the buyer on the business value produced (recovered revenue, a $3k report, a human salary) and hides the underlying token/API cost inside a fat fixed margin. Exposing usage-based or hourly pricing kills perceived value and creates buyer anxiety. This is the single biggest lever on Abdi's rate climb from $45/hr.
How we use itOpen every proposal with the client's own money math (e.g. missed-call calculator: calls/day x AOV x close-rate = $X lost/month), then quote a flat deliverable well below that number. Bake token cost into fixed price; never itemize per-token or 'time saved' (buyers are numb to it).
Productize a flat recurring offer, not one-off custom workseen in 10, 13, 19
Why it matters£399/mo (id10), $297/mo (id13), and $5k/mo flat-unlimited (id19) all beat hourly because the build is templated and margin compounds as MRR. Recurring revenue is the enterprise-value driver; one-off jobs don't compound.
How we use itPackage a fixed monthly managed-agent / website+automation retainer in Abdi's Project Catalog with a one-time setup fee (pure margin on a templated job) and month-to-month / no-contract to kill risk objections. Control real cost by consolidating to 1-3 well-built agents per client.
Template-once, clone-forever + reusable skill/playbook libraryseen in 04, 10, 16, 19
Why it mattersNear-zero marginal delivery cost is what makes flat pricing profitable. Build one vertical agent/pipeline, then swap the client's website/data and bolt on vertical skill packs. Anthropic's 'Skills' concept (id16) formalizes this as versioned markdown playbooks.
How we use itMaintain a library of vertical agent templates (RAG KB + prompt + tool config) and a base 'executive assistant' core (email triage, follow-ups, memory). Each new client = swap content + custom fields. Sell 'we build you a reusable skill library' as a deliverable, not just a chatbot.
Ship a live demo built from the client's OWN data/website before the closeseen in 10, 16, 19
Why it mattersA working artifact trained on the prospect's real prices/services converts far better than a generic portfolio. Danny literally phones the agent live on the sales call (id10); Nick screen-shares an agent driving a real computer (id19); Howie ships an automated research brief (id16). Abdi's Claude+FastAPI+Postgres stack does exactly this.
How we use itFor any bid, scrape the client's site into a KB, build a working demo agent, and attach it (or a Loom of it) to the proposal. Front-load education with a VSL so calls stay short and pre-sold.
Go vertical / niche down (both for winnability and AI-search era)seen in 04, 13, 16, 19
Why it mattersCommodity 'ChatGPT/Claude' loses; industry-specific offers win. Sub-niching (id04: 'senior living for dementia'; id19: 'commercial real estate agencies in Florida'; id16: mini/medium $1-2B markets giants ignore) makes the buyer feel 'this speaks to me' and is winnable on SEO and LLM-citation.
How we use itFilter Upwork jobs and pick showroom niches toward legacy, people-heavy verticals (med spas, contractors, law/insurance/real estate; avoid healthcare/finance regulatory red tape). Build 1-2 showroom pieces per vertical with structured, citable, AI-search-ready data.
Land low, then expand the existing accountseen in 13, 19, 10
Why it mattersEnter cheap to beat the 'I've been scammed before' objection and farm the first review, then upsell add-ons to a client whose card is already on file ('free money' — id13). Existing-client upsell needs only permission, not a new sale, so MRR compounds at near-zero CAC.
How we use itTake 1-2 free/discounted early builds explicitly to farm reviews/case studies (matches Abdi's 'tiny jobs to farm reviews' pivot), then expand each account with RAG chatbot, DB reactivation, reporting agents, review automation.
Reliability/QA layer as the paid differentiator (evals, watchdogs, self-alerting)seen in 04, 16, 19
Why it mattersWhat separates a senior build from a vibe-coder: LLM-as-judge rubrics scoring every run (id16), watchdogs that auto-restart and agents that email you on failure before the client notices (id19), and validate-correct-rerun extraction loops (id04). Managed reliability justifies the retainer.
How we use itAdd an eval/rubric layer (FastAPI + judge LLM call, scores in Postgres, surfaced on the client progress tracker) and watchdog + self-alerting (agent emails hello@domain on failure) to every managed deliverable. Pitch 'automated QA + we fix breaks before you notice.'
Reframe the language: 'AI employee' / 'recovered revenue', not 'agent' / 'time saved'seen in 10, 16, 19
Why it mattersPositioning away from tech jargon toward business outcomes raises perceived value and reduces buyer confusion. 'Digital employee that owns your intake' (id19), 'recover money you already lose from missed calls' (id10), 'human-equivalent time value' (id16).
How we use itRewrite Upwork/Project-Catalog titles and proposal copy around business outcomes and a 'digital employee' framing. Never lead with 'RAG chatbot' or 'automation.'
Agents-that-build-agents (Claude Code / coding agents as the delivery engine)seen in 04, 16, 19
Why it mattersClaude Code drives pipeline setup and client provisioning near-hands-off (id04 installed Crawl4AI in 15 min by pasting the repo link; id19 uses Claude Code on a cloud VM to configure each client's agent; id16 runs parallel coding agents with cross-agent PR review). Throughput per showroom cycle scales.
How we use itStandardize a repeatable 'setup agent' that provisions each new client from a checklist; kick off long builds asynchronously. Ground fast-moving-library work in live docs via Context7/Exa/Perplexity MCPs with fan-out sub-agents.
Cashflow discipline: prepay discounts to self-fund, bank early revenueseen in 10, 13
Why it mattersAnnual prepay at a discount (id10: £4,800/yr for £2,500, 10 spots = £25k ad war chest) and quarterly prepay anchoring (id13: $800/mo unless quarter-in-full then $500/mo) improve cash flow and cut churn/chargeback risk. Rule: don't spend incoming revenue before banking a cushion.
How we use itOffer retainers month-to-month at a high anchor with a meaningful quarterly/annual pay-in-full discount to bankroll acquisition and bridge cashflow.
Content/warm-first acquisition beats cold sellingseen in 10, 19, 04
Why it mattersWarm buyers arrive pre-sold and can't be dismissive (id10 sells to businesses he already patronizes as a customer; id19 makes faceless content so leads arrive warm; id04 is distribution-first via SEO topical clusters). Content compounds into leads, reviews, hiring.
How we use itKeep producing faceless video/content (Abdi's marketing-channels playbook) so inbound arrives pre-sold; mine his own vendor list for warm first clients; use disqualification/curiosity framing ('I don't think this works for a business like yours') instead of a credentials dump.

Top actions to implement

  1. Build a reusable 'missed-revenue / ROI calculator' lead magnet (calls x AOV x close-rate) and lead EVERY proposal with the client's own loss math before any features — the highest-leverage pricing move across id10/16/19.
  2. Productize a flat monthly managed offer in the Project Catalog: pick ONE vertical (med spa / contractor / real estate), build a base 'AI employee' core + vertical skill pack, price flat month-to-month + one-time setup, hide token economics.
  3. Make the personalized live demo the default proposal attachment: scrape the prospect's site into a KB, build a working demo agent, attach a Loom of it driving real work. Convert on their own data, not a generic portfolio.
  4. Add an eval-rubric + watchdog + self-alerting reliability layer to every deliverable (LLM-as-judge scores in Postgres surfaced on the client progress tracker; agent emails hello@domain on failure). Sell it as the QA differentiator vs cheap freelancers.
  5. Adopt land-low-then-expand: take 1-2 discounted early builds to farm reviews, then upsell add-ons (DB reactivation, review automation, RAG chatbot) to the same card-on-file client at near-zero CAC.
  6. Formalize a versioned skills/ + templates/ library per project (markdown playbooks: brand voice, RAG-ingestion rules, compliance) so each new client is a swap-and-bolt-on, hitting a 48h first-deliverable.
  7. Benchmark Opus vs Sonnet vs Haiku through the judge rubric per task type and route high-stakes steps to Opus, bulk to cheaper tiers — measurable ~5x cost cuts that widen fixed-price margins.
  8. Offer quarterly/annual pay-in-full discounts against a high month-to-month anchor to fund acquisition and stabilize cashflow; bank early revenue before spending.
  9. Stand up a data-cleaning + enrichment service (two-pass: junk filter, then per-URL crawl-and-classify with a confidence-score column) as a distinct Upwork offer — Abdi's exact data-layer wheelhouse, sold with the confidence score as a QA deliverable.
  10. Build a form-driven self-serve onboarding layer (intake form fields auto-populate agent custom values/env) to remove Abdi from manual delivery — a real productization moat on his FastAPI stack.

Tools to try

  • Crawl4AI (free open-source LLM-friendly async crawler) — add to default stack for any scrape/enrich/monitor job, pairs with FastAPI+Postgres+Claude
  • Outscraper (cheapest reliable Google Maps business-listing scraping; cheaper than Apify for local-business datasets)
  • Claude Vision API (second-stage image quality filter — dedupe logos, pick hero shots; ~$30 for 700 listings)
  • LLM-as-judge + eval rubrics (automated QA/observability on every agent run; enables Opus->Sonnet downgrade testing)
  • pgvector (memory 'defrag' / consolidation via embedding-similarity clustering — Abdi's Postgres data-layer edge)
  • Composio (one universal MCP connector to thousands of apps with managed auth — auth is the #1 delivery time-sink)
  • Context7 + Exa.ai + Perplexity MCPs (live docs grounding for fast-moving agent libraries; fan out sub-agents per source)
  • Claude Code on an isolated cloud VM per client (provisioning agent + security sandbox + screen-share demo theater)
  • Granola -> Trello -> Loom fulfillment loop (meeting notes auto-create scoped tickets; Loom async updates; enforces scope-cap intake)
  • AgentMail / per-agent email address (self-alerting observability + personal-assistant feel)

Upwork / business angles

  • Data cleaning + enrichment as a service: ingest messy client CSV/scrape, run two-pass FastAPI+Claude pipeline (junk filter -> per-URL crawl-and-classify), return clean enriched dataset loaded to Postgres, with a verification-confidence column as the QA proof.
  • 'AI receptionist / intake agent' flat retainer for local SMBs: match design to economics — transactional FAQ/order bot for high-volume, or qualify-and-route intake agent for big-ticket service businesses (sell on lead quality, one saved $50k+ call pays for itself).
  • $297-style contractor/med-spa website+automation stack productized: missed-call-text-back, lead-form-to-SMS, review-gating funnel + review campaign, GMB optimization — each a discrete reusable module resold at MRR.
  • Database reactivation offer (mass re-engage a client's dormant lead list) — explicitly called out (id13) as low-effort high-value and even the pros hadn't built it; ideal quick-win upsell.
  • 'AI website manager' NL-editing agent for agencies drowning in manual GHL/VA edits — Claude tool-calling over a CMS/component schema with preview; sell to the exact pain described at scale (id13).
  • Managed vertical 'AI employee' retainer (~flat monthly, unlimited-framed) for legacy service firms: base executive-assistant core + vertical skills, 48h first agent, scoped Kanban intake (max 1-2 active requests) to prevent scope creep.
  • Build defensible proprietary data assets in opaque verticals (pricing/availability/spec comparison) — reframe Abdi from 'chatbot builder' to 'builder of citable, AI-search-ready data moats' for higher-value positioning + GEO strategy.
  • Programmatic topical-cluster SEO pages (~1,000 niche long-tail pages) as a repeatable distribution deliverable, then bolt on a micro-SaaS/tool on the Claude+FastAPI+Stripe stack — distribution-first, monetize the audience many ways.
  • 'Fleet of role-based agents + command-center dashboard' offer (content marketer, researcher, email responder, lead enrichment) — narrow specialists + orchestrator, easier to eval per role, sold as ongoing 'gets better every week' retainer.
  • Two-track pipeline: cheap productized SMB showroom offers (top-of-funnel + reviews) AND higher-ticket 'AI transformation / agent-fleet build' consulting for larger clients using the game-theory 'do nothing = get fired' framing.

⚠ Claims to verify before quoting a client

Startup strategy & positioning

How to pick and frame an AI offer that sells: automate a whole job (not a feature), verticalize hard, quantify the pain in dollars, setup fee + retainer + guarantee, and commit to ONE offer to first revenue.

Consensus techniques (9)

Automate a whole existing job (AI employee / operator agent), not a featureseen in 02, 21, 24
Why it mattersThe most-repeated thesis across the cluster: PMF is near-certain because the work already exists and is already paid for. Selling an outcome ('this role's workload done') beats selling a 'chatbot' or dashboard, and it's easier to price against a salary avoided.
How we use itReframe every Upwork proposal and showroom piece as 'we do this named job end-to-end' on Claude+FastAPI+Postgres. Enumerate a role's jobs-to-be-done, ship 2-3 agents first, then land-and-expand. Directly reuses Desert Glow Concierge + his data-layer USP.
Verticalize hard + qualify by dollar-quantifiable pain ('date the product, marry the niche')seen in 02, 20, 24
Why it mattersEvery video says horizontal/generic AI underserves; the money is one vertical + one role + one big pain where the buyer has money. Wrong niche = great tech, no revenue. Niche selection is the decision that de-risks everything downstream.
How we use itPre-bid filter for showroom verticals: (1) underserved, (2) disposable income / spends on the pain, (3) pain quantifiable in dollars + he has an unfair advantage. Narrow each showroom piece to a named vertical (e.g. 'AI receptionist for med spas') not a general tool.
The value is gluing the model to the use case / own the data + orchestration layer, stay model-agnosticseen in 18, 24, 02
Why it mattersModels are already past the capability needed for most business value; the hard, paid part is tool-use, function-calling, data plumbing and action-taking. Model-agnostic design gives clients future-proofing and negotiating leverage and keeps value in the layer that owns the user/data.
How we use itPosition himself as the integration/orchestration specialist ('owns the data layer'), abstract the LLM behind an interface, don't over-index on model choice in proposals. Add tiered model routing (cheap model for extraction/classification, Claude for hard reasoning) and sell it as 'cost governance'.
Setup fee + monthly retainer, de-risked with a dollar-quantified guaranteeseen in 20, 02
Why it mattersRecurring revenue beats hourly; the upfront fee funds the build and filters tire-kickers while the retainer creates MRR. A bolded, measurable guarantee ('answer 100% of calls in 30s or you don't pay the monthly') removes cold-prospect risk and justifies premium pricing.
How we use itRestructure Project Catalog listings from flat hourly to setup ($2-5k) + retainer ($0.5-3k/mo). Attach a guarantee tied to a metric the client-branded tracker page already measures (uptime, response time, leads booked). Only buy tools/subs after client pays upfront.
Recursive/closed-loop agent architecture with pluggable data sourcesseen in 24, 18, 21
Why it mattersWinning agent products aren't one-shot bots: ingest data → agent acts on the world → observe impact → iterate, adding new data types over time. Architecting for pluggable sources creates a natural upsell/expansion path and richer automation.
How we use itDesign every deliverable as a headless agent core (FastAPI loop) with a thin swappable UI, so the same engine sells as web chat, Slack/Teams bot, and embedded 'core loop.' Start narrow, then add ticket data, call transcripts, logs as billable upsells.
Crystal-clear, legible use cases + dollar/ROI framing ('avoid a $X hire')seen in 02, 20, 21, 24
Why it mattersBuyers don't know what agents can do, so the winner sells specific enumerated tasks with hours-saved and 'switch on now,' not vague 'AI automation.' Framing spend against a salary avoided or revenue recovered makes the price read as a bargain.
How we use itRewrite proposals as enumerated task lists with hours saved and a setup timeline. On discovery calls, quantify the pain in real dollars (missed-call value, abandoned-cart revenue). Lead pitches with 'scale revenue/service 10x accounts without adding headcount.'
Free 'aha moment' demo → cheap paid → expansion funnel; treat GTM/site as a productseen in 18, 20, 24
Why it mattersGate a genuine wow-moment before the paywall and treat compute/token spend as the acquisition cost instead of ads. Winning on the buying experience (transparent pricing, self-serve, clean design, live metrics) beats competitors even before product parity.
How we use itFor Ayuvara and each showroom piece, build free-demo → cheap paid → managed-tier ladder. Use a 'free demo build for a specific prospect' as the cold-outreach hook. Ship a live public metrics/progress page per project as both trust signal and marketing surface (feeds his mandatory tracker standard).
Augment don't replace — position agents as 'juniors' the human configuresseen in 02, 21, 24
Why it mattersFounders don't trust AI to replace seniors/creatives but every company needs junior grunt work done. Framing agents as a junior teammate the client's staff supervises and configures defuses buyer fear and lowers objection-handling on cold clients.
How we use itIn proposals, frame deliverables as 'a junior teammate that removes the boring tasks,' and ship an editable rulebook/policy/guardrail layer as part of every build — both a selling point and a natural retainer/iteration engagement.
Ambitious vision + ship the smallest increment this week; commit to ONE offerseen in 24, 20
Why it mattersAmbitious 'do-the-whole-job' offers are easier to sell and market (remarkable = remarked upon), but the more ambitious the plan the more important small weekly increments are. Overbuilding everything at once is the #1 time-waster; focus drives first revenue.
How we use itPitch clients the grand vision but deliver in weekly shippable milestones (his 5-6 round iteration process). Counter his tendency to build 10 showroom pieces at once — drive the single highest-fit offer (AI receptionist/agent) to first paid revenue before diversifying.

Top actions to implement

  1. Package a single flagship productized offer now: 'AI receptionist / operator agent' for one high-ticket local-services vertical (med spa — reuse Desert Glow), priced setup $2-5k + $0.5-1.5k/mo, with a bolded dollar-quantified guarantee tied to the tracker page. Commit 90 days, focus on sales not tinkering.
  2. Rewrite every Project Catalog listing and proposal template as: named job automated end-to-end → enumerated task list with hours/dollars saved → setup+retainer pricing → guarantee line → 'junior teammate, you review exceptions' framing.
  3. Re-architect his default build as a headless agent core (FastAPI loop) + thin swappable UI, so one engine ships as web chat, Slack/Teams bot, and embedded core loop — and add a tiered model router (cheap model for extract/classify, Claude for hard reasoning) sold as 'cost governance.'
  4. Run the warm-then-Dream-100 acquisition play in parallel to Upwork to farm first case studies/testimonials fast: message 50-100 known contacts for intros, then 25-100 researched prospects each with a FREE working demo build as the hook.
  5. Build the AI SDR / hyper-personalized cold-email agent as his highest-leverage showroom+outbound tool (per-prospect research + reply handling on Claude); make clients pay for Clay/Sales Navigator; price $2-4k/mo or performance ($250-500/qualified call).
  6. Ship a live, public metrics/progress page for every project (build-in-public) as trust signal + marketing surface; treat each showroom site's GTM (transparent pricing, self-serve demo, clean design) as a product that wins on buying experience.
  7. Apply the 3-filter niche screen before building any new showroom piece (underserved + disposable income + dollar-quantifiable pain + unfair advantage); narrow each to one role/one vertical instead of a general tool.
  8. Build the interview→30-days-of-content pipeline as a productized 'content engine' offer (transcribe → Claude prompt chain → multi-format output) — dogfood it on these transcripts and sell it at $1.5-3k setup + $2-5k/mo.

Tools to try

  • OpenCode (open-source, model-agnostic Claude Code alt — run cheap open-weight models GLM/DeepSeek/Kimi for routine coding, keep Claude for hard reasoning, cut his own delivery cost)
  • Claude Agent SDK (thin agent-first wrapper layer instead of building the loop from scratch)
  • Clay.com + LinkedIn Sales Navigator (targeted prospect lists + per-prospect research for the AI SDR offer — NOT bulk Apollo)
  • Fireflies / transcription (feed the content-engine pipeline)
  • Klaviyo (e-commerce email+SMS retention flows productized offer)
  • Magic Patterns / v0-style AI front-end tool (ship polished client UIs solo without a designer)
  • models.dev + opencode.ai/data (reference for model/provider selection and the build-in-public live-metrics pattern)
  • OpenRouter (model routing/aggregation to implement tiered cheap-vs-frontier routing)

Upwork / business angles

  • AI receptionist / 24-7 appointment-setter for med spas, PI law, dental, HVAC, roofing (setup+retainer+guarantee) — maps directly onto his Desert Glow showroom piece
  • 'Internal operator agent' that eats account-onboarding/integration work so a client services 10x accounts with one FTE (GigaML-Atlas pattern) on his data-layer stack
  • 'Single source of truth ops console' — cross-data RAG+SQL interface unifying siloed systems so clients 4x revenue with flat ops headcount (Legion Health pattern = his Concierge Agent)
  • AI SDR lead-gen: per-prospect research + hyper-personalized cold email + reply-handling agent, priced per qualified call or % of close (breaks the hourly ceiling)
  • Content engine: one client interview → transcript → Claude chain → 30+ days multi-format content in their voice; service 8-10 clients solo
  • E-commerce email+SMS retention system on Klaviyo (welcome/abandoned-cart/post-purchase/win-back) — week-1 visible ROI for $50k-500k/mo Shopify brands
  • Personal-data 'brain' vertical: ingest a user's/client's records (health, legal, finance) into Postgres, RAG+agent over them for personalized guidance — repackage his Concierge/RAG pattern
  • 'What do you do all day' automation audit → ship small narrow per-employee agents (PhaseShift pattern), turning one client into many small billable builds + retainer
  • Token-governance / admin add-on: per-team model allowlists, spend caps, usage dashboard — upsell on any agent build for orgs worried about runaway LLM bills
  • White-label arbitrage: stay the single point of contact, subcontract ad-buying under his brand, mark up 2x — sell 'AI + ads' bundles without becoming a media buyer

⚠ Claims to verify before quoting a client

Market intelligence & content

What's actually happening in AI (Anthropic, the model race) plus how to make content that drives demand: own the grounded context, humanize commodity AI output, and run a repeatable content engine.

Consensus techniques (6)

Agent runs real tools / owns broad context (not the model choice) = the differentiatorseen in 08, 15, 23
Why it mattersEvery video lands on the same idea: value comes from wiring an agent into many real tools, data sources, and connectors so it can chain actions and act on grounded context — NOT from which frontier model is hot this week. This is literally Abdi's 'owns the data layer' positioning validated from three independent angles, and it's the durable moat as models commoditize.
How we use itMake 'breadth of grounded context + real tool access' the headline of every agent proposal. Wire the client's actual data sources and action tools (email, DB, connectors) early rather than a single API. Sell reliability ('the agent runs the task granularly, doesn't hallucinate') over model hype.
Humanize / human-in-the-loop on top of commodity AI generation is the moatseen in 15, 22, 23
Why it mattersAffiliate video (22) says pure copy-paste AI content doesn't rank — the edge is real testing, original photos, an editor pass. Kova (23) uses a research-agent -> human-edited spec -> execution-agent loop. Anthropic (15) tunes a deliberate 'professional warmth' persona by hand. Same lesson: the human/data layer bolted onto cheap generation is what clients can't get from a 'I'll ChatGPT it' freelancer.
How we use itPosition every deliverable as commodity-generation + a hard-to-copy human/data layer. Bake a human-edit checkpoint into content and agent pipelines (agent drafts spec -> Abdi edits -> agent executes). Pitch it as the reason to pay him over cheap freelancers.
Productize into one narrow, recurring, live-demoable artifact — escape hourlyseen in 08, 15, 22
Why it mattersGreg/Nick (08) push a vertical 'managed AI employee' selling ONE weekly artifact at a monthly retainer with a paid-pilot ladder. Anthropic (15) picked enterprise outcome-tools over consumer engagement. Affiliate (22) scopes to a narrow deep-catalog niche. Convergent signal: pick one narrow, concrete, recurring, demoable deliverable and sell it as a productized service, not a vague hourly build.
How we use itScope every Upwork proposal to one recurring artifact (weekly client report, lead-qualification summary, reconciliation doc). Structure pricing as paid pilot -> monthly managed seat -> multi-seat. This is Abdi's route off $45/hr into retainer revenue.
Parallel / fan-out agent workflows for delivery speedseen in 08, 15, 23
Why it matters08 (5 terminals + master agent that spawns workers), 15 (Anthropic runs a few to a few thousand parallel Claudes, ~100% of code written by Claude), 23 (Cursor/Claude Code doing bulk file ops). All three treat parallel agent operation as the normal way to work — the concrete mechanism behind the fast delivery Abdi already pitches.
How we use itAdopt parallel Claude Code as the STANDARD delivery workflow: while one agent scaffolds the FastAPI/Postgres layer, others do tests, Stripe/SendGrid wiring, and the client progress-tracker page. Also a sellable feature — client agents that fan out subtasks for throughput.
Files + documented templates + a coding agent = a scalable, sellable systemseen in 08, 22, 23
Why it mattersKova (23) runs her whole content op as Obsidian markdown + templates executed by Claude Code/Cursor; 08 uses Obsidian as agent memory/knowledge base; 22's ThirstyAffiliates 'single source of truth, update-once-propagate' is the same idea. Plain structured files are the substrate an agent operates against — ties straight to 'owns the document/data layer.'
How we use itRun client-delivery ops as file-based vaults with reusable templates (project template, style guide, progress-tracker template) an agent executes against. Then sell it: 'systematize your content/ops into a file-based system an AI agent can run.'
Content-engine loop feeding faceless/reel marketing (research -> script -> creative -> publish)seen in 08, 22, 23
Why it matters08's VidIQ-outlier -> thumbnail -> publish loop, 22's SEO outline-then-section drafting, and 23's Manus teardown -> five-act script -> Freepik creative all describe the same reusable content pipeline. This directly powers Abdi's own showroom marketing (ElevenLabs/Kling/CapCut) and is a resellable client deliverable.
How we use itStand up one reusable content pipeline: reference teardown -> structured script/outline -> batch creative gen -> human edit -> publish. Use it for Abdi's own showroom pieces AND package it as a marketing-agent deliverable for clients.

Top actions to implement

  1. Rescope Abdi's Upwork/Project-Catalog offer from hourly builds to ONE narrow productized deliverable sold as paid pilot -> monthly managed seat (anchor: ~$1.5K pilot, $2.5K/mo single seat, $6.5K/mo multi-seat). The client-reporting / weekly-market-report agent is the ideal wedge — it maps to his mandatory client progress-tracker standard and is trivially live-demoable. (08,15)
  2. Make parallel Claude Code the standard delivery workflow: fan out scaffolding, tests, Stripe/SendGrid wiring, and the progress tracker across simultaneous agents. Bank it as a documented delivery playbook applied to Ayuvara and every showroom build. (15,08)
  3. Adopt the research-agent -> human-edited spec -> execution-agent loop as a reference architecture for RAG/agent deliverables (one agent proposes structure/taxonomy, Abdi edits, a second agent executes against the plain-file spec). Sells reliability and puts the human/data layer front and center. (23,08)
  4. Write persona + constitution as explicit deliverables for every chatbot/RAG build: a one-paragraph character brief with a tone dial ('professional warmth') plus an allowed/forbidden principles doc loaded as the system-prompt backbone. Test edge cases for over-refusal. Especially valuable for regulated verticals (Desert Glow med spa, Ayuvara health). (15)
  5. Use lead-targeting filters from the data: prioritize verticals already feeling AI pressure with budget — management ops, finance, legal document automation (Anthropic Economic Index) — and, for content/affiliate plays, low-competition deep-catalog hobby niches. Pull the actual Economic Index dataset to name specific high-adoption tasks in proposals. (15,22)
  6. Stand up one reusable content pipeline for showroom marketing AND as a client offering: competitor teardown -> structured five-act script/SEO outline -> batch creative gen -> human edit -> publish, on his existing ElevenLabs/Kling/CapCut stack. (23,22,08)
  7. Add a metrics/observability + email-notification layer to 'managed seat' deliverables (log agent failures and user-frustration signals, surface to a branded tracker) to justify recurring retainer pricing over one-off builds — leverages his banked App Insights. (08)
  8. Build his own affiliate showroom piece the lean way: broad-name domain + WordPress, 20-50 humanized AI-assisted articles (info + 'best-of' transactional), recurring-SaaS commissions via PartnerStack on the exact stack he already uses, publish-first-monetize-later. (22)

Tools to try

  • Composio (one-click SaaS connector layer — evaluate vs hand-wiring integrations to cut agent build time; weigh against his default FastAPI+direct-API stack per job)
  • Manus AI (agentic — actually runs scripts to download/transcribe/parse a video or asset instead of hallucinating; use for competitor/brand teardown deliverables and any 'parse real assets -> structured artifact' agent)
  • Latitude (agent observability — flags agent failures AND user-frustration signals; feeds the managed-seat metrics tracker)
  • Obsidian (markdown vault as agent memory + file-based content/ops production system driven by Claude Code/Cursor)
  • Freepik + Nano Banana Pro (generative background re-dressing of real footage + start-frame/end-frame video gen — upgrade cheaply-shot showroom/ad footage to premium)
  • VidIQ (outlier-video discovery to seed the content engine)
  • KeySearch (keyword-difficulty scoring for niche/keyword validation — could be wrapped into a paid market-research automation service)
  • PartnerStack (recurring-SaaS affiliate network — affiliate the exact tools he builds on for his affiliate-business project)
  • Orgo / always-on cloud agent + Telegram/email entry point (reliability selling point; he already has Azure for this)
  • MCP servers for a client's proprietary domain/data (defensible productized offering that leverages 'owns the data layer')

Upwork / business angles

  • 'Managed AI employee' per-vertical retainer: pre-build the RAG+agent stack on Claude/Azure/FastAPI for ONE vertical from a real Upwork ad, sell it as a monthly seat (paid pilot -> $2.5-6.5K/mo), not an hourly build. This IS the Labor Marketplace / Showroom playbook and Abdi's escape from $45/hr.
  • Weekly client-reporting agent as the wedge deliverable: RAG over the client's own data + a branded live page = low-risk, demoable, maps to his mandatory client-progress-tracker standard, and justifies deeper agent work later.
  • 'Brand/content teardown' productized service: run Manus over a client's competitor/reference account to auto-emit a style guide + shot list + script structure — a repeatable low-cost deliverable that leads into bigger content-automation work.
  • Niche + keyword-validation automation service: FastAPI+Postgres pipeline that enumerates a niche's product sub-categories via Claude, scores 'best+product' keywords against a keyword-difficulty API, returns a ranked opportunity map — sell to affiliate/e-comm clients (leverages data-layer positioning).
  • SEO content-automation microservice: Claude-driven outline-then-per-section drafting (keyword-front-loaded intro, H1, top-pick H2s, 'how we tested', meta) as an agent (outline node -> section node), sold as content generation for content/affiliate sites.
  • 'We design the assistant's character, not just its answers': persona brief + written constitution as a paid differentiator, especially for regulated verticals.
  • 'Systematize your content/ops into a file-based vault an AI agent runs': sell the Obsidian + Claude Code templated-ops system as a service.
  • Ad/reel creative upgrade service: generative background re-dressing + start/end-frame transitions to make cheaply-shot client footage look premium (retention -> distribution as the business case).
  • His own affiliate showroom piece: recurring-SaaS commissions (PartnerStack) on the stack he already uses, layered later with display ads — a self-funding content asset that doubles as proof of his content pipeline.
  • Model-swappable architecture as a maintenance/retainer selling point: sell the throughput gain (not a lower bill) and 'your stack auto-improves on the next model upgrade.'

⚠ Claims to verify before quoting a client

Part 3 — All 26 video distillations

Agentic Engineering — the core build checklist

03Building the best agentic analytics harness (Claude + Claude Code)
Omni (Omni.co) — CTO talk at Anthropic "Code with Claude" event  ·  13 techniques
SummaryOmni built "Blobby," a production text-to-data analytics agent, by putting a semantic/context layer between the LLM and the warehouse and evolving through concrete phases (single-shot → richer field metadata → agentic loop → trace-driven debugging → SQL generation). The durable lessons: localize context next to the data definition it describes, don't split the "brain" between outer/inner agents, invest in error messages + recovery budget, let Claude write real SQL (with CTEs) instead of a proprietary JSON query form, and treat eval traces as your primary observability tool.
One-lineHow Omni built a production text-to-SQL analytics agent: semantic layer + localized context, single consolidated agent brain, trace-driven evals, and letting Claude write real SQL.
Semantic/context layer between LLM and warehousedurablerelevance 5/5
What it isA translation layer over the database that curates which of the many redundant tables actually matter, encodes business definitions (e.g. 'last quarter' = fiscal vs calendar), and maps NL questions to correct SQL. Solves the fact that real warehouses have hundreds of near-duplicate revenue/opportunity tables the LLM can't disambiguate alone.
How we apply itFor any 'chat with your data'/RAG-over-SQL client build, don't point the LLM at raw schema. Build a curated semantic layer (a Postgres metadata table or config) that says which tables to use, defines business terms, and constrains joins. This IS the data-layer product Abdi sells — position it as the moat.
Localize context next to the definition it describesdurablerelevance 5/5
What it isRather than dumping all business context into one big prompt/file, attach each piece of context to the specific field it applies to (analogous to putting CLAUDE.md next to the code it governs). Field-local context produced measurably better answers.
How we apply itStore per-field/per-table 'AI context' inline with each field definition in the semantic metadata, not in a monolithic system prompt. Retrieve only the context for fields relevant to the query. Directly improves RAG answer quality on client warehouses.
Per-field metadata: AI context, sample queries, sample valuesdurablerelevance 5/5
What it isBeyond label/description, add three LLM-specific fields: (1) 'AI context' = how to use this field/when to reach for it, (2) sample queries = canonical query for a typical question, (3) sample values = a taste of actual values (e.g. region = EMEA/NAM/APAC) so the model can infer/normalize inputs like 'United States'→'US'.
How we apply itAdd these three columns to the client's data dictionary and inject them into the query-generation prompt. Sample values especially fix filter/fuzzy-matching errors cheaply — a quick win to demo on a client deliverable.
Give the agent an error-recovery budget + descriptive error messagesdurablerelevance 5/5
What it isOne of the largest quality jumps came from (a) explicitly telling the agent how to recover from errors and giving it a token/step budget to retry, and (b) investing in error messages that describe what went wrong and how to fix it. Hard evals improved dramatically from this alone.
How we apply itIn FastAPI tool layers, return rich, instructive error strings (not stack traces) back into the agent loop, and prompt the agent with an explicit retry/recovery policy + budget. Cheap, high-ROI robustness upgrade for any agent deliverable.
Consolidate the brain — avoid split outer/sub-agent knowledgedurablerelevance 5/5
What it isTheir outer agent planned tasks but a sub-agent generated queries; the outer agent didn't know what a single query could answer, so it handed impossible multi-query tasks to a single-query sub-agent. Pulling the query tools up into the outer agent ('consolidating the brain') removed the surprising failures.
How we apply itDon't reflexively split into sub-agents. Only separate an agent when the boundary doesn't require shared knowledge to plan correctly. If the planner must know the sub-agent's capabilities/limits to delegate well, keep the tools in one agent. Prevents a whole class of flaky behavior in client agents.
Trace-driven debugging ('blobotomies') as primary observabilitydurablerelevance 5/5
What it isWhen users flagged bad answers, they invested in capturing and reading full agent traces to see the agent 'talking to itself.' Reading raw traces revealed root causes (like the split-brain bug) behind seemingly random failures; this was more valuable than aggregate scores.
How we apply itInstrument every agent build to persist full step-by-step traces (prompts, tool calls, tool results). When a client reports a bad output, read the trace to find the real cause instead of guessing. Sell this observability as a deliverable feature.
Evals with an LLM judge, backed by raw trace datadurablerelevance 5/5
What it isBuild an internal eval suite; the CTO's key point is the value is the raw trace/observability data first, then codifying the 'why this was bad' judgment into an LLM-as-judge for efficient repeatable scoring. Predictability/same-answer-every-time is the core product promise.
How we apply itShip an eval harness with client agent projects: a fixed question set, stored expected behavior, and an LLM judge scoring runs. Use it to demonstrate reliability and to catch regressions — a strong Upwork differentiator and upsell.
Let Claude write real SQL (with CTEs), then parse it — not a proprietary JSON query formdurablerelevance 4/5
What it isThey moved from a highly-structured JSON query representation to having Claude emit raw SQL that their engine parses (with guardrails to keep the parser from failing). Claude already knows SQL, favors CTEs, and could one-shot questions that previously took 3-4 chained queries. Efficiency and quality both rose.
How we apply itPrefer having the model generate the native query language (SQL) with constraints/validation, rather than teaching it a bespoke intermediate DSL. Add a validation/parse step + allowlist of forms. Fewer tokens spent teaching format, more correct one-shot answers.
Continuous-learning feedback loop feeding new questions back into definitionsdurablerelevance 4/5
What it isBecause real orgs change constantly, each new question asked of the data is fed back to refine the context/definitions in the semantic layer, keeping it current and accurate.
How we apply itLog every user query + correction and periodically fold them back into the semantic metadata / sample queries. Turn a static RAG build into a self-improving deliverable the client keeps paying to maintain.
Outer checkpointing loop for failure recoverydurablerelevance 4/5
What it isCurrent architecture has an outer loop that checkpoints executions so the system can recover from any failure, wrapping an inner loop of growing tools (query gen, dashboards, viz, validation, data modeling).
How we apply itCheckpoint long agent runs (persist state per step) so a failure resumes instead of restarting. Important for expensive multi-query analytics jobs in client deliverables.
Match model tier to conversation complexity (Haiku → Sonnet)decayingrelevance 3/5
What it isSimple single question/answer ran on Haiku; once flows became long, multi-step agentic conversations, they switched to Sonnet — accepting higher token consumption by design because the quality unlock was worth it.
How we apply itRoute by task: cheap/fast model for simple lookups, stronger model for multi-step agentic flows. Budget tokens accordingly and set client expectations that agentic quality costs more per query.
Be your own tool's user — mine Claude Code's harness for design patternsdurablerelevance 3/5
What it isBeing heavy Claude Code users helped their engineers understand what a good agent harness feels like; they explicitly borrowed patterns (e.g. exploring a semantic model like a codebase, since a semantic model isn't that different from a codebase).
How we apply itModel client agent UX on tools you actually use daily. Treat structured client data/config like a codebase the agent can navigate. Ground design decisions in real usage, not theory.
AI-to-build-UI: agent output opens into an editable workbookdurablerelevance 3/5
What it isProduct philosophy of 'AI to build UI to validate/troubleshoot/refine' — Blobby's chart/SQL result can be opened in an editable workbook so the user can riff (swap repo, filter a user) instead of squinting at a SQL block.
How we apply itDon't make the LLM the only interface. Let agent outputs drop into an editable UI (table/filter/chart controls) so users can verify and tweak. Builds trust and reduces re-prompting in client dashboards.
Tools mentioned: Claude Code, Claude Opus, Claude Sonnet, Claude Haiku, CLAUDE.md, SQL / CTEs, data warehouse, LLM-as-judge evals, trace/observability tooling
⚠ Verify:
  • Omni switched Blobby's model from Haiku to Sonnet once conversations became longer/agentic, driving up token consumption by design
  • Claude tends to generate SQL using CTEs (common table expressions)
  • Merging query-generation sub-agent tools back into the outer agent ('consolidating the brain') removed unpredictable behavior
06Finally. Agent Loops Clearly Explained.
Unnamed solo Claude Code / knowledge-work productivity YouTuber (non-coding background, runs a free Skool community). Cites Boris Cherny, Peter Steinberger, and Matthew Berman's "loop library."  ·  8 techniques
SummaryStop hand-prompting coding agents; instead design "loops" — a trigger + action + stop-condition (reason → act → observe → repeat) — where the agent iterates on its own output and self-verifies against an objective done-criterion until quality is high enough. The loop is only as good as its verification/done check. Most tasks need a simple solo loop, not fleets of 24/7 agents.
One-lineAgent loops = reason/act/observe/repeat until an OBJECTIVE done-check passes; a loop is only as good as its verification criteria and the tools it has to self-check.
Reason-Act-Observe self-verifying loopdurablerelevance 5/5
What it isStructure an agent as a loop (reason/plan -> act/implement -> observe/verify -> check done-criterion -> repeat) instead of one-shot prompting. Outsources the human feedback-iteration cycle to the agent so output quality climbs faster and higher per attempt.
How we apply itWrap every non-trivial deliverable in a self-check loop: generate -> validate output -> compare to spec -> fix -> repeat. E.g. a data-extraction agent re-runs against a validation schema until 100% of rows parse before returning to the client; a RAG answer generator self-grades against retrieved context before responding.
Objective, checkable done-criteriondurablerelevance 5/5
What it isDefine the stop condition as objectively as possible: 'keep iterating until X metric = Y result' beats 'until you're satisfied.' Subjective criteria ('until confident') cause endless or under-quality runs. Pair with a hard cap on passes.
How we apply itIn every agent/pipeline spec, encode a measurable done gate: test suite green, JSON schema validates, eval score >= threshold, all rows deduped. Add a max-iterations cap so client jobs can't run away on cost. Makes deliverables demonstrably 'done' for the client.
Give the agent the right verification toolsdurablerelevance 5/5
What it isVerification looks different per task type: visual (browser screenshot), functional (run tests), flow/tone (read output), gameplay (play levels). It is the engineer's job to equip the agent with the tools needed to actually check its own work.
How we apply itFor each build, wire in the matching check tool: pytest for scripts, Playwright/screenshot for UI, schema/row-count assertions for data pipelines, an LLM-judge for content tone. Ship verification as part of the deliverable so the system stays correct after handoff.
Prefer a solo loop over agent fleetsdurablerelevance 4/5
What it isMost tasks don't need swarms/managers-of-managers. A single terminal session with one agent reasoning/acting/observing plus a good prompt handles the majority; escalate to maker-checker or manager-with-helpers only when justified. 24/7 fleets often just scale bugs.
How we apply itDefault client architecture to one well-verified agent, not a multi-agent showpiece. Reserve added agents for real need. Keeps builds cheaper, more debuggable, and easier to hand off/maintain — protects margins and reliability.
Maker-checker pattern (dedicated scorer sub-agent)durablerelevance 4/5
What it isSplit generation from evaluation: one agent produces, a second agent grades and gives feedback. Move subjective scoring into a dedicated scorer sub-agent that you separately prompt and run through evals so you trust its judgment.
How we apply itFor quality-sensitive outputs (content, lead scoring, classification), add a separate grader agent validated against a labeled eval set, then let the maker loop against its feedback. Sell the eval'd checker as a quality guarantee to the client.
Loops as the mechanism behind 'one-shot' resultsdurablerelevance 4/5
What it isThe impressive 'did it in one prompt' outputs are actually loops with built-in verification and iteration (e.g. video edit that transcribes, cuts pauses, makes+syncs beats, renders, then verifies all beats are in-bounds and aligned). The magic is the internal verify+iterate, not a single pass.
How we apply itFrame deliverables to the client as a single 'goal' command that internally loops and self-verifies. Set expectations that loops get you much closer on the first try, not to 100% perfect — they compress human review, not eliminate it.
Loop-first meta approach (design the system that prompts)durablerelevance 4/5
What it is'Loop engineering' = replacing yourself as the prompter; you design the system that prompts the agent (trigger + action + stop condition), rather than typing prompts. But apply it selectively — it doesn't apply equally to every role/use case.
How we apply itPackage repeatable client workflows as reusable /goal loop definitions (a small internal 'loop library') so each new job starts from a proven trigger-action-stop template instead of ad-hoc prompting. Speeds delivery across showroom pieces.
Overnight / cadence-based loop runsdurablerelevance 3/5
What it isFire a chunky loop before bed for big/experimental goals (4-8 hrs), then feed the morning output into more loops or human iteration. Run agents on a cadence or on event triggers rather than blindly 24/7; match run length to actual value (35 min-few hrs is the sweet spot; 12-hr runs rarely pay off).
How we apply itFor large client jobs (bulk generation, big refactors, corpus processing), schedule long unattended runs off-hours, then review/refine. Use event- or schedule-triggered agents (not always-on) to control cost while delivering volume.
Tools mentioned: Claude Code (slash /goal commands), Matthew Berman loop library, Browser screenshot verification, Sub-agents (dedicated scorer agent), Hyperframes (Claude Code video editing)
⚠ Verify:
  • Boris Cherny and Peter Steinberger publicly said they no longer prompt coding agents, they write loops
  • Matthew Berman published a public 'loop library' of submittable agent loops
  • Peter Steinberger works at OpenAI
09Harness Engineering is the future
David Andrzej podcast — guest Magnus Müller, co-founder/CEO of Browser Use  ·  10 techniques
One-lineHarness engineering: ship agents a tiny self-modifiable toolset + full code control, gate irreversible actions behind human approval, and flip to a 24/7 agent that proactively suggests actions you swipe yes/no.
Schema-aware DB skill for coding agents (RLS/migrations guardrails)durablerelevance 5/5
What it isSponsor segment but concrete: a Supabase 'agent skill' you install with one command so Claude Code/Codex/Cursor get the DB's schema, RLS policies, and docs in context — SQL changes land on the first try instead of the agent guessing. Enforces production patterns: RLS on every exposed schema, security-invoker on views, no orphaned migrations.
How we apply itDirectly on-brand for owning the data layer. Package a per-client 'database skill' — a markdown/skill file dumping their Postgres schema, RLS rules, naming conventions, and migration policy — so any agent (or the next dev) makes safe changes first-try. Ship it as a deliverable artifact, not just code. Postgres RLS + security-invoker views + clean migrations is a checklist to actually enforce.
Proactive 'agency' loop — the AI prompts youdurablerelevance 5/5
What it isFlip the interface: a 24/7 agent runs on a schedule (e.g. every 30 min), watches connected services, and generates suggested actions ('should I reply to this WhatsApp?', 'should I DM the Codex team?'). Human just approves/rejects. Solves the real bottleneck — that a human has to come up with prompts. Agent is instructed to keep each suggestion short and self-explanatory so it can be judged in ~3 seconds.
How we apply itHigh-value client deliverable: a proactive assistant instead of a passive chatbot. Cron/worker on Azure runs Claude over the client's inbox/CRM/tickets, drafts next-actions, and posts them for one-click approval. This is a differentiated, sellable product (not 'another chatbot') and fits the FastAPI+Postgres+Claude stack.
Approval gate before irreversible actionsdurablerelevance 5/5
What it isHuman-in-the-loop checkpoint on anything that touches money, sends external messages, or is otherwise irreversible: 'send me a screenshot of the cart before you buy', 'ask me for approval before the PR/email is public'. The agent can act autonomously right up to the point of consequence, then pauses for a yes/no.
How we apply itBake a confirm-before-commit step into every client automation that spends money or emails third parties (returns a preview + waits for approval). Reduces client liability fear, makes autonomous agents sellable, and is trivial to implement as a pending-action row in Postgres + a notification.
Minimal self-modifying harness (agent writes its own tools)durablerelevance 4/5
What it isInstead of a heavy framework, ship the agent a tiny toolset (Browser Harness is ~600 lines) plus full read/write access to that code. When it hits a missing capability (no file-upload tool, a signature/draw field, a native browser dialog), the agent just writes the tool into its own harness and proceeds. Works now because coding models are strong enough to compose primitives without a hand-tuned system prompt.
How we apply itFor an automation deliverable, don't hard-code every branch. Build a small tool layer (FastAPI endpoints / function-calling tools) and let Claude extend it in a scratch module for edge cases you didn't anticipate, then promote the working code into the client's repo. Sell 'handles edge cases we didn't spec' as a robustness selling point.
Collapse multi-agent eval loop into one self-fixing agentdurablerelevance 4/5
What it isOld setup ran three agents: a doer, a fixer, and an LLM-as-judge watching browser traces — slow inter-agent chatter. New setup: ONE agent that both does the task and can inspect/patch its own harness when something breaks ('I couldn't see the screenshot' -> 'fix it' -> it finds the bug and pushes). Claimed ~10x faster dev cycle.
How we apply itWhen an agent pipeline is flaky, resist adding more supervisor agents. Give the single doer agent access to its own trace/logs and code so it can diagnose and patch in one loop. Fewer moving parts = cheaper to run and easier to hand off to a non-technical client.
SQL-backed preference/memory store for the agentdurablerelevance 4/5
What it isThe agency agent persists learned user preferences in a SQL database ('you don't care about GitHub PRs, you care about distribution') so suggestions improve over time. Also self-tuning meta-prompt: 'your goal is that I accept as many suggestions as possible; if you send too many or too long, I'll ignore you.'
How we apply itAdd a preferences/feedback table so approve/reject decisions feed back into future suggestions — an agent that visibly learns the client's taste. Cheap durable memory layer (Postgres) rather than reaching for a vector DB. Reinforces the 'owns the data layer' pitch.
Messaging app as the agent front-enddurablerelevance 4/5
What it isRuns the whole operation from Telegram: a forum's topics map to separate agent sessions, /claude and /codex switch models mid-thread, and there's a one-click '24/7 box' (cloud VM) holding auth, browser profiles, and context. Chosen because the messaging app is already installed, mobile, and has notifications/attachments built in — ship fast, swap to a custom app later.
How we apply itFor SMB clients, skip building a UI: deliver the agent through Telegram/WhatsApp/Slack they already use. Faster to ship, lower support burden, and lets you validate usefulness before investing in a web app. The pattern (meet users in existing messaging) is durable; the specific app is swappable.
CDP-connected real browser for authenticated workflowsdecayingrelevance 4/5
What it isBrowser Harness attaches over Chrome DevTools Protocol to the user's real local Chrome, inheriting existing logins/cookies so auth and captchas mostly disappear; a stealth browser in the cloud covers the same for hosted runs. Payments handled by trusting the already-trusted coding agent with the card.
How we apply itWhen a client task needs a site with no API and a login, drive their real authenticated browser over CDP rather than rebuilding auth/OAuth. Sidesteps the hardest part of browser automation (login/captcha) and is the practical unlock for 'automate this portal we log into daily' jobs.
Long-running goal with verifiable end-statesdurablerelevance 3/5
What it isCodex /goal-style pattern: hand the agent one high-level objective and a set of verifiable success criteria, and let it run unattended for many hours (12-36h) instead of babysitting it with many short prompts. The human abstracts one level up (from 'build a website' to 'get users').
How we apply itFor larger builds, frame the client work as an objective plus explicit acceptance checks (tests, metrics, 'done when X') and let the agent grind, rather than micro-prompting. Also a proposal framing: define done as verifiable outcomes — echoes the 'Upwork ad is the contract / definition of done' rule.
Publish solved edge cases as shareable skillsdurablerelevance 3/5
What it isOnce one agent figures out a gnarly case (native geolocation dialog, printing a page, signature fields), it writes a reusable skill and pushes it to a shared repo so every other agent instance inherits the fix and handles it faster next time.
How we apply itMaintain your own growing library of solved-automation skills across client jobs (a private skills repo). Each new job that hits an edge case adds a reusable asset, compounding delivery speed — the same 'banked upgrades for the next job' idea already in your delivery-stack notes.
Tools mentioned: Browser Use, Browser Harness, Claude Code, Codex, Cursor, Supabase (agent skills), Telegram, Chrome DevTools Protocol (CDP), Superset (worktrees), SQLite/SQL database, Gmail, Slack, Notion, Linear, GitHub, WhatsApp, DeepSeek, Minecraft (hackathon agent demo)
⚠ Verify:
  • Browser Harness is ~600 lines of code and is the mechanism that lets a coding agent control a real Chrome via CDP
  • Supabase agent skills are free/open source, install with one command, and enforce RLS on exposed schemas, security-invoker on views, and no orphaned migrations
  • Collapsing a doer/fixer/LLM-judge multi-agent setup into one self-fixing agent yields ~10x faster dev cycle (anecdotal, not measured)
  • Codex /goal can run unattended for 12-36 hours on a single objective
11How AI agents & Claude skills work (Clearly Explained)
Ross Mike (guest) on Greg's podcast ("the pod") — Ross Mike breaks down AI agents/skills on YouTube & X  ·  11 techniques
One-lineStrip bloated agent.md files; build Claude Skills by walking the agent through a real workflow to success then codifying, and harden them with a failure-feedback loop.
Codify Skills from a proven live run, not from scratchdurablerelevance 5/5
What it isDon't hand-write or AI-generate a skill up front. First identify a real workflow, then walk the agent through it step by step (do the research, feed it results, correct it, tell it where the Google Sheet/API call goes). After one or more successful end-to-end runs, tell the agent 'review what you just did and create the skill.' The skill inherits the context of what a working run actually looks like — API calls, data shapes, decision rules.
How we apply itFor each client deliverable (e.g. Desert Glow concierge, KalEdge research agent), build the automation by co-piloting the agent through a real client workflow first, capturing the successful trace, then have Claude generate the Skill/prompt from that trace. Deliver skills that are proven on the client's actual data, not generic templates.
Recursive skill refinement via failure feedback loopdurablerelevance 5/5
What it isSkills still fail because of info gaps. When the agent fails, ask it 'why did you fail / what error did you get' — it will report descriptively (e.g. 500, insufficient credits). Feed that failure back ('you failed here, fix this'), let it fix, then tell it 'update the skill so this doesn't happen again.' The creator ran ~5 iterations to get an 8-data-source report generator that runs flawlessly.
How we apply itBake a failure-capture-and-patch loop into every agent deliverable: on error, surface the exact error, patch behavior, and self-update the skill/prompt. Matches Abdi's 5-6x iteration process — sell it as a hardening cycle where the automation gets more reliable each run.
Prefer Skills over agent.md/CLAUDE.md for token efficiency (progressive disclosure)durablerelevance 5/5
What it isA skill file only loads its name + description into context (~53 tokens); the full body loads only when the agent decides it's relevant. An agent.md/CLAUDE.md loads its entire body (e.g. 944–7000 tokens) on every single turn. Reserve persistent config files for genuinely proprietary, must-be-referenced-every-turn info (currency conventions, company methodology) — 95% of projects don't need one.
How we apply itArchitect client agents with a lean system layer plus a library of on-demand Skills instead of one giant always-on instruction file. Cuts per-turn token cost (directly lowers client API bills) and keeps the agent sharper. Justify it in proposals as cost + reliability engineering.
Keep context utilization in the 10–70% banddurablerelevance 4/5
What it isAgents get measurably dumber as the context window fills toward 80–100%. Keep working context between the baseline (~10% system prompt) and ~70%. This both saves money and keeps the agent performant; it's why Claude Code/Codex auto-compact near limits.
How we apply itDesign long-running client agents (RAG, multi-step research) to actively manage context: prune, summarize/compact, and offload static knowledge to retrieval or skills rather than stuffing the prompt. Treat 70% as a budget ceiling in the data-layer design.
Treat the agent like a new employee, not a black boxdurablerelevance 4/5
What it isLLMs predict tokens; they don't 'understand' your business or workflow. Their default answers are shallow ('legit, legit, perfect') until you give them explicit, experiential step-by-step instruction and let them fail and be corrected — exactly how you'd onboard a new hire who lacks context (the Office 'rundown' analogy).
How we apply itSet client expectations up front: an agent needs a 1–2 week onboarding/iteration window on their specific workflow before it's reliable. Frames the iteration process as normal engineering rather than a defect, and positions Abdi's workflow-capture skill as the value-add.
Scale for productivity, not for looking cool — start with one agent, add subagents only when justifieddurablerelevance 4/5
What it isDon't spin up 15 subagents + 30 skills before you have working workflows. Start with one main agent that does everything; once a workflow is codified into reliable skills, promote it to a dedicated subagent (creator ended at ~5: marketing/business/personal). Each subagent must carry real skills and context, not exist for show.
How we apply itArchitect multi-agent client systems incrementally: prove single-agent workflows first, then split into subagents where there's a real productivity boundary. Avoids over-engineered, brittle deliverables and keeps builds shippable.
Don't download third-party skills — security + context riskdurablerelevance 4/5
What it isDownloaded skills are (a) an easy attack vector against your agent and (b) lack the context of a successful run on YOUR workflow, so they underperform. Study others' skills for ideas / feed them to your AI to learn from, but build your own.
How we apply itNever ship client agents with random marketplace skills; build bespoke skills per client. Sell 'no untrusted third-party code in your agent' as a security selling point. Reinforces the data-layer-ownership positioning.
Give autonomous agents their own isolated email/account, not your credentialsdurablerelevance 4/5
What it isThe creator's Open Claude agent has its own dedicated email; he forwards sponsor emails to it rather than granting access to his real inbox, limiting attack surface (he'd been hacked before). Agent polls every 15 min for new mail.
How we apply itFor any client agent that touches email/accounts, provision dedicated scoped identities/mailboxes instead of the client's primary credentials. Pairs with Abdi's per-project hello@<domain> mailbox standard as a security best practice.
Solid templates/starters as durable agent contextdurablerelevance 4/5
What it isBecause 'code itself has become context,' agents build best on top of a solid starting foundation. Verbose stack instructions (React/Next/Supabase in agent.md) are now unnecessary — the model reads the codebase. A strong template becomes the context the agent extends, predicted to have a renaissance.
How we apply itMaintain a well-structured FastAPI+Azure+Postgres+Stripe+Claude starter template as Abdi's default project base; the agent infers stack from the code rather than needing config. Speeds delivery and gives consistent, high-quality builds across showroom pieces.
Encode decision rules as explicit reject/accept criteria in the skilldurablerelevance 4/5
What it isVague tasks yield rubber-stamp output. The creator gave concrete gating logic: check the entity's Twitter/YouTube/Trustpilot/funding; if 2+ are missing or not in good standing = automatic rejection; only strong ones trigger the email + sheet update. Explicit thresholds turn a fuzzy 'evaluate' into a deterministic, auditable step.
How we apply itIn client research/qualification agents (lead scoring, vendor vetting, KalEdge signal filtering), codify hard accept/reject thresholds and required data sources rather than asking the model to 'assess.' Produces consistent, defensible outputs clients can trust.
The harness matters as much as the modeldurablerelevance 4/5
What it isBenchmarks showed different output quality across Cursor vs Claude Code vs Codex on similar models — proof that the surrounding harness, tools, and injected context increasingly determine quality, and will matter more as base models plateau in 'good enough' territory.
How we apply itCompete on the harness/data layer, not the model. Abdi's differentiation is context assembly, tool wiring, and workflow codification around whichever frontier model — exactly the 'owns the data layer' pitch.
Tools mentioned: Claude Code, OpenAI Codex, Cursor, Open Claude / Open Claw (autonomous cloud agent), Paperclip (agent product), Claude Skills (skill.md, progressive disclosure), agent.md / CLAUDE.md files, OpenAI Tokenizer, Notion, Google Sheets, YouTube/Twitter/Trustpilot analytics APIs, Opus 4.6, GPT 5.4
⚠ Verify:
  • Claim that a skill loads only ~53 tokens (name+description) vs a 944-token agent.md loading fully every turn — verify exact progressive-disclosure token behavior in current Claude Skills spec
  • Claim that agents get measurably 'dumber' past ~70-80% context utilization — directionally true but the specific band is anecdotal
  • Cited benchmark showing output-quality differences across Cursor/Claude Code/Codex — creator admits he doesn't fully endorse it
  • Google 'memory paper' enabling agents to index information — vaguely referenced, unverified
  • Model version names 'Opus 4.6' and 'GPT 5.4' are speculative/future and may be fictional to the recording date
12How Anthropic Engineers ACTUALLY Prompt Claude Code
Unnamed YouTube creator (AI-workflow/content channel; references the AI Engineering Code Summit and Anthropic engineers Barry & Eric; "anti-slop" branding)  ·  7 techniques
SummaryStop writing one-off prompts; encode repeatable work as Claude Code "skills" — folders combining a description (routing), instructions (playbook), and tools/scripts (the real leverage) — that are composable, permission-gated, and continuously refined so Claude gets measurably better at your workflow over time.
One-lineEncode repeatable work as composable Claude Code skills (description + playbook + deterministic tool scripts), gate risky ones with invocation flags, and fold every correction back in so the system compounds.
Prompt skills, not one-off promptsdurablerelevance 5/5
What it isReplace ad-hoc prompting for repetitive work with reusable Claude Code skills (folders of packaged procedural knowledge) invoked via slash commands, e.g. /draft-email. Skills are the 'application layer' — the durable asset — while raw prompts vanish when the chat closes.
How we apply itFor every recurring build step (RAG ingestion, eval runs, client-tone email/report drafting, deploy checklists), author a Claude Code skill in the repo instead of re-prompting. Ship the .claude/skills folder as part of the deliverable so the client's own team can run /ingest-docs or /run-evals. Positions Abdi as delivering a reusable system, not a chat transcript.
Three-layer skill anatomy (description / instructions / tools)durablerelevance 5/5
What it isA skill has (1) a description Claude reads to decide when to auto-invoke it — must be specific, not vague; (2) instructions = the step-by-step playbook; (3) tools = scripts, API calls, reference files. Most people over-polish layer 2 and neglect layer 3, where the real leverage is.
How we apply itWhen packaging a skill, write a crisp trigger description so Claude routes to it automatically, and invest in layer 3: attach real, well-documented tools (typed params, docstrings — not params named A/B) that hit Postgres, call the client API, or run FastAPI endpoints. Abdi 'owns the data layer', so wiring skills to actual DB/query scripts is exactly his differentiator.
Save deterministic scripts inside skills (trade tokens for code)durablerelevance 5/5
What it isWhen Claude keeps regenerating the same script each session, have it save the script into the skill folder as a tool for future runs. Code is deterministic, cheaper, faster, and repeatable vs. re-interpreting via tokens. Rule: if code can do it, use code, not the model.
How we apply itFreeze repeatable pipeline steps (chunking/embedding jobs, SQL report generators, data-cleaning transforms, slide/PDF styling) into committed Python scripts referenced by the skill. Reduces client token spend and makes deliverables reproducible — a concrete selling point (lower run cost, consistent output). Fits his Claude+FastAPI+Postgres stack directly.
Composable focused skills, not one mega-skilldurablerelevance 5/5
What it isBuild small, single-purpose skills that chain and call each other rather than one giant skill. Benefits: bugs are easy to localize, improvements compound across every workflow that reuses a skill, and skills become reusable building blocks (build once, plug in everywhere).
How we apply itDecompose each client system into narrow skills (e.g. doc-ingest, retrieve, rerank, draft-answer, cite-sources) that compose, instead of a monolithic 'do-everything' agent. Maintain a private library of proven skills (e.g. a domain/DB check tool) to reuse across Upwork jobs — faster delivery, higher margin, easier debugging when a client reports an issue.
Compounding refinement loop (skills get smarter each session)durablerelevance 5/5
What it isAfter each skill run, ask: is this a one-time fix or should it live in the skill forever? If forever, update the skill with the new rule/example/edge case. Use the chat history itself as source material: 'review the back-and-forth I just had; enhance the skill so this is handled automatically / the mistake doesn't recur.' Goal: Claude on day 30 outperforms day 1.
How we apply itAfter each client iteration, fold captured tone rules, edge cases, and corrections back into the repo's skills — turning the standard 5-6x paid iteration process into cumulative asset value. Pitch it: the system he hands over keeps improving with use. Encodes client-specific voice/process durably instead of losing it when the session ends.
Invocation flags: user-invocable vs disable-model-invocationdecayingrelevance 4/5
What it isTwo skill flags control who can run a skill. Setting user-invocable=false hides it from the slash menu so only agents use it (good for internal agent-only tooling). disable-model-invocation makes it human-only so the model can't trigger it — for high-risk actions like sending messages or deploying to production.
How we apply itGate dangerous deliverable actions behind human-only skills: a deploy-to-prod or send-client-email skill the agent can never fire autonomously, while keeping low-level data tools agent-only and hidden. Demonstrates safety/guardrail engineering to clients — a trust and liability win, especially for automated agent products.
Sub-agent fan-out over a shared skilldurablerelevance 4/5
What it isOnce a capability is a skill, spin up many sub-agents that each invoke it in parallel to do work at a scale a single session couldn't — the example: 10 sub-agents using a domain-check skill to scan 10,000+ domains.
How we apply itUse parallel sub-agents running the same ingestion/enrichment/QA skill to process large client datasets (bulk document classification, lead enrichment, mass record validation) — turns a slow serial job into a scalable batch deliverable he can price accordingly.
Tools mentioned: Claude Code, Claude Skills (.claude/skills folders), slash-command skill invocation, sub-agents, Python scripts-as-tools, user-invocable flag, disable-model-invocation flag
⚠ Verify:
  • Claude Code skills support a 'user-invocable' flag (set false to hide from slash menu / agent-only)
  • Claude Code skills support a 'disable-model-invocation' flag (human-only, model cannot trigger)
  • A skill's description field is what Claude uses to auto-decide whether to invoke the skill without explicit call
  • Anthropic engineers (Barry, Eric) publicly presented these skill practices at the AI Engineering Code Summit

Technical / dev workflow

017 INSANE loops you need to try right now
Unclear from transcript; an AI-coding-agent YouTuber (Codex/Claude Code power user; references Peter Steinberger, here.now, a "loop library" free resource, and DigitalOcean sponsorship)  ·  9 techniques
Summary"Loops" — giving an AI coding agent a trigger plus a goal so it runs autonomously until the goal is met — are the current biggest unlock. Loop = trigger (manual / scheduled / action like PR-open) + goal (verifiable e.g. 100% test coverage, or LLM-as-judge e.g. "refactor until happy"). Strong for verifiable maintenance tasks, weak for greenfield feature-building, and token-expensive.
One-lineAutonomous agent 'loops' (trigger + goal) for maintenance: perf, docs, refactor, logging→error-sweep, SEO/GEO, and self-generating RAG eval suites — verifiable goals only, token-costly, not for greenfield features.
Loop framework: trigger + goaldurablerelevance 5/5
What it isEvery autonomous agent run decomposes into a trigger (manual, scheduled, or action-based e.g. on PR-open) and a goal (verifiable/deterministic OR LLM-as-judge). Verifiable goals are reliable; LLM-as-judge goals are brittle because taste/judgment is delegated to the model.
How we apply itMake 'autonomous maintenance loops' a productized add-on/retainer line on every delivered RAG/agent system. In proposals, frame nightly/scheduled loops (via cron/GitHub Actions on the FastAPI+Postgres stack) as ongoing value. Always prefer verifiable goals (metrics, test pass, error-count=0) for client-facing loops to avoid brittleness.
Logging coverage loop → production error sweep (chained loops)durablerelevance 5/5
What it isLoop A: 'review logging and add missing coverage until every important path produces useful, tested logs.' Loop B (nightly): 'review production logs for errors; if actionable, trace to root cause, fix, verify, open PR, then ping me in Slack with findings + PR link; if none, ping that result instead.' Chaining loops (coverage feeds the sweep) compounds power.
How we apply itDirectly buildable on Abdi's stack: structured logging (matches his python-observability practice) + a scheduled root-cause-fix loop that files PRs and posts to Slack/email. This is a killer 'self-healing app' retainer offer — and dovetails with his standing email-notification standard (ping admin on events).
Full product evaluation loop (LLM-generated eval scenarios)durablerelevance 5/5
What it is'Create N realistic scenarios covering every major capability; define clear success criteria; pick a consistent eval method (pass/fail or scoring rubric); run all under identical conditions; record evidence; fix underlying causes of failures; rerun affected + then the full suite; continue until every scenario meets the quality bar.' Non-deterministic 'living test suite'. Can be app-specialized, e.g. 'generate 100 wide-ranging LLM questions and judge whether responses are good enough with sources; iterate if not.' Runs 12h+.
How we apply itThis is the highest-value one for Abdi's RAG work: an automated eval/regression harness that generates its own scenarios and grades answer quality + source accuracy — exactly his 'accurate response with sources' use case. Package as a RAG-quality guarantee for clients (evals are the credible differentiator). Use a rubric-based verifiable-ish goal to control cost.
Sub-threshold performance loopdurablerelevance 4/5
What it isPrompt: 'continue optimizing for speed; after each significant change measure page-load across every page under the same repeatable test conditions; continue until every page loads under 50ms.' Verifiable goal, walks every page/modal, optimizes one then moves to next. Ran ~50 min in demo.
How we apply itOffer as a concrete deliverable: a performance-hardening loop with a measurable SLA (e.g. p95 API latency <Xms) on client apps. The 'same repeatable test conditions' detail is the key reliability trick — bake a fixed benchmark harness into the loop.
Overnight docs sweep (scheduled)durablerelevance 4/5
What it isNightly automation: 'review the codebase in full, ensure all docs reflect the previous day's changes, update as needed, then open a PR.' Set up as a recurring Codex automation. LLM-as-judge (no verifiable 'complete docs' metric).
How we apply itCheap, high-perceived-value retainer item and matches Abdi's own 'restart-safe docs / session continuity' standard. Sell as 'your docs never go stale' — schedule via cron/GitHub Actions, output a PR the client reviews.
Architecture satisfaction loop with progress filedurablerelevance 4/5
What it is'Refactor until you are happy with the architecture. After each significant step, live-test the system, run auto-review, commit, and track progress in [markdown file].' Reportedly used by Peter Steinberger. Can add strictness constraints ('be strict about simplicity', 'every line DRY'). Key trick: agent tracks its own loop progress in a markdown file.
How we apply itAdopt the markdown progress-tracking pattern for any long agent run — aligns with Abdi's client progress-tracker standard. Use as a nightly code-hygiene loop between feature deploys. Constrain the LLM-judge with explicit rules to reduce brittleness.
SEO-GEO visibility loopdurablerelevance 4/5
What it is'Run an SEO-GEO audit across crawlability, indexation, page intent, titles, internal links, structured data, source citations, answer-first content. Rank the gaps, fix highest-leverage issues, rerun the same crawl, repeat until no critical technical issues remain.' Run ~weekly. Note the GEO (generative-engine/AI-recommendation optimization) angle alongside classic SEO.
How we apply itSell as a recurring 'AI-visibility' service for the showroom sites (Ayuvara, KalEdge, abdialamir.com) and for clients. GEO — optimizing for AI-answer citations — maps to Abdi's marketing-channels playbook (GEO/AI-recommendation already listed). Fixed-crawl-then-rerun is the reliability pattern.
Caveats: where loops fail + token costdurablerelevance 4/5
What it is(1) Loops are bad at greenfield feature-building — you can't 'loop until you build a permissioning system' because the AI's direction/feature choices are unpredictable (an Excel-clone feature-parity loop with computer-use ran for days). Use loops for verifiable maintenance, not day-zero features. (2) Loops are very expensive — they burn tokens autonomously until goal; watch budget and keep a close eye when token-constrained.
How we apply itScope loops in proposals only for verifiable maintenance/quality goals, never as the feature-delivery mechanism. Price in token cost and set stop-conditions/budgets so a client loop can't run for days. Manage expectations: loops = ongoing hardening, not the initial build.
Codex / Claude Code 'slash goal' + automations tabdecayingrelevance 3/5
What it isCodex has a /goal command: append it to a prompt and the agent keeps working until the condition is met (runs minutes to hours). Claude Code also has a /goal feature. Recurring loops set up via Codex's Automations tab ('create via chat'). here.now used for one-command deploy of the loop-library site.
How we apply itKnow these primitives exist, but for client work prefer owning the loop on his own stack (cron/GitHub Actions + FastAPI) rather than depending on Codex's proprietary /goal — more control, portable, and fits his 'own the data layer' positioning. Verify the current /goal syntax before relying on it.
Tools mentioned: Codex (/goal, Automations tab), Claude Code (/goal), here.now (deploy), Slack (loop notifications), GitHub PRs, DigitalOcean (sponsor — inference infra), computer use
⚠ Verify:
  • Codex has a /goal command that runs an agent until a condition is met
  • Claude Code has an equivalent /goal feature
  • Peter Steinberger publicly endorses the 'refactor until happy with architecture' loop
  • here.now supports one-command deploy
05FDE: The $1M/Year AI Job Explained
Greg Isenberg-style startup podcast interviewing "Voss" of Veric Agents (also runs agency LCA)  ·  13 techniques
SummaryIntelligence is now commoditized (every company can buy the same frontier models via Claude Code, Codex, Cursor, Copilot), so competitive advantage has shifted from HAVING AI to DEPLOYING it into a specific business's real, messy processes. The Forward Deployed Engineer (FDE) is the person who bridges business reality and the tech stack, combining consulting-grade communication with production engineering. The repeatable delivery loop is Audit -> Evals -> Deployment, run over and over. Sell an audit first to de-risk and win trust; most AI pilots fail because nobody maps the actual workflow (including exceptions) before slapping AI on it.
One-lineFDE playbook: intelligence is commoditized, value = deploying AI into a business's real workflow via Audit -> Evals -> Deployment, sold audit-first.
Sell the audit first (audit-as-wedge)durablerelevance 5/5
What it isEvery engagement starts with a paid (or free-to-start) audit that maps a department's real workflows, exception handling, and produces an ROI/priority matrix of what's worth automating vs not. It builds trust, surfaces use cases the client never considered, and is reportedly 'worth 10x what they paid.' Rename 'audit' to 'sprint' or 'design sprint' because clients have an allergic reaction to the word audit (tax-audit connotation).
How we apply itMake a fixed-price 'AI Opportunity Sprint' the first deliverable on every Upwork engagement: interview the client, map their actual workflow (with exceptions), and hand back an operating map + ROI matrix ranking workflows to automate. Do the first 1-3 for free/cheap to farm reviews, then charge. Land-and-expand into the build.
Map the REAL workflow, not the documented onedurablerelevance 5/5
What it isThe documented process is rarely the real process. 'An email arrives' actually means 40+ senders, no consistent format, PDFs/screenshots/Excel, half are exceptions, and the routing logic lives in one person's head. FDEs sit with the person (ideally on-site, or observe remotely) for hours instead of a 1-hour interview to capture exceptions that no SOP documents.
How we apply itBefore quoting any RAG/automation build, run a discovery call where you extract every input source, edge case, and 'when I see X I do Y' rule that lives in someone's head. Document exceptions explicitly. This becomes your scope, your moat, and prevents building for a fantasy happy-path system.
FDE judgment: decide where intelligence belongsdurablerelevance 5/5
What it isDon't put AI everywhere ('token maxing'). In a 10-step workflow maybe only 3 steps need non-deterministic judgment (route those to an LLM); the rest are if/else + API calls (deterministic software). Best solutions are mostly deterministic software + selective LLM calls + human-in-the-loop, not agents doing everything.
How we apply itFor each client workflow, classify every step as deterministic-software / agent / human-approval. Pitch the mostly-deterministic architecture (cheaper, lower-risk, higher accuracy) as a differentiator against 'slap an agent on it' competitors. Owns the data layer angle: you decide the plumbing.
Build agents for the unhappy path (exception handling)durablerelevance 5/5
What it is'There's one way something goes right and 1,000 ways it goes wrong.' An agent that only handles the happy path is worth nothing; one that handles the 1,500 failure modes is worth a million times more. Week-2 engineering focus: JSON schema validation (not freeform text), defined failure modes, retry logic.
How we apply itQuote and build explicit exception handling into every agent: enforce JSON schema outputs, validate, define failure modes, add retries. Sell this as the reason your builds survive production where others break. Charge more for the exception coverage.
Evals: turn non-determinism into evidencedurablerelevance 5/5
What it isBuild a golden data set from historical data (e.g. 10,000 past emails, 5,000 past presentations) to define what 'good' looks like. Run eval reports: '50 runs, 41 passed; of the 9 fails, 5 missing data, 4 wrong record' then fix systematically. For subjective tasks, encode explicit rules (logo top-left, larger font) and always bake in human-in-the-loop feedback to keep improving the harness.
How we apply itAsk every client for historical examples of the task to build a golden set. Deliver an eval report with pass/fail breakdown and failure categorization as a formal deliverable. Add a human-in-the-loop feedback mechanism so the system improves post-delivery, justifying a retainer.
Integrate on top of existing systems, never force migrationdurablerelevance 5/5
What it isClients spent years and millions on their ERP/CRM (NetSuite, Salesforce, SAP). Telling them to migrate = 'get lost.' Instead build on top of and connect their existing stack (NetSuite + Salesforce + Concur + Gong + Workday). Roll out via controlled environment -> shadow mode -> increasing autonomy -> production, not a big-bang switch.
How we apply itPosition every proposal as 'I'll build on top of your existing tools and make them better' with connectors, not rip-and-replace. Deploy in shadow mode first, then ramp autonomy. This de-risks the sale and matches Abdi's 'owns the data layer' positioning (integrate/pipe data between their systems).
Measure in 3 business buckets: revenue uplift, risk mitigation, cost savingsdurablerelevance 5/5
What it isOnly three measurement buckets matter to a business. Every agent must be measured against all three: how much time/cost saved, how much risk mitigated, how much revenue uplift. Present accuracy improvement over iterations (e.g. 70% -> 95%).
How we apply itFrame every proposal and delivery report around these three metrics with concrete numbers (hours saved/week, error rate reduction, revenue impact). This is the language that gets your client-contact promoted, which is what actually sells the deal.
30-day 'do the job before you have the title' plandurablerelevance 5/5
What it isWeek1: build one agent that completes a real enterprise back-office loop (finance/HR/procurement/logistics/sales) end-to-end with agent looping, tool use, guardrails, memory, and audit trail. Week2: harden it to recover from failures (JSON schemas, failure modes, exception handling). Week3: make it measurable and economical (retry logic, golden eval set, cheaper models, the 3 metric buckets). Week4: 'defend it like an FDE' - rehearse the pitch as both engineer (architecture/decisions) and VP (problem/outcome/evidence/risk), and pitch it to real businesses for feedback.
How we apply itUse this to build the next showroom piece: pick one real back-office workflow, build a fully instrumented agent, produce an eval report + ROI numbers, then package it as a buyable Project Catalog offering. The finished agent + metrics = portfolio proof that wins the first paid FDE-style engagement.
Audit trail / observability so clients trust the agentdurablerelevance 4/5
What it is'If you can't show the client what the agent is doing, they will never trust you.' Log every agent trace, tool call, and decision. This is a software-engineering problem and a trust differentiator against fear of runaway agents.
How we apply itBuild visible logging/trace dashboards into every agent deliverable so the client can see each step and decision. Pair this with the client-branded progress tracker standard already in Abdi's playbook. Present traces during handoff to build trust.
Sell to the human's incentive: help your contact get promoteddurablerelevance 4/5
What it isYou're pitching a person who fears getting fired and wants a promotion. Even involving you is a risk to them. De-risk by driving measurable value cost-effectively so they can point to the project at their performance review. Pitch 'make your existing system better' = 'fishing with dynamite' (obvious no-brainer), not a scary overhaul.
How we apply itIdentify who your client contact is and what win makes them look good internally; frame the deliverable so they own the success story. Under-promise, over-deliver, only get paid on proven value for the first few engagements.
Pick one model/agent platform, master it, be agnostic laterdurablerelevance 4/5
What it isModel-agnosticism is valuable at scale but NOT where a beginner's value lies. Get very good at ONE model + ONE agent-building platform (Claude Agent SDK or OpenAI's) first, then branch to others/open-source and benchmark. Your value is understanding both business and tech, which transfers to any model. Match the model to the task ('sommelier of agents') rather than defaulting to the most expensive frontier model.
How we apply itStandardize on Claude + Agent SDK (matches Abdi's existing stack) and get deep before diversifying. When delivering, benchmark cheaper models (Gemini Flash / Haiku tier) for steps that don't need frontier reasoning to cut client cost and improve margin.
Definition of a real agent (prompt-like-an-idiot test)durablerelevance 4/5
What it isA real agent isn't you prompting Claude perfectly. It runs in the background with repetitive motion and solves the task at high accuracy even if the user 'prompts like an idiot' - not reliant on perfect prompting. Components: looping, tool usage, guardrails, context/memory, audit trail.
How we apply itBuild client agents so a non-technical end user can trigger them sloppily and still get correct output. Design for imperfect input as an acceptance criterion, not perfect prompts. This is what makes the deliverable durable after you leave.
The loop compounds across a businessdurablerelevance 4/5
What it isAfter you improve one workflow, the next becomes clear - bottlenecks are interconnected (upstream/downstream). You're not 10x-ing one workflow, you're 100x-ing the whole business, so one successful deployment creates demand for everywhere else.
How we apply itAfter delivering one workflow, proactively map the adjacent upstream/downstream workflows you uncovered and pitch them as the next engagement. Turns a one-off Upwork job into an expanding retainer relationship.
Tools mentioned: Claude Code, OpenAI Codex, Cursor, GitHub Copilot, Claude Agent SDK, OpenAI agent-building platform, ChatGPT (workflow ideation), Salesforce, HubSpot, Apollo, Clay, Gong, Chili Piper, NetSuite, SAP, Concur, Expensify, Workday, Gemini Flash (cheap model tier), Llama / open-source models (Kimi, GLM)
⚠ Verify:
  • MIT stat that 95% of generative AI pilots fail
  • FDE compensation ranges from $150k base with equity up to $1M/year
  • Palantir popularized/coined the term 'forward deployed engineer'
  • Clients reportedly said the audit was 'worth 10x what they paid for it'
07Full Walkthrough: Workflow for AI Coding — Matt Pocock
Matt Pocock (AI Hero / Total TypeScript) — conference workshop  ·  16 techniques
One-lineMatt Pocock's AI-coding workflow: grill for alignment → PRD → vertical-slice Kanban → AFK Ralph/Sandcastle agent loops, kept sane by 100k smart-zone budgeting, deep modules, TDD feedback loops, and human QA.
Smart zone vs dumb zone (100k-token budget)durablerelevance 5/5
What it isLLM attention degrades quadratically as context grows; quality craters around ~100k tokens regardless of the 200k/1M window. Size every task to stay inside the smart zone; the 1M window is for retrieval, not coding.
How we apply itOn client RAG/agent builds, cap each coding task so context stays under ~100k. Watch the token status line; when a session bloats, stop and split the task rather than pushing through into sloppy output.
Grill-me skill (alignment before planning)durablerelevance 5/5
What it isA tiny skill that makes the agent interview you relentlessly one question at a time — with its recommended answer for each — until you share a 'design concept', surfacing decisions (e.g. backfill retroactively?) you'd never have specced. Replaces eager premature plans.
How we apply itBuild a reusable grill-me skill; run it at the start of every client feature. Feed in the client's Slack/brief, and feed meeting transcripts (via Gemini/notes) into a grilling session to validate assumptions. This is your requirements-extraction moat with non-technical clients.
Vertical slices / tracer bullets, not horizontal layersdurablerelevance 5/5
What it isAI defaults to coding horizontally (all schema, then all API, then all UI) so you get no integrated feedback until phase 3. Force thin end-to-end slices (schema + service + minimal UI) so each slice is testable/QA-able immediately. From Pragmatic Programmer.
How we apply itIn your PRD-to-issues skill, mandate vertical slices and reject horizontal ones ('first slice is too horizontal'). First deliverable a client sees should touch DB→API→UI so they can click something real early.
Human-in-the-loop vs AFK task classificationdurablerelevance 5/5
What it isSplit work into tasks needing a human present (alignment/planning/QA — the 'day shift') and away-from-keyboard tasks agents run unattended (implementation — the 'night shift'). Tag each issue with its type.
How we apply itFront-load the paid human hours into grilling+planning, then queue AFK implementation to run cheaply overnight. Sell the planning rigor as the value; let agents grind the code.
Review in a fresh context (clear before reviewing)durablerelevance 5/5
What it isIf an agent reviews its own code in the same session, it reviews from the dumb zone. Clear context (or use a separate reviewer agent) so review happens in the smart zone. Always add an automated review step before human QA — tokens are cheap and AI reviews well.
How we apply itNever let the implementer self-review inline. Run a separate reviewer pass on a clean context as a standard build step; it catches a lot of bugs before you QA.
TDD red-green-refactor as the AI's guardraildurablerelevance 5/5
What it isHave the agent write a failing test first, confirm red, then implement to green. Because tests are written before the code, the AI can't cheat by rubber-stamping its own implementation (which it does when it writes all code then all tests). Feedback-loop quality is the hard ceiling on AI output.
How we apply itShip a red-green-refactor skill; require failing-test-first on service logic. If AI output is bad, fix the feedback loops (tests/typecheck) before blaming the model.
Deep modules vs shallow modules (Osterhout)durablerelevance 5/5
What it isSmall interface, lots of hidden functionality = deep module you can wrap in one meaningful test boundary. Many tiny exported functions = shallow modules the AI can't navigate or test cleanly. Bad code bases make bad agents; testable code raises the AI ceiling.
How we apply itDesign client services as deep modules (one clean interface, e.g. a gamification/quiz service) so a single test boundary covers real behavior. Run an 'improve-code-base-architecture' scan to find shallow clusters to consolidate before agents work in the repo.
Clear, don't compact (Memento reset)durablerelevance 4/5
What it isCompacting leaves 'sediment' — a lossy summary that carries forward. Prefer /clear to reset context to a clean, identical base state so every fresh session starts sharp.
How we apply itStructure work so tasks are self-contained enough to /clear between them. Treat compaction as a smell that the task was too big; re-scope instead.
PRD as destination doc — don't read itdurablerelevance 4/5
What it isAfter grilling, a write-a-PRD skill summarizes the shared understanding into problem/solution/user-stories/implementation+testing decisions plus an explicit out-of-scope section. He doesn't review it — once aligned via grilling, you're only checking the LLM's summarization, which it does well.
How we apply itGenerate a PRD per feature as the 'definition of done' artifact; the out-of-scope section captures rejected options and rationale, protecting you in scope disputes. Trust the summary if the grilling was thorough.
Kanban issues with blocking DAG (not sequential multi-phase plan)durablerelevance 4/5
What it isTurn the PRD into independently-grabbable issues with explicit blocking relationships, forming a directed acyclic graph. Unlike a numbered phase plan (one agent only), a DAG lets multiple agents grab unblocked issues in parallel.
How we apply itStore issues as local markdown or GitHub issues, each tagged as human-in-loop or AFK, with blockers. This is the backlog your night-shift agents consume and enables parallelization later.
Ralph loop — AFK agent over a backlogdurablerelevance 4/5
What it isA bash loop that injects all issue files + last N commits into a fresh Claude run each iteration, tells it to pick the next AFK task by priority, implement with TDD, run feedback loops, commit, and emit 'no more tasks' when done. Run the 'once' version repeatedly first to tune the prompt.
How we apply itWrap your FastAPI/Postgres builds in a Ralph-style loop reading a markdown backlog; each iteration starts clean (smart zone) and commits a reviewable unit. Great for churning through well-specced CRUD/service issues.
Interface-own, implementation-delegate (gray boxes)durablerelevance 4/5
What it isKeep your mental model by designing module interfaces yourself, then delegating the internals to AI. You know each module's shape/behavior without code-reviewing every line inside — retains code-base sense while moving fast.
How we apply itFor each client project keep a module map you author; let agents fill implementations. You stay able to reason about and improve the system instead of losing it to AI-shaped sprawl.
Own your planning stack (inversion of control)durablerelevance 4/5
What it isNo clear winner among spec-kit/open-spec/task-master/beads; over-relying on an opaque framework leaves you unable to fix it when it breaks. Build small skills you control and understand end-to-end.
How we apply itKeep your grill/PRD/issues/Ralph skills as owned, editable markdown you can tune per client, rather than adopting a heavyweight framework you can't observe or debug.
QA imposes taste and refills the backlog; kill doc rotdurablerelevance 4/5
What it isManual QA is where you inject human taste (fully automated pipelines produce tasteless slop). QA generates new blocking Kanban issues even mid-implementation. Delete/close PRDs once done — stale docs ('doc rot') mislead future agents.
How we apply itAlways keep a manual QA pass as your differentiator vs vibe-coded competitors. Feed QA findings back as new issues. Close finished PRDs so a future agent editing the feature isn't poisoned by outdated specs.
Push vs pull for standards; model routingdecayingrelevance 3/5
What it isSkills = pull (agent fetches when relevant) — good for giving implementers optional standards. Reviewers should be push (standards forced into context alongside the diff). He runs Sonnet for implementation, Opus for review (review needs more smarts).
How we apply itPut coding standards in a pull-able skill for implementers; hard-inject them into the reviewer prompt. Route cheaper models to implementation, stronger models to review to control cost without losing quality.
Throwaway prototype routes for front-enddecayingrelevance 3/5
What it isAI is weak at multimodal front-end (Playwright MCP screenshots aren't good enough yet). Instead ask for 3 clickable prototype variants in a throwaway route, pick one by eye, and feed that choice back into the grilling session as an asset.
How we apply itFor any UI-facing client work, generate a few disposable design variants, let the client/you choose, then spec against the winner. Don't expect agents to nail production front-end unaided.
Tools mentioned: Claude Code, custom skills (grill-me, write-a-PRD, prd-to-issues, red-green-refactor, improve-code-base-architecture), Sandcastle (Matt's TS lib for sandboxed parallel agent loops via git worktrees + Docker), Docker sandbox, GitHub issues, TLDraw, Playwright MCP / Agent Browser, vitest / npx vitest, Ask User Question tool (Claude Code UI), spec-kit, open-spec, task-master, beads, Cucumber
⚠ Verify:
  • Attention scales quadratically with tokens and coding quality degrades around ~100k tokens regardless of 200k/1M window
  • Claude Code announced 1M context window the day Matt launched his Claude Code course
  • Matt's course-video-manager repo has ~744 closed issues and the app holds 284 tests
  • A grill-me explore subagent burned ~93.7k tokens on Opus without materially raising the parent context
14I Took All 7 Anthropic Courses in One Weekend (Honest Review)
Jasmine — AI & cybersecurity tech educator / security engineer (independent YouTube channel)  ·  9 techniques
SummaryA walkthrough-review of the 7 free Anthropic Academy "core practitioner" courses with a recommended take-order per persona (beginner, developer/builder, security practitioner). The actionable payload for a builder like Abdi: a free, structured curriculum covering the exact Claude-native primitives he sells (RAG, tool use, MCP, prompt caching, extended thinking, agents, Claude Code, agent skills), plus which sections to skip to save time.
One-lineHonest review of Anthropic Academy's 7 free courses with a builder take-order — free curriculum on RAG, tool use, MCP, prompt caching, extended thinking, Claude Code & agent skills.
Building with the Claude API — the core technical coursedurablerelevance 5/5
What it is~8hr course covering setup, model selection, temperature, streaming, prompt engineering, tool use, RAG, text embeddings, prompt caching, extended thinking, workflows, and agents. Reviewer calls it more in-depth and clearer than the same concepts scattered in other courses.
How we apply itThis maps 1:1 to Abdi's Claude+FastAPI+Postgres RAG/agent deliverables. Use it to lock down prompt caching (cut token costs on repeated-context client agents) and extended thinking (harder reasoning tasks) — two Claude-specific levers he can turn into a cost/quality selling point in proposals.
Developer/builder course path through Anthropic Academy (free)durablerelevance 4/5
What it isRecommended order for builders: Claude 101 (skim/skip if daily user) -> AI Fluency: Frameworks & Foundations -> Building with the Claude API (core technical course) -> Intro to MCP -> MCP Advanced Topics (after hands-on MCP) -> Claude Code in Action -> Intro to Agent Skills.
How we apply itTreat this as a free structured curriculum to formalize the Claude stack Abdi already sells. Block a weekend, run the builder path, and lift concrete patterns straight into Upwork deliverables. All free, so zero cost to close knowledge gaps in RAG/MCP/agents.
Prompt caching + extended thinking as Claude-specific differentiatorsdurablerelevance 4/5
What it isCourse flags two Claude-native features worth knowing: prompt caching (reuse large static context cheaply across calls) and extended thinking (more compute on hard reasoning).
How we apply itOn RAG/agent builds with big system prompts or fixed document context, enable prompt caching to lower per-request cost — a concrete margin/pricing edge. Reserve extended thinking for complex client tasks. Verify current caching pricing/params against Anthropic docs before quoting (decaying specifics).
MCP staged learning (Intro -> hands-on -> Advanced)durablerelevance 4/5
What it isIntro to MCP is a beginner-friendly, code-along explanation of servers, clients, resources, and the SDK; Advanced covers sampling, transport (streamable HTTP), message types, and filesystem access. Advice: do intro, actually build with MCP, THEN do advanced or it won't stick.
How we apply itMCP is Abdi's mechanism for wiring Claude agents to the data layer he owns (Postgres, tools, files). Build a small MCP server to expose a client's data/tools to Claude — reusable pattern across projects. Note MCP is provider-agnostic (works with any AI system), widening where he can sell it.
Claude Code in Action — coding-workflow leveragedurablerelevance 4/5
What it isCovers how coding assistants work under the hood, using Claude inside GitHub Actions, commands, and the Claude SDKs, plus efficiency tips; files provided to follow along.
How we apply itDirectly relevant to Abdi's own delivery speed. The 'Claude inside GitHub Actions' pattern is a sellable automation (e.g., automated PR review/CI agents) and can also speed his own Azure/FastAPI builds.
Agent Skills — writing, distributing, troubleshootingdurablerelevance 3/5
What it isShort course on what agent skills are, how to write/use/distribute them, with useful troubleshooting coverage. No exercises; watch-only.
How we apply itSkills are how Abdi can package reusable, distributable capabilities for client Claude agents (e.g., a domain-specific skill per vertical). The troubleshooting section is the practical payoff when a skill misfires in a delivered build.
AI Fluency 'Diligence' framework (verify AI output = shared responsibility)durablerelevance 3/5
What it isThe AI Fluency course's diligence pillar — critically vetting AI output rather than trusting it — is singled out as underrated and uniquely well-covered, and reframed as shared responsibility with the model.
How we apply itBake a verification/QA layer into every deliverable and name it in proposals as a professional safeguard — differentiates him from prompt-and-pray freelancers, especially for clients wary of hallucination in RAG answers.
Skip-list to compress the curriculumdurablerelevance 3/5
What it isConcrete time-savers: skip the prompt-engineering section in Building with the Claude API if you did AI Fluency (they overlap); skip watching code walkthroughs/exercises you can just read; skip Claude 101 if you use Claude daily (bookmark only its skills/connectors section).
How we apply itLets Abdi harvest the high-value builder content in far less than the full 12 hours — go straight to tool use, RAG, caching, MCP, agents, and skip the reading-heavy overlap.
Security-practitioner lens on tool use / prompt injection / RAGdurablerelevance 3/5
What it isReviewer notes Building with the Claude API is also valuable for understanding tool-use and prompt-injection risk and RAG security implications, and that MCP has attack surfaces worth understanding.
How we apply itSince Abdi owns the data layer, add prompt-injection hardening and MCP-surface awareness to RAG/agent deliverables as a trust selling point — clients pay more for agents that won't leak or be hijacked.
Tools mentioned: Anthropic Academy (free courses), Claude API, Model Context Protocol (MCP), MCP SDK, Claude Code, Claude SDKs, GitHub Actions, Agent Skills, Claude connectors, prompt caching, extended thinking, RAG / text embeddings, streamable HTTP transport
⚠ Verify:
  • All 7 Anthropic Academy core practitioner courses are currently free
  • Building with the Claude API course is ~8 hours
  • Total completion time ~12 hours across the 7 courses
  • There are 6 additional Anthropic Academy courses beyond the 7 reviewed
  • Current prompt caching pricing/params and extended thinking availability (verify against live Anthropic docs before quoting clients)
17Microsoft Agent Framework Explained: Foundation & Hands-On Lab (Part 1)
Unnamed Azure AI / cloud tutorial channel (inferred; instructor-led Azure AI Foundry walkthrough style)  ·  10 techniques
SummaryMicrosoft's new Agent Framework unifies Semantic Kernel's structure + AutoGen's multi-agent flexibility into one enterprise-ready Azure stack, built from six primitives: agents, threads (state), tools/function-calling, middleware, workflows (executors+edges), and MCP. Part 1 is conceptual plus a hands-on lab showing four ways to instantiate an agent (new via framework, reuse existing portal agent, model-direct/local to dodge Agent Service charges, plus file-search RAG, multi-tool routing, human-in-the-loop, and structured output).
One-lineMicrosoft Agent Framework Part 1: six agent primitives + lab, with reusable patterns — MCP as shared data-layer, middleware guardrails, thread state, structured output, and human-in-the-loop approvals.
MCP as the shared data-layer boundarydurablerelevance 5/5
What it isInstead of every agent hardcoding a SQL/API connector, expose the database/API once behind an MCP server; agents (and other teams) discover and query it dynamically at runtime through that single secured boundary.
How we apply itThis is Abdi's 'own the data layer' thesis made concrete. Sell one MCP server per client that fronts their Postgres/APIs, then let multiple agents/tools plug into it — a reusable, defensible deliverable he controls. Mirror the pattern on his Claude+FastAPI stack (Claude's MCP support) rather than Microsoft's.
Structured JSON output to feed downstream tools/formsdurablerelevance 5/5
What it isForce the agent to emit a fixed schema (e.g. name/age/occupation/city, or a calendar's exact date-time format) so free-form chat can be captured and piped into a strict downstream system like Outlook 365 booking or a Microsoft Form.
How we apply itHigh-value automation pattern: 'chat with a user, extract structured data, auto-fill the form / book the calendar / write the row.' Sell as intake automation. On Claude use tool-use/JSON-schema output for the same effect. Directly reusable in his automation offers.
Model-direct / ephemeral local agent to dodge Agent Service chargesdurablerelevance 4/5
What it isPoint the framework straight at the Azure OpenAI model endpoint + key instead of Azure AI Agent Service; the agent lives locally/in-process (nothing persisted in the managed service) so you only pay model tokens, not the Agent Service surcharge.
How we apply itCost-control lever for fixed-bid Upwork jobs: default to model-direct agents and only reach for the managed Agent Service when a client needs its persistence/knowledge-tool features. Bank as a line item in proposals ('runs on raw model tokens, no per-agent service fees').
Three-tier middleware interception (run / function-call / chat-client)durablerelevance 4/5
What it isPlug logging, auth, guardrails, validation, and tracing as middleware around three points — the whole agent run (logging/auth), each tool call (validation/security), and each model call (tracing/transformation) — without editing agent code; all agents inherit it.
How we apply itBuild a reusable middleware layer (guardrails + audit log + PII redaction) once and reuse across every client agent. Pitch it as the 'safety/observability harness' that separates a toy chatbot from an enterprise deliverable. Maps directly to FastAPI middleware/dependency patterns.
Thread-based state for durable multi-turn memorydurablerelevance 4/5
What it isEach conversation is a thread; reuse the same thread_id across runs and the agent retains prior messages automatically. Threads can be persisted to make conversations survive across sessions.
How we apply itStandard requirement for any chatbot deliverable — persist thread state to Postgres so conversations resume across sessions. Abdi's Postgres data-layer is exactly where these threads should live; make thread persistence a checkbox feature in his catalog.
Human-in-the-loop approval callback on destructive toolsdurablerelevance 4/5
What it isAutonomous agent runs freely, but a tool flagged as approval-required (e.g. delete_file) pauses and fires an approval callback; a human types yes/no before the action executes, while safe tools (create_file) run without gating.
How we apply itEnterprise trust feature — gate any destructive or costly action (DB writes, sends, deletions, refunds) behind an approval step. Pitch it explicitly in proposals as the reason clients can trust an autonomous agent. Cheap to add, big perceived-risk reduction.
Allowed-tools / approved-function allowlistdurablerelevance 3/5
What it isRestrict an agent so it can only attach a pre-approved set of functions, preventing it from invoking anything outside the vetted list — an enterprise security control.
How we apply itAdd a per-agent tool allowlist to every build and mention it in the security section of proposals. Low effort, signals maturity to enterprise-leaning clients.
Multi-tool routing (agent picks the tool)durablerelevance 3/5
What it isAttach several typed functions (weather, calculator, time) and let the model choose which to call — even multiple in one turn — based on the question and each tool's schema.
How we apply itBaseline agent capability; the durable lesson is that clean tool schemas drive correct routing. Invest in tight tool descriptions/schemas rather than prompt hacking. Standard on Claude tool-use.
Reuse an existing vector store by ID for file-search RAGdecayingrelevance 3/5
What it isAzure AI Agent Service auto-handles chunking/embedding/managed storage when you upload a file via the knowledge tool, creating a vector store; instead of rebuilding, attach the existing vector_store_id to new agents. Answers come back with source citations.
How we apply itThe transferable idea: decouple the vector store from the agent and reuse it across agents (parallels the MCP data-layer point). On Abdi's stack that's a shared pgvector/Azure AI Search index multiple agents read. The Azure-portal specifics are decaying; the reuse principle is not.
Framework-evolution narrative for positioningdecayingrelevance 2/5
What it isSDK (raw prompts) -> Semantic Kernel (skills/planners/memory, but flaky multi-step) -> AutoGen (multi-agent, but community-driven, weak enterprise security/observability) -> Agent Framework (unified, enterprise-ready).
How we apply itMarket-awareness only: lets Abdi speak credibly about Microsoft's stack when a client is Azure/MSFT-committed, and position his Claude-based approach against it. Useful for discovery calls, not for building.
Tools mentioned: Microsoft Agent Framework, Azure AI Foundry, Azure AI Agent Service, Azure OpenAI, Semantic Kernel, AutoGen, MCP (Model Context Protocol), Azure AI Search, GPT-4o, Azure Identity, python-dotenv, VS Code, Outlook 365 / Microsoft Forms (as integration targets)
⚠ Verify:
  • Azure AI Agent Service carries a per-agent service charge above raw model token cost, avoidable by pointing the framework directly at the Azure OpenAI model endpoint
  • Microsoft Agent Framework exposes exactly three middleware types: run, function-calling, and chat-client
  • Reusing the same thread_id across runs automatically retains prior conversation context in the framework
  • Agent Framework's file-search tool requires connecting to Azure AI Agent Service and a pre-existing vector store (cannot be done model-direct)
26How to Build Mobile Apps with Claude Code: Full Course (2026)
Nick Saraev (Left Click agency / Maker School)  ·  10 techniques
SummaryYou can ship real iOS/Android apps with Claude Code using an Expo + React Native + Supabase stack by building web-first, testing through a fixed 3-stage loop (Chrome -> phone mirror -> real device), and repeating one standardized pipeline: MVP-ideate -> build -> design -> test -> add DB/auth -> re-test -> security audit -> deploy. No prior mobile dev experience needed; the constraints are token budget, a disciplined test loop, and app-store paperwork, not coding skill.
One-line26 - Nick Saraev's Claude Code mobile course: Expo+React Native+Supabase stack, web-first 3-stage test loop, 5-step MVP framework, Claude-API edge functions, repeated security audits, screenshot-driven design, and EAS store submission - a full playbook for selling mobile-app builds on Upwork.
Expo + React Native single-codebase default stackdurablerelevance 5/5
What it isOne TypeScript/JavaScript codebase that compiles to iOS, Android, and web; Expo handles cloud builds (EAS), hot reload on device, and store submission. Claude scaffolds the whole workspace from the plain prompt 'build a mobile app with Expo and React Native, set up my workspace'.
How we apply itMake this the default when a client asks for a 'mobile app' or 'app for iOS and Android' - one build satisfies both platforms plus a web demo you can show mid-project. Ask Claude to scaffold, don't hand-download templates. Duplicate a prior app folder to start new client projects fast.
Web-first build + 3-stage test loop (Chrome -> mirror -> real phone)durablerelevance 5/5
What it isDevelop and eyeball everything first at localhost:8081 in Chrome (zoom/resize to mobile), then Expo Go via QR + device mirroring, then the actual physical phone. Physical-phone pass is mandatory and non-skippable because haptics, push notifications, native status bar, thumb-reach UX, long-press/scroll behavior, and icon-cutoff bugs only surface there.
How we apply itBake this exact loop into every mobile deliverable and quote 10-15 min buffer per bug. Catch/fix on Chrome first (cheap), only propagate to device once clean. Tell the client the physical-device pass is part of QA - it's your differentiator over vibe-coders who ship untested.
5-step app design framework as scoping specdurablerelevance 5/5
What it isEvery app is defined by: (1) core function - the one thing that IS the app, (2) core loop - action->reward cycle under ~30s with visual/haptic/sound feedback, (3) accessory features that support the loop, (4) surface-area check - cap at 5-7 screens, (5) retention hook - an unfinished state (streak/challenge/check-in) that pulls users back. Dictate the whole thing to Claude as one prompt, then have it implement all phases at once ('do all of it, phases 1-4').
How we apply itUse as your discovery/scoping template with clients - forces a tight MVP and prevents scope bloat. The filled-out framework IS the build spec you paste into Claude. Store it in CLAUDE.md so it drives every project consistently.
Supabase backend: Postgres + auth + RLS + local-first cachingdurablerelevance 5/5
What it isSwap local device storage for Supabase: Postgres tables (Claude auto-designs schema + user_id foreign keys), built-in email/password + Google/Apple/GitHub OAuth, and Row Level Security (enable automatic RLS at project creation - lowest-hanging security win). Keep AsyncStorage as an instant read/write cache layer and sync to DB periodically so the app feels snappy. You paste project URL, publishable key, direct connection string, and CLI login into Claude so it runs the schema itself.
How we apply itDirect fit with Abdi's 'owns the data layer' positioning - this is the exact multi-user persistence + auth pattern clients need. Note Postgres here vs his usual Azure Postgres; Supabase bundles auth+RLS+edge functions, a faster path for small mobile jobs. Always enable RLS and disable email-confirmation for smoother onboarding demos.
AI features via Supabase Edge Functions calling Claude APIdurablerelevance 5/5
What it isServerless edge functions fire on a schedule (daily/weekly), read DB data (streaks/completions), send it to Claude API (Sonnet) with a prompt, write the result back to a table, and push a notification. Architecture: phone -> app -> edge function -> DB read -> Claude API -> DB write -> push. Cheaper than an always-on server. Anthropic API key lives in .env (never pasted in chat - it leaks into conversation history + multiple files). Prompt-tune outputs by generating 10 sample messages before hardcoding (e.g. ban em-dashes, add emojis to titles only).
How we apply itThis is Abdi's core competency (RAG/agents/Claude) wrapped in a mobile shell - smart-coaching nudges, weekly AI reflections, photo analysis. Sell 'AI-native app' upsells. The edge-function-as-serverless-backend pattern replaces his usual FastAPI for lightweight scheduled AI calls; use sample-output iteration to control tone before shipping.
CLAUDE.md via /init + /clear token hygienedurablerelevance 4/5
What it isAfter scaffolding a working demo, run /init to write CLAUDE.md capturing architecture/theme/state/paths so Claude doesn't re-read every file each session (saves tokens, keeps context accurate). Run /clear between phases to reset the token meter; /compact around 250-300k tokens because model quality on fine-grained edits degrades past ~200k. Update CLAUDE.md whenever the app materially grows.
How we apply itStandard practice already for Abdi's backend work - apply identically to mobile repos. Keep a reusable CLAUDE.md 'system prompt' encoding the 5-step framework + preferred stack so new client apps kick off by Claude asking you questions, not you re-explaining.
Repeated security-audit prompt with fresh contextdurablerelevance 4/5
What it isAfter the app is store-ready, /clear to a zero-token fresh Claude and paste a comprehensive security-audit prompt that tiers findings (critical/high/medium/low) by CWE and checks vibe-code hotspots: hardcoded secrets, missing server-side validation, default-open DB policies, hallucinated packages, inconsistent auth middleware, .gitignore coverage, expensive/DoS-able operations. Run it 2-3 times fresh - fixing one issue can create another, and a new context spots what the prior fix introduced. Then 'fix all, move yellows/reds to green.'
How we apply itReusable audit prompt = a concrete pre-delivery QA gate you can name in proposals as a selling point (most competitors skip it). Especially critical once a live DB/auth makes the app internet-exposed and when handling health/financial/PII data. Frame as 80/20 low-hanging-fruit hardening, not a security guarantee.
Design via reference screenshots + AI-generated mockups + screenshot-loopdurablerelevance 4/5
What it isBuild functionality first with a throwaway design, then restyle by feeding Claude screenshots of reference apps (from Dribbble or a target app) or mockups generated by GPT Image, instructing 'emulate this, then diverge so it's not a clone.' Extract image assets (trees/backgrounds) from generated mockups, drop into an /images folder, and have Claude wire them in. Use Chrome DevTools MCP so Claude autonomously screenshots each page, enumerates spacing/alignment/truncation issues, and self-loops until near-pixel-perfect. Design changes are cheap because they're just styles/fonts/colors over fixed functionality - do them while DB is still local (changing schema later is costly).
How we apply itLets Abdi deliver polished, on-brand UIs without being a designer - client sends an app they like or a Dribbble ref, you match it. Chrome DevTools MCP gives autonomous visual QA. Sequence: lock functionality -> restyle -> only then add DB, so redesigns don't force schema migrations.
EAS build + eas submit store-submission pipelinedecayingrelevance 4/5
What it isPrep: Claude generates app.json (name, identifier, version, icon, splash, Android adaptive icon) and eas.json. Build: 'eas build' via Expo's cloud (free tier queues slower). Submit: 'eas submit --platform ios' selects the built .ipa and hooks App Store Connect via API key. Requires an Apple Developer account + App Store Connect (and Google Play Console for Android - use a business/Workspace email, must verify on a real Android device). Claude auto-generates store screenshots (per iPhone/iPad size), icons, description, keywords. You must supply a web-hosted privacy policy + support URL (Claude writes both from Apple's guidelines and hosts on your site) and a reviewer test-login credential. TestFlight is the pre-release beta channel.
How we apply itThis is the deliverable most freelancers can't finish - actually getting the client's app live. Offer end-to-end 'built + submitted to stores' as a premium package. The privacy-policy/support-page requirement pairs with Abdi's existing habit of hosting client pages. No submission is guaranteed to pass; set that expectation and use review feedback to iterate.
Autonomous Claude Code workflow acceleratorsdecayingrelevance 3/5
What it isdangerously-skip-permissions toggle so Claude runs without approval prompts; voice-transcription (Aqua) to dictate long prompts fast; message queueing (fire unrelated design changes while a build runs); asking Claude to 'run this in a NEW terminal window' for Expo QR (in-thread terminals miss the QR flow); Ctrl+O to inspect loaded context/docs; sub-agent teams + plan mode (Claude asks clarifying questions and recommends defaults before spending tokens); paste error messages verbatim to self-heal (e.g. AsyncStorage v3 incompatible with Expo Go, ngrok tunnel needing email verification).
How we apply itThroughput multipliers that cut delivery time. Queue independent changes, dictate specs, let plan-mode + sub-agents scope before burning tokens. Trust the paste-error-and-fix loop for the inevitable native/tunnel/dependency bugs. Note: dangerously-skip-permissions is convenience-vs-safety - fine on isolated app repos, riskier on sensitive systems.
Tools mentioned: Claude Code, Expo / EAS (Expo Application Services), React Native, Expo Go, Supabase (Postgres, Auth, RLS, Edge Functions), AsyncStorage, Anthropic Claude API (Sonnet), Chrome DevTools MCP, Google Antigravity (VS Code-style IDE w/ Claude Code extension), GitHub, iPhone mirroring, Aqua (voice transcription), GPT Image (gpt-image-2), Dribbble, ui colors (uicolors.app) palette generator, Apple Developer / App Store Connect, Google Play Console, TestFlight, Reanimated (animation lib), ngrok (Expo tunnel)
⚠ Verify:
  • 'Automatic RLS' toggle at Supabase project creation exists as described and is the current recommended default
  • Expo Go incompatibility with a specific AsyncStorage version (v3) requiring downgrade - version-specific, may be stale
  • Claude Code 'sub-agent teams' and in-IDE plan-mode behave as shown inside the Antigravity/VS Code extension
  • eas submit still auto-hooks App Store Connect via API key with the exact flow shown (Apple/Google submission UIs change frequently)
  • Whether an Anthropic API key must be hardcoded per-app vs a proxy/backend pattern - shipping the dev's own key in-app is a cost/security risk the video glosses over
  • Cal.ai '$50-100M sale to MyFitnessPal' figure
  • Claim that model quality noticeably degrades past ~200k tokens for fine-grained edits
  • Google Play requiring a physical Android device for verification

Monetization — how AI freelancers actually make money

04Claude Code built me a $273/Day online directory
Greg Isenberg (podcast host, "The Startup Ideas Podcast" / Late Checkout) interviewing guest "Frey" (Mr. Directory)  ·  14 techniques
SummaryBuild niche online directories with Claude Code + the open-source Crawl4AI crawler, where the real moat and the hardest part is acquiring, cleaning, and enriching valuable data (especially price transparency) at scale; monetize via lead-gen, ads, affiliate, or a bolt-on micro/vertical-SaaS, and win SEO via topical relevance on local, decision-phase queries.
One-lineClaude Code + Crawl4AI pipeline to scrape, clean, and enrich data for niche lead-gen directories — data (esp. price transparency) is the moat.
Two-stage LLM data cleaning: dumb junk-removal, then website-verification enrichmentdurablerelevance 5/5
What it isStage 1: hand Claude Code the raw scraped CSVs with explicit junk criteria (no business name/address/city/state, permanently closed, off-niche big-box retailers) to cut 71k rows to 20k. Stage 2: use Crawl4AI to actually visit each surviving business website and have Claude classify/verify against niche keywords + synonyms, cutting 20k to 725 true matches with a verification-confidence score column.
How we apply itThis is Abdi's exact wheelhouse (owns the data layer). Offer 'data cleaning + enrichment as a service': ingest a client's messy CSV/scrape, run a two-pass FastAPI+Claude pipeline (junk filter, then per-URL crawl-and-classify with a confidence score), return a clean enriched dataset or load it into Postgres. Sell the confidence-score column as a QA deliverable.
Crawl4AI as the crawling engine + Claude as the reasoning braindurablerelevance 5/5
What it isFree, open-source, locally-installed LLM-friendly crawler does the fetching at scale; Claude Code writes the prompts/logic and reasons over the page content. Use the async web crawler module to crawl many sites concurrently for large speedups. Frey installed it in ~15 min by pasting the repo link to Claude Code and letting it drive setup.
How we apply itAdd Crawl4AI to Abdi's default delivery stack for any 'scrape/enrich/monitor competitor or supplier data' job — pairs cleanly with FastAPI+Postgres+Claude. Use async concurrent crawling to keep 20k-URL jobs to hours not days. Frame it as a zero-license-cost engine so margins stay high on fixed-price Upwork jobs.
Enrich one field at a time, not one giant laundry-list promptdurablerelevance 5/5
What it isGiving Claude/Crawl4AI a huge CSV + a long list of everything to extract (inventory, images, amenities, pricing, service areas) produced low-quality garbage. Doing separate passes per field (inventory pass, image pass, amenities pass, service-area pass) was far higher quality, and each pass lets you inspect results and catch edge cases before the next.
How we apply itDesign extraction pipelines as sequential single-responsibility passes with a human/QA checkpoint after each, rather than one mega-prompt. Sell reliability: 'each attribute is extracted and validated independently.' Directly informs how Abdi structures RAG-ingestion and agent extraction jobs.
Inspect-edge-cases-and-rerun loop after every passdurablerelevance 4/5
What it isAfter each enrichment pass, examine outputs for one-off failures (e.g., non-features like 'and'/'the' captured as amenities, or service-area picking up wrong states for out-of-state businesses), tell Claude explicitly what it got wrong, and rerun 2-3x until clean. Treats the LLM extraction as iterative, not one-shot.
How we apply itBake an explicit 'validate + correct + rerun' loop into any extraction deliverable and quote it as part of scope. Matches Abdi's iteration-process memory rule (run the workflow 5-6x). Good talking point for why his output beats a one-shot vibe-coder.
Ask Claude Code for its game plan before burning tokensdurablerelevance 4/5
What it isBefore running an expensive pass, prompt: 'give me your game plan, tell me if I'm missing anything, and let me know before we go for it.' Surfaces flaws and prevents wasted expensive runs on large datasets.
How we apply itStandard practice for any costly agent/batch run — a plan-first checkpoint. Cheap insurance against expensive mistakes on client data, and demonstrates a controlled, senior workflow.
Price-transparency as a data moat / differentiatordurablerelevance 4/5
What it isMany boring industries have no accessible pricing. Manually/semi-manually surfacing price comparison is unscalable and hard, which is exactly why it's defensible and drives traffic. All three showcased directories succeeded partly by bringing price transparency where none existed.
How we apply itPitch clients on building proprietary datasets (pricing, availability, spec comparisons) in opaque verticals as a durable competitive asset, not just a website. Reframe Abdi from 'chatbot builder' to 'builder of defensible data assets' — higher-value positioning.
Niche-down for both SEO and the AI-search eradurablerelevance 4/5
What it isDon't fight broad competitive terms ('senior living homes'); target specific deal-breaker sub-niches ('senior living for dementia', 'ADA-accessible bathroom contractor', 'tap water quality') that still get hundreds-thousands of searches but are winnable. In AI search, LLMs return 1-3 sources and must cite/link the underlying data, so hyper-niche specialized directories are favored over horizontal ones.
How we apply itWhen advising clients (or picking Abdi's own showroom niches), pick specific decision-driving sub-niches. Position deliverables as 'AI-search-ready': structured, citable, niche data that LLMs will reference and link. Directly relevant to the showroom-engine and marketing-channel GEO strategy in memory.
Directory + agency/vertical-SaaS monetization combodurablerelevance 4/5
What it isBiggest directories don't rely on ads; they layer a vertical/micro-SaaS or agency back end on top of the traffic (e.g., Parting.com's 'Parting Pro' cremation software + website/marketing agency). Lead-gen (selling qualified inbound to businesses) is the classic base; the software/agency layer is where the real revenue and enterprise value sit.
How we apply itSell clients the sequence: build the traffic-generating asset first, then bolt on a micro-SaaS/tool that Abdi builds on his Claude+FastAPI+Stripe stack. Aligns with his 'showroom piece -> buyable funnel -> vertical tool' model. Distribution-first, then monetize the audience many ways.
Distribution-first business model (SEO / ads / organic social)durablerelevance 4/5
What it isThe top three distribution channels are ads, organic social, and SEO — pick one deliberately and build around it first. Directories are inherently distribution-first: publishing ~1,000 topically-related pages gives topical relevance so you rank easily on long-tail local terms ('luxury restroom trailer Bakersfield') then climb to bigger metros.
How we apply itLead client conversations with 'how will this get seen?' before features. Use programmatic topical-cluster pages as a repeatable SEO deliverable. Reinforces Abdi's marketing-channels memory: choose a channel, build for it first.
Vision model as a second-stage image quality filterdurablerelevance 3/5
What it isScraping raw images returns logos, favicons, junk. Fix: scrape top-3 candidate images per listing (via alt text, filenames, page context, highest resolution), then pass them to Claude Vision to pick the genuinely best/on-topic image. ~$30 in API credits for 700 listings, ran overnight.
How we apply itOffer a 'visual QA' enrichment tier: use Claude Vision to validate/rank scraped or user-uploaded images (dedupe logos, pick hero shots, flag off-topic). Cheap, high-perceived-value add-on for catalog/directory/e-commerce data jobs.
Crappy MVP still captures real high-ticket leads (validate before polishing)durablerelevance 3/5
What it isA genuinely bad WordPress directory with Lorem Ipsum on the homepage and duplicate images still inbounded real leads, including a $20k+ New Mexico State Fair order. Proves latent demand before investing in a polished build.
How we apply itShip a rough lead-capture MVP to validate niche demand before over-building; use captured leads as proof to justify the paid full build. Good de-risking narrative for clients hesitant to spend up front.
Aligned-incentive engagement mechanics (public leaderboard + giveaways)durablerelevance 3/5
What it isGasBuddy sustained 5,800+-day contributor streaks via a public leaderboard plus small giveaways ($100 gas debit cards, formerly e-bikes) — 150 pts per report, 1,000 pts = one giveaway entry. Simple psychology, and monetization (saving on gas) aligns with why users come.
How we apply itFor any client product needing UGC/crowdsourced data or retention, add a leaderboard + points + low-cost giveaway loop. Cheap gamification Abdi can build; align the reward with the core user motivation.
Strip columns, then let Claude scaffold the DB from the exact schemadurablerelevance 3/5
What it isAfter enrichment, create a cleaned CSV keeping only the valuable columns, then tell Claude Code to build the Supabase database using those exact columns as the schema. Data-first, then design the front end freely on top.
How we apply itStandard clean pattern: finalize the data contract/schema from the enriched dataset, have Claude generate the Postgres/Supabase schema + loader, then build UI. Matches Abdi's data-layer-first identity and Postgres stack.
Outscraper for cheap Google Maps lead scrapingdecayingrelevance 3/5
What it isOutscraper is the cheapest reliable way to pull business listings from Google Maps (got 71k porta-potty rows nationwide); cheaper than Apify for this. Abundant tutorials exist. Total project cost under $250: $100 Claude Code Max, $100 data, $50 Claude API for deep cleaning.
How we apply itUse Outscraper as the cheap top-of-funnel source when a job needs local-business datasets; keep the whole enrich pipeline under a few hundred dollars to protect fixed-price margins. Note the specific cost breakdown as a client-facing budgeting reference.
Tools mentioned: Claude Code (Cloud Code), Crawl4AI (open-source LLM-friendly web crawler), Outscraper (Google Maps scraping), Apify, Claude Vision API, ChatGPT (prompt drafting), Supabase (Sibu database), WordPress, Ahrefs, Data.gov / public databases, Nano Banana (image gen), Wayback Machine
⚠ Verify:
  • Crawl4AI is free and open-source with an async web crawler module for concurrent crawling
  • Cleaning ~700 listings' images via Claude Vision cost ~$30 and ran in about an hour
  • GasBuddy gets ~1.1M organic monthly visitors; A Place for Mom ~824k; Parting.com ~61k
  • Total directory build cost under $250 ($100 Claude Code Max + $100 data + $50 Claude API)
  • 'senior living homes for people with dementia' gets 1,000+ monthly searches per Ahrefs
  • A community member's tap-water-quality directory hit 40,000+ monthly visitors with no backlinks and got into Mediavine
10He Sold 100 AI Receptionists to Local Businesses in ONE Month (£399/mo clients)
"What's Working" interview segment (GoHighLevel-focused podcast); guest Danny Harris (Catons, UK AI voice-agent agency)  ·  14 techniques
SummarySell voice AI receptionists to local businesses by reframing the offer as "recovering money you already lose from missed calls." Anchor value with the client's own missed-call math (calls/day x average order value = £X/month lost), then close for a fixed monthly fee well below that number so it can't be refused. Delivery is templated and near-zero-effort; distribution is warm/everyday conversations plus one simple Facebook ad.
One-lineSell AI phone receptionists to local SMBs by anchoring on their own missed-call revenue loss, closing with a flat £399/mo no-contract offer, and delivering via cloned per-vertical templates + a website-trained live demo.
Missed-call-revenue anchor (the whole pitch)durablerelevance 5/5
What it isGet the owner to state their own numbers: how many calls/day do you miss? x average order value = £X lost per month. Their number is almost always far bigger than your fee, so all objections evaporate. Danny walks a florist to '£16.5k/mo lost, fix it for £400 — keen?' Let THEM compute the loss; they talk themselves into it (florist volunteers wedding=£2k, funeral=£500 flowers).
How we apply itFor any lead-capture/receptionist/chatbot bid, open the proposal with the client's own loss math, not features. Build a tiny 'missed-revenue calculator' (calls x AOV x close-rate) as a lead magnet / discovery-call script. Frame every RAG/agent build as recovered revenue, not 'automation.'
Template-once, clone-forever deliverydurablerelevance 5/5
What it isBuild one agent per vertical (restaurant, flower shop, garden room), then clone and edit. Feed the client's website into a knowledge base, paste an existing template into ChatGPT ('turn this restaurant agent into a flower shop'), tweak custom values. New agent in under an hour; a complex one still <1hr.
How we apply itMaintain a library of vertical agent templates (RAG KB + prompt + tool config). Each new client = swap website content + custom fields. Sell the same core build repeatedly; margins scale because setup is near-zero after template #1.
Live phone demo built from THEIR websitedurablerelevance 5/5
What it isBefore the close, ingest the prospect's website into a knowledge base and build a working demo agent trained on their prices/services. On the sales call, literally phone the agent live ('it's my girlfriend's birthday, I know nothing about flowers') and let them hear it handle their business. Then: 'this is after 1 hour of training — imagine it fully trained.'
How we apply itShip a personalized working demo (scraped from client site) as your proposal attachment or first call. A live artifact trained on their own data converts far better than a generic portfolio. Your Claude+FastAPI+Postgres stack does exactly this.
Two setup archetypes: high-volume vs big-ticketdurablerelevance 5/5
What it is(1) High-volume/low-price (restaurants, play parks, zoo, climbing wall): agent handles FAQs + full orders/bookings, value = never miss a call. (2) Big-ticket/low-volume (garden rooms, HVAC, construction, car dealers): agent does qualification questions (type, timeline, budget) to filter tire-kickers and book only qualified appts — 'Mr Smith wants a home office, £50k budget, Monday 2pm.' Here saving ONE £100k call/year pays for itself many times over.
How we apply itMatch agent design to client economics: transactional FAQ/order bot vs qualifying-and-routing intake agent. Sell the second type to high-ticket service businesses on lead-quality/appointment-setting, not call volume.
Fixed simple pricing: £399/mo + £450 setup, no contractdurablerelevance 4/5
What it isOne standard price (£399/mo ~ $500) plus a setup fee (£450) that is 'extra sauce' on a 10-minute templated job. Month-to-month, cancel anytime. 'Start low as a beginner' is a myth — same offer whether beginner or expert.
How we apply itProductize a flat monthly 'AI receptionist / intake agent' retainer + one-time setup instead of hourly. The setup fee is pure margin because the work is templated. Offer no-contract month-to-month to kill risk objections.
'I don't think this would work for a business like yours' (anti-sell opener)durablerelevance 4/5
What it isNever lead with 'Hi I'm X from Y company' — shutters go up ('everyone wants to buy, nobody wants to be sold to'). Instead: 'Can I ask you a question? I don't think my new idea would work for a company like yours — can you tell me if I'm right?' The reflexive contrarian response makes them argue FOR it. Close with 'Do you know anyone else I could pitch this to?' → they say 'don't pitch anyone else, WE'll buy it.'
How we apply itUse disqualification/curiosity framing in cold outreach and discovery calls. Position as market research, not a pitch. On Upwork proposals, lead with a doubt/question about fit rather than a credentials dump.
Sell to businesses you already patronize (warm local)durablerelevance 4/5
What it isList every local business you personally use (vet, florist, hairdresser, dentist, carpet cleaner, restaurant, gym). Go in as a customer — they literally cannot be rude/dismissive to a paying customer, removing cold-call fear. Danny closed a florist mid-delivery-call, a soft-play, a vet — all as a customer. Bring a dog/kid, wear shorts not a suit, so you don't read as a salesperson.
How we apply itFor local/SMB clients, mine your own vendor list first for warm intros and case-study clients. Farm those first wins into testimonials/reviews (mirrors your Upwork review-farming strategy).
Integrate via in-house software API, bypass aggregatorsdurablerelevance 4/5
What it isFor order/booking flow, connect the agent's custom action to the business's OWN in-house software API (kitchen order system, booking system), NOT Uber Eats/Deliveroo/Booking.com which skim commission. Agent even checks current order queue and estimates wait time (quiet/medium/busy → 15min/30min/1hr). Setup = give the endpoint + a couple params, ~2 minutes.
How we apply itWhen wiring agents to client systems, prioritize direct API integrations that avoid commission-taking middlemen — a concrete money-saving selling point. Add a 'dynamic status' tool (query live load, return ETA) as a differentiator.
Objection handling: 'we're personal/family-run'durablerelevance 4/5
What it is#1 objection = 'we pride ourselves on personal service.' Jokey comeback: 'Is it more personal to NOT answer the phone at all?' Then STOP convincing — 'no worries, I won't try to convince you.' The less you push, the more they run the loss numbers in their own head. The vet came back a week later and bought. Backstop offer: 'try it a month, no contract, cancel if you don't like it.'
How we apply itPre-empt the 'AI feels impersonal' objection with the reframe + a no-risk trial month. Then go quiet — let the ROI math do the persuading rather than over-selling.
Self-serve onboarding via form → custom valuesdurablerelevance 4/5
What it isEndgame: client fills a form (restaurant name, phone, hours, etc.) → form fields auto-populate the agent's 'custom values' → agent live with zero manual setup. Deliver via a snapshot + short how-to videos. Removes Danny (non-technical) from delivery entirely.
How we apply itBuild a form-driven provisioning layer so onboarding is client-self-serve: intake form maps to agent config/env values. This is squarely your data-layer/FastAPI wheelhouse and a real productization moat.
Pay-in-advance to self-fund ad spenddurablerelevance 3/5
What it isOffer £4,800/yr agent for £2,500 if paid a full year upfront — but only to 10 people. That's £25k of ring-fenced ad money that 'isn't even yours.' Throw in free setup + a second bonus agent to close. Rule: never spend incoming revenue until you've banked a cushion ('don't sell for £400 and spend £398 down the pub').
How we apply itUse annual-prepay discounts to bankroll paid acquisition or bridge cashflow when starting. Bank early revenue instead of spending it, to build a reinvestment war chest.
One Facebook ad, copy-only, no targetingdecayingrelevance 3/5
What it isWhole funnel = 1 campaign, 3 ad sets, 1 ad each. Copy: 'Restaurant owners — are you missing phone calls?' Image (made in ChatGPT): a stressed restaurant manager pulling his hair out, phone ringing, 50 plates. No audience targeting — 'it's all copy now, the algorithm targets.' Costs ~£75 to acquire a paying client; ~100 clients/month. Prompt ChatGPT: 'write a high-converting FB ad — think like Dan Kennedy / Frank Kern / Alex Hormozi / John Loomer.'
How we apply itFor your own showroom lead-gen and as a client deliverable: audience-callout headline + pain image, minimal ad structure, ChatGPT-drafted copy in the voice of named direct-response legends. Lead with the callout ('[niche] owners, are you...'), let copy do targeting.
15-min sales call via VSL + prebuilt demodurablerelevance 3/5
What it isAds → prospect watches a VSL first (already knows what it is) → 15-min call where you show the demo built from their website → done. Website is a single one-page landing: 'here's a demo, book a call.' Don't overcomplicate.
How we apply itFront-load education with a VSL so calls are short and pre-sold. Keep the landing page to one page: demo + calendar. Reduce sales-call time by having the personalized demo ready before the call.
Closing lines: 'This is the worst it will ever be' + memorable brand namedurablerelevance 3/5
What it isEnd-of-pitch line: 'Here's the thing — this is the worst it's ever going to be, it only gets better' (underlying models improve constantly). Prospects love it. Also: use a sticky, easy-to-recall business/domain name (kids' names 'Catons'; the 'itchybum.com' bathroom-poster story) so people can Google you later without a card.
How we apply itAdd the 'worst it'll ever be' line to proposals/close to neutralize 'is the tech good enough' doubt. Pick memorable brand/domain names for showroom pieces so word-of-mouth prospects can find you.
Tools mentioned: GoHighLevel (HighLevel) AI voice agents, ChatGPT (agent config, ad copy, ad images), Missed-call text-back, Facebook Ads, In-house booking/order software APIs (custom actions), VSL (video sales letter), One-page landing + calendar booking
⚠ Verify:
  • £399/mo + £450 setup pricing and ~£75 CAC / ~100 paid clients per month are Danny's self-reported figures, not independently verified
  • Claim that HighLevel voice agents are 'powered by ChatGPT' is the guest's guess ('I'm fairly sure'), not confirmed
  • 'No targeting needed, it's all copy' reflects a specific point in Meta's ad algorithm and may not generalize
  • Zero churn except a restaurant that caught fire is anecdotal
13How to Make 500k/mo With AI Websites
Agency-growth YouTube channel in the GoHighLevel / local-SMB SaaS niche (host runs the "SWS" School community, based in Medellín). Guest: "Michael," ex-software-engineer co-founder of a contractor-website agency (partnered with Kai Stone), claiming $500k/mo.  ·  10 techniques
SummarySell local SMBs a cheap recurring website+automation package, expand each account via upsells, and use AI to automate delivery — the durable playbook is productized recurring offers plus land-and-expand pricing.
One-line$297/mo contractor website+automation agency ($500k/mo) — productized offer, land-and-expand upsells, quarterly prepay, and an AI NL-editing agent replacing VAs.
Productized local-SMB automation stack ($297/mo)durablerelevance 5/5
What it isOne fixed monthly package for local service businesses: a website plus missed-call-text-back, lead-form follow-up via SMS, and a Google-review funnel + review campaign. Low-ticket, recurring, same build every time.
How we apply itPackage this exact stack as a fixed-scope Upwork/Project-Catalog listing for contractors/med-spas/etc. He already owns the data layer and Claude+FastAPI+Postgres, so he can build missed-call-text-back, form-to-SMS notifier, and review automations as reusable modules and resell per client at recurring MRR instead of one-off hourly.
Natural-language website-editing agent (AI replacing VAs)durablerelevance 5/5
What it isAt 1,300+ clients GHL hit limits, so they move to custom-coded sites where a non-technical account manager types requests into a ChatGPT-style interface that edits the live site; VAs doing manual edits get eliminated.
How we apply itThis is a directly buildable AI product for him: a Claude-driven agent that takes NL instructions and edits a client's site/content (tool-calling over a component/CMS schema, with preview). Sell it as 'AI website manager' or offer to build it for existing agencies drowning in manual GHL edits, exactly the pain described here.
Land-low, then upsell existing clientsdurablerelevance 5/5
What it isEnter at a trust-cheap price ($297 vs the typical $2k ads retainer) to beat the 'I've been scammed before' objection, then upsell one-time GMB fix ($500) and recurring SEO/LSA ($500/mo each) to clients whose card is already on file. Called 'free money.'
How we apply itStructure his Upwork ladder the same way: small first deliverable to farm the review + trust, then expand the same account with add-on automations (RAG chatbot, DB reactivation, reporting agent). Existing-client upsell needs only 'permission,' not a new sale, so it compounds MRR at near-zero CAC.
Quarterly prepay anchoringdurablerelevance 4/5
What it isPrice is framed as '$800/mo, unless you commit to a minimum of a quarter paid in full, then it's $500/mo,' pushing clients to pay 3 months upfront for the discount.
How we apply itOffer his retainers as month-to-month at a high anchor with a meaningful discount for quarterly pay-in-full. Improves cash flow and reduces churn/chargeback risk on Upwork-adjacent recurring work.
Client-quality lead filtersdurablerelevance 4/5
What it isOnly pursue prospects with a verified Google Business Profile and a minimum of ~5 reviews; skip zero-review / unverified ones because they become fulfillment nightmares.
How we apply itApply the mirror image when screening Upwork clients: filter for payment-verified, funded, reviewed clients (which his workflow rules already emphasize). Bad-fit low-signal clients cost more in delivery pain than they pay.
Concrete SMB deliverable list to selldurablerelevance 4/5
What it isNamed, buildable services: missed-call-text-back, lead-form-to-SMS notifications, review-gating funnel (intercepts unhappy customers before they post), automated review-request campaign, GMB optimization, Google Local Service Ads, SEO, and database reactivation of past leads (admitted as an untapped upsell).
How we apply itTreat this as a ready-made catalog of automation offers. Each is a discrete Upwork gig he can implement on his stack; database reactivation (mass re-engage a client's dormant lead list) is explicitly called out as low-effort high-value that even they hadn't built.
One-owner service-delivery modeldurablerelevance 3/5
What it isAssign ONE account manager full A-to-Z accountability for each client instead of splitting work across VAs + specialists who blame each other; also staff client-facing roles with people who have sales ability so they drive upsells.
How we apply itAs he scales past solo delivery, make one person (or himself) end-to-end owner per client to kill finger-pointing, and give the client-facing role an upsell mandate. Clean accountability boundary for any small delivery team.
Lean cold-outreach client acquisitiondurablerelevance 3/5
What it isScrape Google Maps for a niche (contractors) with visibly bad web presence, then cold-call at extreme volume (400-700 dials/day); pre-qualify with cold SMS first and only call positive responders to lift show/close rates. Start-up kit is just Stripe + a dialer + a lead list, no logo/website needed.
How we apply itDirect outbound to local SMBs is a parallel channel to Upwork for selling the same automation stack. Cold-SMS-then-call is the higher-leverage variant. Sales/outreach is framed as the one durable meta-skill worth acquiring even for a technical founder.
'Saturation is a myth' market sizingdurablerelevance 3/5
What it isArgues no local niche is saturated: tens of millions of US contractors mean even <1% market share at $300/mo = $10M/mo; clients churn and replace sites constantly, so 'they already have a website' is not a real objection.
How we apply itReassurance for choosing a crowded vertical (med-spa, contractors) for his showroom pieces. TAM math beats the saturation worry; competition on execution quality, not niche novelty, is where he should focus.
Fake-referral cold-call pretext ('Julie Becker' script)decayingrelevance 2/5
What it isOpener claims a fabricated person ('Julie Becker, a friend of my mom') referred the business and mentioned they lacked a website, then offers to show one already built. Presenter admits it is a complete lie; it tripled their booked appointments.
How we apply itNote the MECHANIC (lead with a specific warm-sounding reason + a pre-built asset to react to) but DO NOT copy the fabrication — it's dishonest and would poison Upwork reputation. Use a truthful version: 'I noticed your site/profile and already built a quick mockup, want to see it?'
Tools mentioned: GoHighLevel, ChatGPT / GPT natural-language interface, Stripe, Google Business Profile (GMB), Google Local Service Ads (LSA), SEO, custom-coded websites (replacing GHL at scale), dialer for cold calling, cold SMS, Google Maps (lead scraping)
⚠ Verify:
  • $500k/mo revenue and ~40% (target 50-60%) margins
  • $150k/mo ad spend
  • 1,300-1,400 clients on GoHighLevel
  • GHL hitting scale limits forcing move to custom-coded sites
  • cold-SMS-then-call tripling booked appointments vs cold calling alone
16Making $$ with AI Agents — Howie Liu (Airtable/HyperAgent) on the agent opportunity
Greg Eisenberg (Startup Ideas podcast) interviewing Howie Liu (co-founder/CEO, Airtable) — sponsored show-and-tell for HyperAgent  ·  13 techniques
SummaryFrontier models are already smart enough to do almost any white-collar job autonomously; the bottleneck is deployment craft, not capability. The money is in (1) pricing agent work against human-equivalent time value not token cost, and (2) building durable, self-improving agent systems — skills + eval rubrics + fleets — rather than one-shotting prompts. Whoever invests daily practice to get outputs to a high bar captures the arbitrage.
One-lineAirtable's Howie Liu on the agent gold rush: price on human-time value, and win with skills + eval rubrics + self-improving agent fleets, not one-shot prompts.
Price against human-equivalent time value, not token costdurablerelevance 5/5
What it isReframe cost from '$150 of tokens sounds expensive vs a $10/mo sub' to 'what would a human cost to produce this, and what is my time worth?' Howie's example: an agent-researched board memo cost ~$150 in tokens but was his best-received memo ever and took 10x less time.
How we apply itThis is Abdi's core pricing argument. In proposals and rate justification ($45/hr climbing), anchor the client on the human/agency equivalent (a $3k market report, a $5k content month) rather than the API/infra spend. Bake token cost into a fixed deliverable price with fat margin; never expose per-token pricing to clients.
Skills as the key primitive — playbooks that turn a general model into a domain expertdurablerelevance 5/5
What it isModels are like a brilliant generalist (Einstein) who lacks domain playbooks. A 'skill' is a reusable manual/context pack (voice, platform, rules, style constraints) pinned to an agent or invoked on demand. Built interactively: agent researches the target's real style/outputs, then distills a skill (e.g. 'hook in first 7 words, use ordered lists, never end with What do you think?').
How we apply itFormalize Abdi's reusable context as versioned 'skills' (markdown playbooks) per client/domain — RAG-ingestion rules, brand voice, compliance constraints. This is exactly Anthropic's Skills concept; standardize a skills/ folder per project. Sell 'we build you a reusable skill library' as a deliverable, not just a chatbot.
Eval rubrics + LLM-as-judge for scalable quality at fleet scaledurablerelevance 5/5
What it isDefine 'what good looks like' as a rubric (e.g. 5 dimensions for great content), then a separate LLM-as-judge scores every agent run against it. Gives a trend line of quality over time and lets you inspect any single run's score. Solves 'when you scale agents, you the human can't be the judge of every output.'
How we apply itAdd an eval/rubric layer to every agent Abdi ships (FastAPI + a judge LLM call, store scores in Postgres). Pitch it as the differentiator vs cheaper freelancers: 'automated QA / observability on every agent output.' Ties directly to his client progress-tracker standard — surface the quality trend line to the client.
Rubric-driven model downgrade for cost reductiondurablerelevance 5/5
What it isOnce a rubric is scoring outputs, test dropping from Opus to Sonnet — if the score barely falls you get roughly a 5x cost reduction for near-identical quality. The rubric makes the tradeoff measurable instead of a guess.
How we apply itStandard cost-optimization play: run a benchmark set through the judge on Opus vs Sonnet vs Haiku, keep the cheapest tier that clears the quality bar per task type. Route high-stakes steps to Opus, bulk/low-stakes to Sonnet/Haiku. Widens Abdi's margin on fixed-price jobs.
Fleet of role-mapped agents (agent command center)durablerelevance 4/5
What it isInstead of one omni-agent, build many purpose-built agents that map to human job roles — content marketer, market researcher, customer-email responder, lead enrichment, competitive research — overseen in one command-center view. Rationale: finite context windows mean partitioning agents by role (like partitioning employees) is structurally necessary, not just convenient.
How we apply itProductize as a repeatable offer: 'a fleet of 5-20 role-based agents for your business' with an overview dashboard. Design multi-agent systems as narrow specialists + orchestrator, not one huge prompt — better for context limits and easier to eval per role.
Self-improvement loop from every run (memory + skill suggestions)durablerelevance 4/5
What it isAfter each run, the system curates learnings — new memories, plus suggestions like 'add this skill', 'tweak the system prompt', 'give access to this tool'. Skills are treated as evergreen and iteratively improved, never one-and-done. Includes a memory 'defrag' tool that clusters related memories by keyword AND embedding similarity to consolidate them.
How we apply itBuild a post-run reflection step that appends structured learnings to a memory store; periodically dedupe/consolidate memories via embedding-similarity clustering (fits Abdi's Postgres/pgvector data-layer specialty). Sell 'agents that get better every week' as ongoing retainer value.
Research-then-build: agent as founder, not just developerdurablerelevance 4/5
What it isApp-building is now a commoditized feature. The differentiator is doing the end-to-end business research first (TAM, Reddit user-validation of the pain, competitive analysis, the actual market problem) and then building the V1 informed by that context. Demoed on 'hyperlocal real-estate market reports from public data.'
How we apply itFor any 'build me an app/agent' Upwork job, lead with an automated research brief (market, competitors, real user complaints scraped from Reddit/forums) BEFORE building — matches Abdi's rule to analyze the client's money-machine first. Ship the brief as a proposal-stage freebie to win the bid.
Teach an agent an arbitrary API by having it read the docs and build its own skilldurablerelevance 4/5
What it isFor any tool without a prebuilt connector, point the agent at the API docs; it researches them, writes a reusable integration skill for itself, then prompts you to enter credentials securely — after which it can call that API every future time. Demoed building a custom Twilio SMS/voice skill.
How we apply itRemoves the 'no connector' blocker on integration jobs. Have a doc-reading sub-agent generate a typed client + skill file for any obscure client API, store secrets properly. Lets Abdi promise 'connects to anything you use' without hand-coding every integration.
Deploy agents as always-on Slack coworkers + scheduled/live 'heartbeat' modedurablerelevance 3/5
What it isOne-click deploy an agent into Slack: always-on, listening to channels, chiming in when relevant, answerable like a virtual coworker. Plus scheduling ('turn this thread into a daily 8am email') and a 'live mode' heartbeat that polls every ~30 min and pushes new output via Slack/Telegram/email. Full-YOLO auto-posting exists but is discouraged — human-in-loop for hits-driven content.
How we apply itOffer Slack-bot and scheduled-digest deployments as productized add-ons (Abdi's stack: FastAPI + cron/worker + Slack API + SendGrid). Default to draft-and-notify, not auto-send, for anything client-facing — matches his under-promise/over-deliver guardrail.
Daily-reps discipline to become a top-1% agent builderdurablerelevance 3/5
What it isMost people try agent tools too sporadically, one-shot, get a mediocre result, and quit. Fix: calendar 30-min blocks daily for 30/60/90 days so it becomes workflow; skill quality compounds. Analogy to writers writing pages daily and to the door-to-door-salesman-vs-early-ecommerce parable — the one who fully pivots to the new tool wins big in ~6 months.
How we apply itPersonal operating cadence for Abdi's showroom builds — daily deliberate reps on the agent stack, iterate skills across many runs rather than shipping first drafts. Reinforces his existing 5-6x paid-project iteration process.
Target 'mini/medium' markets (~$1-2B TAM) big players ignoredurablerelevance 3/5
What it isSweet spot is markets too big to be worthless but too small for giant incumbents — capturing a double-digit % can yield a few hundred million/yr while the majors stay away. Example given: hyperlocal real-estate reports for agents.
How we apply itNiche-selection filter for Abdi's showroom pieces and vertical SaaS bets — pick unglamorous verticals (med spas, local services, real estate) where he can dominate a narrow segment, rather than crowded horizontal AI markets.
Two GTM wedges: PLG vs top-down enterprise 'fix your AI problem' checksdurablerelevance 3/5
What it isTwo ways to build a valuable AI business: (1) PLG — ship a free/low-friction thing that works and let raw usage drive growth; (2) top-down Palantir-style — pitch enterprise CEOs/boards a large check to 'solve your AI transformation,' which game-theory says they'll pay (do nothing = get fired; try = maybe fail but covered).
How we apply itTwo-track Abdi's pipeline: cheap productized showroom offers for SMBs (PLG-ish top-of-funnel + reviews) AND higher-ticket 'AI transformation / agent fleet build' consulting for larger clients. The game-theory framing is a proposal talking point for hesitant buyers.
Parallel autonomous coding agents with cross-agent PR reviewdecayingrelevance 3/5
What it isHowie's dev modality: ~30 cloud coding-agent instances running in parallel, each coupled to a browser, fully autonomous, able to recruit other agents to comment on the PRs they create — a shift from human-written-code-with-AI-augmentation to agent-written-code-with-human-review (Karpathy's Oct/Nov inversion).
How we apply itScale Abdi's own build throughput: run multiple autonomous coding agents in parallel on separate worktrees/branches, with a second agent doing automated PR review before he reviews. Higher output per showroom cycle.
Tools mentioned: HyperAgent, Airtable, OpenClaw (open-source agent tool), Manus, Perplexity Computer, Codex, GitHub Copilot / tab autocomplete, Slack, Notion, Granola, Twilio, Google Maps / Street View, Telegram, Reddit (for user validation), Zillow, LLM-as-judge / eval rubrics, Opus / Sonnet / Haiku (Claude tiers)
⚠ Verify:
  • Model version references are garbled/inconsistent ('Opus 4.5/4.6/4.7', '2.5.4', 'GP 5.4') — do not treat any specific version number as accurate
  • '$1,000 free HyperAgent credits to first 1,000 people / $1M committed' is a promo offer, verify terms before acting
  • Claimed OpenAI + Anthropic combined revenue '~$80B+' is an offhand estimate, not sourced
  • Sequoia charts cited (AI agent domain penetration, ~$1T TAM, unit economics) are referenced verbally, not shown — verify against actual Sequoia material
  • '82% of US businesses have zero employees' appears as tweet-bait in the demo, unverified
  • Airtable financials ('half billion revenue, $100M FCF this year, $1B+ on balance sheet') are the guest's own promotional claims
19The $1M+ Solo AI Agent Business (Full Course)
Greg Isenberg (Startup Ideas Podcast / The Startup Ideas Pod) with guest Nick from Orgo  ·  13 techniques
One-lineSolo operator sells managed vertical 'AI employees' at ~$5K/mo flat-unlimited to legacy service firms, fulfilling with agents-that-build-agents on isolated cloud VMs.
Sell an 'AI employee,' not an 'AI agent'durablerelevance 5/5
What it isPosition the deliverable as a digital employee that knows the client's business and improves weekly. The client never touches tokens, models, or infrastructure. Reframing away from 'agent/automation' toward 'employee/outcome' raises perceived value and reduces buyer confusion.
How we apply itRewrite Abdi's Upwork offer and project-catalog titles around 'a digital employee that owns your [inbox/intake/follow-ups]' rather than 'RAG chatbot' or 'automation.' Frame proposals in business outcomes (revenue, cases handled, leads booked), never 'time saved' which buyers are numb to.
Frictionless 'unlimited' abundance offer at flat monthly retainerdurablerelevance 5/5
What it isOffer unlimited agents / usage / monitoring / support / changes for a flat ~$5K/mo (Hermes-tier framed as $10K/mo). The trick: clients THINK they need 5-100 agents but really need 1-3, so flat pricing is safe. Never expose tokens/credits/usage-based pricing — it kills the magic and creates buyer anxiety.
How we apply itPackage a flat monthly managed-agent retainer in Abdi's Project Catalog: 'unlimited requests, unlimited support, we run everything.' Hide the token economics; control real cost by consolidating to 1-3 well-built agents per client. Cap scope operationally (see Trello intake), not in the pitch.
Go vertical, diverge-then-converge into a sub-nichedurablerelevance 5/5
What it isSell industry-specific agents, not commodity 'ChatGPT/Claude.' Best target industries: marketing agencies, law firms, insurance agencies, manufacturers, wholesalers, real estate (avoid healthcare/finance — regulatory red tape). Legacy, people-heavy, want-to-be-AI-native businesses. Don't over-niche upfront; try several, see where the market pulls, then go sub-niche (e.g., 'commercial real estate agencies in Florida').
How we apply itFilter Upwork jobs toward these verticals. Build showroom pieces for 1-2 of them (fits the 10-showroom strategy). Use geography or role to sub-niche a landing page/offer so the buyer feels 'this is speaking to me.'
Executive-pain template layer + vertical skills layerdurablerelevance 4/5
What it isEvery decision-maker across industries has the same pains: too many emails, meetings, follow-ups, open loops, scattered context. Build a reusable base agent that solves these, then layer vertical-specific skills on top (e.g., law firm: demand letters, case management). One template, many verticals.
How we apply itBuild a reusable 'executive assistant agent' core (email triage, follow-up tracking, meeting/context memory) on Abdi's FastAPI+Postgres+Claude stack, then keep a library of vertical skill packs to bolt on per client. Speeds delivery to the promised <48h first-agent turnaround.
48-hour first-agent delivery + scoped intake to prevent scope creepdurablerelevance 4/5
What it isGet the first working agent live within 48 hours to show magic fast (faster time-to-yes, faster happy customer). Use a client-facing Trello Kanban (Backlog/To-Do/Doing/Done) where the client drag-drops requests; enforce a limit of 1-2 requests per 48h window to avoid a fulfillment nightmare, since agents can now do so much that unbounded requests drown you.
How we apply itGive every retainer client a shared Kanban intake board with a 'max 1-2 active requests' rule stated up front. Aligns with Abdi's client progress-tracker standard. Promise and hit a 48h first-deliverable to build trust early.
Content-first, warm-audience sales; free work for case studiesdurablerelevance 4/5
What it isNever cold-call/cold-sell. Make content (faceless/AI-assisted OK) so buyers arrive warm and already know your offer — that's the ideal call. Content compounds: leads, podcasts, hiring. Early on, do free work to bank case studies and referrals. 'Content is king in 2026.'
How we apply itKeep producing faceless video/content per Abdi's marketing-channels playbook so Upwork/inbound leads arrive pre-sold. Take 1-2 free/discounted early builds explicitly to farm reviews and case studies — matches his 'tiny jobs to farm reviews' pivot plan.
Agents-that-build-agents (use Claude Code/Codex to set up client agents)durablerelevance 4/5
What it isIf you can't hand-build an agent, use a coding agent (Claude Code / Codex desktop app) to install and configure the client's agent. Spin a cloud VM, install Claude Code in the terminal, tell it in natural language to set up the harness. Kick off long-horizon setup tasks remotely via Telegram while away. 'More agents is the answer.'
How we apply itStandardize a repeatable 'setup agent' (Claude Code driven) that provisions each new client's agent from a checklist, so onboarding is near-hands-off. Kick off long builds asynchronously.
Ground agent setup in live docs via search/docs MCPs + parallel sub-agentsdurablerelevance 4/5
What it isBecause agent frameworks change weekly, don't rely on the model's stale knowledge. Attach real-time context MCPs — Perplexity, Exa.ai, Context7 (up-to-date GitHub docs), Firecrawl, the X/Twitter MCP (community setups) — and spawn one sub-agent per source, converging results to a main agent for best-practice setup.
How we apply itWhen Claude builds/debugs on a fast-moving library, wire Context7 + Exa/Perplexity MCPs and fan out sub-agents per source, then merge. Directly applicable to Abdi's stack to avoid outdated setup steps.
Reliability layer: watchdogs + agent self-alerting observabilitydurablerelevance 4/5
What it isGateways connecting agents to Telegram/WhatsApp crash; set up a watchdog that auto-restarts a gateway on crash. Add observability: give each agent its own email so it emails YOU when a cron job/skill fails, so you fix it before the client notices. Handle everything tip-to-tail so the client never worries.
How we apply itBuild watchdog + self-alerting into every managed deliverable (fits Abdi's email-notifications standard — agent emails hello@domain on failures). Sell 'we detect and fix breaks before you notice' as a proposal selling point; managed reliability justifies the retainer.
Isolated cloud VM per client for security + demo theaterdurablerelevance 3/5
What it isRun each client's agent in a disposable, isolated cloud computer (one workspace per client, agents inside). Benefits: manage all clients remotely from one place, deletable in a second, limited blast radius vs a personal Mac mini, and a VISUAL sandbox you can screen-share/Loom to convince skeptical buyers it's secure. Letting a buyer watch the agent drive a real computer (e.g., Google a query) is a powerful demo.
How we apply itProvision one isolated environment per client on Abdi's Azure stack; record Loom demos of the agent doing real work as a sales/onboarding asset and security reassurance.
Fulfillment/ops software stack (meeting notes → intake → updates)decayingrelevance 3/5
What it isConcrete tooling: Granola (meeting notes via MCP, auto-synced into Trello requests), Trello (client-facing Kanban), Loom (async progress updates at any hour), Calendly + personal site (simple funnel), Superhuman (fast keyboard-driven email at volume), Asana (internal task tracking).
How we apply itAdopt the pattern: transcribe client calls → auto-create scoped tickets → deliver Loom updates → book via Calendly. Abdi can substitute equivalents he already uses; the meeting-notes-to-ticket automation is the reusable win.
Standard agent tool bundle: universal connector + agent email + context vaultdecayingrelevance 3/5
What it isInstall for every agent: Composio (one MCP connector to thousands of apps — Gmail/Slack/Notion/GitHub — handling auth + tool-calling; auth is the #1 time sink and security risk, so this solves it), AgentMail (give each agent its own email address for a personal-assistant feel and send/receive), and Obsidian (markdown 'second brain' wiki of people/projects for deep agent context, favored over Notion).
How we apply itFor managed clients, use a universal connector to avoid per-app OAuth pain and insecure credential sharing (auth is the real bottleneck). Maintain a structured markdown knowledge base per client so the agent has durable context — Abdi 'owns the data layer,' so a Postgres/markdown context store is his edge.
Model-agnostic harness + current model picksdecayingrelevance 2/5
What it isDon't marry a platform/model — use a harness (Hermes preferred for reliability & self-evolving; OpenClaw cheaper/commoditized) that can swap models instantly when a cheaper/smarter one drops. Their current picks: GPT 5.5 as default (efficient tool calls, cheap on paid plans), GLM 5.1 (ZAI) best affordable open-source for light tasks, Kimi second, Opus 4.7 for long-horizon coding (route to Claude Code). Note: model names/versions are speculative/near-future and will change.
How we apply itKeep Abdi's builds harness-abstracted so he can swap the underlying model per task/cost without rework. Treat the specific model names as placeholders — re-benchmark at build time. (Abdi's stack is Claude-first; keep an escape hatch for cheaper models on light tasks.)
Tools mentioned: Orgo, Hermes (harness), OpenClaw, Claude Code, OpenAI Codex, Composio, AgentMail, Obsidian, Granola, Trello, Loom, Calendly, Superhuman, Asana, Telegram, Perplexity MCP, Exa.ai MCP, Context7 MCP, Firecrawl MCP, X/Twitter MCP, GPT 5.5, GLM 5.1 (ZAI), Kimi, Opus 4.7, Limitless (wearable mic), Hostinger
⚠ Verify:
  • $5,000/mo per customer (and Hermes-tier $10K/mo) as achievable managed-agent pricing
  • Claim that most clients only need 1-3 agents despite thinking they need 5-100, making flat 'unlimited' pricing profitable
  • Model claims: GPT 5.5 most token-efficient for tool calls, GLM 5.1 best affordable open-source, Opus 4.7 best for long-horizon coding (all near-future/speculative model names)
  • 48-hour first-agent delivery being realistic for a vertical-specific build
  • OpenClaw having more gateway-crash issues than Hermes
  • Composio connecting to 'thousands' of apps via one MCP with managed auth
25COLD EMAIL COPYWRITING & OUTREACH Full Course 2026
Nick Saraev (LeftClick / Maker School)  ·  16 techniques
SummaryCold outbound is applied persuasion psychology: to get a stranger to say yes with zero pre-existing trust, give value first and stack micro-commitments, then package every message with a 4-part structure (personalization > who-am-I > offer > CTA) built on a guarantee-heavy offer. Learn the underlying SYSTEM, not templates (templates decay, systems don't), and treat campaigns like a data scientist — send at volume, iterate on reply rate, kill losers.
One-lineNick Saraev's cold-outbound course: 7 persuasion principles + 4-step message framework (personalize>who-am-I>offer>CTA) + offer formula (ROI x Trust / Friction) with guarantee-based offers, human-voice single-step CTAs, data-scientist iteration (500-1k/variant), and AI used ONLY for a 'casualization' variable — maps to both an AI-SDR product spec and Abdi's own Upwork outreach.
4-step message framework (Personalization > Who-am-I > Offer > CTA)durablerelevance 5/5
What it isEvery cold message has exactly four parts: (1) a short personalized opener that proves you're not a spammer, (2) 1-2 sentences on who you are + why it matters via social proof, (3) an observation + too-good-to-ignore offer, (4) one specific call-to-action. ~80-90% of outbound situations fit this.
How we apply itBake this as the templating schema for the AI SDR product (four named blocks the agent fills per-lead). Use it verbatim for his own Upwork proposals/Loom cold intros — proposal = personalization + 'I build RAG/agents on Claude+Azure, just shipped X for a client' + guarantee offer + specific call time.
Seven persuasion principles (Cialdini-based)durablerelevance 5/5
What it isGive-first, micro-commitments, social proof, authority, rapport, scarcity, shared identity. Score any draft against all seven; strong messages hit most of them, usually as throwaway lines not headlines.
How we apply itUse as a scoring rubric the AI SDR agent runs against generated copy (7-point checklist), and as a self-audit for his own emails. Give-first + micro-commitment (offer a free asset, ask only for a title/topic) is the highest-leverage pair.
Offer formula: Conversion = (ROI x Trust) / Frictiondurablerelevance 5/5
What it isNot literal math — a lens forcing every offer to maximize perceived ROI, maximize trust that you'll deliver (via in-group match, social proof, authority), and minimize friction to start. Weak on any one factor tanks conversion.
How we apply itSell it as the 'offer engine' inside the SDR product. For his own bids: quantify ROI ('I'll build you an AI agent that saves ~X hrs/week'), stack trust (named client results), strip friction ('15 min once, I handle the rest, one-click Meet invite').
Guarantee / risk-reversal offer templatedurablerelevance 5/5
What it isFormula: 'I will do X [quantified, specific result] in Y [time-bound] or Z [you don't pay / full refund / gift card].' Result must be quantified (20 meetings, not 'meetings'), time-bound, and put ALL risk on you. Offers ~3x top-of-funnel at ~10% margin cost. Scale the promised number to a small % of the client's revenue so it's easy to hit.
How we apply itHis core differentiator: 'I'll build you a working AI coach/agent in 7 days; if it doesn't save you 5 hrs/week you don't pay.' Deliverable-based (a built asset) is safer than revenue-based. Also his Maker-School-style flagship offer: 'first result in 90 days or money back.'
Casualization layer (the one AI variable worth automating)durablerelevance 5/5
What it isUse AI on ONE small templated variable: rewrite the scraped company name / neighborhood / school the way an insider would say it ('Left Click Incorporated' -> 'Left Click'; 'Vancouver BC' -> 'East Van'). Signals you actually know them; strips the tell-tale scraped-data formality.
How we apply itA concrete, sellable feature of his AI SDR agent — a 'casualization layer' node (name/location/school normalization) that measurably lifts reply rates. Easy to build on Claude; strong demo differentiator.
Use AI ONLY for small templated variables, never whole copydurablerelevance 5/5
What it isFull-AI-written cold emails underperform and are instantly detectable (LLM slop openers). AI can reach ~75% skill in weeks but the top 25% gap it can't cross. Correct use: AI writes only the personalization snippet slotted into a human-written, already-working template; humans write offer/social-proof/CTA.
How we apply itScope-setter for the SDR product — 'human-grade templates + AI-filled variables + scraping/enrichment,' NOT 'AI writes your emails.' Avoids overpromising and matches what actually converts.
One-sentence goal + single-step CTAdurablerelevance 5/5
What it isIf you can't state the campaign goal in one sentence, you're not ready to write it. Pick ONE action (reply, watch, or book-call — almost never 'buy' in cold email). Give a specific ask with a specific time so there's one step between yes and booked. Every extra back-and-forth leaks ~5% of the funnel (~25% total lost to typical multi-step scheduling).
How we apply itEvery Upwork Loom/DM ends with a concrete time + one-click Meet invite, not 'let me know your thoughts.' Build the SDR agent to always emit a single time-boxed CTA with a calendar link.
Iterate like a data scientist (volume + kill losers)durablerelevance 5/5
What it isCampaigns rarely work on send-one; you climb from ~2.5% to plateau via iteration. Rules: always run >1 variant; 500-1,000 sends per variant before judging (100 is meaningless); make BIG differences early then shrink late; kill bottom performers, breed variants from winners; fixed cadence (Sunday, 20-30 min) so cycles happen.
How we apply itCore value-prop of a managed SDR service (A/B infra + weekly iteration reports = the client-progress-tracker he already builds). For his own outreach: batch bids, track reply rate, don't judge off 5 sends.
Match the reference group / in-group social proofdurablerelevance 5/5
What it isUse specific numbers, real names, concrete counts — and match the case study to the prospect's industry/size ('I work with a retail co about your size, made $85k in 12 weeks'). Set the guaranteed number LOW vs. what you've actually done to make trust obvious.
How we apply itCurate niche-matched mini case studies (Desert Glow for med-spa, KalEdge for fintech). SDR product: pull the closest-matching reference per lead's industry.
Cold reading (general statements that feel personal)durablerelevance 4/5
What it isOpen with a vague-but-specific-feeling line that actually applies to ~80% of the target list ('love your channel, very no-BS'). Reader thinks 'wait, who is this?' — buys 30 seconds of attention without any real research. Keep it 1-2 sentences; shorter = feels more real.
How we apply itThe default personalization mode for the SDR product when scraped data is thin — cheaper and often better than AI personalization. Build a library of cold-read openers per niche.
Subject line = plausible deniability, never selldurablerelevance 4/5
What it isSubject's only job is to buy the click by piquing curiosity without answering 'who is this / why care.' Best: short, lowercase (looks human), include the name, or use loss-framing ('nick you're wasting $2,300/month'). Bad: anything that sells, spelled-out acronyms, too-long, or no subject (spam-correlated).
How we apply itSDR product generates name-personalized, loss-framed, lowercase subject variants and tests them. His own outreach: short curiosity subjects, never 'AI automation services.'
Follow-ups: start with 2, simple human pings, add steps only after provendurablerelevance 4/5
What it isDon't blast 5+ elaborate follow-ups upfront — extra touches on an unproven sequence raise spam/block risk. Start with initial + one short human ping, different subject line. Only add a 3rd/4th step after a campaign proves out. One follow-up alone beats 99.9% who send none.
How we apply itConfigure SDR sequences to open at 2 steps, auto-expand on winners. His own bids: send one genuine human follow-up, not a case-study newsletter.
Write like a human / kill corporate signalsdecayingrelevance 4/5
What it isFrame is 1:1 person-to-person even when templated. Kill 'hope this finds you well', formal signatures, 'we' (use 'I'). Short, casual, slightly imperfect. Text-message test: would a friend think you wrote this just to them? Decaying tricks: 'Sent from my iPhone' footer + one intentional typo.
How we apply itGeneral tone rule for all outreach and the SDR product's default voice. Treat the deliberate-typo / iPhone-footer tricks as decaying gimmicks, not principles.
Per-platform optimization surface + no linksdecayingrelevance 4/5
What it isOptimize EVERY visible field, not just the body: sender name, subject, preview teaser, profile pic, email address; LinkedIn adds title/badge/certs; iMessage blue bubble + fill the ~90-char teaser with a hook. No links in cold email (spam trigger); minimize on SMS/LinkedIn too.
How we apply itOptimize his own Upwork profile fields the same way. SDR product: expose per-channel field-length constraints and strip links by default for deliverability.
Self-liquidating / commission-aligned offersdurablerelevance 4/5
What it isFree-until-outcome structures ('won't charge until your first 10 paying clients', 'only pay if you like it', 'mostly on commission') remove time-pressure and friction while signaling confidence.
How we apply itLow-risk entry offers to farm his first paid reviews: build the asset free, client pays only if they keep it. Aligns with his 'over-deliver on first paid job' strategy.
Gray-hat scaling (know, don't necessarily use)decayingrelevance 2/5
What it isPre-warmed mailboxes / bought aged accounts to skip warmup; power dialers (parallel dialing ~2.5x efficiency); blue-bubble iMessage emulation & cold SMS/WhatsApp APIs. All trade ToS/legal compliance — accounts get banned; heavily regulated.
How we apply itAwareness only — speak credibly to clients about deliverability infra and explicitly build the SDR product on the compliant side (real warmup, opt-outs, consented B2B data) as a selling point.
Tools mentioned: Instantly, Smartlead, HeyReach, LinkedIn Sales Navigator, Airscale, Vein.io, MailSuite, Claude Code skills, Liquid syntax, Power dialers, Cialdini's Influence (book)
⚠ Verify:
  • Creator claims $15M+ in outbound sales and a business doing $4M/yr profit; Maker School ~$230-250k/month
  • Offers ~3x top-of-funnel revenue at ~10% margin cost
  • Every extra scheduling back-and-forth leaks ~5% of funnel; multi-step loses ~25%
  • Reply-rate benchmarks (2.5% climbing to 6-10%+); 500-1,000 sends per variant for significance
  • AI copywriting stuck at 'good' not 'great' tier across 10,000+ Maker School users

Startup strategy & positioning

029 biggest startup ideas right now (AI, B2C, mobile etc)
Greg Isenberg — The Startup Ideas Podcast (guest: Jonathan Courtney / "Jay Icecream")  ·  11 techniques
SummaryThe biggest near-term opportunities are AI agents that DO the work rather than apps humans operate: 'action apps' (agent-first mobile/SaaS on the Claude Agent SDK), verticalized 'AI employees' that replicate one job title's jobs-to-be-done at ~$5k/mo, and personal-data brains — all won by narrow verticalization and disciplined niche selection (underserved + disposable income + big pain), not generic horizontal tools.
One-lineAgent-first 'action apps' + verticalized $5k/mo 'AI employees' (jobs-to-be-done per job title) are the plays; win via niche selection and crystal-clear use cases, not generic AI.
Action apps / agent-first, not human-operateddurablerelevance 5/5
What it isReframe any workflow app from 'human stares and clicks' to 'agent does it for you' — clearing inbox, booking calendar, filing expenses. Build a thin layer on the Claude Agent SDK rather than the model from scratch (the 'agent wrapper' era).
How we apply itPosition every build as agent-first: don't sell a dashboard, sell the outcome the agent executes. On his Claude+FastAPI+Postgres stack, wrap the Agent SDK, own the data layer that feeds it, and pitch clients 'we automate 80% of this task, you only review the exceptions' — the email example (agent answers 80%, surfaces 1-2 you approve) is a reusable UX blueprint.
AI employee offer, verticalized by job titledurablerelevance 5/5
What it isSell/host managed 'digital workers' for one vertical + one job title. Method: ask Claude to enumerate the 50 jobs-to-be-done of that role, ship agents for 2-3 first, then keep adding until it's a true digital employee. Referenced ~$5k/mo pricing with a one-time setup fee.
How we apply itConcrete productized offer: pick a niche (accountants, law firms, a YouTube producer) + job title, list its jobs-to-be-done, build agents on Claude, host on Azure. Land-and-expand: start with a few tasks (low risk), invoice setup + monthly retainer, add tasks over time. This is a recurring-revenue alternative to hourly Upwork work.
Make the use case crystal-clear to sell itdurablerelevance 5/5
What it isThe AI-employee companies that win show founders exactly: this agent does A, B, C; it removes THIS much work from your day; it costs a fraction; we switch it on now. Buyers don't know what agents can do — the winner sells legible, specific use cases, not capability.
How we apply itRewrite proposals/offers as enumerated task lists with hours-saved and a 'switch on now' setup, not vague 'AI automation.' A crystal-clear use-case list turns 'maybe' into a no-brainer. Directly upgrades his Project Catalog listings.
Verticalize horizontal AI offeringsdurablerelevance 5/5
What it isRecurring lesson across every idea: horizontal products (generic email AI, generic health/nutrition) underserve; the money is 'ZOE for GERD', 'ZOE for men in Germany', agents for one job title. Specificity to a real pain beats broad tooling.
How we apply itWhen a client wants 'an AI assistant,' narrow it to one role/one pain and own that vertical deeply — easier to demo, easier to price, less competition. Turn each showroom piece into a named vertical rather than a general tool.
'Juniors' positioning — augment, don't replacedurablerelevance 4/5
What it isMarket AI workers as junior employees doing menial/annoying work, explicitly NOT replacing senior or creative talent. Founders don't trust AI to replace seniors, but every company needs junior grunt work done. Optionally brand as pro-human ('AI never touches your creative work').
How we apply itDefuse buyer fear in proposals: frame deliverables as 'a junior teammate that removes the boring tasks slowing you down,' not 'replace your staff.' Lowers perceived risk and objection-handling on cold Upwork clients.
Niche selection: 'date the product, marry the niche'durablerelevance 4/5
What it isPick the niche first on three filters: (1) underserved, (2) has disposable income (or spends heavily on the pain despite low income, e.g. pet owners), (3) big pain point + you have an unfair advantage. The product will change as you learn; the niche shouldn't.
How we apply itScreen which showroom verticals / Upwork niches to chase using these 3 filters before building. Prevents building great tech for an audience with no money or no pain.
Personal-data 'brain' via a Claude project (RAG over your own records)durablerelevance 4/5
What it isGuest built 'Stomach Helper' — a Claude project loaded with all his blood tests + doctor notes he queries for personalized answers, because no product on the market does it. Signals demand for a vertical app: dump user health markers to the cloud + AI-interpret + act (send food, book chef). Data sources now exist (Function Health, Zoe microbiome kits, CalAI).
How we apply itTextbook 'own the data layer' build: ingest a client's/user's documents into Postgres, RAG + agent over them, deliver personalized guidance. Repackage his Concierge/RAG pattern for any records-heavy vertical (health, legal, finance) where users are cobbling together Claude projects manually.
CVS-shelf heuristic for finding pain pointsdurablerelevance 3/5
What it isTo find a lucrative vertical, walk a pharmacy and note which OTC categories fill entire aisles (antacids/GERD, migraines) — that volume maps to widespread, unsolved, willing-to-pay pain.
How we apply itCheap market-research tactic for choosing which vertical AI product/showroom to build next: mass-market OTC volume = validated demand + spend.
Recurring membership + free/premium ladderdurablerelevance 3/5
What it isDefault to a membership model for recurring revenue. Tim Ferriss ladder: a free/low-cost version (meetups, basic tier) feeding a premium version (high-ticket, e.g. $7-8k retreats). Same offer sold to entrepreneurs vs. general public = 20x revenue.
How we apply itStructure deliverables as subscriptions not one-offs; offer a free/cheap entry (audit, lite agent) that upsells a premium managed tier. And target the buyer with money (established business owners) over beginners.
AI-native media to build audience, then sell productsdecayingrelevance 3/5
What it isBuild a niche audience with AI avatars/faceless content (HeyGen + ElevenLabs), disclose the AI, aim for top-1% quality (human-in-the-loop, not slop), then monetize by selling apps/products to that audience. Example: 0→~400k followers in 18-24mo via an AI news avatar.
How we apply itMatches his marketing-channels playbook: use faceless AI video to build an audience around a vertical (e.g. GERD, a job-title automation), then funnel to his productized offers. Quality bar matters — slop won't work in 2026.
Facebook ads still convert the 40-65+ wealthy segmentdecayingrelevance 2/5
What it isContrarian: FB isn't dead, its users just skew older/wealthier. Facilitator.com's most valuable customers are 45+ (highest earners/savings) despite goofy branding; people buy same-day off FB. Also 'elder tech' (65+, 70M boomers) is underserved — don't market it with gray-hair imagery.
How we apply itIf running paid acquisition for showroom pieces or clients targeting older buyers, don't skip Facebook. Consider an elder-tech / 40+ vertical as an underserved AI niche with disposable income.
Tools mentioned: Claude / Claude Code, Claude Agent SDK, Hermes, OpenClaw, Superhuman, Opus Clip, HeyGen, ElevenLabs, Zoe (microbiome), CalAI, Function Health, Incogni, Discord, Patreon, Twitch, Facebook Ads, 23andMe
⚠ Verify:
  • CalAI does ~$50M ARR
  • TBPN/tech business show sold for over $100M
  • ~22% of Americans have less than one close friend
  • ~60M Americans / ~20% of US adults have GERD
  • Global pet industry ~$140B with <2% of pets on smart AI monitoring
  • 222 and Fabric (community/events startups) are 'crushing it' with membership models
18Opencode CEO: Blocked, 20X Growth in 6 Months, Building the Coding Agent for the World
Y Combinator — Lightcone Podcast (guest: Jay, founder/CEO of OpenCode)  ·  9 techniques
SummaryOpenCode is an open-source, model-agnostic coding agent (fork-alternative to Claude Code) whose growth came from letting users pick any model — including cheap open-weight ones (DeepSeek, GLM, Kimi) — and from splitting the product into a UI plus a separately-embeddable headless agent 'server.' Durable lessons for a builder: route work across a tiered model mix to control token cost, embed the agent loop behind other surfaces (Slack bots, product core loops), and use a free 'aha moment' tier as customer acquisition that converts power users into high-spend accounts.
One-lineOpenCode CEO on model-agnostic coding agents — embed a headless agent server (Slack bots/product core loops), tier-route cheap vs frontier models to cut token cost, and run a free-'aha' → subscription → whale funnel.
Headless agent 'server' embedded separately from the UIdurablerelevance 5/5
What it isOpenCode is two parts: the terminal UI, and an agent loop (the 'server') that actually calls the LLM and does work. The server can be embedded independently — RAMP ran a Slack bot with OpenCode's agent loop behind the scenes, and enterprises embed it inside their product's core loop.
How we apply itArchitect every agent build as a headless core (FastAPI service running the tool/LLM loop) with the chat UI as a thin, swappable client. Then the SAME engine sells three ways: a web chat, a Slack/Teams bot, and an embedded 'core loop' inside the client's own product. Package 'AI agent as a Slack bot over your data' as a concrete Upwork deliverable — it's exactly his RAG/agent+data-layer wheelhouse.
Tiered model routing to control token costdurablerelevance 5/5
What it isUsers burn cheap models (DeepSeek Flash) for routine work and near their limits, and reserve frontier models for hard tasks. OpenCode gets volume discounts by aggregating tokens; per-token whales feed margin directly. Different models are picked for different traits (GLM for front-end design, Kimi for high tokens/sec, DeepSeek for cost).
How we apply itBuild a model-router layer into agent/RAG deliverables: cheap model for classification/extraction/summarization sub-steps, Claude for the hard reasoning step. Sell it as 'cost governance' — a knob that cuts a client's monthly token bill without dropping quality. Quote clients a lower run-cost than single-frontier-model competitors. This is a durable design principle even as the specific cheap model changes.
Free 'aha moment' tier → subscription → whale funneldurablerelevance 4/5
What it isFree tier exists to give everyone the magic first experience (the CAC is spent on tokens, not ads). A cheap subscription ($10, open-weight models) lets people do 'real work,' which justifies bigger spend, and a slice become high-spend 'whales.' Enterprises then inbound-ask to sign security questionnaires — 'you know you have PMF when enterprises beg to sign your security agreement.'
How we apply itFor his showroom pieces (Ayuvara etc.) and any productized offer, gate a genuine wow-moment behind a free/trial step before the paywall, and treat token/compute spend as the acquisition cost instead of ad spend. Design the funnel free-demo → cheap paid → expansion, not a single price wall.
Own the end-user relationship; be the neutral model marketplacedurablerelevance 4/5
What it isOpenCode wins by owning the user relationship and letting users freely pick/switch models — a marketplace where lab competition benefits the consumer. Being locked to one vendor forfeits that leverage; value accrues to the layer that owns the user, not just the model.
How we apply itPosition deliverables as model-agnostic: abstract the LLM behind an interface so a client is never locked to one provider and can swap as prices/quality shift. Pitch this to clients as future-proofing and negotiating leverage. Reinforces his 'owns the data layer' positioning — own the data + orchestration layer, stay neutral on the model.
Build in public with transparent live metricsdurablerelevance 4/5
What it isOpenCode publishes usage data (opencode.ai/data — token volume by model, unique users, geo) and shares growth numbers openly; because the code is public, NOT talking publicly is a disservice. Followers treat the transparent journey like a reality show, which compounds distribution.
How we apply itDirectly feeds his mandatory client-branded progress/status tracker standard: ship a live, public metrics/progress page for every project as both a trust signal and a marketing surface. Build his own AI-engineer presence in public (transparent build logs, live showroom metrics) to compound inbound.
OpenCode as a working tool to cut his own build costsdecayingrelevance 3/5
What it isOpenCode is an open-source Claude Code alternative that works with any model, has a model picker with new open-weight models available immediately, and reportedly handles large, complex codebases well with open-source models (guest+host both dropped real PRs).
How we apply itAdd OpenCode to his toolbox to run cheaper open-weight models (GLM/DeepSeek/Kimi) on routine coding for client projects, keeping Claude for hard reasoning — lowering his own cost of delivery while staying model-flexible. Also a fast way to trial any newly-released open model before adopting it.
Enterprise token-governance features as a product surfacedurablerelevance 3/5
What it isEnterprises pull OpenCode toward per-org access limits, restricting frontier models where not needed, creative token-spend management, and usage visibility dashboards — the emerging 'vibe shift' toward token budgeting even at well-funded US firms.
How we apply itOffer an admin/governance layer on top of AI deliverables: per-team model allowlists, spend caps, and a usage-visibility dashboard. Sellable add-on for any org worried about runaway LLM bills — an upsell beyond the core agent.
Occupy the 'open default' position and own the enabling datasetdurablerelevance 3/5
What it isWhen a market has one or two dominant players, it coalesces around an open alternative — pick that slot fast and it's hard to displace (name 'OpenCode' was deliberate). To back a claim of '70+ models supported' they built models.dev, an open dataset of all models/providers that became the best such dataset and a moat/community asset.
How we apply itWhen entering a crowded niche, deliberately take the open/neutral position and build the boring enabling asset others lack (a clean dataset, an integrations catalog, a benchmark). For his showroom niches, an authoritative open resource can become both moat and lead magnet.
Adversarial-blocking / 'Streisand' distribution effectdecayingrelevance 1/5
What it isWhen Anthropic tried to block OpenCode from using Claude Code subscriptions (rejecting requests whose system prompt contained 'opencode'), it backfired — it equated OpenCode with Claude Code in users' minds and drove a wave of new users (like the 'death of Instacart' meme post-Whole-Foods).
How we apply itMinor/opportunistic: being singled out by a bigger incumbent can be free positioning as the credible alternative. Not something to engineer, but worth leaning into if it happens.
Tools mentioned: OpenCode, Claude Code, Codex, Cursor, models.dev, opencode.ai/data, OpenRouter, DeepSeek (Flash/Pro), GLM (5.0/5.2), Kimi, MiniMax, Anthropic Sonnet/Opus, Slack (bot integration), SST, NeoVim, AWS serverless
⚠ Verify:
  • OpenCode ~4.6M weekly / ~13M monthly active users, ~20X growth since start of year
  • OpenCode processing ~7 trillion tokens/day vs OpenRouter's ~6 trillion total
  • ~160,000 monthly subscribers; ~$38-40M annualized inference run-rate; ~$18M annualized from subscriptions
  • ~5% of Codex subscribers reportedly use OpenCode as their harness
  • Anthropic blocked requests whose system prompt contained the word 'opencode'
  • China ~17%, Indonesia ~4%, Brazil ~5% of OpenCode traffic
  • RAMP built a Slack bot running OpenCode's agent server (Dec 2024 blog post)
  • OpenCode claims to be the largest customer for most open-source model labs by token volume
  • Company is a ~16-year-old legal entity (incorporated 2010); founders did 9 YC applications / 4 interviews before acceptance in 2021
  • Kimi 2.4/2.5 was first open model to surpass Anthropic models in OpenCode usage (Feb, 4-week span)
20The 5 AI Businesses That Will Make Millionaires in 2026 (No Employees Needed)
Unnamed AI-consulting/agency creator (SkillLeap-style "AI agency in a box" channel; ~15k free Skool community + $50 3-day AI challenge upsell)  ·  13 techniques
SummaryFive productized AI services that close on cold traffic — each priced as setup-fee + monthly retainer with a dollar-quantified guarantee — plus a warm-then-cold client-acquisition playbook.
One-lineFive cold-traffic-ready productized AI offers (receptionist, funnel+ads, content engine, AI SDR lead-gen, e-com email/SMS) with setup+retainer pricing, dollar-quantified guarantees, and a warm-then-dream-100 acquisition playbook.
AI appointment-setter / 24-7 receptionist offerdurablerelevance 5/5
What it isAI voice + website chat that answers every call within 2 rings / chat within 10s, qualifies leads, answers pricing/service questions, handles objections, books straight to calendar. Sold to businesses with 50+ calls/week OR where one missed call = $1k+ (med spas, PI law firms, dental/cosmetic, HVAC, roofing, plastic surgeons, luxury home services).
How we apply itPackage this as an Upwork listing built on his Claude+FastAPI+Postgres stack (owns the data/qualification layer). Setup $2k-5k + $500-1.5k/mo retainer; optionally stack white-label ads for +$1-2k/mo. Sell against the concrete pain (the $8k med-spa call lost at 7pm). This maps almost exactly to his Desert Glow med-spa concierge showroom piece.
Dollar-quantified performance guaranteesdurablerelevance 5/5
What it isEvery offer is de-risked with a specific, measurable promise: e.g. 'answer 100% of calls/chats within 30s or you don't pay the monthly'; 'installed in 7 days'; 'first 10 leads in 30 days or full setup-fee refund'; 'work free until we hit 50 purchases.'
How we apply itAdd a bolded guarantee line to every Upwork proposal and showroom pitch. Tie it to a metric his tracker page already measures (uptime, response-time, leads booked). Removes cold-prospect risk and justifies premium pricing.
Setup-fee + monthly-retainer pricing modeldurablerelevance 5/5
What it isConsistent structure across all 5 offers: charge an upfront build fee (proof-of-work) then recurring management. Receptionist $2-5k+$0.5-1.5k/mo; funnel $3-7k+$1-3k/mo; content $1.5-3k+$2-5k/mo; lead-gen $2-4k/mo or perf; email/SMS $2-4k+few-k/mo.
How we apply itRestructure his Project Catalog listings as setup+retainer instead of flat hourly. Upfront fee funds the build and filters tire-kickers; retainer creates MRR. Only pay for tools/subs (e.g. white-label) after client pays upfront.
Deep-personalized cold email / AI SDR lead-gendurablerelevance 5/5
What it isBuild 200-500 tightly-targeted prospect list (Clay ~$150/mo + LinkedIn Sales Navigator ~$80/mo, NOT bulk Apollo lists) filtered by size/industry/tech/funding/job-posts/growth signals; AI researches each prospect's site, blog, job posts, tech stack and writes hyper-personalized emails -> 10-20% reply vs 1-3%. AI SDR handles replies, objections, qualifies, books calls.
How we apply itHighest-leverage build for his agent skills: an AI SDR agent on Claude that does per-prospect research + reply-handling. Sell as $2-4k/mo retainer OR performance ($250-500/qualified call, or % of close). Make the client pay for Clay/Sales-Nav. Pure-performance pricing = his favorite scaling lever.
'Dream 100' personalized cold outreach (weeks 2-8)durablerelevance 5/5
What it isBuild a researched list of 25-100 perfect-fit prospects (not random Google results); spend a few min each on their pain; send fully custom messages leading with FREE value (free demo build, audit, script, teardown); frictionless CTA; follow up 2-3x over 6 days. Low volume + high personalization = 15-25% reply vs 2%. Only after proving 5-10% reply rates do you scale volume (buy 20-30 domains / 60 inboxes, automate research with Clay) — never scale a broken message.
How we apply itHis 'free demo build' offer = build a working showroom demo for a specific prospect as the outreach hook — exactly his showroom-piece strategy weaponized for outbound. Prove message manually first, then automate with Clay/Sales-Nav. Applies to landing Upwork clients and direct clients alike.
White-label agency arbitragedurablerelevance 4/5
What it isStay client's single point of contact but subcontract the part you can't/won't do (ad buying) to a white-label agency running under your brand; mark up (pay $1k, charge $2k = $1k pure profit). Only engage the partner after client pays upfront.
How we apply itLets him sell 'ads + AI' bundles without becoming a media buyer — deliver the AI/data layer himself, subcontract paid media. Structural margin play he can apply to any showroom offer that needs a skill outside his stack.
Interview-to-30-days-of-content pipelinedurablerelevance 4/5
What it isOne 30-60min recorded interview with client (their frameworks, client stories, wins) -> transcribe (Fireflies ~$20/mo) -> feed transcript to LLM -> generate 30+ days of content in client's voice across LinkedIn/Twitter/YouTube/newsletter/IG, SEO-optimized, 1 piece repurposed into ~8 formats. ~4-6 hrs/mo per client once dialed, service 8-10 clients solo.
How we apply itDirectly buildable on his stack as a productized 'content engine' offer: transcription -> Claude prompt chain -> multi-format output. Charge $1.5-3k setup + $2-5k/mo. This is also literally the pipeline he's running now on these transcripts — he can dogfood and sell it.
Performance/pay-per-result pricing on high-ticket clientsdurablerelevance 4/5
What it isFor clients with $3k+ offers (deals worth $5k-50k), charge per qualified call booked ($300 ea) or % of closed revenue. 30 calls/mo = $9k from one client; client happily pays because 25 calls -> ~$250k potential revenue.
How we apply itOnce he can prove booking volume, shift lead-gen clients to per-call pricing to break the hourly ceiling. Only target high-ticket niches where the math obviously works for the client. Run multiple clients simultaneously since AI does the heavy lifting.
Ideal-client-profile qualification / niche selectiondurablerelevance 4/5
What it isDon't sell to anybody — filter to businesses where the pain is quantifiable in dollars: high inbound-call volume, high-ticket deals, existing email lists + purchase data, $500k-5M revenue with zero content, etc. Wrong niche = wasted effort.
How we apply itUse as a pre-bid filter: before building/pitching any showroom piece, confirm the target segment has dollar-quantifiable pain the offer removes. Prevents building offers that 'sound great but fall apart on cold traffic.'
Warm-outreach-first client acquisition (weeks 1-2)durablerelevance 4/5
What it isBefore any cold outreach, message 50-100 people you already know with a low-pressure ask: 'Do you know anyone who runs a [ideal business] that might want to never miss another call / automate email marketing?' You're asking for intros, not a sale. ~30% say 'maybe me' or intro someone; aim to close 1 client in 2 weeks. Fastest proof, highest conversion, builds pitch confidence + first testimonials.
How we apply itEven though he sells on Upwork, run this in parallel to farm his first case studies/testimonials fast (his stated need to get to $45/hr and build reviews). $0 cost, 2-3 hrs total.
Discovery-call pain-quantification frameworkdurablerelevance 4/5
What it isOn the call: ask about current situation, identify pains, QUANTIFY the pain in real dollars (what it's costing them now), make them feel the cost of not solving it, then offer to build a demo / show the solution. Get them on the phone ASAP after they reply — momentum matters.
How we apply itScript for any client call: convert vague interest into a dollar figure (missed-call value, abandoned-cart revenue, hours of exec content time) so the price reads as a bargain vs the loss. Pairs with his tracker page to show ongoing quantified ROI.
E-commerce email + SMS retention system (Klaviyo)durablerelevance 3/5
What it isSet up foundational automated flows (welcome, abandoned-cart, post-purchase/review, win-back at 60-90 days) = +15-25% revenue immediately; then weekly broadcasts + SMS (98% open vs 20% email). AI writes all copy from product catalog + brand voice + past performance; segment by purchase history. Target Shopify/Woo brands doing $50k-500k/mo with 5k+ list.
How we apply itA concrete, fast-ROI productized offer (results in week 1) he could add as a showroom piece. Setup $2-4k + few-k/mo (scale to $8k for bigger stores). Client usually already pays for Klaviyo. Easy retention because ROI is directly visible in their revenue.
Commit to ONE offer for 90 daysdurablerelevance 3/5
What it isDon't build end-to-end everything or run all 5 models — pick one matching your skills/personality, commit 90 days, focus on SALES not system-tinkering. Overbuilding is the #1 time-waster.
How we apply itCounter-weight to his tendency to build 10 showroom pieces at once — focus messaging says pick the single highest-fit offer (AI receptionist/agent, matching his Claude-agent + data-layer strength) and drive it to first paid revenue before diversifying.
Tools mentioned: Claude, ChatGPT, Clay.com, LinkedIn Sales Navigator, Fireflies (transcription), Klaviyo, ClickFunnels, GoHighLevel, Shopify, WooCommerce, Apollo (mentioned as what NOT to use), Facebook Ads, Google Ads, Local Service Ads
⚠ Verify:
  • AI cold email with per-prospect personalization gets 10-20% reply rates vs 1-3% for generic
  • Email should generate 25-40% of e-com revenue but most brands only get 10-15%
  • SMS has ~98% open rate vs ~20% for email
  • AI phone systems close 30-40% of calls, often better than human staff
  • Abandoned-cart + core flows lift e-com revenue 15-25% immediately
  • One content person can service 8-10 clients at ~4-6 hrs/mo each
21The New Way To Build A Startup
Garry Tan / Y Combinator (YC founder-interview style essay)  ·  7 techniques
SummaryLean "20x companies" beat far larger incumbents by automating ALL internal functions (code, support, sales, marketing, hiring, QA, billing) with AI agents/teammates — not just one or two — letting tiny teams postpone hiring, keep payroll/culture tight, and outgrow rivals. Three concrete automation patterns: (1) an internal AI teammate that operates the whole product, (2) a unified AI-integrated source-of-truth interface, (3) custom per-employee agents built from documented manual tasks.
One-lineLean "20x companies" out-build incumbents by automating ALL internal functions — 3 patterns: internal operator agent, unified source-of-truth interface, per-employee custom agents.
Internal AI teammate that operates the whole product (GigaML 'Atlas')durablerelevance 5/5
What it isA single internal agent that can use browsers, edit policies, write code, and do anything a human op would inside the product — absorbing all customer boilerplate/integration work so each engineer's scope doubles/triples and one human FTE can service dozens of enterprise accounts.
How we apply itSell 'internal operator agent' builds: a Claude+FastAPI agent over the client's own tools (browser use, DB writes, policy/config edits) that eats the repetitive account-onboarding/integration work. Position as 'lets you service 10x accounts with one operator.' Directly reuses his data-layer + agent stack.
Unified AI-integrated source-of-truth interface (Legion Health)durablerelevance 5/5
What it isOne custom internal interface that pulls patient history, scheduling, insurance codes, messages etc. into fingertip reach for the whole ops team, so nothing gets lost across fragmented channels. Let them 4x patients/revenue with flat ops headcount (one clinical lead, one support, one billing).
How we apply itThis is his exact wheelhouse — a cross-data RAG+SQL interface (like his Desert Glow Concierge Agent). Package as a productized offer: 'single source of truth ops console' unifying a client's siloed systems. Lead the pitch with the ROI: scale revenue without adding ops headcount.
Custom per-employee agents from documented tasks (PhaseShift)durablerelevance 5/5
What it isAsk each employee to document exactly what they spend their day doing, then build quick, narrow AI agents for those specific manual tasks. Culture of relentless automation lets them delay hiring whole functions (12 people vs 100s).
How we apply itA repeatable discovery-to-delivery method: run a 'what do you do all day' audit with a client's team, then ship small targeted agents per workflow. Turns one client into many small billable agent builds and recurring work; also his own internal ops model.
Automate every internal function, not just one or twodurablerelevance 4/5
What it isThe differentiator isn't automating code or support alone — it's building automation across ALL functions (code, support, marketing, sales, hiring, QA, billing) so each employee is orders of magnitude more powerful and hiring/payroll stays flat.
How we apply itFrame proposals around breadth: don't just pitch a chatbot, pitch a roadmap of agents covering multiple functions. Gives natural expansion/upsell path after landing the first small job and farming reviews.
ROI framing: postpone hiring / flat headcount as the selldurablerelevance 4/5
What it isEvery case study leads with the same outcome — delay hiring entire departments (design, sales, ops, billing), keep payroll down and culture from drifting, while growing 4x. Leanness is the superpower.
How we apply itWrite proposals/landing copy in this language: 'avoid hiring a $X/yr ops/support/design hire' quantifies the agent's value far better than feature lists. Ties automation spend to a concrete salary avoided.
Run multiple Claude Code instances in parallel per humandecayingrelevance 3/5
What it isAnthropic's own devs each manage 3–8 Claude instances implementing features, fixing bugs, and researching; humans meet only for foundational architecture/product decisions. Claude effectively builds Claude.
How we apply itAdopt a parallel-agent workflow for his own delivery to move faster on Upwork builds (more throughput = more jobs/reviews). Also a credibility talking point when pitching agent-driven teams.
Use AI design tools to skip a design hire (Magic Patterns)decayingrelevance 3/5
What it isPhaseShift avoided hiring any designer by using Magic Patterns; their engineers build all front-end designs with it.
How we apply itAdd an AI front-end/design tool (Magic Patterns / v0-style) to his stack so he can ship polished client UIs solo without a designer — relevant to his showroom pieces and client front-ends.
Tools mentioned: Claude Code, Magic Patterns
⚠ Verify:
  • GigaML closed DoorDash and 10+ Fortune 500 pilots with ~4-5 engineers and a single human FTE via its 'Atlas' agent
  • Legion Health grew 4x patients/revenue in a year with no net new hires (one clinical lead, one support, one billing person)
  • PhaseShift is a 12-person team competing against companies with hundreds of employees since 2006, using per-employee agents
24Why Ambitious Startup Ideas Are Actually Easier To Sell
Y Combinator (interview with James Hawkins, co-founder/CEO of PostHog)  ·  14 techniques
SummaryInstead of building narrow point-solution tools, target an actual job that already exists inside a company and automate it end-to-end with an AI loop that ingests all available data and produces real deliverables (PRs, resolved tickets); ambitious "do-the-whole-job" offers are easier to sell, market, and win than incremental features.
One-linePostHog's James Hawkins (YC): automate a whole existing job with a recursive AI loop, sell the ambitious version, and win on gluing the model to the use case — not on the model itself.
Target an existing job, not a missing featuredurablerelevance 5/5
What it isRather than inventing a novel product or replacing a slice of software, identify a job already being performed inside a company (product management, support triage, QA) and build something that does that whole job to a higher standard. PMF is near-certain because the work already exists and is already paid for.
How we apply itScreen every Upwork job post and client business by asking 'what recurring human job is this?' Pitch to automate the whole job (e.g. 'your support team's first-response triage', 'your PM's user-feedback synthesis') not just a chatbot feature. Frame proposals around replacing/accelerating a named role's workload with a RAG+agent system on his Claude/FastAPI/Postgres stack.
The value is gluing the model to the use case, not the modeldurablerelevance 5/5
What it isModels (he cites GLM 5.2) are already far past the capability needed for most business value. The hard, valuable part is wiring the LLM into the workflow: giving it tools, letting it send emails, run analytics, instrument products, act on data. That integration gap is where startup/service opportunities live.
How we apply itPosition himself as the person who does the gluing — tool-use, function calling, data-layer plumbing, action-taking agents — not model selection. This is exactly his 'owns the data layer' USP. Sell integration/orchestration on top of whatever model, and don't over-index on which model in proposals.
Self-contained recursive AI loop architecturedurablerelevance 5/5
What it isTake input data, feed it to an AI with a set of rules/policies, have the AI act on the world, observe the impact, and iterate. Add more data types over time (support tickets, session recordings, logs/errors, Slack, video clips, meeting transcripts, AI trace data) to enrich the loop. Humans supervise by writing the rulebook and unblocking the agent.
How we apply itDesign agent deliverables as closed loops, not one-shot bots: ingest client data -> agent proposes/acts -> measure outcome -> feed back. Architect for pluggable data sources so he can add ticket data, call transcripts, logs later as upsells. Fits his RAG + agent + Postgres stack directly.
Split-brain: max ambition vision + next practical ship this weekdurablerelevance 5/5
What it isHold the most ambitious version of the idea in your head (Sam Altman mode) while simultaneously directing the actual work to the smallest concrete step shippable today/this week. The more ambitious the idea, the MORE important shipping small increments is, because ambitious plans are likelier to go wrong.
How we apply itFor each project, articulate the grand vision to the client but break delivery into weekly shippable milestones (his iteration process already does 5-6 rounds). Ask internally 'when can we launch this / how can we launch sooner?' as the first question on every ambitious build.
Human role shifts to 'philosopher/configurer' of the agentdurablerelevance 4/5
What it isWhen you automate a job, the human doesn't get replaced — they move up to writing the manual, defining rules and policies, iterating and improving the agent. Sold as augmentation ('supporting the agents to do their job'), which is more palatable to clients.
How we apply itNeutralize client fear of job loss in proposals: frame agents as tools their staff configure and supervise. Deliver a 'rulebook/policy config' layer (editable prompts, guardrails, escalation rules) as part of every agent build — both a selling point and a natural retainer/iteration engagement.
Ambitious offers are easier to sell and marketdurablerelevance 4/5
What it isIn saturated markets the only marketing job is standing out. Remarkable (bigger, bolder) offerings get remarked upon and generate word-of-mouth; narrow point solutions blend in. Ambition also makes hiring and fundraising easier because it attracts strong people and the right buyers.
How we apply itWrite proposals and showroom pieces around a bold outcome ('a self-improving support system that closes tickets') rather than a commodity deliverable ('I'll build a chatbot'). Make each showroom piece remarkable enough to be talked about. Lean into ambition as differentiation in a crowded AI-freelancer market.
Treat go-to-market / website as a productdurablerelevance 4/5
What it isMost people obsess over the product then copy-paste their GTM. Instead treat the website and marketing as products: define use cases, user profiles, who's showing up and why. PostHog got early traction by doing non-product things better (clean site, real pricing, self-serve signup, credit card + free tier) while the actual product lagged competitors.
How we apply itApply product thinking to his own showroom sites and to client deliverables: define visitor profiles and use cases for each landing page. Win against competitors on the buying experience (transparent pricing, instant self-serve, clean design) even before product parity. Reinforces his client-branded progress tracker as a GTM asset.
Enter busy markets and win on standing outdurablerelevance 4/5
What it isGoing into a crowded market is underrated: demand already exists and buyers are already educated, so the entire marketing challenge collapses to differentiation. PostHog's competitors all had blue websites, jargon, and pricing pages with no pricing — being visibly different (branding, personality, developer-first audience) was enough.
How we apply itDon't avoid crowded Upwork categories (chatbots/automation); differentiate hard on brand, clarity, and buying experience. Study competitor sameness (blue sites, jargon, hidden pricing) and deliberately break the mold in his own showroom brands (Ayuvara, KalEdge etc.).
Validate ideas by taking many fast, committed shotsdurablerelevance 4/5
What it isPMF luck = number of shots x quality of each shot, with diminishing returns on quality. Set weekly learning goals ('can we get ONE user in production' not '20K MRR'), commit fully to each idea, but abandon fast when you keep hitting the same wall (can't get meetings, can't get production use, can't get paid).
How we apply itRun showroom pieces and offer experiments as fast committed shots with weekly learning goals (one real interested lead, one demo request). Kill an angle when it repeatedly fails the same test; don't polish a dead idea. Volume of well-executed attempts beats perfecting one.
Capture the 'why/intent' before the technical specdurablerelevance 4/5
What it isCurrent AI harnesses jump to technical questions (which database?) but skip the product questions a good engineer asks first: why build this, who's it for, what's special. PostHog is building a harness/desktop tool to grab intent data from the operator as they prompt, so the agent optimizes toward a goal, not just requirements.
How we apply itBuild an intent-capture step into his agent/RAG deliverables and his own client intake: before coding, elicit why/for-whom/what's-special and store it as the optimization target and system context. Differentiates his builds from generic 'prompt-to-app' output that lacks product judgment.
Price as a value signal / willingness-to-pay testdurablerelevance 3/5
What it isPostHog learned that inability to raise price on a customer signaled they didn't truly value the product. Full in-person commitment to each sale removed excuses ('they were distracted') so failure to close or raise price was clean signal about real value.
How we apply itUse price resistance as a diagnostic: if a client won't move up in price, the offer isn't delivering perceived value — fix the offer, don't discount. Test raising rates ($45/hr -> higher) on clients who value the work; resistance tells him where value is thin.
Over-commit to the sale so signal is cleandurablerelevance 3/5
What it isPostHog took multiple trains and a bus to win a $300/mo customer, spending roughly the contract value to get there — because phoning it in produces noisy signal. Full effort means a lost deal is a real 'no', not a preventable one.
How we apply itOver-deliver on early/small jobs to farm reviews (already his 11th-move strategy). Treat first paid clients as investments where effort exceeds pay, so any failure is genuine signal and any success compounds into reviews and referrals.
Deprogram downside-thinking; optimize for 'what if it works'durablerelevance 3/5
What it isStartups are default-screwed, so it's all upside — you can only lose 1x but win 1000x. Strong buyers/investors focus on 'what if it all works out.' European/risk-averse instinct asks 'what if it fails / what will people think'; that instinct must be actively unlearned.
How we apply itWhen choosing projects and pitching, weight asymmetric upside (a bold build that could become a repeatable product/catalog listing) over safe incremental gigs. Pitch the ambitious vision to clients, not the cautious minimal version. Applies to his own build-vs-safe-job decision.
Co-lead + role-swapping to fight boredom and gapsdurablerelevance 2/5
What it isTwo co-CEOs split domains (one all-in on AI/product, other on finance/hiring/sales) and periodically swap roles — swapping restored energy 'like a new job' and covered the anxiety each felt about the area they weren't running. Do work that fits what you want + what you're good at; drop the rest.
How we apply itSolo-founder takeaway: consciously rotate focus areas to avoid burnout, and offload/automate the domains he dreads (use agents for the finance/ops grind) so he stays on the high-leverage, fun work. Guards against the 'killed myself doing day-to-day' failure the interviewer described.
Tools mentioned: GLM 5.2 (LLM), Slack (data source/signal), pull requests / GitHub (agent output), session recordings, desktop intent-capture tool, AI trace data
⚠ Verify:
  • Models like GLM 5.2 are already 'super adequate' for most internal business work, making integration the bottleneck rather than model capability
  • PostHog's support product had ~1100 companies using it at time of recording
  • A meaningful chunk of PostHog's own pull requests are now auto-generated by their AI loop
  • YC has invested in ~7000 companies and ~90% of total returns come from ~5 companies

Market intelligence & content

08Grok 4.5 is a bigger deal than Fable 5
Greg Isenberg (The Startup Ideas Podcast) w/ Nick from Orgo  ·  12 techniques
SummaryStop framing AI agents as "automation"; treat a tool-connected agent as a co-founder/AI employee. The real leverage is a productized, vertical-specific "managed AI employee" agency—narrow offer, one weekly deliverable, high monthly retainer—not per-model hype.
One-lineProductize a vertical 'managed AI employee' (one weekly artifact, paid-pilot -> $2.5–6.5K/mo retainer) on an over-connected, always-on cloud agent—not another per-model hype cycle.
Managed AI employee, sold per-vertical at agency pricesdurablerelevance 5/5
What it isInstead of selling a generic $200/mo prosumer agent, package a vertical-specific agent (HVAC, home services, agencies) with prompts/skills/tools pre-configured, and charge $5K/mo because you solved their problems up front. Framed as 'the 2013 Facebook-ads-agency moment' repeating for AI employees.
How we apply itThis IS Abdi's Labor Marketplace / Showroom playbook. Pick ONE vertical from a real Upwork ad, pre-build the RAG+agent stack on Claude/Azure/FastAPI, and pitch it as a managed monthly seat rather than an hourly build. Lets him escape $45/hr into recurring retainer territory.
Sell ONE weekly artifact / one employee role, not 'AI in general'durablerelevance 5/5
What it isThe agent's own advice: 'Do not sell AI employees in general. Sell one weekly artifact.' Pick one narrow role (e.g. a client-reporting employee for agencies) that produces a weekly visible, live-demoable deliverable that maps to a known client pain.
How we apply itScope every Upwork proposal to one concrete recurring artifact (a weekly market report, a lead-qualification summary, a reconciliation doc) instead of a vague 'AI agent.' Easier to price, demo, and over-deliver on for review-farming.
Concrete productized-agent pricing ladderdurablerelevance 4/5
What it isThe demo agent auto-generated a real pricing page: 14-day pilot $1,500 one-time, $2,500/mo single managed seat, $6,500/mo for three seats, with a 'book a pilot' CTA and lead-qualification flow.
How we apply itDirect pricing anchors for Abdi's Project Catalog / showroom offers. Structure as paid pilot -> monthly managed seat -> multi-seat tier. The paid pilot de-risks the client and gets him off pure hourly.
Client-reporting agent as the wedge deliverabledurablerelevance 4/5
What it isThe recommended first pilot role: a 'client reporting employee' for agencies producing a weekly visible deliverable, live-demoable. Chosen because it maps to a real agency pain and is trivially demoable.
How we apply itAligns exactly with Abdi's mandatory client progress-tracker standard. A weekly auto-generated client report (RAG over the client's own data + a branded page) is a low-risk wedge that then justifies deeper agent work.
Context-is-king: over-connect the agent to tools/connectorsdurablerelevance 4/5
What it isCore repeated point: don't be shy about tools. Give the agent email, phone number, payment card, knowledge base/memory (Obsidian), and many app connectors. The 'magic' emerges only when the agent can reach many tools and chain them (e.g. VidIQ outliers + YouTube channel context -> tailored thumbnail).
How we apply itFor agent builds, wire in the client's actual data sources and action tools early rather than a single API. Abdi 'owns the data layer'—this reinforces selling breadth of grounded context/connectors as the differentiator, not the model choice.
One-click connector layer (Composio) instead of hand-wiring integrationsdecayingrelevance 3/5
What it isUses Composio to one-click connect an agent to many SaaS tools (Gmail, YouTube, Google Docs, search tools like Exa/Perplexity), then hands the single Composio connector to the agent so it inherits all of them.
How we apply itEvaluate Composio as a fast integration layer to cut build time on client agent projects that need many SaaS hookups—faster delivery = more review-farming jobs. Weigh against his default FastAPI+direct-API stack per job.
Cloud-hosted always-on agents (not local)durablerelevance 3/5
What it isRun agents on a cloud computer so they stay reachable when your laptop is off; you can text them via terminal/Telegram/iMessage. Orgo is pushed, but named alternatives are generic cloud VMs (Hostinger, Hetzner).
How we apply itAbdi already deploys on Azure—reinforces that client agents should live on always-on cloud infra with a messaging entry point (Telegram/email), which is a sellable reliability point in proposals.
Agent observability that detects failure AND user frustrationdurablerelevance 3/5
What it isUses a tool (Latitude) that flags when the agent is failing or when the user is getting frustrated in chat, signaling 'add this capability / fix this use case.'
How we apply itBake observability into deliverables: log agent failures and frustration signals so you can proactively improve and show the client a metrics-backed tracker. Differentiates a 'managed' seat from a one-off build. (Abdi has App Insights banked for this.)
Parallel multi-session agent operationdurablerelevance 3/5
What it isSpin up 5 terminals against the same agent so one works the landing page, one finds content ideas, one makes the thumbnail, etc.—parallelism instead of one blocking session. Also: one master agent that can spin up new pre-configured agent instances on demand.
How we apply itDeliver client agents that fan out subtasks in parallel and can self-provision workers; sells throughput. Practical pattern for his own delivery speed too.
Build vertical MCP servers where LLMs lack domain contextdurablerelevance 3/5
What it isStated opportunity: LLMs lack vertical-specific context, so there's an MCP-after-MCP land grab (design MCP, business-building MCP, etc.). 'What do we need context in that you could build an MCP for?'
How we apply itAbdi owns the data layer—building a niche MCP server (e.g. for a client's proprietary data/domain) is a defensible productized offering and a differentiator vs generic prompt-jockeys.
The efficiency paradox (cheaper/faster model => you spend more, not less)durablerelevance 3/5
What it isFaster+cheaper models don't cut your bill; you just do 8x more work in the freed time, so token spend rises but output rises far more. Also: build agents now so future model upgrades give free overnight capability gains ('ride the wave').
How we apply itBudget/scope framing for clients: sell the throughput gain, not a lower bill. And architect model choice as swappable so a client stack auto-improves on the next model—a maintenance/retainer selling point.
Content-engine loop: outlier analysis -> thumbnail -> publish via chatdecayingrelevance 2/5
What it isAgent uses VidIQ to find outlier videos in a niche, generates on-brand thumbnails using the creator's face/channel style, drafts transcripts, and can publish—all triggered by a Telegram message.
How we apply itReusable pattern for a client marketing-agent deliverable, and for Abdi's own showroom/faceless-video marketing pipeline. Fits his ElevenLabs/Kling/CapCut content stack.
Tools mentioned: Orgo (cloud agent computers), Hermes / OpenClaw (agent harnesses), Composio (one-click SaaS connectors), Idea Browser MCP, VidIQ, Latitude (agent observability), agent mail / agent phone / agent card, XMCP (X/Twitter MCP), Exa search / Perplexity search, Telegram / iMessage agent interface, Obsidian (memory/knowledge base), Linear, Google Docs
⚠ Verify:
  • Model names Grok 4.5, Fable 5, Opus 4.8, GPT 5.6 Sol, Meta Spark 1.1 appear fictional/garbled — verify actual current model landscape before quoting
  • Claim that Grok is ~1/10th the cost and 10-15x faster than 'Fable' — unverified marketing
  • Claim a Maltbook-style 'social media for agents' was acquired by Meta within a week
  • $300/mo 'super Grok' plan and $200/mo AI-employee framing — pricing unverified
  • Composio/Latitude/Orgo capabilities are pitched by an interested co-founder — verify independently before adopting in client stack
15Inside Anthropic, the $965 Billion AI Juggernaut — The Circuit
Bloomberg — The Circuit (Emily Chang)  ·  6 techniques
SummaryA magazine-style profile of Anthropic's Amodei siblings; low on tactics, but confirms Claude Code writing ~100% of internal code, parallel multi-agent Claude workflows, deliberate "professional warmth" persona design, and enterprise-over-consumer positioning as durable signals for a builder like Abdi.
One-lineAnthropic profile — signal for builders: parallel multi-Claude coding workflows, 'professional warmth' persona + constitution design, enterprise-over-consumer positioning.
Parallel Claude Code agents (orchestrate many, not one)durablerelevance 4/5
What it isBoris Cherny (creator of Claude Code) describes talking to one Claude while it codes, then a second, running 'a few Claudes' up to 'a few thousand Claudes' simultaneously on different tasks. Internally Claude writes almost all of the code; for his own work, 100% for 6+ months.
How we apply itStop treating Claude Code as a single chat. Fan out work: while one agent scaffolds the FastAPI/Postgres data layer, spin up parallel agents for tests, the Stripe/SendGrid wiring, and the client progress-tracker page. This is the concrete way to hit the fast delivery you already pitch on Upwork. Bank it as a standard delivery workflow across showroom builds (Ayuvara etc.).
'Professional warmth' as a persona spec for chatbotsdurablerelevance 3/5
What it isAnthropic deliberately tunes Claude's character to feel 'approachable but distant' — professional warmth, not best-friend, not cold/calculating. Described as tuning a dial between over-cautious (nannyish 'I'm concerned about you' for a weather query) and rote.
How we apply itMake persona an explicit, written deliverable in every client chatbot/RAG build (Desert Glow Concierge, Ayuvara). Give each bot a one-paragraph character brief and a tone dial, then test edge cases for over-refusal/over-warning. Sell 'we design the assistant's character, not just its answers' as a differentiator.
Anchor model behavior to a written constitution / founding documentsdurablerelevance 3/5
What it isClaude is trained against a 'constitution' of principles, drawing on sources like the UN Declaration of Human Rights and cross-religion shared values to define character, and to suppress hallucination ('lying') and harmful output.
How we apply itFor client agents, write an explicit principles doc (allowed/forbidden behaviors, tone, refusal rules, hallucination guardrails) and load it as the system prompt backbone. Turns 'we set some rules' into a documented, auditable artifact clients can review — good for regulated verticals (med spa, health).
Enterprise/coding over consumer engagement — pick the aligned business modeldurablerelevance 3/5
What it isAnthropic's profitability came from lucrative business tools (Claude Code, Claude Cowork) rather than splashy consumer apps; Dario frames consumer/social as an attention-addiction/ad model that conflicts with building genuinely useful tools.
How we apply itReinforces Abdi's own positioning: sell B2B outcome tools (RAG, automation, data-layer ownership) to funded businesses rather than chasing consumer app novelty. Bias the showroom pieces toward enterprise/SMB workflows that save labor, not engagement-maximizing apps.
Target the verticals AI is actually adopting (Anthropic Economic Index)decayingrelevance 3/5
What it isAnthropic published a paper estimating which fields will make most use of AI near-term — management, finance, and legal flagged as jobs that could soon look very different.
How we apply itUse as a lead-targeting filter: prioritize Upwork jobs and showroom niches in management ops, finance, and legal document/automation work, where buyers already feel AI pressure and have budget. Pull the actual Economic Index dataset to name specific high-adoption tasks in proposals.
Coding agents build full apps in minutes (delivery-speed proof point)durablerelevance 2/5
What it isLive demo: 'make a recipe app that suggests meals for the week' — Claude Code builds a working, clickable app in a few minutes; what used to take hours or days.
How we apply itConcrete demo pattern for sales: on a discovery call or in a proposal video, build a small working slice of the client's actual product live/near-live to prove speed and de-risk the engagement. Mirrors his showroom-piece strategy.
Tools mentioned: Claude, Claude Code, Claude Cowork, Anthropic API, Palantir Maven Smart System
⚠ Verify:
  • Boris Cherny led Claude Code and Claude Cowork development and was hired by Anthropic in 2024
  • Anthropic engineers run from a few to a few thousand parallel Claude agents; Claude writes ~100% of some engineers' code
  • Anthropic API volume up ~17x year-over-year; 8 frontier models shipped in 12 months; ~80x annualized Q1 growth
  • Anthropic published an Economic Index paper flagging management, finance, and legal as high AI-adoption fields
  • Claude Cowork release coincided with ~$285B software market-cap drop ('SaaSpocalypse')
22The ONLY Affiliate Marketing Tutorial You Need: Step By Step with AI
Unnamed affiliate-marketing YouTuber (software-niche blogger since 2019, PartnerStack top affiliate; likely a channel like "Income School"-adjacent / solo AI+SEO educator selling a free masterclass + prompt pack)  ·  10 techniques
One-lineAI-assisted affiliate marketing: target low-competition hobby niches with deep product catalogs, mass-produce SEO 'best-of' roundups with Claude, then win by humanizing with real testing, photos, and recurring-SaaS commissions.
Humanize AI content to beat commodity output (moat)durablerelevance 5/5
What it isCopy-paste AI content doesn't rank because everyone can make it and it adds nothing. Differentiate: real first-person testing claims ('I tested these 5 paddles, I've played 10 years'), original photos of yourself using products (spend one day shooting hundreds), unique comparison criteria per niche, and an 'editor-in-chief' editing pass. This is the durable edge over pure-AI competitors.
How we apply itCore principle for ALL his AI-generated deliverables (his own showroom sites and client work): the value is the human/data layer on top of commodity generation. Positions his services above cheap 'I'll ChatGPT it' freelancers — same logic as 'owns the data layer.'
Niche selection by product-catalog depth + low keyword competitiondurablerelevance 4/5
What it isPick a niche not by passion alone but by how many distinct products it contains (like an Amazon category) AND low SEO competition. Avoid health/finance/software/electronics (high comp); target hobbies/outdoors like hiking, pickleball, lawn care, archery, coffee, prepping, parenting. Validate with a keyword tool (KeySearch) searching 'best + [product]' and checking difficulty scores (~40s = low-to-mid = winnable).
How we apply itReframe as a paid 'niche + keyword validation' service or a client deliverable: build a FastAPI+Postgres pipeline that pulls a niche, enumerates its product sub-categories via Claude, scores each 'best+product' keyword against a keyword-difficulty API, and returns a ranked opportunity map. Sells as market-research automation to affiliate/e-comm clients — leverages his data-layer positioning.
SEO/AI-optimized outline+draft generator promptdurablerelevance 4/5
What it isSecond prompt takes a target keyword and outputs a full SEO-structured article: keyword-front-loaded intro, H1, 6-8 H2 top-pick sections, 'how we tested' section, meta description, semantic keywords, conclusion — then can write each section on demand. Claim: good AI-SEO = good SEO, so the same structure ranks in both Google and AI answers.
How we apply itDirectly reusable as a Claude-driven content-drafting microservice. The structured-outline-then-section-fill pattern is a solid agent design he can implement (outline node → per-section generation node) and sell as SEO content automation.
Affiliate networks vs. keyword-first strategydurablerelevance 4/5
What it isTwo networks named — PartnerStack (SaaS/software programs, up to 30% recurring 12mo) and Impact (broad: beauty, courses, insurance, travel, 100+ programs per category). Recommended approach = keyword/niche-first (build real brand, find programs later) over program-first. Each program gives a unique tracked link + reporting + PayPal/Payoneer payout. Creator claims $1.29M lifetime from PartnerStack alone (mostly recurring SaaS commissions).
How we apply itDirectly relevant to his own affiliate-business memory project: recurring SaaS commissions (PartnerStack) is the highest-leverage model given he already builds on SaaS tools. He can affiliate the exact stack he uses (Webflow, ConvertKit, Surfer SEO, etc.) and write authentic reviews.
Two content types per site: informational + transactionaldurablerelevance 3/5
What it isEvery affiliate site is just how-to/info content (how to swing a golf club, watercolor for beginners) plus transactional 'best X' roundups with affiliate links. Big sites run 90-95% informational content to build topical authority (Google E-E-A-T) that lifts the money pages.
How we apply itUse as the content-architecture blueprint when he builds content sites or SEO tooling for clients: model each site as two linked content tables (info vs transactional) with internal-link graphs. Bake into a Claude content-generation agent that auto-classifies and interlinks the two types.
Transactional-article idea generator promptdecayingrelevance 3/5
What it isA reusable Claude/ChatGPT prompt: 'What sub-niche would you like to generate 20 best transactional affiliate articles for?' → returns 20 'best [product]' article ideas, surfacing non-obvious products (bear canisters, satellite communicators, noise-reducing pickleball paddles) that reveal catalog depth.
How we apply itPackage as a stored, parameterized prompt template in his content pipeline. Generalizes to any client vertical for content-calendar generation — a concrete reusable asset for content-automation gigs.
Skimmable, click-fast roundup layoutdurablerelevance 3/5
What it isDesign money articles so readers skim and click out fast (counterintuitive): identical repeating product blocks (image, pros/cons list, short paragraph, affiliate button/text link), consistent per-niche comparison criteria, first-mention text links. Goal is click-and-leave, not long dwell time — that's when commissions happen.
How we apply itTemplated component pattern for any content/affiliate site he builds — reusable React/HTML product-card component fed from a Postgres product table. Concrete UX spec he can ship.
Publish-first, monetize-later sequencingdurablerelevance 3/5
What it isWhen starting, don't insert affiliate links yet — publish high-quality content fast, add links only once pages generate traffic. Link-insertion time is better spent scaling content. Manage/swap links at scale later with ThirstyAffiliates (centralized link management, one-place updates) and Easy Table of Contents plugin for WordPress.
How we apply itSequencing principle for his showroom builds: ship content/traffic first, bolt on monetization once validated — avoids premature optimization. ThirstyAffiliates-style centralized link table is a clean data-layer pattern (single source of truth, update-once-propagate-everywhere) he can replicate in his own stack.
Broad-name domain + WordPress + 20-50 article game plandurablerelevance 3/5
What it isConcrete launch plan: spend 1-2 weeks choosing niche with AI brainstorm + light keyword research; buy a broad (non-pigeonholing) domain or use your own name; build on WordPress (AI now handles theme/design); publish 20-50 genuinely-good AI-assisted+human-edited articles on a consistent schedule; then expand to one social channel (Pinterest/Instagram/YouTube). Quality of the right articles > hundreds of generic ones.
How we apply itReady-made project checklist for spinning up his own affiliate showroom piece or a client's content site. The 20-50 curated-articles benchmark is a scoping number he can quote.
Layer ad-network revenue on top of affiliatedurablerelevance 2/5
What it isMature sites stack display ads (Mediavine mentioned) over affiliate articles for a second revenue stream, and the biggest sites (Epic Gardening) add YouTube + their own e-commerce/drop-ship shop — evolving from affiliate blog into a multi-channel brand.
How we apply itMulti-revenue-layer thinking for any content asset he owns or builds for clients: affiliate + display ads + owned product. Informs the business model of his own showroom/affiliate pieces.
Tools mentioned: Claude, ChatGPT, KeySearch (keyword research), PartnerStack (affiliate network), Impact (affiliate network), WordPress, ThirstyAffiliates (link management plugin), Easy Table of Contents (WordPress plugin), Mediavine (ad network), Amazon Associates, PayPal, Payoneer, Surfer SEO, Pinterest / Instagram / YouTube
⚠ Verify:
  • Creator claims $1.29M lifetime affiliate commissions from PartnerStack alone, ~$18-34k/month recent withdrawals
  • PartnerStack SaaS programs pay up to 30% recurring for the first 12 months
  • 'Best + product' keywords in hobby niches (hiking, pickleball) score ~40s difficulty = low-to-medium competition
  • Claim that copy-paste unedited AI content ranks poorly while human-differentiated content ranks — general SEO assertion, not proven in-video
  • Claim 'good AI SEO is good SEO' (same structure ranks in Google and AI answers)
23Using AI Tools (Manus, FreePik etc) to Create Viral IG Reels
Kova (guest) on Greg Isenberg's Startup Ideas Podcast  ·  10 techniques
SummaryA viral short-form creator (Kova) walks through her exact AI stack: use Manus (agentic, actually runs scripts/parses video) to reverse-engineer any creator's video into a reusable style guide + five-act script structure; use Freepik + Nano Banana Pro to AI-edit real footage backgrounds (add props/lighting) to lift retention; use Freepik video gen (Seedance/Kling) with start-frame+end-frame for impossible transitions; and use Obsidian + Claude Code/Cursor with documented templates and a personal style guide to systematize content production at scale.
One-lineKova's AI reel stack: Manus reverse-engineers any video into a style guide; Freepik/Nano Banana re-dresses real footage; Obsidian+Claude Code systematizes production.
Manus as a competitor-video reverse-engineering agentdurablerelevance 4/5
What it isFeed Manus a link/upload of an admired creator's video and prompt: 'I really like the style and story of this video. Break it down into style + aesthetic keywords, transcribe the script and separate into story sections, then give me a replication plan.' Manus actually runs scripts to download/parse/transcribe rather than guessing, and outputs a full style guide (typography tiers, lighting, B-roll types, five-act script structure, music BPM/texture, post checklist).
How we apply itTurn this into a productized 'brand/content teardown' deliverable. For any client with a competitor or reference account, run Manus to auto-generate a style-guide + shot-list + script-structure doc. Same agentic pattern (agent runs real tools instead of hallucinating) is exactly what Abdi sells: build client-facing agents that parse real assets (video, docs, data) and emit structured artifacts. Prefer this reliability framing when pitching agents that 'do the task granularly, not make assumptions.'
Obsidian + Claude Code/Cursor as a content production systemdurablerelevance 4/5
What it isKeep every project as markdown files in an Obsidian vault with reusable templates (storyboard template, editor-facing storyboard template, personal 'CovaCut' style guide). Open the vault in Claude Code/Cursor and issue file-level ops: 'turn this script into my storyboard template', 'do a first pass following my style guide', 'restructure my projects using this folder nomenclature'. Cursor+Claude is faster for these; the agent indexes files, converts one file type to another, and does bulk restructuring.
How we apply itStrongest transferable idea: files + documented templates + a coding agent = scalable, automatable systems. Abdi can (a) run his own client-delivery ops this way (project templates, style guides, doc conversion), and (b) sell it as a service — 'systematize your content/ops in a file-based vault an AI agent can execute against.' Ties to his 'owns the data/document layer' positioning: structured files are the substrate the agent operates on.
Manus-to-Obsidian style-guide handoff loopdurablerelevance 4/5
What it isExport the Manus-generated style guide into Obsidian, hand-edit it, then let Cursor/Claude Code read and execute against it (e.g., fill a storyboard following the style guide). Closes the loop from research -> editable spec -> agent execution.
How we apply itA clean reference architecture: one agent generates a spec, human edits it, a second agent executes against it — all mediated by plain files. Reusable blueprint for RAG/agent deliverables where a curated, human-in-the-loop document drives downstream automation.
Put the burden of proof / planning on the AIdurablerelevance 3/5
What it isInstead of over-specifying, tell the agent 'I'm not exactly sure what I'm looking for — break it down overall and give me a plan for how I should replicate it.' Let the model produce the structure/vocabulary/moodboard.
How we apply itUse in discovery and spec-drafting: hand the agent messy client goals and ask it to produce the plan, taxonomy, or schema. Good pattern for RAG/agent projects where the client can't articulate requirements — the agent proposes structure you then refine.
AI background re-dressing of real footage (Freepik + Nano Banana Pro)decayingrelevance 3/5
What it isTake a single frame from a static talking-head shot, load into Freepik's image editor, select Nano Banana Pro, and use the annotate-on-image (visual/inpaint) feature to add props, plants, fairy lights, windows, bookshelves, RGB lighting. Keep prompts deliberately simple ('more flowers', 'orange tulips in a vase') to let the model output what it's naturally good at across multiple generations. Then mask the added elements over the moving footage in Premiere/CapCut; keep additions away from the body so movement doesn't reveal the fake.
How we apply itDirectly usable for the video/content pipeline in Abdi's showroom pieces and client ad creative — upgrade cheaply-shot footage to look premium without a studio. The durable principle: masking + generative inpainting to composite AI elements onto real footage. The retention argument (better sets -> higher watch time -> more algorithmic distribution) is a sellable business case for ad/reel deliverables.
Simple-prompt, multi-generation image workflowdurablerelevance 3/5
What it isKeep image prompts general on purpose and run several generations rather than crafting one hyper-specific prompt — simpler prompts push the model toward outputs it's reliably good at, and you pick the best of several.
How we apply itApply to any image-gen step (thumbnails, ad creative, hero images): batch cheap generations from short prompts, curate, rather than fighting one long prompt. Cost/quality heuristic for creative pipelines.
Start-frame + end-frame video generation for impossible transitions/hooksdecayingrelevance 3/5
What it isFor a transition, generate a clip in Freepik's video generator (Seedance Pro for audio, or Kling 3) by supplying a start frame and end frame, then a story-narration prompt. Two rules: (1) always explicitly state what the CAMERA is doing ('camera is static'); (2) avoid negatives like 'doesn't/not' — models parse keyword presence, not logical negation, so phrase everything positively. Stitch 3-4s clips together instead of hard cuts to preserve story; front-load the 'aha' shot in the first ~15s for retention.
How we apply itReusable video-gen craft for ad/reel deliverables. Durable principles: describe camera motion explicitly, use only positive phrasing in prompts, and use start/end-frame conditioning for controlled transitions. The 'first 15 seconds = retention = distribution' rule is a concrete spec to hold client video work to.
Prompt-editor step before video gendurablerelevance 3/5
What it isUse Freepik's 'prompt editor' to rewrite/optimize a rough description into a model-friendly prompt before spending a generation credit; reliably yields good output.
How we apply itGeneralize as a meta-prompting layer: add an LLM prompt-optimization pass in front of expensive generation calls (image/video) so paid jobs aren't wasted. Cost-control pattern for any generation pipeline Abdi builds.
Five-act / hero's-journey short-form script structuredurablerelevance 3/5
What it isReusable viral-video skeleton surfaced by the teardown: Hook (visual-first then verbal, one-sentence concept explainable in <10s with immediate visual payoff) -> Conflict/stakes (personal relatability) -> Build (3 numbered steps) -> Problem-resolution (too slow/too fast/just right comedic beat) -> Resolution + CTA/series hook. Plus a post checklist (vertical, product shown in first 3s, concept in first 10s, word-by-word captions, <75s runtime, lowercase casual caption ending in 'day one/episode one').
How we apply itA ready template for scripting client reels/ads and for the faceless-video pipeline in Abdi's playbook. The one-sentence-concept-with-visual-payoff rule and the checklist are concrete QA gates to apply to every video deliverable.
Differentiation-through-tooling positioningdurablerelevance 3/5
What it isAs creator culture fragments, differentiation matters more than raw scale, and being smart about the right AI tools is itself the differentiator — Kova's edge is AI-enabled artistry no one can easily replicate (e.g., deliberately hard-to-copy VFX composite shots).
How we apply itPositioning lesson for Abdi's Upwork brand: don't compete on generic 'I use AI'; make the specific tool-chain + a hard-to-copy signature deliverable (like his live client progress tracker + owning the data layer) the differentiator clients can't get elsewhere.
Tools mentioned: Manus AI, Freepik, Nano Banana Pro, Seedance (C-Dance) Pro, Kling 3, Adobe Premiere Pro, After Effects, CapCut, DaVinci Resolve, Obsidian, Claude Code, Cursor, Poke, OpenClaw / hosted OpenClaw, Pinterest (moodboard)
⚠ Verify:
  • Manus runs actual scripts/commands to download and transcribe a video rather than hallucinating, making it more reliable than Claude/ChatGPT/Gemini for video analysis
  • Instagram Reel links were broken for Manus at time of recording (agent-blocking); uploading a downloaded video file works as a fallback
  • Manus launched a hosted version of OpenClaw (in beta)
  • Nano Banana Pro is currently the strongest image-editing model exposed in Freepik
  • Negative prompt terms ('doesn't', 'not') degrade video-gen output because models parse keyword presence, not logical negation
End of document — 26 videos, 288 techniques. Source playbooks live in memory: reference-ai-agent-techniques, reference-ai-monetization, reference-ai-startup-strategy, reference-ai-market-content. 5 long courses still downloading — will be appended when processed.