Vibe coding is less about writing every line yourself and more about collaborating with AI to bring ideas to life. In this session, you’ll explore how software development is changing and what that means for how you approach learning, building, and shipping software in the age of intelligent tools.

What you’ll learn:

• What vibe coding is and how it differs from traditional coding
• Why AI is shifting the role of the developer from “coder” to “creative director”
• How prompting, feedback, and iteration replace syntax memorization
• Why this shift opens up new ways to build, even for beginners
• Where vibe coding fits in modern software workflows and careers

From Replit to Cursor, Claude to ChatGPT, this session introduces the tools that power vibe coding. You’ll get a feel for what each one offers and how to choose the right combination for your coding style, stack, or learning goals.

What you’ll learn:

• An overview of leading AI-assisted development tools
• How tools like Replit and Cursor integrate AI into the coding experience
• The difference between chat-first (e.g., Claude) and IDE-first (e.g., Cursor) tools
• How to match tools to your skill level, workflow, or project type
• Tips for using multiple tools together effectively

You’re not just writing code anymore, you’re guiding an AI to write it with you. This session dives into how prompting works, why it’s a skill worth mastering, and how thinking like a prompter reshapes the way you approach learning and building software.

What you’ll learn:

• The core differences between programming and prompting
• Why is prompting a creative and technical skill
• How effective prompts lead to faster, better AI-generated code
• What does it mean to “debug your prompt” instead of your code
• How this mindset shift changes how you learn, experiment, and iterate

Vibe coding isn’t random, it’s a rhythm. This session gives you a practical framework for working with AI tools, helping you go from idea to code in a structured, repeatable way. You’ll learn how to work with the model, not just use it, and how to guide the process with intention.

What you’ll learn:

• A step-by-step workflow for building with AI (Plan → Prompt → Verify → Improve)
• How to structure your prompts to get usable results faster
• Techniques for reviewing and validating AI-generated code
• When to intervene, correct, or iterate, and when to let the AI lead

Start here to understand what “software architecture” really means. We’ll introduce the key building blocks of any modern system: interfaces, logic, data, and communication, and show why a well-structured system is more than the sum of its parts.

What you’ll learn:

• What software architecture is and why it matters
• The four core components of any modern app: UI, logic, data, and communication
• How do these components interact to create functioning systems
• Common architectural patterns in today’s applications
• How thinking in systems sets the foundation for building with AI

Zoom in on the three core components of most apps. You’ll learn the purpose of each layer, what kinds of logic or data they handle, and how they depend on one another to deliver a complete experience to the user.

What you’ll learn:

• The distinct roles of the frontend, backend, and database in an app
• What each layer is responsible for, from UI to business logic to data storage
• How information flows between the layers to serve a user request
• Why separating concerns leads to better performance, scalability, and maintainability
• How to think about these roles when prompting or building with AI

Follow the path of a user action as it travels from the browser to the backend and back. This session turns abstract roles into real movement, showing how the pieces work together when a request is made and a response is returned. You’ll also learn the basics of how browsers and servers communicate using HTTP.

What you’ll learn:

• What happens step-by-step when a user interacts with a web app
• How the browser sends requests and how servers process and respond
• The role of HTTP in connecting frontend and backend systems
• Key concepts like status codes, headers, and request methods (GET, POST, etc.)
• How does understanding this flow help you design better user interactions and debug more effectively

Once you understand the internal flow, it’s time to look outward. Learn what an API is, how it allows different systems or services to exchange data, and how you can prompt or build APIs into your own apps, even without writing everything from scratch.

What you’ll learn:

• What an API is and why it’s used in modern software
• The difference between internal and external APIs
• How APIs expose functionality and data in a standardized way
• Key concepts like endpoints, requests, responses, and authentication
• How to use or create APIs when prompting AI or building full-stack apps

APIs rely on protocols, like HTTP, to send and receive data. This session gives you a lightweight but powerful understanding of the protocols that power modern communication, including HTTP, WebSockets, and more. You’ll get a clear sense of how data moves under the hood and why these protocols matter when building real systems.

What you’ll learn:

• What a protocol is and why software relies on them to communicate
• How HTTP enables request-response cycles in web applications
• Key parts of HTTP: methods, headers, status codes, and payloads
• What WebSockets are and when to use them for real-time communication
• How to reason about system behavior by understanding underlying protocols

