Skip to content
47% off: the complete course for $79 (reg. $149)Order now →
AI Builder
Join
CurriculumPricingGlossaryFAQSign inAccount
Theme

Curriculum

The complete AI builder course

15 modules, 132 lessons, about 23 hours of reading. Start at the beginning or jump to what you need — every lesson stands on its own.

00

Start Here

Beginner

Get oriented: what makes something an AI product, the tools builders actually use in 2026, a working setup, and your first AI feature shipped in under half an hour.

6 lessons · 54 min

  1. 1Welcome: What You'll Build in This CourseHow the course is organized, the two tracks (code and no-code), the running example app, and the six capstone products you'll be able to build by the end.9 minFree
  2. 2What Makes Something an AI Product?Where language models genuinely add value inside software — and where they don't. A practical test for spotting AI features worth building.10 minFree
  3. 3The AI Builder Stack in 2026A map of the layers every AI app is made of — models, provider APIs, SDKs, retrieval, evals, observability, and hosting — and the sensible default at each layer.9 minFree
  4. 4Your Builder Setup: Node, TypeScript, and API KeysSet up Node.js 22+, a TypeScript project, provider API keys stored safely, and a scratch playground you'll use to try every idea in the course.9 minFree
  5. 5Your First AI Feature in 20 MinutesHands-on: build a working "summarize this" endpoint with a real model call, test it on messy input, and see the core loop of AI feature development.9 minFree
  6. 6Thinking Like an AI BuilderBuilding on a probabilistic component changes how you design, test, and ship. The habits that separate AI products that work from impressive demos that don't.8 minFree
01

LLM Fundamentals for Builders

Beginner

The working knowledge of language models a builder actually needs: how text is generated, tokens and context, the anatomy of an API call, output controls, reasoning models, failure modes, and how provider APIs and SDKs differ.

8 lessons · 72 min

  1. 1How LLMs Generate Text: A Builder's Mental ModelTokens, next-token prediction, training, and instruction tuning — explained through the lens of what it means for the features you build.10 minFree
  2. 2Tokens, Context Windows, and What They CostHow text becomes tokens, how to count them, what a context window really limits, and why input and output tokens are priced differently.9 min
  3. 3Anatomy of a Model API CallMessages, roles, system prompts, content blocks, stop reasons, and usage — every field of a real request and response, and what each one is for.9 min
  4. 4Output Controls: Max Tokens, Stop Sequences, and EffortThe knobs you actually have over a model's output in 2026 — length limits, stop sequences, effort levels, and why sampling parameters like temperature are disappearing.9 min
  5. 5Reasoning Models: When Thinking Is Worth Paying ForHow thinking models change latency, cost, and quality inside product features, and how to pick an effort level per feature instead of per app.8 min
  6. 6Why Models Get Things WrongHallucination, knowledge cutoffs, sycophancy, instruction drift, and refusals — the failure modes you must design around, and the product patterns that contain them.9 min
  7. 7Comparing Provider APIs: Anthropic, OpenAI, and GoogleThe same feature built against the three major APIs: where they agree, where they differ, and what that means for portability.9 min
  8. 8SDKs and Abstraction Layers: Provider SDKs vs. the AI SDKWhen to call a provider SDK directly and when a multi-provider toolkit like the Vercel AI SDK earns its place — with the same feature written both ways.9 min
02

Prompting & Context for Apps

Beginner

Prompting for software is different from prompting in a chat app: your prompt runs thousands of times on inputs you never saw. Learn to write, template, chain, version, and debug prompts as product code.

