AI Product Builder build products with AI agents

• ·How large language models work: tokens, context windows, fine-tuning vs prompting
• ·The difference between a chat, an agent, and a multi-agent system
• ·When to use which model: cost / quality tradeoffs
• ·First hands-on session: prompt → result → error analysis
• ·Overview of agentic tools: Claude Code, OpenAI Codex, Google Antigravity

Outcome: a model chosen for the task and a first "prompt → result → error analysis" loop done

• ·Claude Code as a local tool: install, setup, MCP (Model Context Protocol)
• ·GitHub from scratch: repos, branches, commits, pull requests — even if you've never touched git
• ·How Claude Code reads and writes code within a versioned project
• ·Reviewing AI-generated diffs before you merge: what to actually check
• ·Hands-on: your first webpage, committed to your own GitHub repo

Outcome: your first webpage, committed to your own GitHub repo

• ·OpenAI Codex: an agentic CLI and cloud agent for writing, refactoring, and reviewing code
• ·Google Antigravity: Google's agentic development environment built on Gemini — when to pick it over Claude Code
• ·Comparison matrix: Claude Code vs Codex vs Antigravity — strengths and weaknesses of each
• ·Structured output: JSON schemas, function calling, result reproducibility
• ·Cursor: the AI-native IDE for day-to-day work — inline edits, agent mode, when it beats the CLI
• ·Lovable: rapid prototyping of UIs and whole apps from text — and where the no-code limit is
• ·Hands-on: the same task solved across these tools — comparing the results

Outcome: the same task solved across several tools — and a justified choice of your stack

• ·Managing the context window: what the agent actually "sees" — and why the result depends on it
• ·CLAUDE.md / AGENTS.md: instructions for the agent as the project's "constitution"
• ·Breaking work into md files: specs, task lists, plans, project memory
• ·Few-shot, chain-of-thought and instruction templates for predictable results
• ·Hands-on: set up project context so the agent doesn't get lost in a large codebase

Outcome: project context (CLAUDE.md, specs) the agent no longer gets lost in

• ·From idea to requirements: getting clear requirements without a business analyst
• ·User flows, wireframes, data models: what AI needs to write correct code
• ·Design and UI with AI: Tailwind, shadcn/ui, v0.dev — a professional look without a designer
• ·A technical spec an agent understands: API contracts, error cases, edge cases
• ·Documentation as source of truth: README, API docs, architecture docs AI can read
• ·Hands-on: writing a spec for a complete web application

Outcome: a finished technical spec for a whole web app

• ·Supabase vs Firebase: when to choose which, and how they differ
• ·Designing your database schema together with an AI agent
• ·Authentication and sign-up: email, OAuth, magic links
• ·Row-Level Security and access control — keeping user data safe
• ·File storage and serverless / edge functions for your logic
• ·Hands-on: wire a database, auth and storage into your product

Outcome: database, auth and storage wired into your product

• ·How to verify AI-written code: linting, unit and integration tests
• ·GitHub Actions: automatic CI on every push and pull request
• ·Vercel preview deployments: check changes before they hit production
• ·A code-review checklist + verification loop: the agent fixes itself from feedback
• ·When the agent breaks: hallucinated APIs, runaway edits, "it deleted my code" — and rolling back with git
• ·Production readiness: when code is ready to ship vs. needs rework

Outcome: tests + CI on GitHub Actions that catch breakage before production

• ·Why AI-generated code tends to ship more vulnerabilities — and how to compensate
• ·Secrets and access keys: .env, environment variables, what never goes into git
• ·Common holes: exposed API keys, insecure defaults, excessive access rights
• ·Row-Level Security and user-data access control in practice
• ·Basic vulnerability scanning and a pre-launch security checklist
• ·Hands-on: run a security audit of your own product against the checklist

Outcome: a product passed through a security checklist, with no exposed secrets

• ·Single-agent vs multi-agent: when one agent isn't enough
• ·Specialized agents: code writer, code reviewer, architect, product manager
• ·Synchronization: how agents exchange context and artifacts (code, specs, reports)
• ·Orchestration patterns: sequential, parallel, conditional flows between agents
• ·Hands-on: architecture, coding, and review split across 3 agents

Outcome: a working multi-agent workflow: agents write, check and optimize together

• ·Deploying to Vercel: CI/CD, environment variables, secrets, your own domain
• ·Sentry.io: real-time error and performance tracking
• ·Resend: transactional email — confirmations, notifications, magic links
• ·Monitoring, logs and alerts: find out about a breakage before your customer does
• ·Iteration: user request → task for an agent → fix in production

Outcome: a product in production with error monitoring and transactional email

• ·The web-first strategy: web product first, then a mobile app on the very same backend
• ·Expo.dev (React Native): why it is the fastest path to mobile for agentic development
• ·One backend for web and mobile: a single Supabase / API — two clients
• ·Differences from web: navigation, state, offline, permissions, adapting to screens
• ·Publishing with Expo (EAS Build): App Store Connect and Google Play — icons, screenshots, review process
• ·Hands-on: add a mobile app to your web product and prepare it for submission

Outcome: a mobile app on the shared backend, ready to submit to the App Store and Google Play

• ·Stripe for the global market + LiqPay / Fondy / WayForPay for Ukraine: when to use which
• ·One-time payments, subscriptions and pricing tiers — what fits your product
• ·Checkout, webhooks and recording transactions in your database — safely and reliably
• ·Escrow logic for safe marketplace settlement (svio.com.ua case)
• ·Test mode, keys and payment security — without leaking secrets
• ·Hands-on: wire payment acceptance into your product

Outcome: payments wired in (Stripe + a Ukrainian gateway) with transactions recorded

• ·Writing specs as a non-engineer: giving engineers/agents a clear task
• ·Tradeoffs: cost vs quality vs speed when choosing a model and architecture
• ·Evals: measuring how well an AI agent performs, not just "the code runs"
• ·Analytics & metrics: what matters for AI products beyond bug counts
• ·Hands-on: write a spec for a 3-module system, feed it to 3 different agent setups

Outcome: a spec and evals you can use to steer AI-agent quality

• ·Project selection: your own idea or one of 5 suggested directions
• ·Full stack: GitHub + Supabase/Firebase + Vercel + Sentry + Resend
• ·Build: using all three tools in parallel (Claude Code, Codex, Antigravity)
• ·Deploy: launch to production, first 50-100 users, first feedback loop
• ·Presentation & portfolio: documentation, presenting your project

Outcome: a launched product with its first 50-100 users and a portfolio case