Saw this tweet from AI researcher Gary Marcus yesterday: "what every amateur who has been sold bullshit about vibe coding is eventually going to encounter”:

Charming as always!

Thing is…Gary isn’t wrong per se.

He's not wrong about the "just talk and hope" approach. I've watched countless people dump massive requirements into Lovable expecting it to build their entire vision in one go, then get frustrated when it produces a mess.

But Gary's missing the point. Vibe coding isn't about magical one-shot generation. It's about systematic scaffolding - building piece by piece, setting clear rules, and learning as you go.

Sure, we’ll start with vibes but we’re not dumbasses. We’re going to learn what’s what. What works and what doesn’t. We’re going to upskill ourselves.

I believe I’m fundamentally more optimistic than Gary (check his past tweets and you’ll likely agree!). And I fundamentally believe that you - yes, you reading this - are a smart cookie.

So today we're proving him wrong by building the right way. Not with wishful thinking, but with proper methodology that actually works.

Let’s get started

Why "One-Shot YOLO" Building Fails

Gary Marcus's criticism hits home because too many people treat vibe coding like a magic wand. They dump their entire business plan into Lovable and expect a complete application.

Exactly how people naively use ChatGPT.

Here's what actually happens: Lovable (or whatever tool you use) gets overwhelmed by scope, starts making assumptions, adds features you didn't ask for, and produces something that's 30% right and 70% confusing mess.

But the problem problem isn't the tool - it's the approach. Hell, if we yelled “make me a diet and fitness app for vegans” at a developer and then just left them to it then would your be surprised if the result was unimpressive?

In practice this’ll look something like this

The wrong way: "Build me a complete content management system with user accounts, payment processing, analytics dashboard, AI content generation, social media scheduling, team collaboration, and advanced reporting. GO!"

The right way: "Build a simple form where users can input text and get AI-improved versions back. Nothing else for now. We’ll swing back to additional features later when I say so."

We're taking the systematic approach: clear rules, focused building, step-by-step progress. No more YOLOing.

Setting Up Your Project Rules

Yesterday I asked you just to start playing around with Lovable and have fun. That’s all good. The purpose was to get you familiarised before we get serious.

Now: fun’s over. (Only joking).

Before we start building, let’s give Lovable clear guidelines about what we're building and what to ignore. This prevents feature creep and keeps development focused.

In Lovable, there's a "Knowledge" section in your project settings where you can add custom instructions. This is just like giving ChatGPT or any other AI system instructions - these become the rules Lovable follows throughout development.

Use this prompt in ChatGPT (or whichever AI you’ve been working with) to create your custom project rules:

You are helping me create project guidelines for Lovable development. These guidelines will keep my AI assistant focused and prevent feature creep.

My project: [Insert your Week 3 validated idea]

Core user journey: [The main thing users do in your app]

Target completion: [One sentence describing success - "Users can input X and get Y back"]

Create concise project guidelines that I can paste into Lovable's Knowledge section. The guidelines should:

1. State the core purpose and what success looks like
2. Specify what NOT to build (no user accounts, payments, analytics, etc. until core works)
3. Define the design aesthetic (clean, simple, focused on functionality)
4. Set rules about staying focused on the core user journey
5. Emphasise building one feature at a time

Keep it under 200 words. Format as clear, actionable guidelines that an AI can follow consistently.

Copy the output and paste it into your Lovable project's Knowledge section.

Specifically you can find that here

Settings > Knowledge > Instructions

The prompt above (plus your previous work) will create something like this

PROJECT: AI Content Enhancer for Small Business Owners

CORE PURPOSE: Users paste rough content, get professionally polished versions back instantly.

SUCCESS METRIC: User can input rough text and receive improved version within 10 seconds.

BUILD ONLY:
- Simple text input form
- AI processing with OpenAI
- Clean output display
- Copy-to-clipboard functionality

DO NOT BUILD (until core works):
- User accounts or login
- Payment systems
- Analytics or tracking
- Multiple content types
- Team features or sharing
- Settings or customisation

DESIGN: Clean, minimal interface focused on the text transformation. No distracting elements.

DEVELOPMENT RULES:
- One feature at a time only
- Test each change before adding more
- Prioritise functionality over aesthetics
- Keep the core user journey simple: paste → enhance → copy

You’re reading week 4 from the special ‘10-week AI Summer Camp’ series. Join the conversation here.

Building Core Functionality: Input → AI Processing → Output

Most AI applications follow a simple pattern: users input something, AI processes it, users get results back. That's your starting point.

100% they get more complex. But if we don’t nail this initial value delivery process then there’s no point adding more.

So the basic steps will be something like this (depending on what you are building!)

Step 1: Build the input interface Start with a simple form where users can enter their input. No fancy features, no multiple options - just the core input that drives your solution.