9 lessons · 96 min

  1. 1Prompts Are Product CodeWhy a prompt inside an app needs the same care as code — ownership, review, tests, and versioning — and how that changes the way you write it.10 min
  2. 2Writing System Prompts for Product FeaturesA repeatable structure for feature-level system prompts: role, task, inputs, rules, output format, and edge cases — built up on a real feature.12 min
  3. 3Few-Shot Examples: Showing Instead of TellingHow to choose, format, and maintain examples that teach a model your exact output style without overfitting it to the examples themselves.11 min
  4. 4Prompt Templates, Delimiters, and Safe InterpolationBuild prompts from typed templates, wrap user data in clear delimiters, and keep untrusted input from being read as instructions.10 min
  5. 5Breaking Work into Prompt ChainsSplit a complex task into small, checkable steps — with validation gates between them — and know when one bigger call is the better choice.11 min
  6. 6Context Assembly: Deciding What the Model SeesSelecting, ordering, and trimming the user data, documents, and history that go into each call — the hidden skill behind features that feel smart.12 min
  7. 7Managing Conversation History and StateStore, replay, trim, and summarize multi-turn conversations; keep app state out of the transcript; and avoid the bugs that come from editing history.11 min
  8. 8Versioning and Managing PromptsWhere prompts should live, how to version and review them, when a prompt management tool helps, and how to roll back a bad change fast.9 min
  9. 9Debugging Prompts SystematicallyA method for fixing a prompt that misbehaves: reproduce, isolate, form a hypothesis, change one thing, and confirm on a test set — not on vibes.10 min
03

Building Core AI Features

Intermediate

Build the AI features that show up in almost every product — streaming chat, summarization, extraction, classification, transformation, inline writing help, natural-language queries, and background jobs — inside a real Next.js app.

10 lessons · 105 min

  1. 1Building a Streaming Chat FeatureBuild an in-app AI chat from scratch: a streaming route handler, a React client, conversation storage, and the details that make it feel polished.11 minFree
  2. 2Streaming End to EndHow token streaming works from the provider to the browser — server-sent events, backpressure, cancellation, and errors that arrive mid-stream.10 min
  3. 3Summarization Features Users TrustDesign summaries for a purpose (triage, catch-up, handoff), handle long and messy inputs, and prevent summaries that sound right but drop what matters.10 min
  4. 4Extracting Structured Data from Messy TextTurn emails, tickets, and notes into clean typed records — with schemas, null handling, confidence, and a review path for the uncertain ones.11 min
  5. 5Classification, Tagging, and RoutingBuild label-and-route features with fixed taxonomies, multi-label tags, an "other" escape hatch, and the metrics that tell you it's working.10 min
  6. 6Rewrite, Translate, and TransformTone rewrites, translation, simplification, and format conversion — the transformation features that look trivial and fail in subtle ways.10 min
  7. 7Inline AI Writing AssistanceAutocomplete, suggested edits, and "improve this" actions inside your editor UI — with diffs the user can accept or reject piece by piece.10 min
  8. 8Natural Language to Filters and SQLLet users ask for data in plain English by translating to validated filters or read-only SQL — safely, with guardrails against bad and malicious queries.11 min
  9. 9AI Features in a Next.js AppWhere AI calls belong in a modern React app — route handlers, server actions, and server components — plus keys, timeouts, and caching done right.11 min
  10. 10Background and Bulk AI JobsMove slow or high-volume AI work out of the request path: queues, job status, retries, idempotency, and reporting progress back to users.11 min
04

Structured Outputs & Tool Use

Intermediate

Make model output reliable enough to drive software: schema-constrained outputs with Zod and Pydantic, validation and repair, tool use for in-app features, generative UI, and where MCP fits into a product.