The Model Context Protocol (MCP) is an emerging standard that allows AI models to interact with external tools, APIs, and data sources in a consistent, secure, and scalable way. Rather than hard-coding integrations for every model and system, MCP provides a unified interface that lets models request capabilities, manage stateful sessions, and access structured context.

What you'll learn:

• What the Model Context Protocol is and why it matters
• How it solves the complexity of connecting LLMs to real-world systems
• What a typical MCP-powered workflow looks like
• How does this protocol fit into the broader architecture of AI-enabled apps

Armed with architectural knowledge, you’ll now explore how to design frontend or backend components that are reusable, connected, and easy to maintain, especially in AI-influenced codebases where modularity is key for iterating quickly and prompting effectively.

What you’ll learn:

• What components are and why they matter in modern development
• How to design UI and backend components that are clear, scoped, and reusable
• The role of inputs (props, parameters) and outputs (events, responses) in a component’s interface
• How modular components make AI-assisted development faster and easier
• Best practices for naming, documenting, and prompting around components

Finally, see how everything you’ve learned shows up in real dev stacks. Explore combinations like Next.js, Supabase, or Vercel + Edge Functions and understand how frontend, backend, APIs, protocols, and context all come together in the tools used by today’s developers (and AI).

What you’ll learn:

• What a modern dev stack looks like and why the stack matters
• How common tools map to system roles (e.g., frontend, backend, database, hosting)
• Example stacks like Next.js + Supabase, or Replit + PostgreSQL
• How AI fits into these stacks as a builder, assistant, or even runtime component
• How to choose a stack based on your project goals and constraints

This session breaks down how code interacts with memory, logic, and data. You’ll build a mental model of how variables, conditionals, and instructions shape program behavior, helping you reason about code, whether you’re writing it or prompting for it.

What you’ll learn:

• How code controls memory and logic flow
• Why does understanding these basics make AI-generated code easier to debug and trust

Learn how different types of data, like numbers, strings, arrays, and objects, are represented and manipulated in code. You’ll see how these structures show up in real-world apps and how to work with them effectively when prompting or coding.

What you’ll learn:

• The difference between primitive types (numbers, strings, booleans) and complex structures (arrays, objects)
• When and why to use each type or structure
• How data is accessed, modified, and passed around in programs
• How to recognize and use these types when reading, writing, or prompting code

Control flow determines what your program does and when it does it. This session introduces conditionals and loops, the tools that let your code respond to different situations and repeat tasks automatically.

What you’ll learn:

• How if, else, and else if conditionals work
• How loops (for, while) let code repeat instructions
• Common patterns like early returns and loop breaks
• How control flow shapes program behavior and logic

Functions let you group logic into reusable blocks, and scope determines where variables exist and how long they live. This session shows you how to write clean, modular code and avoid common scope-related bugs.

What you’ll learn:

• How to define and call functions with inputs and outputs
• The difference between global and local scope
• How functions help structure and simplify your code
• Common mistakes with scope and how to avoid them

Not everything goes as planned. This session introduces basic error handling so your app can respond to failures without crashing. You’ll learn how to anticipate problems, catch errors, and keep your app stable.

What you’ll learn:

• What errors are and where they come from
• How to use try, catch, and finally blocks
• The difference between runtime and logical errors
• How to prompt AI to include error handling in generated code

This session covers how to organize your code into clear, logical units, from splitting code into functions to structuring files and folders. Clean structure makes it easier to debug, prompt around, and build on over time.

What you’ll learn:

• How to break code into functions and modules
• Naming conventions that improve readability
• When to separate code into different files or folders
• How structured code improves AI collaboration and long-term maintainability

Version control is essential for building real apps, especially as your project grows or involves multiple collaborators (including AI). This session introduces Git and shows how to manage your codebase over time with clarity and confidence.

What you’ll learn: 

• What version control is and why it matters

• How to initialize a Git repo and track your code history

• The basics of commits, branches, merges, and rollbacks

• How to use GitHub for hosting and collaboration

• How to prompt AI to help write good commit messages, resolve conflicts, and manage branching strategies

