By playing, you agree to uListen's Terms and Privacy Policy and YouTube's Terms of Service.

Masterclass: How to Turn an AI Agent into a Real Product (No Code)

Tyler Fisk reveals how to build AI agents that actually work in production. He breaks down the meta-prompting system, shows how to build multi-agent architectures live, and demonstrates why most teams fail at production agents.

Aakash GuptahostTyler Fiskguest

Oct 16, 20251h 40mWatch on YouTube

Summaries, chapters, transcripts, and FAQs on this page are made by uListen, not YouTube.

Great conversations run long. Their best ideas don't have to.

uListen is free on iPhone, iPad, Android, Chrome, and Claude.

CHAPTERS

Jump to publisher timestamps

Chapter summaries

Production AI agents without a CS degree: what you’ll build today
Aakash introduces Tyler Fisk and frames the goal: build a production-style, multi-agent workflow live—without code. Tyler sets expectations for going from idea to coordinated agents that work together in real time.
- •Goal: build multiple agents that orchestrate as a workflow
- •No CS degree required; practical agent-building is accessible
- •Focus on productionization vs. “vibe coding” demos
- •Live build constraints: speed, clarity, and iteration
Tooling setup: TypingMind + “Gigawatt” agent + MCP tools
Tyler opens in TypingMind and introduces Gigawatt, his prompt/AI engineering agent. He explains why tool access (Exa, Perplexity, sequential thinking) matters and how his process starts with practitioner-style discovery.
- •TypingMind as an LLM playground with API-layer control
- •Gigawatt as a dedicated prompt engineering / AI engineering assistant
- •MCP/tools enabled: Exa, Perplexity, Sequential Thinking
- •Discovery mindset: understand business/problem before building
Defining the Apple customer-service workflow and agent roles (Core + “You’ve Got Mail”)
They decide to build for Apple: one expert agent that researches and supplies verified answers, and a separate email-writing agent that responds to customers. Tyler gathers clarifying requirements to prevent role confusion and ensure clean handoffs.
- •Use case: inbound Apple customer-service emails (broad coverage)
- •Two-agent architecture: expert researcher (Core) + email responder
- •Clarifying questions to constrain scope and expectations
- •Information hierarchy: RAG first, then system knowledge, then web with verification
How to recreate Gigawatt: meta-prompting, research frameworks, and verification
Aakash asks how someone could replicate Gigawatt without Tyler’s course/product. Tyler explains his approach: collect best-practice prompting techniques, incorporate research (e.g., chain-of-verification), and let LLMs help write strong prompts.
- •Gigawatt productization plans vs. course distribution
- •Rebuilding approach: codify your own “what good looks like”
- •Chain-of-verification to reduce hallucinations (confidence + fact-checking)
- •Meta-prompting: agents helping build/improve other agents
RAG knowledge base setup: domain scrape + deep research parallelization
Tyler sets up a RAG knowledge base by scraping Apple’s domain in Cassidy AI, then spins up deep research tasks in parallel. He introduces a second agent (“Clear”) specialized in writing deep research prompts for Perplexity/Claude.
- •Cassidy AI used for no-code scraping and knowledge base creation
- •Domain-level scrape (1,000 pages) to seed RAG quickly
- •Clear agent generates deep research prompts for multiple tools
- •Parallel execution: multiple agents + multiple research engines
Building the PRD for the expert agent: alignment before prompting
With research running, Tyler has Gigawatt produce a PRD for the expert agent (Core). They emphasize why PRDs prevent agents from mixing roles (e.g., expert accidentally drafting customer-facing emails).
- •PRD as structured alignment: what it does/doesn’t do, outputs, audience
- •Core’s audience is another agent, not the end customer
- •Avoid role mix-ups by explicit inputs/outputs
- •Planning before building increases reliability and speed
Why multi-agent beats single-agent + temperature explained (Ice Peak analogy)
Tyler explains multi-agent design using a real business analogy: experts aren’t always good customer communicators. He then explains temperature as controlling randomness/creativity using the “claw machine / icy peak” probability distribution analogy.
- •Separate domain expertise from customer-facing writing for better outputs
- •Different agents can use different temperatures/settings
- •Temperature controls probability distribution of next-token selection
- •Low temp = deterministic; high temp = more creative but riskier
System-instruction engineering for Core: XML structure, examples, and emotion prompting
Tyler switches to prompt-engineering mode to generate Core’s system instructions in XML (role/context/instructions/criteria/examples). He explains why he avoids premature few-shot examples, and introduces “emotion prompting” as a research-backed technique.
- •System prompt sections: role, context, instructions, criteria, examples
- •Meta-style scenarios instead of strict input/output few-shot early on
- •Emotion prompting: positive reinforcement can improve model performance
- •XML chosen due to Claude’s strengths and structured parsing benefits
Self-review loop: scoring the prompt, iterating to A-level, then deploying Core
Gigawatt critiques its own system prompt section-by-section with quantitative scores and improvement suggestions. Tyler uses saved prompts to generate an improved version, then deploys Core into Cassidy with tools (RAG, web search, data analysis).
- •Meta-eval prompt: score + rationale + targeted improvements
- •Saved prompts accelerate repeatable iteration workflows
- •Cassidy deployment settings: model choice, context window, tools toggles
- •RAG configured to always search a curated folder
Testing Core: JSON inter-agent outputs, citations, and human-readable conversion
They test Core with a real buying question (iPhone Air vs Pro) and see Core return structured JSON suitable for agent-to-agent transfer. Tyler highlights citations for auditability and then converts output to markdown for easier human review.
- •Inter-agent JSON improves downstream parsing and reliability
- •Citations enable verification during evals
- •RAG + web research combine for up-to-date comparisons
- •Switching formats (JSON → markdown) for different audiences
Designing the email agent (Echo): brand voice translation and system prompt creation
Tyler uses an existing “You’ve Got Mail” agent (built for a Nashville hot chicken brand) as inspiration, then adapts the concept to Apple’s tone. Gigawatt proposes the name “Echo” and generates XML system instructions with escalation criteria and examples.
- •Reuse proven patterns: start from an existing email-agent template
- •Brand voice shift: playful “Southern” → clean, Apple-like clarity
- •Name selection matters for mental model consistency (Core + Echo)
- •System instructions include escalation triggers and formatting conventions
Running Core + Echo together: observational evals and XML-tagged drafting stages
Tyler routes Core’s research output into Echo to generate the customer email. He explains how tags like <think>, <scratchpad>, and <answer> support internal drafting and production parsing, while noting brand/tone improvements to iterate on.
- •Manual orchestration mimics production message passing
- •Drafting pipeline: reasoning → scratchpad → finalized answer
- •Tags enable extraction of subject/body for workflow automation
- •Client review checkpoint: tone, verbosity, bullet use, brand fit
From demo to production: human-in-the-loop workflows, Slack approvals, and evals
Tyler walks through a real Cassidy workflow: email ingestion, sentiment analysis, expert + research agents, drafting, QA iteration, and Slack-based approval before sending. He stresses human-in-the-loop safety, then highlights the need for systematic evals and audit trails.
- •Production requires human-in-the-loop gating and gradual autonomy
- •Workflow example: sentiment agent, expert agent, web research agent, email agent
- •Slack approval pattern: “ship it / revise / confirmed” generative filter
- •Evals + observability: audit trail, goldens database, continuous improvement
Scaling costs, enterprise RAG, and results: course business growth + what’s next
They discuss tool costs in context of labor replacement and improving model economics, then touch on handling large enterprise document corpora (OCR, vectorization, GraphRAG). Tyler closes with AI Build Lab’s growth metrics and future plans: scaling education and productizing Gigawatt.
- •Cost framing: compare agent spend to human time and approval overhead
- •Enterprise docs: OCR (e.g., Gemini Flash), unstructured pipelines, embeddings
- •Limitations of plain RAG and move toward agentic/GraphRAG approaches
- •Business outcomes: ~$1.6M run rate; future: scale courses + build Gigawatt product

Publisher timestamps

Get more out of YouTube videos.

Read along on your phone, search it beside the video, or ask your favorite AI app what was said.