8 lessons · 83 min

  1. 1Structured Outputs in PracticeGet guaranteed-valid JSON from a model with schema-constrained decoding, parse it into typed objects, and know the limits of what the guarantee covers.11 min
  2. 2Designing Output Schemas with Zod and PydanticSchema design choices that change answer quality: field order, enums, descriptions, optional vs. nullable, and reasoning fields that come before the answer.10 min
  3. 3Validation, Retries, and RepairSchema-valid isn't the same as correct. Add business-rule validation, targeted retries with feedback, and graceful fallbacks when output still fails.10 min
  4. 4Tool Use for App FeaturesLet a model look things up and take actions inside your product — defining tools, running the call-and-return cycle, and keeping it bounded.10 min
  5. 5Tools That Read and Write Your App's DataExpose your app's existing API as model tools with the user's own permissions, confirmation steps for writes, and audit logs for everything.10 min
  6. 6Generative UI: Rendering Components from Model OutputGo beyond text: have the model choose and fill real UI components — cards, forms, charts — while your code stays in charge of what renders.10 min
  7. 7Multi-Step Tool Flows (and When You Need an Agent)Chain a few tool calls into a reliable feature, cap the steps, and recognize the point where you've crossed into agent territory.11 min
  8. 8MCP for App BuildersWhat the Model Context Protocol means for a product team: connecting MCP servers to your features, exposing your product to AI clients, and the security trade-offs.11 min
05

Embeddings, Search & RAG

Intermediate

Build retrieval into real products: embeddings and vector storage, semantic and hybrid search, document ingestion and chunking, reranking, grounded answers with citations, freshness and permissions, and how to measure whether retrieval works.

12 lessons · 125 min

  1. 1Embeddings in PracticeGenerate, store, and compare embeddings in code; pick an embedding model; and build intuition for what similarity scores do and don't mean.11 min
  2. 2Choosing a Vector Storepgvector, dedicated vector databases, and managed search services compared — with a clear default for most apps and the signals that you've outgrown it.10 min
  3. 3Building Semantic Search into Your AppShip a "search by meaning" feature end to end with Postgres and pgvector: indexing, querying, filtering, and a results UI users understand.10 min
  4. 4Hybrid Search: Keywords Plus VectorsWhy pure vector search misses exact names, codes, and IDs — and how to combine full-text and vector results with reciprocal rank fusion.10 min
  5. 5Ingesting Documents: PDFs, HTML, and Office FilesTurn real-world files into clean, structured text: extraction tools, tables and layout, metadata worth keeping, and an ingestion pipeline you can re-run.11 min
  6. 6Chunking Strategies That WorkFixed, structural, and semantic chunking compared; chunk size and overlap; and contextual chunk headers that make retrieval dramatically better.10 min
  7. 7A RAG Pipeline End to EndWire retrieval and generation into a working question-answering feature: query, retrieve, assemble context, answer, and handle "I don't know."11 min
  8. 8Reranking and Query RewritingTwo upgrades with outsized impact: rerank candidates with a cross-encoder or model, and rewrite vague or conversational questions into good search queries.11 min
  9. 9Citations and Grounded AnswersMake every claim traceable: citation formats, provider citation features, verifying quotes against sources, and UI that lets users check the work.10 min
  10. 10Keeping Indexes Fresh and Permission-AwareHandle updates, deletes, and re-embedding — and make sure users can only retrieve documents they're allowed to see.11 min
  11. 11Evaluating Retrieval and RAG QualityMeasure retrieval separately from generation: recall@k, MRR, faithfulness, and answer relevance — with a small labeled set you can build in an afternoon.10 min
  12. 12Long Context vs. RAG: When You Don't Need RetrievalWith million-token context windows, sometimes the best retrieval system is none. How to decide between stuffing context, caching it, and retrieving.10 min
06

Choosing, Routing & Running Models

Intermediate

Pick models feature by feature, route between them, add gateways and fallbacks, and run open-weight models locally, on your own GPUs, or in the browser — plus fine-tuning and distillation, and staying portable.

