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

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

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

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 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

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

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 components

• The importance of consistency, comments, and structure

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

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

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

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

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

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

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

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

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

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

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