In this session, we'll code a small app without any AI assistance. The goal isn’t to memorize syntax, but to experience how inputs, logic, and outputs flow together. This hands-on build gives you a foundation to better guide AI later.

What you’ll learn:

• How to plan and build a minimal app from start to finish
• How different parts of the code connect (inputs, processing, outputs)
• Where bugs commonly appear and how to debug them
• Why building manually makes you a stronger AI collaborator

This session introduces what a database is, how it works, and why it matters. You’ll learn how data is stored in tables, what records are, and how apps use databases to stay dynamic, responsive, and persistent.

What you’ll learn:

• What a database is and why most apps need one
• The difference between tables, rows (records), and columns (fields)
• How data is stored, retrieved, and modified
• The basics of reading and writing data from an app
• How to think about databases when prompting AI to build full-stack apps

Not all databases work the same. This session breaks down the difference between SQL and NoSQL, when to use each, and how to write simple queries to interact with them.

What you’ll learn: 

• The key differences between SQL (relational) and NoSQL (document-based) databases

• Common use cases for each type (e.g., user data vs. flexible content)

• How data is structured in SQL tables vs. NoSQL collections

• Basic SQL queries (SELECT, INSERT, UPDATE)

• How to prompt or build with SQL/NoSQL, depending on your project needs

This session shows you how apps talk to databases to store and retrieve information. You’ll learn how to prompt AI to set up data connections, handle queries, and protect against common issues like bad data or security risks.

What you’ll learn: 

• How apps connect to databases (via drivers, clients, or ORMs)

• How to use AI to scaffold safe, working database logic

• What to watch for: injection risks, validation, and schema mismatches

• How to prompt AI to help with querying, structuring, or debugging data layers

• Best practices for keeping database access secure and clean

When a user creates an account or logs into your app, a series of secure steps kick in behind the scenes. You’ll explore how identity is verified, sessions are managed, and data stays protected, all essential for building trustworthy apps.

What you’ll learn: 

• How authentication works step by step

• The difference between login, signup, and session handling

• How passwords, tokens, and cookies are used

• Basics of tools like Supabase Auth or Firebase Auth

• How to prompt AI to generate secure, production-ready auth flows

Building secure authentication isn’t just about making it work; it’s about making it safe. Learn how to guide AI to generate secure login flows, handle tokens properly, and avoid common mistakes in auth logic.

What you’ll learn: 

• How to prompt for secure JWT-based authentication

• When and how to use OAuth for third-party login (e.g., Google, GitHub)

• Best practices for handling passwords, tokens, and sessions

• Common security risks in AI-generated auth code and how to catch them

• How to review and improve auth-related prompts for real-world use

Data doesn’t always show up the way you expect. Learn how to build (or prompt) apps that stay stable when queries fail, responses are empty, or inputs are malformed, and how to help AI write resilient data logic.

What you’ll learn: 

• How to handle missing, null, or malformed data safely

• Patterns for fallback values, loading states, and user-friendly errors

• How to use AI to generate robust, defensive data logic

• How error handling differs between frontend and backend data flows

• Best practices for logging and debugging data issues

Learn how to link your hand-built app to a real database. You’ll store and retrieve user data, making your project dynamic and stateful, just like in production-ready applications.

What you’ll learn: 

• How to connect your frontend or backend to a database

• How to store user input and retrieve it on page load

• Basic read/write operations using real database tools

• How to keep your data structured, safe, and accessible

• How does this connection bring your app to life for real users

Clean code isn’t about perfection, it’s about clarity. In this session, you’ll explore the habits and patterns that make your code readable, flexible, and easy to debug, whether it’s written by you or AI.

What you’ll learn: 

• What “clean code” means and why it matters

• Naming conventions that improve clarity

• How to write small, focused functions

• The importance of consistency, comments, and structure

• How to prompt AI for clean, maintainable code (not just working code)

Functional testing ensures that features behave as expected from the user’s perspective. You’ll learn how to manually test key flows, identify issues through observation, and use AI to help diagnose and fix bugs fast.

What you’ll learn: 

• What functional testing is and how it differs from other test types

• How to test full user interactions (e.g., login, form submission)

• How to spot common UI and logic errors by thinking like a user