9 lessons · 94 min

  1. 1The Model Landscape for BuildersFrontier, mid-tier, and small models; closed and open-weight; general and specialized — how the market is shaped and how to keep up without chasing every release.11 min
  2. 2Choosing a Model per FeatureA practical selection process: define the bar, shortlist, test on your own examples, and weigh quality against latency and cost for each feature.11 min
  3. 3Model Routing and CascadesSend easy requests to small models and hard ones to big models — rule-based routers, classifier routers, and cascades that escalate on low confidence.10 min
  4. 4LLM Gateways and Provider FallbacksPut a gateway between your app and providers for retries, fallbacks, keys, and spend tracking — and know what it costs you in complexity.11 min
  5. 5Building with Open-Weight ModelsWhen open-weight models make sense, how licenses differ, where to run them (hosted inference vs. your own GPUs), and how to serve them with vLLM.11 min
  6. 6Running Models Locally with Ollama and llama.cppRun capable models on a laptop for development, privacy, or offline features — quantization explained, and an OpenAI-compatible local endpoint in minutes.10 min
  7. 7On-Device and In-Browser AIRun small models in the browser and on phones with Transformers.js, WebGPU, and built-in platform models — and what they're genuinely good for.10 min
  8. 8Fine-Tuning and Distillation for Product FeaturesHands-on distillation: use a large model to label data, fine-tune a small one for a narrow feature, and prove with evals that it was worth it.10 min
  9. 9Model Portability and Avoiding Lock-InKeep the freedom to switch models: thin adapters, provider-neutral prompts and schemas, portable evals, and a migration checklist for model upgrades.10 min
07

Multimodal AI: Vision, Audio & Images

Intermediate

Add images, documents, audio, and video to your product: vision input, document understanding, image generation and editing, speech-to-text, text-to-speech, realtime voice, video, and multimodal search — plus the media pipelines behind them.

9 lessons · 90 min

  1. 1Adding Vision to Your AppSend images to a model and get useful answers back: input formats, resolution and cost, prompting for visual tasks, and the things vision models still miss.12 min
  2. 2Document Understanding: Receipts, Forms, and PDFsRead invoices, receipts, IDs, and multi-page PDFs into structured data — native PDF input vs. OCR, page-level citations, and human review for edge cases.11 min
  3. 3Image Generation and Editing in ProductsAdd text-to-image and image editing to an app: choosing a model, prompt templates for consistent results, storage, moderation, and licensing questions.11 min
  4. 4Speech-to-Text FeaturesTranscription for meetings, voice notes, and dictation: model options, diarization, timestamps, long files, and post-processing with an LLM.9 min
  5. 5Text-to-Speech and Voice OutputGive your product a voice: TTS models and voices, streaming audio, pronunciation control, and the consent rules around voice cloning.9 min
  6. 6Realtime Voice InterfacesSpeech-to-speech models vs. chained STT-LLM-TTS pipelines, latency budgets, turn-taking and interruptions, and when voice is the right interface at all.10 min
  7. 7Video Understanding and GenerationAnalyze video by sampling frames and transcripts, summarize and search long recordings, and where generative video fits in a product today.9 min
  8. 8Multimodal Search with Image and Text EmbeddingsSearch photos by description and find similar images with multimodal embeddings — plus captioning as a simple, powerful alternative.9 min
  9. 9Media Pipelines: Uploads, Storage, and CostThe plumbing behind multimodal features: direct uploads, validation, resizing, object storage, async processing, and keeping media costs predictable.10 min
08

AI UX & Product Design

Intermediate

Design AI features people actually adopt: choosing the right interface beyond the chat box, designing for uncertainty and errors, perceived speed, user control, onboarding, feedback, trust and disclosure, accessibility, and rapid prototyping.

