You've discovered a valuable product management resource
Trusted by 2,200+ product managers worldwide
Enter your details to access session recordings, slide decks, and notes.
Trusted by 2,200+ product managers worldwide
Learning resources for the live AI Builder Sprint: session recordings, slide decks, and what each evening covers.
When
Jul 10-12, 2026
Friday · Saturday · Sunday
Time
8:00 PM IST onwards
Where
Online · Zoom
Tools you’ll learn to use
Session recordings
Each session builds on the last: from understanding AI, to thinking like a builder, to shipping a real product.
Starting with the fundamentals so AI stops feeling like magic and starts feeling like leverage.
Session 1 of a three-part AI builder series. The agenda:
More than 60% of companies now pay a salary premium to people with AI skills over those without. Most job descriptions across every function, not just engineering or product, now list some form of AI skill. Across recent research, AI sits in the top three most in-demand skills alongside communication and management.
The deeper shift: the cost and skill required to build something have dropped close to zero. A three-day sprint is now enough to take someone from zero to shipping a working product. That compression is the opportunity: whoever moves first captures a window that will not stay open.
Two camps exist publicly: AI as an existential threat, and AI as a helpful companion. Neither framing is the point. What matters is the market data.
OpenAI was recently valued near $500 billion. Anthropic is approaching $1 trillion. xAI has been valued around $250 billion. Legacy tech giants betting on AI, Microsoft, Google, Meta, Nvidia, have grown 2x to 10x in the last four to five years. Google took over 20 years to add its first $1.1 trillion in value; it added roughly 4x that in the last 3 years alone. Nvidia’s growth curve shows the same inflection.
Beneath the giants, AI-native companies are compounding fast: Cursor recently sold to a large valuation, Glean (enterprise knowledge search) is valued in the billions, ElevenLabs went from nothing to a large valuation in a few years, Perplexity sits around $20 billion.
The stock market can go up and down. The question worth asking is not “is this a bubble,” but “is there real value in this technology.” Most of today’s Fortune 500 are internet-based companies that survived the dot-com cycle. The pattern tends to repeat.
Personally: decision support, emotional and professional reflection, coding, writing, learning, travel planning, data summarisation.
In business: customer support agents that can take low-risk actions (like small refunds) without a human, software engineering at scale, ad and content production, document and credit processing for loans, fraud and risk detection, forecasting, internal knowledge search, and agentic workflows that go beyond search into booking and execution.
The internet took 4 years to reach the first search engine, 5 years to the first shopping site, 8 years to music sharing, 14 to 17 years to Facebook and Gmail, and around 30 years to quick commerce. AI is compressing that same arc dramatically. The honest number: an estimated 99% of AI use cases have not been discovered yet. The alphabet exists; almost none of the stories have been written.
The common mistake: treating AI like a school subject, and trying to start from mathematics, statistics, and machine learning before touching a tool. This demotivates people within a week, because the distance between “linear algebra” and “something I can ship” feels enormous.
The corrective is purpose-driven learning: pick a real problem, and learn only what that problem requires, in the order it requires it. A student mid-MBA built a small tool to help classmates choose electives, not because he studied computer science first, but because he had a specific, felt problem. A 48-year-old grocery shop owner with no coding background built an inventory and wholesaler-proposal tool on Lovable and Google AI Studio, driven entirely by a concrete need.
Learn to drive the car. You do not need to know how to repair the engine or build one from scratch to get real value from driving.
This does not mean skipping fundamentals entirely. A working vocabulary of how LLMs function is still worth having, both to build responsibly and because interviewers will ask.
Humans learn by exposure: reading, observing, absorbing patterns, then applying them to new situations. LLMs learn the same way, structurally. The first phase is pre-training: collect enormous amounts of text from the internet and books, clean it, and break it into small pieces the model can consume one at a time.
Machines only understand numbers, so every word needs a numeric representation. This is done through vectors: a set of numeric features that capture what a word means. A simplified example: represent “man,” “woman,” “king,” and “queen” using features like gender, royalty, and authority, each assigned a number. The real vectors used inside models like GPT have hundreds of dimensions, and nobody, including the researchers, can name exactly what each dimension represents. It is a black box that finds its own structure from data.
Vectors are not limited to text. Images, audio, and video can all be represented the same way; a single pixel, for instance, is just three numbers for red, green, and blue.
Take two sentences: “the bat flies in the sky and eats insects” and “Sachin uses his bat to smash a century.” The word “bat” means something completely different in each. Before 2017, models evaluated words mostly in isolation, one at a time. Researchers at Google found that meaning only becomes accurate when every word is compared against every other word in the sentence.
This mechanism is called attention, introduced in the 2017 paper “Attention Is All You Need.” Every token attends to every other token to resolve what it actually means in context.
Attention requires massive matrix multiplication, comparing long strings of numbers against each other at scale. CPUs are built for sequential processing and are slow at this kind of parallel math. GPUs, originally built to render game scenes in parallel, turned out to be exactly the right hardware for this job. That single fact is a large part of why Nvidia’s valuation grew roughly 10x in a few years: GPUs became the compute backbone of the AI revolution.
Building the model is called training. Using the model, sending it a prompt and getting a response, is called inference. Both terms come up constantly in AI vocabulary and are worth having on hand.
A freshly pre-trained model is a base model: it has broad knowledge but no judgment, similar to a newborn who has basic instincts but no social training. Post-training is where labs curate data and correct behaviour, similar to how a child is raised with structured moral and social education after birth.
A concrete failure mode: base models are next-token predictors at their core, so if asked something they do not know, they will still try to produce a plausible-sounding answer rather than admit uncertainty, similar to a young child inventing a story rather than saying “I don’t know.” Labs have specifically trained models on invented, unanswerable questions, for example, asking for a summary of a nonexistent book by a nonexistent author, and rewarding the response “I don’t know.” This is one direct lever for reducing hallucination.
Two post-training methods:
Both methods are expensive because they need either expert-curated data or human judgment at scale. Newer approaches increasingly use AI to generate that training data, a technique sometimes called distillation. It is widely believed, though not confirmed, that some frontier labs in China trained newer models substantially on data generated by GPT and Claude for exactly this reason.
Whatever the tool, whatever the use case, an LLM is always doing one of three jobs:
Nearly every AI product, from customer support bots to coding agents, is a combination of these three (UTG) applied to a specific use case.
Tools like Granola (meeting note-taking) work by capturing a live transcript and feeding it, along with a written system prompt, to an LLM. A representative system prompt: “You are an expert chief of staff and note-taker. Given the following raw meeting transcript, generate a structured and actionable summary that includes: meeting title, date, key decisions, action items, open questions.” Every AI product you use, ChatGPT included, has some version of this system prompt working behind the scenes.
An agent is different from a chatbot in one specific way: it takes action, not just conversation. MakeMyTrip’s assistant Myra, Notion’s agents, GitHub Copilot, and Lovable are all agents because they go beyond generating text into executing a task.
Take a flight-booking example. MakeMyTrip holds a database of flights (route, cost, timing). To search it, an engineer exposes an API (application programming interface): an endpoint plus a defined set of variables, for example, origin city, destination city, and date. APIs require structured input: the right endpoint name paired with the right variables, or nothing works.
To turn a natural-language request like “book a flight from Delhi to Bangalore on 11th July” into something the API can execute, the system does not send that sentence to the API directly. It sends it to an LLM, along with a system prompt describing which APIs exist and what each one needs. The LLM converts the natural-language request into a structured output (commonly JSON or XML) that the API can actually consume, then the product executes it, often with a confirmation step first.
This is exactly what MCP (Model Context Protocol) formalises: a standard way of describing a technical API so an LLM can reliably call it. MCP will get its own deeper treatment in a later session.
Product management splits into three modes: discovery (understanding users, market, and deciding what to build), delivery (building it with engineers and designers), and distribution (getting it to market with marketing and sales).
Almost every PM agrees discovery is where they should spend most of their time. In practice, nearly all of them spend most of their time in delivery, chasing engineers, designers, and stakeholders just to ship anything at all. That pressure pushes PMs toward safe, mediocre, defensible bets rather than genuinely high-impact ones, because the cost of being wrong is wasted engineering time.
AI directly attacks that bottleneck. If the cost and skill required to build a small prototype drop close to zero, PMs can run real experiments with real users before ever involving an engineering team. That is the actual unlock: not “AI writes your PRD,” but “AI removes the reason you were avoiding discovery in the first place.”
The live build stays entirely inside Google AI Studio for this session (GitHub, Cursor, and Anti-Gravity are Day 2 and Day 3 territory). AI Studio can build web apps, Android apps, and connect to Google Drive or Sheets, all from a typed or dictated prompt, optionally with a reference screenshot attached.
The chosen build: a tool that shows knowledge workers how much money their meetings cost. The approach: take a monthly salary, derive an hourly rate, multiply by meeting duration and attendee count, and translate the result into something visceral, like “this meeting cost the equivalent of an iPhone.”
“Build a single-page web app called Meeting Money Burner. Purpose: show knowledge workers how much money their meetings cost. For the first version, build only this: input for annual salary in INR. Assume 22 working days per month. Show the computed hourly rate. Update live as the user types, no submit button. Handle edge cases: empty input, negative salary. Do not build any other features right now, this is version one.”
The deliberate restraint matters: only one feature, explicit edge cases named up front, and an explicit instruction not to add anything else. Giving a model too much context at once increases the odds of it going off track or hallucinating a feature that was not asked for.
“Now add the meeting cost feature below the current display, after version one. Input: meeting duration, number of attendees, assume all attendees earn the same rate. Show the meeting cost, and below it, a comparison line converting the number into something concrete, for example, ’12 plates of biryani.’ Keep everything from version one unchanged.”
Result: a working app in roughly 5 to 7 minutes, entirely from two short, specific prompts. No formal prompt-engineering framework was needed, just a clear statement of scope, constraints, and edge cases.
The bigger point behind the demo: this is not a rare skill. If a 5-to-7-minute build is achievable live, in front of a room, without a rehearsed script, the barrier was never technical ability. It was starting.
Day 2 moves from foundation into execution: taking what gets built in AI Studio onto GitHub, running it locally, and editing it with Anti-Gravity or Cursor.
A deeper pass on the leverage ladder, Gems and Skills, vibe coding platforms, automation agents, and the POWER framework for figuring out where AI actually helps.
Day 2 of the AI Builder Sprint. The agenda:
Most people learning AI make the same mistake: they start with tools. They ask “how do I learn n8n” or “how do I learn Cursor” before they’ve figured out what’s actually worth building. Tools are not the ceiling. Imagination is the ceiling.
The deeper problem is that most people don’t know what’s possible with AI in the first place, so they default to shallow use cases (writing emails, small apps) instead of thinking bigger. This session is built to fix that ordering: understand possibilities and opportunities before touching a single tool.
Either AI is dismissed as hype, or analysis paralysis sets in, spending so much time deciding on the “perfect” tool that no action ever gets taken.
Daily use of ChatGPT, Claude, and Gemini for research, drafting, and communication. Almost everyone already sits at this level.
Reusable micro-utilities for repeatable tasks: a PRD generator, a resume-to-job-description matcher, an experiment-writing assistant. The point is not repeating the same instructions every time you need the same kind of output.
Building actual prototypes in Lovable, Google AI Studio, or Replit. This is where you stop asking a chatbot for help and start generating a working product.
Tools like n8n, Zapier, Relay, and Make, used to orchestrate multi-step workflows and connect AI to real business processes. Called “controversial” here because these platforms sit in an ambiguous space between simple automation and true agentic behavior.
Levels 3 and 4 can swap order depending on the person. Some people find automation platforms more natural before vibe coding; others go the other way. There’s no fixed sequence.
Editing and hosting your own code directly, full-stack control. Deliberately reserved for Day 3.
Writing a great prompt takes effort. Repeating that effort every time you need the same kind of output is wasteful. Gems (Google), Custom GPTs (OpenAI), and Skills (Anthropic) all solve this by turning a one-time, well-crafted prompt into a reusable tool.
The build: a Gem that takes a resume and a job description, then suggests line-by-line edits to improve alignment, without fabricating anything, and scores the resume’s likelihood of getting shortlisted.
The instruction-writing process itself modeled a lesson: rather than writing the Gem’s instructions solo, the better approach is collaboration. Take a rough version of what you want, hand it to ChatGPT or Claude, ask it to sharpen the instructions, then paste the refined version into the Gem.
Good is the enemy of best. If AI gives you surface-level output and you accept it without pushing further, you’ll never notice the gap between adequate and excellent.
Most companies don’t post entry-level product management roles publicly, they’d be flooded with applicants. Instead: search LinkedIn for “associate product manager,” click People (not Jobs), and you’ll surface everyone currently working in that role across companies. That tells you which companies actually hire at that level, even without an open posting. The next step isn’t cold-DMing those people, it’s researching the company and proposing real value to someone senior there.
Gems and Custom GPTs have a switching cost: you have to know which one to open for which task, and dumping all your instructions into one giant chat either overflows the context window or gets expensive even when it doesn’t.
Skills solve this with progressive disclosure. A Skill has three parts: a name, a description, and a body of instructions. By default, only the name and description load into context. The full instruction body only loads if the model decides this specific Skill is needed for the task in front of it. That means you can have dozens of Skills available without ever bloating the context window.
skills.sh hosts a community library of these, including a front-end design Skill that helps AI-generated interfaces look less generically AI-made. Skills can also be created conversationally: describe what you want, let Claude ask clarifying questions, and it writes the Skill file for you.
Every vibe-coding tool (Lovable, AI Studio, Replit, Emergent) runs the same underlying process, regardless of brand:
This loop, goal, action, observe, decide, repeat, is sometimes called loop engineering, and it’s the same architecture behind essentially every agentic coding tool on the market.
A landing page for HelloPM’s offline community events (10 to 11 cities) was built by renaming a set of photos with their location and handing them to an AI builder with no further description. The tool inferred context from the images themselves, correctly tagging a “curtain up” moment from a stage photo without being told what was happening in it.
You are only limited by your imagination about what these tools can do.
Tools like n8n, Zapier, Relay, and Make are workflow orchestration platforms. Every workflow, regardless of the specific tool, follows the same structure:
A visitor fills out a form on a B2B website. That information goes to an AI agent, which researches the company, drafts a tailored proposal, and emails it to the salesperson, who can then call the lead or hand off to an AI calling agent for further qualification.
A mention of your product on X (Twitter) gets captured, categorized by AI as positive feedback, negative feedback, or a feature request, researched further if needed, and routed to email or Telegram depending on urgency.
Built live: a Gmail trigger that feeds incoming emails to an AI node, which categorizes each one as urgent, non-urgent, or spam.
The build hit an error partway through, which became a teaching moment repeated from Day 1: rather than searching for a tutorial, screenshot the error and hand it to Claude or ChatGPT with a plain description of what you’re trying to build. These platforms update constantly, so memorizing today’s exact interface is less valuable than knowing how to recover when it inevitably changes.
If you lose the motivation, you won’t complete the task. Motivation comes from having a real, specific problem, not from watching someone else demo a tool.
Most people jump straight to tools when trying to “leverage AI.” POWER puts tools in their correct place, fourth, not first.
What’s possible with AI, at the level of the world, not yet your specific situation. Most people underestimate this because they’ve only used AI for shallow tasks like writing emails.
Ways to expand this list:
Where those possibilities apply specifically to your own business, workflow, or life. This requires real domain knowledge, not just AI knowledge.
Practical method: run a one-week diary study of your own workflow, or have a daily check-in conversation with an AI project describing what you did that day. After a week, patterns and opportunities become visible on their own.
Going deeper into the granular steps of a specific opportunity, not just naming it at a high level.
Example: user research. The full workflow: decide user segments, find users, design interview questions, run the survey, interview, synthesize insights, build personas or journey maps, then write the PRD.
A common failure point: asking leading questions that produce false positives, the same reason your mom can’t tell you honestly if you look fat.
Bad feedback is better than wrong feedback.
The fix: run interview questions against The Mom Test principles (a short, widely recommended book on this exact problem), which can itself become a Gem or Skill you check every future interview script against.
The actual tool and build step, deliberately placed fourth. Jumping here first is the most common mistake in how people approach AI.
P is more important than your tools.
AI use isn’t a “set it and forget it” decision. Periodically check whether a given solution is actually improving efficiency, revenue, or customer satisfaction, and be willing to revise it.
Since willpower and motivation are unreliable, the practical fix is calendar-blocking: schedule a recurring slot for reflection, the same way you’d schedule a gym session, rather than relying on remembering to check in.
Day 3 moves into Level 5: full code control, pushing to GitHub, and editing with Cursor and Anti-Gravity.
Bringing the stack together to move from idea to working product with confidence.
Day 3, the final session of the AI Builder Sprint. The agenda:
Platforms like Google AI Studio and Lovable are fast to start with, but they come with a ceiling. After enough prompting, products on these platforms can start hallucinating, breaking older features, slowing down, or locking you inside that one company’s environment. Level 5 removes that ceiling entirely: your code, your repository, your hosting, your choice of AI model.
The stack taught here (Next.js, Supabase, OpenRouter, GitHub, Vercel) is described as what builders across the world, from small teams to large ones, actually use in production. None of it requires knowing how to write code by hand. The coding agent does that. What it requires is knowing the vocabulary well enough to give the agent clear instructions and debug when something breaks.
.env file, never directly into code, and never get pushed to GitHub.The problem with platforms like Google AI Studio and Lovable: you’re building inside someone else’s environment. A product can work well on free credits, then start hallucinating, breaking older features, or slowing down, and there’s no way out except staying stuck.
The fix isn’t abandoning these tools, it’s using them as a starting point, then exporting to GitHub the moment you want real control. Every vibe-coding platform (Google AI Studio, Lovable, Replit, Bolt, Emergent) offers this export option. That’s where ownership begins.
GitHub does three things:
You don’t need the command line. GitHub Desktop gives you the same functionality through a simple interface: a dropdown of your repositories, and a few buttons.
ChatGPT only gives you OpenAI’s models. Claude only gives you Anthropic’s models. The idea: build one interface where you can talk to any model in the world, Claude, GPT, Gemini, DeepSeek, GLM, Mistral, side by side. Tools like LLM Arena and AI Fiesta already do something similar; this session built a version of it from scratch.
If you’re building anything at enterprise or B2B scale, customers want the ability to switch between models. OpenRouter is how you give them that.
The build started from a single detailed prompt, covering: a PIN-based login (since this was a personal tool, not public-facing), a chat interface with model selection powered by OpenRouter, per-message token count and cost tracking across models, all logs saved to Supabase, an .env file to capture every credential, and a clean design with soft gradients, specified in advance because the plan was to deploy through Vercel.
Every LLM has two memories: training memory (what it learned during pre-training) and context memory (what’s in front of it right now). You can’t rely on training memory for anything that changes over time, documentation, versions, pricing, so give the model the current documentation directly in your prompt rather than assuming it already knows.
For a toy project, one detailed prompt is enough. For anything production-grade, the better sequence is: have a conversation with the model first, turn that into a proper product requirement document, then build from the PRD.
All three, Anti-Gravity, Cursor, and Claude Code, work the same way and offer the same core features. What differs is the underlying models and the price:
Plan mode is worth using before letting any of these actually write code. Instead of jumping straight to implementation, plan mode produces a proposed implementation plan first, what it intends to build, what questions it still has, what database tables it will create, what it plans to test. Reviewing that plan before approving it catches problems early.
Don’t overthink model selection. Whenever a top-tier model like Opus 4.8 is available to you, use it. That’s the current reality.
.env fileAnything secret, API keys, passwords, one-time tokens, goes into an environment file that never gets pushed to GitHub. You don’t need to remember to do this yourself, the coding agent typically sets this structure up on its own once it understands the product needs external services.
An agent can’t connect to Supabase or OpenRouter until you hand it the actual keys. This means creating an account on each service, copying the API key from their dashboard, and pasting it to the agent (or directly into the .env file yourself). Interfaces change often enough that even experienced builders sometimes screenshot a confusing dashboard and ask the AI where the key actually is, rather than hunting for it manually.
Errors are expected, not a sign something went wrong with your process. The demoed build hit a real error on first run: a screenshot of the error, pasted back into the same conversation, was enough for the agent to diagnose and fix it. The same pattern repeated for UI glitches later in the build.
AI doesn’t owe you a perfect one-shot result. You have to keep iterating. It’s not required to start with complete clarity, it’s only required to start.
Vercel is a deployment platform (also the company behind Next.js and Bolt). Once your GitHub account is connected, any repository you create becomes automatically visible on Vercel. The flow: click Add New Project, select the repository, click Import, then Deploy. Within moments, the product is live on a public URL.
For generous usage, Vercel is free.
Once a product is live, you need to know how it’s actually being used, sign-ups, conversations, which models people are choosing. PostHog (positioned as “Google Analytics, but better”) handles this. As with everything else in this stack, you don’t need to configure it manually, hand your API key to the coding agent and ask it to integrate PostHog, and it builds the dashboards for you.
This is one path, not the only path. Don’t be limited by only the tools shown here, go find what fits your own build.
The assignment isn’t to copy the exact OpenGPT build. Using the same stack (Anti-Gravity, GitHub, Supabase, Vercel, OpenRouter, optionally PostHog), build something different: an LLM Judge, a tool that sends the same prompt to multiple models, collects their answers, and returns a verdict on which response is better and more efficient.
The sprint’s purpose was never just tool literacy. The closing argument: most people default to thinking about AI only inside their own small circle, their own job, their own family, how to be more productive, how to do their own work faster. That instinct is human, but it leaves a much bigger opportunity untouched.
Some scale, cited directly in the session: rural India has roughly one doctor for every 11,000 people, versus 1 in 800 in urban areas. Over 100,000 schools in India operate with a single teacher for the entire school. Problems at this scale, healthcare access, education access, are exactly the kind of problems AI is now cheap and accessible enough to help address, not just inside a company, but at a societal level.
The most sophisticated scientist at NASA has access to the same tools you now have.
The final ask wasn’t to enroll in anything. It was this: if there’s a change you want to see in the world, the tools to start building toward it are no longer out of reach. That responsibility now sits with whoever picks it up.