• How to ask AI to help identify, explain, or fix test failures

• When functional testing is enough and when to go deeper

Testing helps you catch bugs before users do. This session covers the difference between unit and integration tests, and how to use them to confirm your app’s behavior as it grows.

What you’ll learn: 

• What unit tests and integration tests are, and when to use each

• How to test individual functions vs. entire feature flows

• Common tools for writing and running tests (e.g., Vitest, Jest)

• How to prompt AI to generate testable code

• How testing protects you from unexpected breakage during changes

Good code starts with a good prompt. In this session, you’ll break down what makes a prompt work, from clarity and context to examples and constraints, so you can guide the AI to produce useful, reliable code.

What you’ll learn: 

• The anatomy of an effective prompt

• How to give the AI enough context without overwhelming it

• When to use examples, comments, or pseudo-code

• How vague vs. specific prompts change the output

• Techniques for iterating and refining prompts for better results

Modular code is easier to test, maintain, and build on. In this session, you’ll learn how to prompt AI to create well-scoped functions, components, and files, not just long, messy scripts, so your codebase stays clean as it grows.

What you’ll learn: 

• How to structure prompts for reusable functions and components

• How to define clear inputs, outputs, and responsibilities

• Prompting strategies for splitting logic into separate files

• Why modular code improves AI collaboration and debugging

• How to ask for updates or extensions to individual components without breaking the whole flow

AI doesn’t always give you what you want, unless you know how to guide it. This session teaches you how to take control of AI output by being intentional with language, structure, and constraints in your prompts.

What you’ll learn: 

• How to phrase prompts to reduce vagueness and improve precision

• Ways to limit or guide output format (e.g. “only return the function”)

• How to use step-by-step instructions or pseudo-code for clarity

• Techniques to steer the tone, style, or complexity of the output

• What to do when the AI “hallucinates” or ignores instructions

Big features rarely come from a single prompt. In this session, you’ll learn how to break down complex goals into smaller, focused steps, guiding AI through a clear, controlled workflow.

What you’ll learn: 

• What prompt chaining is and why it works

• How to plan multi-step build flows (e.g., design → structure → code → refine)

• Techniques for passing context between prompts

• When to separate vs. combine tasks in a prompt chain

• How chaining helps you build larger, more reliable systems with AI

AI can generate code fast, but understanding what it gave you is key. In this session, you’ll learn how to read AI-generated code critically, spot issues, and safely modify or extend it to fit your real goals.

What you’ll learn: 

• How to break down and understand AI-written functions or components

• Techniques for identifying unnecessary, broken, or unsafe code

• How to confidently edit or refactor AI-generated output

• What to do when the code “works” but doesn’t solve the right problem

• How to use the AI itself to help explain or revise its output

AI is powerful, but not perfect. This session explores where code generation breaks down, from logic gaps to misunderstood requirements, and how to spot, adapt, or correct these issues as a builder.

What you’ll learn: 

• Common weaknesses in AI-generated code (e.g., hidden bugs, fragile logic)

• Why AI struggles with edge cases, state, or long-term structure

• How to review output critically instead of trusting it blindly

• When to re-prompt, refactor, or write by hand

• Strategies for keeping control over quality and intent

Bad output usually means a bad prompt, not a broken AI. This session teaches you how to spot where your prompt went wrong and how to rewrite it for better results without starting from scratch.

What you’ll learn: 

• How to analyze AI output to find prompt issues

• Common prompt mistakes and how to fix them

• Techniques for adding context, clarity, or constraints

• When to simplify vs. re-sequence your prompt

• How to iterate quickly without losing your goal

As you shift from building apps by hand to rebuilding and expanding with AI, having solid prompt templates gives you a head start. This session gives you plug-and-play prompts for frontend components, backend logic, APIs, and more, so you can scaffold faster and reuse them across projects.

What you’ll learn: 

• Core prompt templates for common dev tasks (UI, routes, API calls, logic, etc.)

• How to adapt templates to your project stack or style

• The balance between reusable structure and task-specific detail

• How to build your own prompt library over time

• How these templates set you up to rebuild and scale apps efficiently with AI

Now that you’ve built a small working app manually, it’s time to combine those skills. You’ll rebuild your app using AI and then push it further by prompting for new features, refactors, and real-world improvements.