9 lessons · 88 min

  1. 1Principles of AI UXWhat changes when the software is probabilistic: set expectations, show the work, make correction cheap, and keep the human in charge of outcomes.10 min
  2. 2Beyond the Chat Box: Choosing the Right InterfaceChat is one interface among many. When to use inline actions, side panels, smart defaults, background automation, or no visible AI at all.11 min
  3. 3Designing for Uncertainty and ErrorsCommunicate confidence honestly, fail gracefully, show sources, and design the moments when the AI is wrong — because it will be.10 min
  4. 4Latency UX: Streaming, Progress, and Perceived SpeedMake slow models feel fast: streaming, skeletons, staged results, optimistic UI, and honest progress for tasks that take minutes.10 min
  5. 5Keeping Users in Control: Edit, Undo, RegenerateReview-before-apply, granular accept and reject, version history, and undo — the controls that turn AI suggestions into something users rely on.9 min
  6. 6Onboarding, Empty States, and Suggested PromptsSolve the blank-box problem: teach capabilities in context, suggest starting points, and help users form an accurate model of what the AI can do.9 min
  7. 7Collecting Feedback That Improves Your ProductThumbs, edits, and implicit signals — what to collect, how to store it with the trace, and how to turn it into eval cases and fixes.9 min
  8. 8Accessible AI InterfacesStreaming text and screen readers, keyboard flows, alt text generation, plain-language output, and making voice and visual features inclusive.10 min
  9. 9Prototyping AI Features FastTest whether an AI feature is worth building in days: prompt prototypes, Wizard-of-Oz tests, and a prototype-to-production checklist.10 min
09

Evals & Quality for AI Features

Intermediate

A practical quality system for AI features: define quality, read outputs with error analysis, build golden datasets from real usage, write code-based and model-graded checks, evaluate extraction and RAG, and run evals in development, CI, and production.

9 lessons · 97 min

  1. 1What Quality Means for an AI FeatureTurn "make it good" into measurable criteria per feature — correctness, completeness, format, tone, safety — and decide which ones block a release.10 min
  2. 2Error Analysis: Read Your Outputs FirstThe highest-leverage quality habit: review real outputs, write open notes, group them into failure categories, and fix the biggest bucket first.10 min
  3. 3Building a Golden Dataset from Real UsageAssemble a test set that represents reality: sampling production traffic, covering edge cases, labeling efficiently, and keeping it fresh.10 min
  4. 4Code-Based Checks and AssertionsThe cheap, deterministic evals to write first — format, schema, length, required facts, forbidden content — and a tiny eval runner in TypeScript.10 min
  5. 5Model-Graded Evals You Can TrustWrite grader prompts with clear pass/fail criteria, calibrate them against human labels, and track agreement so your grader stays honest.11 min
  6. 6Evaluating Extraction, Classification, and GenerationThe right metrics for each feature type: field-level accuracy, precision and recall, confusion matrices, and pairwise comparison for open-ended text.12 min
  7. 7Eval-Driven Development and CIMake evals part of every change: a fast local loop while iterating, a regression suite in CI, and release gates for prompt and model updates.12 min
  8. 8Monitoring Quality in ProductionSample live traffic for grading, watch for drift, alert on quality drops, and close the loop from production failures back into your test set.11 min
  9. 9Experiments and A/B Tests for AI ChangesTest prompt and model changes on real users: choosing metrics that reflect value, sample sizes, guardrail metrics, and reading noisy results honestly.11 min
10

Cost, Latency & Scale

Advanced

Understand and control the economics of AI features: reading your bill, unit economics, prompt caching, response caching, batch processing, latency optimization, rate limits and per-user budgets, token efficiency, and scaling workloads.

9 lessons · 97 min

  1. 1Understanding Your AI BillWhere AI spend actually comes from — input, output, thinking, cached, and tool tokens — and how to attribute every dollar to a feature and a customer.11 min
  2. 2Unit Economics of AI FeaturesCalculate cost per request, per user, and per outcome; model gross margin under different usage patterns; and spot features that lose money at scale.11 min
  3. 3Prompt Caching in PracticeStructure prompts so stable content is cached, verify cache hits in usage data, and avoid the silent invalidators that quietly double your bill.11 min
  4. 4Exact and Semantic Response CachingSkip the model entirely for repeated requests: exact-match caches, semantic caches with embeddings, and the correctness traps of each.10 min
  5. 5Batch APIs and Async ProcessingProcess large volumes at roughly half price with batch APIs: when they fit, how to submit and collect results, and designing features around delay.11 min
  6. 6Cutting Latency: Time to First Token and BeyondMeasure where time goes, then cut it: smaller models, lower effort, shorter outputs, parallel calls, speculative work, and regional endpoints.11 min
  7. 7Rate Limits, Quotas, and Per-User BudgetsHandle provider rate limits gracefully and enforce your own: per-user quotas, spend caps, plan-based limits, and abuse protection.11 min
  8. 8Token Efficiency: Same Quality, Fewer TokensTrim prompts, compress context, constrain output length, and prune history — and prove with evals that quality didn't drop.10 min
  9. 9Scaling AI WorkloadsQueues, concurrency limits, backpressure, and capacity planning for AI traffic that spikes — without blowing through rate limits or budgets.11 min