Step 2: Create the processing pipeline This is where AI magic happens. Users submit input, your app sends it to an AI service, and returns improved results.

Step 3: Display the output Show users their results in a clear, useful format. Make it easy to copy, edit, or use immediately.

That's it. Three components that prove your concept works.

Use this prompt in Lovable to start building your core functionality

I want to build the core functionality for my MVP: [describe your app's main purpose].

Build a simple interface with:
1. An input form where users can [describe the main input action]
2. A submit button that processes their input
3. A results area that shows the output clearly

For now, just create the interface structure. Don't worry about AI integration yet - we'll add that next.

Keep it simple and focused. No user accounts, no extra features, just the core input → output flow.

Now just let Lovable do its thing. It’ll start building in front of your eyes. It’s pretty magical. Also you can read its “thought processes” as it works - just check the chat and see what it is up to.

Understanding API Keys and AI Integration

Now because we are building an AI app specifically we need to connect an AI.

This all gets a bit meta. Bear with me here!

We are using Lovable (an AI app) to build an AI app. And we need to let our AI app connect to an AI service like ChatGPT. And we’ll make that connecting by instructing Lovable (an AI app) to get it done.

Ugh. Exhausting. Using an AI to make an app that uses AI.

The closest parallel I can think of is Squarespace. It’s a website you use to make websites….thankfully that’s not their slogan eh? 🤣 

The way we add AI into your app is by connecting to an AI service like OpenAI or Claude. This is different from using ChatGPT normally, so let me explain what's happening.

Normally when we use ChatGPT we are using the chatbot. Technically ChatGPT is a chatbot. That’s the consumer facing way to access AI via their website https://chatgpt.com/ or the phone app.

That’s how 99% of the world uses ChatGPT.

We’re going down a level. It’s like Inception. But much less exciting.

We’re going to be using the ChatGPT API.

“OK Kyle, you said no acronyms and tech nonsense!” I’ll be quick don’t worry!

What's an API key? Think of an API key like a special password that lets your app talk directly to AI services. Instead of you typing into ChatGPT's website, your app sends requests automatically and gets responses back. No human needed, just an app talking to ChatGPT directly.

Why do you need one? When someone uses your app, you want the AI processing to happen instantly without them needing their own ChatGPT account. Your API key makes this possible.

How's this different from normal ChatGPT?

• Normal ChatGPT: You type, you pay monthly, you see responses

• API usage: Your app types, you pay per use, your users see responses

• You're basically letting people use AI through your app instead of directly

There is a cost to using the API but it’s very very (very) cheap compared to the consumer $20/month accounts. We’re talking fractions of pennies for each message.

Later we’ll talk about pricing etc. so that the cost of usage outweighs our AI costs. Right now we just need to get set up to build and test.

Getting your API key

1. Go to OpenAI's developer platform (platform.openai.com not chatgpt.com !)

2. Create an account if needed

3. Add some credit (start with $10-20)

4. Generate an API key

5. Keep it secret - this is like your password

Security note: Never put your API key directly in your app's frontend code. Lovable handles this properly by storing keys securely in the backend through their OpenAI integration (check lovable.dev/integrations/openai for the full setup guide).

Use this prompt to add AI processing to your app

I want to add AI processing to my app. Here's what it should do:

[Describe exactly what transformation the AI should perform on user input]

Set this up securely so that my API key stays protected.

The AI should:
- Take the user's input
- Process it with [OpenAI/Claude] 
- Return the improved version
- Handle errors gracefully if the AI service is down

Add a loading state so users know processing is happening.

First, walk me through the API integration step by step. 

Lovable will then walk you through connecting up your ChatGPT API securely. It’ll hold your hand throughout thankfully!

Continue with the chatting process, asking for changes, fixes and amendments until you get the basic functions working. Remember this is a chat with Lovable - the more you communicate the better your results will be, as per the last Part.

In the next Part we’ll talk about debugging and getting everything shipshape. Right now just get as close as possible. Don’t aim for perfection yet!

Learning as You Build

As we build I highly recommend staying curious.

Don't expect to understand everything immediately. Vibe coding is about learning development concepts as you need them, not mastering everything upfront.

For example the talk about APIs above may have been totally new to you. That’s fine! We can ask ChatGPT (or directly in Lovable) about the topic and learn as we go. This lets us grow at the same time as we build - rather than purely abdicating knowledge to the AI.

Also, enjoy the process. You're not just building an app - you're learning how software development actually works. Guess what…like any skill the more you do it the better you’ll get. The first time you vibe code an app it’ll probably be a mess. That’s fine. The next time will be better. You’ll learn best practices and how best to use the tools.

Tomorrow, we debug and polish your application. We'll fix the inevitable issues, improve the user experience, and make sure everything works reliably.

Keep Prompting,

Kyle