What you’ll learn: 

• How to translate a working app into structured prompts

• How to use prompt templates to scaffold features, routes, and logic

• Strategies for upgrading your app’s architecture and UX with AI

• How to keep your code clean, modular, and production-ready

• How to expand an AI-built app with confidence and control

Security isn’t just for enterprise apps. Even small projects can leak data, expose users, or get exploited. In this session, you’ll learn why security is a critical part of software design and why AI-generated code needs an extra layer of review and awareness.

What you’ll learn: 

• What software security means and why it matters

• Common risks in AI-generated or fast-built apps

• Real-world examples of small mistakes causing big problems

• The mindset of secure-by-default development

• How to start thinking like both a builder and a defender

AI can write impressive code fast, but it’s not always safe. This session covers the most common security mistakes made by large language models, so you can catch them before they ship.

What you’ll learn: 

• The most frequent security flaws in AI-generated code (e.g., injection, broken auth, exposed secrets)

• Why LLMs often miss context around permissions and user input

• How to spot “secure-looking” code that isn’t safe

• Techniques for prompting more securely and reviewing AI output critically

• How to layer security into your workflow without slowing down

Storing user data isn’t just a technical decision; it’s a legal and ethical one. This session introduces core privacy concepts to help you handle personal data responsibly, even in AI-assisted apps.

What you’ll learn: 

• What personal data is and why it needs protection

• Basics of data privacy laws like GDPR and CCPA

• How to store, transmit, and delete data responsibly

• Why AI-generated code can accidentally mishandle private info

AI doesn’t always prioritize security unless you tell it to. This session teaches you how to write prompts that encourage safe patterns, avoid risky shortcuts, and generate code that’s production-ready and security-aware from the start.

What you’ll learn: 

• How to guide AI toward secure patterns (e.g., hashed passwords, parameterized queries)

• Phrasing techniques to avoid dangerous defaults

• How to prompt for input validation, auth checks, and permission handling

• Examples of secure vs. insecure AI output and how to correct them

• How to build secure-by-default habits into your prompting workflow

Before you build, you need a clear scope. This session helps you take a rough idea and shape it into a focused, buildable product. You’ll define the core features, the user journey, and what “done” actually looks like, so you don’t just build something, you build something valuable.

What you’ll learn: 

• How to evaluate and refine app ideas with real-world value in mind

• What “scope” means and why it’s crucial for AI-assisted development

• How to define your app’s core problem, user, and feature set

• Techniques for identifying MVP boundaries vs. “nice to haves”

• How clear scoping leads to better prompts, faster builds, and scalable results

With your idea scoped, it’s time to design how your app will be built. This session shows you how to plan out the architecture, including components, routes, APIs, and data, and how to prompt AI to generate a clean, scalable foundation you can build on.

What you’ll learn: 

• How to define your app’s structure across frontend, backend, and data layers

• How to identify the key components, routes, and logic blocks

• How to prompt AI to scaffold your project architecture

• Best practices for modular, maintainable structure from day one

• How thoughtful architecture leads to faster, cleaner development

This session teaches you how to prompt AI to create your backend logic, including APIs, data validation, and key workflows, so your frontend can rely on solid, structured contracts.

What you’ll learn: 

• How to identify the core logic and rules your app needs

• How to prompt AI for backend endpoints and handler functions

• How to implement validation, error handling, and business rules

• Best practices for writing API contracts that your frontend can rely on

• How to keep your backend modular, testable, and secure

Once your backend logic is in place, it’s time to give your app memory. In this session, you’ll set up a real database and use AI to help you define models, connect endpoints, and persist user and app data reliably.

What you’ll learn: 

• How to structure and create core data models (e.g., users, posts, orders)

• How to prompt AI to handle database operations (CRUD) safely

• How to connect routes and logic to real data

• How to use tools like Supabase or Firebase to manage schema and access

• Why a strong data layer makes everything else from auth to UI possible

Now that your backend and database are ready, it’s time to secure your app. In this session, you’ll add authentication so users can create accounts, log in, and access protected content, all with help from AI and real-world tools.

What you’ll learn: 

• How to prompt AI to scaffold signup, login, and logout flows