11

Safety, Privacy & Responsible AI

Advanced

Protect users, data, and your business: risk assessment, prompt injection in apps, moderation, PII and provider data policies, securing model output, abuse and denial-of-wallet, AI regulation, copyright and provenance, and pre-launch red-teaming.

9 lessons · 92 min

  1. 1Risk Assessment for AI FeaturesA lightweight method to find what could go wrong with a feature — who's harmed, how badly, how likely — and pick proportionate mitigations.11 min
  2. 2Prompt Injection in Apps: RAG, Uploads, and User ContentHow injected instructions reach your app through documents, emails, and web pages — and the design patterns that limit the damage.11 min
  3. 3Input and Output ModerationScreen what goes in and what comes out: moderation APIs, classifier prompts, policy definitions, and handling false positives without frustrating users.10 min
  4. 4PII, Data Retention, and Provider PoliciesKnow where user data flows: provider retention and training policies, zero-data-retention options, PII redaction, regional processing, and user consent.10 min
  5. 5Securing Model Output: XSS, Links, and MarkdownTreat model output as untrusted input to your UI: sanitizing HTML and markdown, link and image exfiltration, and safe rendering of generated code.9 min
  6. 6Abuse Prevention and Denial-of-WalletStop free-tier abuse, scraping, jailbreak farming, and attacks designed to run up your bill — with limits, signals, and cheap first-line filters.12 min
  7. 7AI Regulation for BuildersWhat the EU AI Act and other rules mean in practice for small teams: risk tiers, transparency duties, and the documentation worth keeping anyway.10 min
  8. 8Copyright, Licensing, and Content ProvenanceTerms of use for model output, open-weight licenses, training-data questions, and content credentials for generated media — what builders need to know.10 min
  9. 9Red-Teaming Your AI Feature Before LaunchRun a focused adversarial test before shipping: attack categories, a test plan, automated probes, and fixing what you find.9 min
12

Deploying, Operating & Selling AI Products

Advanced

Deploy and run AI features in production — architecture, hosting and timeouts, long-running workflows, tracing, rollouts, incidents — then turn them into a business: pricing, positioning, metering and billing, and launching.

10 lessons · 106 min

  1. 1Architecture for AI-Powered AppsReference architectures for AI features in web apps: where model calls live, an AI service layer, data flows, and the decisions that are hard to undo.10 min
  2. 2Deploying AI Features: Serverless, Containers, and TimeoutsLong-running streams meet platform limits. Choose hosting that fits AI workloads and configure timeouts, regions, and secrets correctly.10 min
  3. 3Long-Running AI WorkflowsDurable workflow engines and job queues for multi-step AI work that runs for minutes — retries, checkpoints, and resuming after failures.11 min
  4. 4Logging and Tracing LLM CallsCapture every model call with inputs, outputs, tokens, latency, and cost — with OpenTelemetry or an LLM observability tool — while respecting privacy.12 min
  5. 5Feature Flags and Gradual Rollouts for AIShip AI changes behind flags, roll out by percentage or cohort, shadow-test new prompts and models, and roll back in seconds.11 min
  6. 6When AI Breaks: Incidents and Provider OutagesPlan for provider outages, quality regressions, and runaway costs: detection, degraded modes, incident runbooks, and honest communication.11 min
  7. 7Pricing AI Products: Seats, Usage, and CreditsPricing models for products with real per-use costs — seats, usage-based, credits, outcome pricing, and hybrids — and how to choose one with margins in mind.11 min
  8. 8Positioning: Beyond "Just a Wrapper"Build defensibility where it actually comes from — workflow, data, distribution, and quality — and position your product so buyers see the difference.10 min
  9. 9Metering Usage and Billing with StripeRecord usage per customer, enforce plan limits, and bill for it with Stripe — including credits, overages, and reconciling against your provider bill.11 min
  10. 10Launching and Iterating on an AI ProductPlan a launch, get your first users, and run the weekly loop of usage data, error analysis, and roadmap decisions that makes the product better.9 min
13

No-Code & Low-Code AI Building

Beginner

For non-developers and fast-moving builders: shareable assistants, prompt-to-app builders, automation platforms, AI in spreadsheets, no-code knowledge bots, shipping safely, and knowing when to graduate to code.

8 lessons · 77 min

  1. 1The No-Code AI Builder LandscapeA map of no-code and low-code AI tools — assistants, app builders, automation platforms, and AI-native databases — and what each can realistically ship.10 min
  2. 2Shareable Assistants: ChatGPT Plugins, Gems, and Claude ProjectsPackage instructions and knowledge into an assistant other people can use — designing, testing, sharing, and maintaining it as a small product.11 min
  3. 3Prompt-to-App BuildersBuild working web apps by describing them with tools like Lovable, Bolt, v0, and Replit — and how to get past the 80% demo to something reliable.10 min
  4. 4AI Automations with Zapier, Make, and n8nAdd model steps to automated workflows: triggers, AI actions, structured output, error paths, and human approval before anything important happens.10 min
  5. 5AI in Spreadsheets and No-Code DatabasesClassify, extract, and enrich rows at scale inside spreadsheets and Airtable-style databases — with spot checks so errors don't spread silently.9 min
  6. 6No-Code Knowledge BotsBuild a question-answering bot over your team's docs without code, test it against real questions, and keep its knowledge current.9 min
  7. 7Shipping No-Code AI Tools SafelyCredentials, data access, prompt injection, cost limits, and ownership — the checklist before you give a no-code AI tool to colleagues or customers.9 min
  8. 8When to Graduate from No-Code to CodeSignals that you've outgrown no-code, how to migrate without starting over, and using AI coding tools to bridge the gap.9 min
14

Capstone Projects

Advanced

Put everything together in guided builds of complete AI products — an AI feature for a SaaS app, a RAG knowledge app, a multimodal expense app, an AI-powered internal tool, a content product with evals, and a no-code AI product — then plan what's next.

7 lessons · 102 min

  1. 1Capstone 1: An AI Feature for a SaaS AppAdd AI ticket triage to a help-desk app: classification, summaries, and drafted replies with structured outputs, evals, cost tracking, and a staged rollout.16 min
  2. 2Capstone 2: A RAG Knowledge Base AppBuild a cited Q&A app over a document collection: ingestion, hybrid search, reranking, grounded answers, permission filters, and a retrieval eval suite.16 min
  3. 3Capstone 3: A Multimodal Expense AppSnap a receipt or speak a note and get a categorized expense: vision extraction, speech-to-text, validation, review UI, and a media pipeline.16 min
  4. 4Capstone 4: An AI-Powered Internal ToolBuild an internal analytics assistant that answers questions over company data with safe natural-language queries, charts, and an audit log.16 min
  5. 5Capstone 5: A Content Product with EvalsShip a product-description generator for online stores with brand voice controls, model-graded quality checks, batch generation, and usage-based billing.14 min
  6. 6Capstone 6: A No-Code AI ProductBuild and launch a lead-qualification assistant without writing code — intake form, AI scoring, automated follow-up, and a review queue.15 min
  7. 7Where to Go NextHow to keep your skills current as models change, ideas for your next AI product, and where to go deeper — including building agents.9 min