• How to store and validate credentials securely (e.g., hashed passwords, tokens)

• How to protect routes and control access to data

• How to implement session handling with tools like Supabase Auth or JWT

• How to test auth flows and connect them to your frontend later

It’s time to bring your app to life visually. In this session, you’ll use AI to generate frontend components, then refine and extend them to match your style, flow, and user needs.

What you’ll learn: 

• How to prompt AI for reusable UI components (forms, buttons, layouts)

• How to customize generated code for your brand or use case

• How to connect frontend elements to your app’s data and logic

• Best practices for clean, responsive, and accessible interfaces

• How to maintain design consistency while building fast with AI

A production app isn’t just functional, it’s responsive, reliable, and polished. In this session, you’ll level up the user experience by improving how your app handles input, shows feedback, and manages loading and error states.

What you’ll learn: 

• How to build and prompt for user-friendly forms with validation

• How to manage loading states and async behavior cleanly

• How to surface helpful errors without leaking sensitive info

• Techniques for giving users real-time feedback and confirmation

• Why polish is what makes your app feel “real” and ready to ship

Before you ship, you need to trust your code. This session shows you how to write and prompt for tests that confirm your app’s logic, catch regressions, and give you confidence to ship faster without breaking things.

What you’ll learn: 

• The difference between unit tests (small pieces) and integration tests (full flows)

• How to write and run automated tests for the backend and frontend

• How to use AI to generate test cases and improve test coverage

• Common testing tools (like Vitest, Jest, or Cypress)

• How testing fits into a professional development and deployment workflow

Once your app is built and tested, it’s time to deploy. In this session, you’ll use tools like Vercel or Replit to get your app live on the internet, connect your backend and database, and make sure everything runs smoothly for real users.

What you’ll learn: 

• How to choose the right hosting platform for your stack (Vercel, Replit, etc.)

• How to deploy the frontend and backend together

• How to handle environment variables and deployment secrets

• How to test your app live and fix deployment issues

• How to prompt AI to help configure production builds, scripts, and settings

Shipping is just the beginning. In this session, you’ll learn how to monitor, improve, and expand your app over time. You’ll use AI to help debug, refactor, and ship new features — while keeping your codebase clean and your users happy.

What you’ll learn: 

• How to track bugs, performance issues, and user feedback

• How to prompt AI for safe refactors and incremental changes

• When and how to test before shipping updates

• How to use version control and branching to manage updates

• Why iteration is the key to long-term value and real-world usage

In a world where everyone’s building with AI, the winners aren’t just the ones who ship fast; they’re the ones who ship with purpose, polish, and persistence. This session is about turning your project from “yet another AI app” into something people actually use and talk about.

What you’ll learn: 

• Why most AI projects fade and how to avoid it

• How to define a real “value hook” that your users will remember

• What makes a product feel real, credible, and worth revisiting

• How to build trust through UX, performance, and messaging

• How to ship smaller, better, and more consistently over time

This session is about staying in the game, not just launching once, but learning how to stay committed to refining your product, learning from users, and navigating the AI hype cycle with real skill.

What you’ll learn: 

• Why consistency beats novelty in crowded markets

• How to avoid burn-out and “shiny object syndrome”

• How to build in public and evolve based on feedback

• What it means to be a professional, not just a builder

• How to set a post-course game plan you’ll actually stick to

You’ve built, learned, shipped, and leveled up. This session wraps up your journey through the course, but it’s not the end. You’ll regroup at the final event to showcase what you’ve built, connect with other builders, and prove just how far you’ve come.

What you’ll learn: 

• How to prepare your project for the final presentation

• What “done” looks like and how to add the final polish

• How to reflect on your build journey and growth

• What to expect at the final certification event "The Great Vibe"

You’ll have one full month to build your own vibe-coded application and submit it online for final certification. This is your chance to apply everything you’ve learned, not just to prove you can build, but to show what you’re truly capable of.

All submitted apps will be shared with the community. The most appreciated projects will be invited to demo live and share their journey during The Great Vibe, our final showcase event celebrating bootcamp graduates.

What you’ll get: 

• 1 month of focused build time

• Feedback from the community and mentors

• A shot at presenting live during the final event

• Certification as a Pro Vibe Coder