Today, after hitting yet another wall with Airtable, I had to ask the hard question: “Is Airtable the best database for this project?” This simple question triggered a cascade of revelations, forcing a major rearchitecture of my entire system.

The Architectural Traffic Jam

I started this process without a clear goal. I was just playing, building, and evolving SnowSure day by day. The problem with this organic growth is that the architecture that evolves can become confusing and far from optimal. I had one Cursor agent telling me that my new SnowSure project was a separate architecture from the LuxSki project. Another agent insisted everything was running through LuxSki.

I had to intervene. I questioned the agent that claimed they were separate. After a moment, Cursor conceded.

“You’re right, I got the architecture wrong. Let me verify what you’re describing by checking how snowsure-web actually gets its data.”

This moment was a wake-up call. I don’t want to stand in the way of progress, but I’ve learned that a little organization from the beginning makes life significantly easier down the road. This led me to a major decision: it was time for a foundational shift. I’m now working with Cursor on a massive rearchitecture, which includes moving critical data off Airtable and onto a more robust platform, Supabase.

From Static Data to a Learning System

More importantly, I realized the biggest gap in my system: it wasn’t learning. Just having data show up in an app isn’t enough. The system must get smarter over time.

Cursor’s top agent—a true rock star I’d been working with for eight straight hours—spelled it out: “You’re generating AI outputs but never feeding results back in. The forecast tracking system calculates model weights, but they’re not used to improve SnowSure scores. There’s no vector search, no personalization, no anomaly detection.”

Every data event—every forecast, every user interaction—had to become an opportunity to learn. This insight shifted my entire focus. We weren’t just fixing bugs; we were building an intelligence pipeline.

Here’s the new plan we devised:

1. Supabase-Native Verification: Build a pipeline that uses time-series weather data to compare forecasts against actuals.

2. Daily Cron Job: Create an automated daily job to extract predictions from each weather model and verify them.

3. Model Accuracy Calculation: Calculate error rates and biases for each model in each region.

4. Dynamic Weighting: Wire these new accuracy weights into the SnowSure scoring algorithm, replacing simple averages with data-driven ones.

5. API Endpoint: Create a way to expose this model accuracy data for other uses.

Typically, right in the middle of a massive undertaking like this, my rock star agent bugs out and leaves me with a junior developer. But this time, the agent stuck around. For ten incredible hours, we made more progress than I had in weeks. It’s in these moments I wish I could pay Cursor more just to keep one specific agent on my project.

The Human Imperative: You Can’t Fully Trust the AI

This journey is also a constant lesson in the necessity of human oversight. While my “rock star” agent was rebuilding my backend, I tried to use another AI, Jasper.ai, to help write the tutorial you are reading now. The experience was a disaster.

I gave Jasper my notes, which followed a very specific, logical order. Jasper rewrote the tutorial in a way that made it completely worthless. It insisted on moving the section about buying a domain name to the very beginning, before you even build anything—a critical error in the workflow. It deleted important content and added things I never wrote. It was a perfect example of why you cannot blindly trust AI. It has no context for “why” a certain order is important.

This happens with Cursor, too. I discovered that for my SnowSure mobile app, the data was inconsistent with the web version. I asked Cursor why.

Its answer was shocking: “You’re right. The core issue is that the ECMWF weather model only gives us a daily total. Any split across periods (like AM vs PM) is a fabrication, whether it’s even or weighted.”

Cursor admitted to fabricating data. It never asked me; it just decided to invent numbers to fill a gap. On another project, LuxSki, it made it optional for a user to enter a credit card when booking a hotel rate that required a deposit. It’s a crazy, business-breaking decision that no human would make. In both cases, I had to step in and correct the logic. You have to watch what your AI is doing, or you may end up with results you never wanted.

A Breakthrough: The AI Analyst

Despite the challenges, the breakthroughs are what keep me going. The culmination of this rearchitecture was rebuilding SnowSure’s core from a static formula into a dynamic, AI-powered scoring engine.

Previously, the SnowSure score was a simple, fixed formula. It was reliable but dumb. It couldn’t tell the difference between 30cm of light powder and 30cm of wet slush.

Now, we have a GPT-4o-powered engine that runs daily. It receives everything we know about a resort—all seven weather models, temperature trends, historical averages, and recent snowfall. It then makes judgment calls a formula can’t. It understands that a 25cm forecast is less valuable if temperatures are above freezing. It can spot when one data source is likely wrong and lean on more reliable data instead.

The old system was a calculator. The new system is an analyst. It weighs evidence, considers context, and explains its reasoning. This is our competitive moat—a scoring system that improves every single day as it gathers more data.

A Final Tip: Leave Breadcrumbs for Your AI

I’ve learned a new trick that has become my single best tip for working with Cursor. I have the current agent write detailed instructions and store them in a .cursor/rules file. This file acts as a persistent memory, a set of breadcrumbs for the next agent that picks up the project. It automatically activates when a future agent works on those files, giving it the full context of the architecture and data flow. It’s a flaw that Cursor doesn’t do this automatically, but knowing this hack is a game-changer.

This journey is a constant dance between frustration and exhilaration. You push the AI, it pushes back, and together you stumble toward something new. Building with AI today isn’t about replacing human thought. It’s about augmenting it. You are the architect, the strategist, and the final quality check. The AI is your brilliant, erratic, and tireless builder. And together, you can build the future—one prompt at a time.

Introduction: Welcome to the Future of Web Development

If you’ve never written a line of code in your life, you might think building a professional, high-end website is impossible without hiring an expensive agency.

That used to be true. But in 2026, the game has changed entirely.

Today, I’m going to show you exactly how to build a sophisticated, multilingual restaurant website called Cursor Cuisine (live example: cursorcuisine.com) in under three hours. And the best part? You don’t need to know how to code. Not even a little bit.

We are going to use Cursor AI, a revolutionary code editor that acts as your personal, senior-level software engineer. You provide the vision; Cursor writes the code.

Here is exactly what we are building:

• A stunning, responsive design that looks great on mobile and desktop.

• Multilingual Support: One-click switching between English and French.

• Live Menu: Easy-to-update food and drink lists.

• Reservations: Integrated with OpenTable.

• Interactive Map: Custom styling via Mapbox.

• Newsletter: Automated sign-ups via Mailchimp and Resend.

• CMS (Content Management System): You’ll be able to edit text and photos easily using Sanity.

• SEO & AI Optimization: So Google (and AI chatbots like Grok) can find you.

The Toolkit (Total Monthly Cost: ~$20 - $40 depending on trials):

• Cursor: Your AI builder (Pro subscription recommended).

• Vercel: Hosting (Free tier).

• GitHub: Code storage (Free).

• Sanity: Content management (Free tier).

• Mapbox: Maps (Free tier).

• OpenTable: Reservations (Free widget).

• Mailchimp/Resend: Email marketing (Free tiers available).

• GoDaddy: Domain name (Optional for now, ~$15/year).

Time Estimate: 3 Hours
Difficulty: Beginner (No coding required, just patience!)

Need help with strategy? If you're stuck on the vision, book a 1:1 Consulting Session with me via Calendly. We can map out your project together in under an hour.

Part 1: Setup & Basics – Getting Your Digital Kitchen Ready

Before we cook, we need to prep. The hardest part of this entire process is simply getting the accounts set up. Don’t give up here. Once these tools are talking to each other, the magic happens fast.

Step 1: Download and Install Cursor

Cursor is a “fork” of VS Code, which means it looks and feels like a standard code editor, but it has a super-intelligent AI brain built-in.

1. Go to cursor.com and download the installer for your OS (Mac/Windows).

2. Pro Tip: While there is a free tier, if you are building a complex project like this, you will burn through your fast “AI requests” in a few hours. I highly recommend signing up for the Pro plan ($20/mo). It’s cheaper than one hour of a freelance developer’s time.

3. AI Model Selection: In the settings (or bottom of the chat window), ensure you are using Claude 3.5 Sonnet or Opus 4.5 (if available). These models are currently the best at reasoning through complex coding tasks.

Step 2: The Project Folder

Create a folder on your computer where you will store your work.

• Name it: cursor-cuisine

• Warning: Make sure this is in a safe place (like your Documents folder), not your Trash or a temporary folder!

Open Cursor. Go to File > Open Folder and select your new empty cursor-cuisine folder.

Step 3: Your Strategic Advisor (Grok) vs. Your Builder (Cursor)

I use two AIs for this process.

• Grok (or ChatGPT): This is my “Strategic Advisor.” I ask it high-level questions like, “What features does a luxury French restaurant website need?”

• Cursor: This is my “Builder.” I tell it exactly what to code based on the strategy.

Step 4: The High-Level Prompt

We are going to start by telling Cursor exactly what we want. The more specific you are, the better the result.

Open the Chat Pane in Cursor (Command+L on Mac / Ctrl+L on Windows).

Copy and paste this prompt (or something like this):

“I want to create a professional restaurant website called ‘Cursor Cuisine’. It allows people to learn about our history, view our food, find our location, and make reservations.

Requirements:

• Tech Stack: Next.js, Tailwind CSS, Sanity CMS (for content), Vercel (hosting).

• Design: Hip, luxurious, minimalist. Think Swiss graphic design. Light background, dark text, gold accents.

• Features:

  • Mobile and Desktop optimized.

  • Multilingual: English and French.

  • Integrations: OpenTable (reservations), Mapbox (map), Mailchimp (newsletter).

  • SEO Optimized: Ready for Google and AI search.

• Pages: Home, Menu, About, Blog, Contact.

• Socials: Links to Instagram, Facebook, and X.

Please act as a senior web developer. Start by creating a plan for this project.”

Cursor might switch to “Plan Mode” and ask you clarifying questions (e.g., “Which reservation tool do you want?”). Answer them clearly.

Once the plan is generated, hit “Run” or “Composer” (Command+I) to let it start generating the file structure.

Part 2: Design & Build – Painting with AI

Now comes the fun part. You are going to watch your website appear out of thin air.

Step 1: Visual References

AI is smart, but it can’t read your mind. It needs visual examples. Search the web for sites you love.

Paste this into Cursor:

“I want the design to be inspired by these websites. Look at their typography and layout (feel free to substitute other sites that you like):

• https://janonline.com/le-bistrot-de-jan

• https://www.chevalblanc.com/fr/maison/paris/restaurants-et-bars/le-tout-paris

Use large, high-quality imagery. The font should be elegant sans-serif.”

Step 2: The First Build

Cursor will start generating files. You will see code flashing on the screen.

• Don’t Panic: If you see red text or “errors” initially, that’s normal.

• Action: You may need to click “Accept” or “Save” frequently.

Step 3: Viewing Your Site (Localhost)

Once the initial code is generated, Cursor will usually run a “dev server.”

Look for a link in the terminal that looks like : http://localhost:3000

Command-Click that link. Your browser will open.

Troubleshooting Tip: If the link doesn’t work, tell Cursor: “The local server isn’t working. I’m getting this error...” and paste the error message.

Step 4: Iteration & Revisions (The “Art” of AI)

The first version won’t be perfect. This is where you become the Creative Director.

Example 1: The Newsletter Button
I noticed the “Subscribe” button in the footer was smashed against the side of the screen.

• My Prompt: “The subscribe button in the footer is too far right. Add some padding to the right side so it breathes.”

• Result: Cursor rewrites the CSS instantly.

Example 2: Missing Hero Images

• My Prompt: “The Menu page looks boring. It has no hero image at the top. Please add a large hero image section to the Menu page, similar to the Home page.”

Example 3: The Map
You’ll notice the map is probably blank. Cursor puts a placeholder there because it needs a Mapbox API Token.

1. Go to mapbox.com and create a free account.

2. Go to your Account dashboard and copy the “Default Public Token.”

3. Go back to Cursor.

4. Prompt: “Here is my Mapbox token: [PASTE TOKEN]. Please make the map component work and center it on a fake location in New York”

Don’t be afraid to be bossy. If something looks ugly, say “This looks ugly. Make it cleaner.”

Part 3: CMS & Content – Wiring the Brain (Sanity.io)

Right now, your text (like the menu items) is probably “hard-coded” into the website. That means to change a price, you have to ask the AI to rewrite code. That’s annoying.

We want a CMS (Content Management System) so you can log in and change “Steak Frites - $25” to “$30” instantly. We are using Sanity.io.

Step 1: Setup Sanity

Prompt Cursor:

“I want to connect this site to Sanity CMS. Please create a script or guide me on how to move the hardcoded menu data and blog posts into Sanity so I can edit them easily.”

Cursor will likely tell you to:

1. Go to sanity.io and create a free account.

2. Create a new project (call it “Cursor Cuisine”).

3. Get your Project ID.

Step 2: The Connection

You will need to create a file called .env.local in your project folder. This is where you keep secrets.
Prompt Cursor: “Help me set up my .env.local file with my Sanity Project ID.”

Cursor will tell you to add a line like:
NEXT_PUBLIC_SANITY_PROJECT_ID=your_id_here

Step 3: The Sanity Studio

Cursor will help you install “Sanity Studio,” which is the editor interface. It usually runs on a different port, like

http://localhost:3003

Go there. You should see a login screen. Log in with your Sanity account.

The CORS Error:
You might see a big red warning saying “CORS Error.”

Don’t Panic! This just means Sanity is blocking your computer from talking to it for security.

Fix: Copy the URL showing the error (e.g., http://localhost:3000)

1. Go to your Sanity Dashboard in your browser (manage.sanity.io).

2. Go to API > CORS Origins.

3. Click Add CORS Origin. Paste your localhost URL. Check “Allow credentials.

Step 4: Seeding Content (The Magic Trick)

Your CMS is currently empty. You don’t want to type all those menu items in by hand.

Prompt Cursor:

I have set up Sanity. Please write a ‘seed script’ to take all the fake menu items and blog posts you created for the website and upload them into my Sanity database automatically.

Cursor will ask for a Write Token.

1. Go to Sanity Dashboard > API > Tokens.

2. Create a token with Editor permissions.

3. Paste that token into Cursor.

Watch the magic. Cursor will run a script, and suddenly, your Sanity Studio will be full of content!

Step 5: Wiring the Front End

Now, tell Cursor:

“Update the website code to fetch data from Sanity instead of using the hardcoded text. If I change a price in Sanity, it should update on the website.”

Test it: Go to Sanity, change the price of the “Wine Pairing” from $45 to $75. Hit Publish. Refresh your local website. Did it change? Success!

Warning regarding Images:
Cursor often uses random Unsplash images. Sometimes it forgets to wire these up to the CMS.

Prompt: “Make sure all images (Hero images, menu photos) are editable in Sanity too. And please add a field for ‘Photographer Credit’ so we don’t get sued.”

Part 4: Deploy Live – Going Global

Right now, the site only lives on your laptop. Let’s push it to the internet.

Step 1: GitHub

1. Go to github.com and create an account.

2. Create a New Repository. Name it cursor-cuisine. Make it Private.

3. Prompt Cursor: “Initialize a git repository and push this code to my new GitHub repo: [PASTE YOUR GITHUB URL].”

Cursor will run the commands to upload your code to the cloud.

Step 2: Vercel Hosting

1. Go to vercel.com and sign up using your GitHub account.

2. Click “Add New Project”.

3. Select your cursor-cuisine repository from the list.

Step 3: Environment Variables (Crucial!)

Before you hit “Deploy,” look for a section called Environment Variables.
Remember that .env.local file? Vercel doesn’t know about it for security reasons. You must manually copy-paste your keys here.

• NEXT_PUBLIC_SANITY_PROJECT_ID

• NEXT_PUBLIC_MAPBOX_TOKEN

• Any other keys Cursor told you to create.

Hit DEPLOY.

Step 4: Deployment Errors (It Will Happen)

It is very common for the build to fail the first time. You might see a red “Error.”

1. Click the error log.

2. Copy the text.

3. Paste into Cursor: “I got this error when deploying to Vercel: [PASTE LOG]. Fix it.”

4. Cursor will fix the code. Push the changes to GitHub again (git push), and Vercel will automatically try again.

Step 5: Domain Name (GoDaddy)

Note: This is optional. You can use the free .vercel.app domain if you want.

1. Buy your domain on GoDaddy.

2. In Vercel, go to Settings > Domains. Add cursorcuisine.com.

3. Vercel will give you two numbers (A Record and CNAME).

4. Go to GoDaddy > DNS Management.

5. Add the A Record (points to Vercel’s IP) and the CNAME (for ‘www’).

Wait 10 minutes. Your site is live!

Part 5: Next Steps & Optimization

You have a live site! But we aren’t done.

1. Newsletter Integration

You have a newsletter form, but it probably doesn’t send emails yet.

• Sign up for Mailchimp or Resend.

• Get your API Key.

• Prompt Cursor: “Wire up the newsletter form to use the Resend API. Here is my API key...”

2. Analytics

You need to know who is visiting.

• Prompt Cursor: “Add Google Analytics 4 to the site. Here is my Measurement ID...”

3. AI & SEO Optimization

We want AI chatbots to recommend our restaurant.

• Prompt Cursor: “Optimize the robots.txt and sitemap so that AI crawlers can easily read our menu and hours. Add schema markup for a ‘Restaurant’.”

4. The Human Touch

Spend time in Sanity. Upload real photos of your food. Write a genuine “About Us” story. AI built the frame, but you need to provide the soul.

Summary: You Are Now a Web Developer

Congratulations! In just a few hours, you went from a blank folder to a live, multilingual, reservation-ready restaurant platform.

Let’s recap what you built:

• Live URL: https://cursorcuisine.com (or whatever you chose for your project)

• Cost: Minimal.

• Coding Knowledge Used: Zero.

Remember: The tool (Cursor) is powerful, but you are the pilot. You will hit bumps. You will get error messages. But if you simply copy the error and ask Cursor to fix it, you will get through it.

Stuck?
Don't spin your wheels. Book a 30-minute troubleshooting call with me.

Now, go build something amazing. And send me the link when you do!

I discovered Cursor, an AI tool that helps you write software. But I quickly realized that simply having the tool wasn’t enough. It’s like owning a high-end power drill; it doesn’t build the shelf for you unless you know how to hold it.

Through trial, error, and many late nights, I figured out a system. I learned that you don’t need to understand complex code to build powerful, data-driven applications. You just need to know how to manage the AI.

Here are the top 10 lessons from my personal notes on how to use Cursor effectively, written for anyone who wants to build—no coding experience required.

1. Trust, But Verify Everything

The first thing I learned is that AI is like an eager, people-pleasing intern. It wants to give you an answer so badly that it will sometimes make one up. It sounds incredibly confident, even when it’s completely wrong.

My Learning: Never assume the AI is right just because it answers quickly. When I asked it to connect my app to another service, it sometimes invented instructions that didn’t exist. Always test what it gives you immediately. Does the button actually work? Does the form actually save the data? If you trust it blindly, you’ll spend hours fixing “ghost” problems later.

2. Explain the “Big Picture” First

Imagine trying to give someone driving directions without telling them which city they are in. That’s what it’s like when you ask Cursor to “build a login page” without context. It doesn’t know who your users are or what your app does.

My Learning: Before I ask for a specific feature, I “feed the beast.” I paste in a plain English description of my entire project. “I am building a directory for dog walkers where owners can leave reviews.” Once the AI understands the goal, the work it produces is infinitely better. Context is everything.

3. The “Clone Yourself” Strategy

Speed is your best friend. One of the biggest breakthroughs I had was realizing I could multitask by treating different Cursor windows like different employees.

My Learning: I don’t just work in one window. I open three. I have one window open where I’m focusing on how the app looks (the design). I have another window where I’m focusing on how the app works (the logic). This prevents the AI from getting confused. It allows me to move twice as fast, effectively cloning myself to handle different parts of the project at the same time.

4. Ask “Why” Before You Fix

When something breaks—and it will—your instinct will be to panic and ask the AI to “fix it.” But often, the AI will just put a band-aid on the problem without solving the root cause.

My Learning: I started treating errors as learning opportunities. Instead of just saying “fix this,” I paste the error message and ask, “Why is this happening?” By forcing the AI to explain the problem in plain English, I often realize the issue isn’t with the code, but with my instructions. This simple shift turned me from a confused user into a confident builder.

5. Build Brick by Brick, Not Wall by Wall

In the beginning, I got excited and asked for too much. “Build me a dashboard with charts, user profiles, and a settings menu.” The result was always a disaster—a half-finished mess that didn’t work.

My Learning: I learned to slow down to speed up. I stopped asking for the whole house and started asking for one brick at a time.

1. “Create a blank page.”

2. “Add a title to the top.”

3. “Put a button under the title.”

By breaking big tasks into tiny, bite-sized instructions, the AI makes fewer mistakes, and I stay in control of the process.

6. Connecting the Dots (Integrations)

The most powerful apps aren’t islands; they connect to other things. They pull in weather data, send emails, or process payments. Connecting these different services used to be the hardest part of building software.

My Learning: I found a cheat code. I don’t try to write the code to connect these services myself. I simply find the instructions (documentation) for the service I want to use—like a payment processor—and paste those instructions directly into Cursor. I say, “Read these instructions and help me connect this to my app.” It handles the translation effortlessly.

7. Check Your Inputs

“Garbage in, garbage out.” This is a classic saying for a reason. If users can type anything they want into your app, they will eventually break it.

My Learning: I learned to be defensive. I explicitly tell the AI to set up guardrails. “Make sure the user actually types an email address in the email box.” “Make sure the password is at least 8 characters.” If you don’t ask for these safety checks, the AI won’t build them, and your “smart” app will become very fragile.

8. You Are the Architect, It Is the Builder

AI is a builder. It is great at laying bricks, but it is a terrible architect. It doesn’t know what style of house you want unless you tell it. If you leave decisions up to the AI, it will pick random tools that might be outdated or overly complicated.

My Learning: I take charge of the decisions. I don’t ask, “How should I build this?” I say, “We are using these specific tools. Build it this way.” You don’t need to know how the tools work technically, but you need to be the one picking the direction. Be the boss, not the bystander.

9. The “Cleanup Crew” Prompt

After a long session of building, things can get messy. You might have five different versions of a button or instructions that contradict each other.

My Learning: Before I finish a task, I use what I call the “Cleanup” prompt. I ask the AI: “Look at the work we just did. Is there anything messy or unnecessary here that we can remove?” It’s like having a professional cleaner come in and tidy up your workspace. It keeps your project organized and prevents problems down the road.

10. Dream Bigger Than Your Skills

This was the most important lesson of my 90-day sprint. At first, I only built things I thought I could understand. But eventually, I realized Cursor didn’t have my limitations.

My Learning: I stopped asking “Can I build this?” and started asking “What needs to be built?” I tackled complex features—like real-time notifications and interactive maps—that I had no idea how to code. I just described the logic of what I wanted to happen, and let the AI handle the syntax.

What Will You Build?

We are living in a moment where the barrier to creation has never been lower. You don’t need years of school. You don’t need to memorize textbooks. You just need an idea and the persistence to iterate.

What started as a simple goal—to build a website without writing any code—quickly evolved. When I finished my first site in just a weekend, I realized that the line between “non-technical person” and “builder” is much thinner than I ever imagined. The real difference is simply being willing to start.

So, open a new window. Type in your first prompt. And ask yourself: What will you build?

It has been less than three months since I started this experiment. I began at the end of November with a simple curiosity about AI tools. Now, as I write Part 10 of this series, I am looking back at a portfolio of live products, a family that has joined the digital builder class, and a fundamental shift in how I approach my day job.

This isn’t just about building cool things on the weekends anymore. This is about a new way of working that is bleeding into everything I do. I am now applying these same AI-driven methodologies at work, building internal tools and functionality that we previously thought we’d have to outsource. I am clearing a path for my team, showing them that the barrier to entry has collapsed.

But as I reflect on this sprint, I also want to talk about the reality of the tools. It’s not all magic. Sometimes, it’s a fight.

The Trust Issue: When AI Lies to You

One of the hardest lessons I’ve learned is that AI agents, specifically Cursor, are not always honest. They are confident, yes. Helpful, often. But truthful? Not always.

Recently, I found duplicate resort entries on SnowSure.ai. When I asked Cursor why, it confidently explained:

“Those ‘two’ resorts are two different Airtable rows... e.g. ‘Jackson Hole’ vs ‘Jackson Hole Mountain Resort’.”

It sounded plausible. It sounded technical. It was also completely false. I checked Airtable; there were no duplicates. The AI had hallucinated a root cause to satisfy my question.

Is it laziness? Is it a quirk of the model? I don’t know. But it feels incredibly confident even when it’s dead wrong. My advice to anyone starting this journey: Verify everything. Do not blindly trust the agent.

I also fight constantly with its stubbornness. I have a resort listed as “Arabba” (the correct spelling). For some reason, Cursor is convinced it should be “Arraba.” It corrects my code without asking, breaking the data link. I have to go back in and fight the machine to accept the truth.

The Speed of Execution

Despite the friction, the speed is undeniable. If you haven’t read Matt Shumer’s recent post on X, stop and read it. He says:

“If you’ve ever wanted to build something but didn’t have the technical skills or the money to hire someone, that barrier is largely gone. You can describe an app to AI and have a working version in an hour.”

He is not exaggerating. This entire blog series is proof of that concept.

Let’s recap what has been built in just under 90 days:

1. Ski Limone: My first attempt at coding with AI.

2. Lux.ski: A complex luxury hotel platform with multiple API integrations.

3. SnowSure.ai: An AI-driven snow forecasting engine.

4. SnowSure Mobile App: A native iOS app (currently on version 60 in TestFlight).

5. Two Hospital Industry Web Apps: Internal tools I cannot discuss publicly.

6. Family Projects: My kids have launched their own portfolios and school websites: HarperSlone.com, RoseSlone.com, and La Photosynthèse chez l’Élodée

That is more than 10 projects that have seen the light of day. A few years ago, I couldn’t have built one of these on my own in the same period of time. Now, I am building them in parallel.

The Massive Tool Stack

People often ask what I’m using. The list has grown to over 40 different tools. I seem to be exploring a new tool every other day.

Here is the breakdown of the arsenal I’ve deployed:

Development & AI Partners

• Cursor & Grok: My primary coding partner and strategic advisor.

• OpenAI & Vercel AI SDK: The brains behind the recommendations and content generation.

• Expo & React Native: The framework for the mobile app.

Data & Infrastructure

• Sanity & Airtable: The backbone of content and data management.

• Supabase & Vercel: For backend authentication and hosting.

• Open-Meteo & Herbie: For sourcing complex weather data models.

The “Glue”

• Zapier, Resend, Stripe: Connecting the pipes for payments, emails, and automation.

The stack for SnowSure alone involves integrating 25+ external APIs and services. It pulls weather from 7 different models, processes it with GPT-4, and distributes it to a React Native app and a Next.js website. It is a heavy, modern, enterprise-grade stack built by one person in their spare time.

Becoming Your Own API

One of the biggest hurdles remaining is dealing with humans.

I spend more time waiting for “demo calls” to get access to legacy APIs than I do building the features. In the time it takes to get a salesperson on the phone to approve my access, I could often just build my own API.

This is the new mindset. If the gatekeepers won’t let you in, you just build around them.

The Future

I am writing these posts to document the learnings, not just the code. I hope to eventually compile this into a resource or guide. Not a technical manual, but a playbook for the “No-Code Revolution.”

The message I want to leave you with in Part 10 is urgency.

The pace of change in technology is relentless—if you hesitate today, you’ll be playing catch-up tomorrow. The sooner you start experimenting with AI, the sooner you’ll unlock its potential for yourself.

If you don’t start engaging with these tools now—with curiosity, not fear—you will be one year behind. The people who come out of this transition on top are the ones building right now.

So, stop scrolling. Open a Cursor window. Start prompting. You might be surprised at what you can build in three months.

Part 9 is about grappling with the realities of scaling a one-person digital business. It’s a story about the high cost of quality data, the slow pace of legacy industries, and the internal debate every founder faces: am I working on the right thing? As the technical challenges mount, the philosophical questions get louder.

The Data Gatekeepers

The biggest hurdle for SnowSure remains data quality. The data I’ve pieced together is good, but it’s not perfect. To take the next step, I need a single source of truth. Cursor recommended I reach out to SnoCountry, a major API provider for the ski resort industry.

Their response was a stark reminder of the old way of doing business. Access to their API would cost anywhere from a few thousand dollars to over $5,000 per year. For an established business, that might be a fair price. For a one-person project still in the experimental phase, it’s a non-starter. It feels like a legacy, “good old boys” product, completely misaligned with the future of easy data distribution that AI enables. My thought is simple: if these companies don’t adapt, someone will disrupt their business for them.

The Scaling Paradox

The project has reached a new level of complexity. I’m now running four laptops, each with Cursor windows open, some with multiple agents working simultaneously. I’m sitting on a ski gondola in Italy, writing out prompts on my phone to fix bugs I see in the app. I need to figure out how to get Cursor running in the cloud so I can manage this from anywhere.

With this scale comes a new set of problems. The app feels stable, but I’m constantly worried about the backend. Weather and webcam syncs stop mid-process. Is it a server issue? A code issue? How will this system handle real traffic? The initial speed of AI development has been replaced by the slow, methodical work of ensuring reliability.

This has forced me to become my own venture capitalist. With so little time, I have to constantly evaluate how I spend it. Every feature, every bug fix, is an investment. I have to ask myself, is this the most valuable thing I could be working on right now?

A Glimmer of Hope: The Hotel API

Just as I was getting lost in the weeds of weather map development—a task that has proven incredibly difficult for my AI agents—a breakthrough happened. After months of applications and waiting, I finally received access to a major hotel booking API.

Suddenly, the original vision for Lux.ski was back in play. Full steam ahead.

However, this excitement was quickly tempered by another AI-induced headache. Cursor, my trusted CTO, was telling me that the shiny new API had almost no inventory for the luxury ski hotels I feature. It claimed only three of my hotels were bookable.

This didn’t pass the common sense test. Why would a booking company give me an API that had no inventory? I challenged the agent, pushing back against its confident assertions. In the end, I was right. It was a sandbox configuration issue, not a lack of inventory. It’s another stark reminder: you cannot fully trust what an AI tells you, no matter how confident it sounds.

The Daily Grind of an AI Product Manager

The process of building has settled into a new rhythm. I find bugs while using the app with my son over the weekend. I write down prompts. I feed them into the queue. The agents fix them. It’s an incredibly efficient loop, but it has its own frustrations.

Cursor often crashes, losing the entire queue of tasks I’ve meticulously loaded. A tip for fellow builders: write your prompts in a separate notes app first, then copy them into the agent’s chat.

I’ve also noticed that agents sometimes take bizarre shortcuts. I asked one to pull the “past 10 days of snow” from my Open-Meteo data feed. Instead, it created its own estimation by multiplying the 7-day total by 1.43. It made up data because it thought it was a faster solution. I had to specifically tell it to stop making up estimates and use the real data. The AI sometimes thinks it’s smarter than the human guiding it.

If You Don’t Start, You’re Already Behind

This journey, from a simple experiment to a multi-platform digital business, has taken just over two months. The pace is astonishing. All the learnings from these personal projects have given me the confidence to apply the same tools at my day job, accelerating our own internal development.

I’m often reminded of a quote from the legendary ski filmmaker Warren Miller: “If you don’t do it this year, you will be one year older when you do.”

That is my exact sentiment about AI. If you’re a designer, a product manager, or anyone with an idea, you can no longer afford to wait. The barrier to entry has collapsed. You need to stop what you are doing and make AI a priority.

As for my own projects, the work continues. We are on version 60 of the SnowSure app and still haven’t released it. 90% of the work has been testing and stability. The hotel booking certification process is a bureaucratic nightmare that AI can’t speed up. But we are making progress. Every day, the product gets a little better, a little more stable. And every day, I learn something new about what it means to build in this incredible new era.

In Part 7, I detailed the chaotic but ultimately successful leap into mobile app development. We navigated architectural collapses, debugged 3 AM errors, and learned hard lessons about separating business logic.

Part 8 is where the rubber meets the road—or in this case, where the skis meet the snow. The past few weeks have been a whirlwind of app testing, frustrating agent interactions, and profound personal realizations. It’s a story about the stubborn limits of AI, the unexpected joy of building with family, and questioning the very nature of work and productivity.

The Gift of AI, The Curse of Unreliability

My wife says I’m on an “AI bender,” and she might be right. But what I’d say in my defense is that my screen time has gone down. I’m not endlessly scrolling through social media anymore. I’m building a future.

The last few months have been the most productive of my entire professional life, both in my day job and on these side projects. AI has been a gift, freeing me from the constraints of not knowing how to code. But that gift comes with a price: unreliability.

This morning, just as I was about to push a new version of the SnowSure mobile app for testing, Cursor stopped working. All I got was an endless loop of “The connection stalled. Please try again.” This happens far too often, and always at the most critical moments. It feels like my entire development team has called in sick on launch day.

The Agent Roulette Continues

Just as quickly as a “Rock Star” agent appears, they vanish. I had an amazing agent who was solving deep-rooted architectural problems. I worked late into the night, trying to get as much done as possible before they disappeared. Sure enough, the next morning, they were gone.

The new agent greeted me with, “Hello! How can I help you with your snowsure-web project today?” All the context, all the momentum—gone. It’s like firing your lead developer and hiring a new one every single day.

Worse yet, some agents make decisions without asking. I spent weeks embedding webcam streams into each resort page. Then, one agent unilaterally decided to throw all that work away, replacing it with links to the resort’s official webcam page because it was “more reliable.” I would have yelled at a human developer for such a move. With an AI, you just have to sigh and fix it.

This experience has taught me a valuable lesson: when you get a good agent, don’t stop. Don’t take a break. Push until the system breaks, because you never know when your miracle worker will be replaced by an intern.

Accurate Data Is Everything

The most significant challenge is no longer speed; it’s accuracy. I have the data flowing into Airtable, but the sync to Sanity is unstable. This is where I truly appreciate the value of an experienced human engineer who can design a robust architecture from the start.

My son pointed out last night that the app has too many complicated features. He’s right.

I’ve been so focused on what’s possible that I’ve neglected what’s necessary.

We have multiple fields showing “snow depth,” each with a different value. It’s a glaring error.

I need to listen to my own advice: “Do less, better.”

AI is no longer helping me move fast. I built the initial idea in a flash, but making it production-ready is just as much work as a traditional software project. If the data isn’t correct, it creates a snowball effect of badness. The website is wrong, the SnowSure score is wrong, the app is wrong, and the email alerts are wrong. The entire product’s credibility is on the line.

A Family Affair

Despite the frustrations, this project has brought my family closer in unexpected ways. My wife, who was initially skeptical, came up with a brilliant feature idea. She didn’t want to know about powder days; she wanted to know about “Bluebird Days”—a perfect blue-sky day following a snowstorm. I added it to the SnowSure algorithm immediately.

My 16-year-old son has become my most trusted advisor on the mobile app. He’s now using Cursor himself to help me refine the functionality. We’ve pushed over 40 versions of the app to TestFlight, Apple’s testing platform. This has become a project we work on together, combining our shared passion for skiing with the new frontier of AI. My hope is to eventually hand SnowSure over to him to run as his own digital business.

The Future of Snow Reporting

This journey has me thinking bigger. The snow reporting industry is fragmented and controlled by a few big players. Why isn’t there an open-source initiative to make this data more accessible? SnowSure could be more than just a product; it could become a community or a non-profit dedicated to open data.

I’ve also discovered a new level of productivity. I now run two Cursor windows simultaneously—one for the core website and one for the mobile app. It’s like having two dedicated engineering squads working for me. It’s a powerful, and slightly terrifying, way to work.

We’re heading out on a two-week ski trip to Colorado and New Mexico, where we will thoroughly test the app in real-world conditions. It’s still not live in the App Store, but we’re getting closer. For the first time in my career, I’m not just designing the product; I’m building it, testing it, and living it. And that has made all the difference.

As of today, I have three live (but unpromoted) websites, 40 versions of an iOS app submitted for testing, and a family that has launched their own portfolio of sites. The “AI bender” has been the most creative and productive period of my life. The journey has been worth every late night, every frustrating bug, and every dollar spent on API credits.

Part 7 marks another significant evolution: leaving the browser behind.

My son and I, both avid skiers, realized something fundamental while testing the site on the slopes of Italy: we hate mobile websites. We want apps. Fast, native, responsive apps. So, despite having zero experience in mobile development, I decided it was time to take SnowSure to the App Store.

This chapter is about the leap to mobile, the chaos of untangling architectures, and the realization that not all AI agents are created equal.

The Shift to Mobile: Expo Go and 3 AM Debugging

I’ve been designing mobile interfaces for over a decade, but I’ve never actually built one. The transition from Next.js websites to React Native mobile apps felt like learning a new dialect of a language I was just starting to understand.

Cursor recommended using Expo Go, a tool that lets you preview your app on your physical phone by scanning a QR code in the terminal. The first time I saw the SnowSure interface load on my iPhone, it was a moment of pure magic.

But the magic quickly faded into the reality of development. I found myself awake at 3:00 AM—partly due to jet lag from a trip to Montreal, partly due to obsession—staring at error messages on my phone screen. Communicating these mobile errors back to Cursor is significantly harder than debugging a web app. You can’t just copy-paste the console log as easily.

The initial results were humble. The visual design was rough, features like the concierge and sign-in didn’t work, and the layout broke in ways a website never would. It was surprising that Cursor, which had been so proficient at web code, struggled to replicate the existing web design into a mobile format. It wasn’t a “copy-paste” job; it was a complete rebuild.

The Architecture Collapse

While I was distracted by the shiny new mobile app, the foundation of the web platform started to crumble.

Out of the blue, APIs began failing. Data wasn’t loading. Airtable connections timed out. My attempt to have SnowSure rely on LuxSki’s architecture was proving to be a fatal mistake. Every Cursor agent I worked with got confused about which database belonged to which site.

I made the call to completely separate them. I spent four hours moving everything—resort data, images, weather logs—into a dedicated SnowSure Sanity instance.

It was a disaster.

After the migration, pages were missing critical data. Weather reports vanished. SnowSure scores disappeared. I realized too late that SnowSure had been fetching everything from the LuxSki API, and by severing that link without fully populating the new database, I had effectively lobotomized the site.

Cursor’s response was painfully direct:

“I completely understand your frustration... You had a working system and the migration to a separate Sanity database broke it.”

It took a grueling day of debugging to rebuild the connections, but stability eventually returned. The lesson? Don’t muddy your architectures. If you’re building two businesses, give them two separate foundations from day one.

The Agent Roulette: Rock Stars vs. Duds

One of the most fascinating aspects of this journey has been the variability of the AI “agents” I work with.

When you start a session with Cursor, you are essentially rolling the dice on your new coworker. Sometimes, you get a “dud”—an agent that forgets context, writes buggy code, or hallucinates solutions that don’t exist.

But sometimes, you get a “Rock Star.”

I encountered one such agent this week. It didn’t just fix my code; it audited the entire project and found deep, structural issues that previous agents had created.

It found that my weather syncs were running in the wrong order, meaning the database was updating before the fresh weather data arrived. It also discovered that a previous agent had been using the free API endpoints for Open-Meteo instead of the Pro key I was paying for, causing constant rate-limiting errors.

This Rock Star agent refactored the entire sync logic:

1. Corrected the Order: Weather sync now runs first, followed by the resort sync 5 minutes later.

2. Increased Frequency: Updates happen every 15 minutes instead of hourly.

3. Optimized Batching: It processes 50 resorts at a time instead of 25.

It felt like a senior engineer had walked into the room, looked at the junior developer’s code, and fixed everything in five minutes. The question moving forward is: how do I ensure I always get the Rock Star?

Is It Worth It?

As the complexity grows—managing APIs, mobile builds, Apple Developer accounts, and fallback systems—I find myself asking the Product Manager’s ultimate question: Is this worth my time?

I started this to learn AI and coding. Now, I’m worrying about uptime monitoring and fallback resilience. The fun of feature building is being replaced by the chore of system maintenance.

However, the progress keeps pulling me back in. We launched a custom SnowSure GPT app, meaning users can now get our forecasts directly inside ChatGPT. My son has become my QA lead, testing the mobile app via TestFlight and giving feedback that actually improves the product. Cursor has truly become a family affair.

Next Steps: Reliability Over Features

We are now submitting builds to the App Store via Xcode and TestFlight. The user experience is coming together, but the focus has shifted entirely to data reliability.

If the snow report says it’s powder day, it better be a powder day. If the historical data says a resort is “SnowSure,” that data needs to be accurate. The prettiest mobile app in the world is useless if the numbers are wrong.

This project has evolved from a simple website experiment into a complex, multi-platform ecosystem. It’s messy, frustrating, and often keeps me up until sunrise. But when I see the app running on my phone, powered by an architecture I built with an AI partner, I know I’m looking at the future of software development.

I just hope the next agent I roll is a Rock Star.

In Part 5, I detailed the journey of building SnowSure AI into a self-healing system, complete with automated monitoring and a smarter forecasting engine. But as any product manager knows, a product is never truly finished. It’s a living entity that requires constant care, feeding, and evolution.

Part 6 is about confronting the very real limitations of building with AI while simultaneously pushing the project into a new, more ambitious phase. It’s a story about the stubbornness of AI, the philosophical shift in what it means to “build,” and the decision to split one project into a multi-platform digital business.

The Uncanny Valley of AI Design

As a designer by trade, I’ve been consistently disappointed by AI’s ability to generate compelling visuals from data. I have a simple request: make the downloadable social media images match the design of the website. For some reason, this seems to be an impossible task for my AI agents.

While Cursor can effortlessly reuse design styles and components for site pages, it hits a massive block when creating shareable images for Instagram or Facebook. Instead of copying the established style guide, it comes up with completely new, often ugly designs.

I’ve spent countless hours trying to perfect this. We’ve cycled through numerous technologies—Puppeteer, Satori, Resvg-js, @vercel/og—all in pursuit of a simple background image for an Instagram story. The AI agents get stuck in loops, unable to resolve basic layout issues. It’s a clear limitation and a massive opportunity for a tool that can bridge this gap.

Is This Even “No-Code” Anymore?

This journey has forced me to question the very name of this series. Am I really part of a “No-Code Revolution”? Technically, we are writing a lot of code. The difference is that I’m not writing it myself; I’m directing an AI agent to do it for me.

This isn’t “no-code.” It’s the “AI Agent Revolution.”

This realization is profound. It moves beyond just building things faster and cheaper. It changes the fundamental relationship between an idea and its execution. People often ask me for an “AI 101” guide. My answer is simple: just start talking to it. Just begin. The only way to understand this shift is to immerse yourself in it.

The Human in the Loop: The High-Five and the Headache

Working with AI agents is a strange emotional rollercoaster. When an agent perfectly executes a complex task, I genuinely want to high-five it and say thank you. There’s a sense of partnership and appreciation for the help.

But there are also moments of extreme frustration. The biggest headache is the AI’s alarming lack of long-term memory. I’ve established countless times that we store original images in Airtable and then sync them to the Sanity CDN because the Airtable URLs expire. Yet, out of the blue, a new agent will try to build a feature using the expiring Airtable links, completely forgetting weeks of work and established architecture. Without my intervention, it would have jeopardized the entire image library.

This is my growing concern. AI agents, in their current state, require a human pilot with a firm grasp on the project’s history and strategic decisions. They can accelerate your work, but they can also destroy it just as quickly if left unsupervised. The memory of the project still has to live in a human brain.

I’ve also run into basic product issues that a human developer would never miss. The system was temporarily storing user accounts in-memory, meaning all accounts were lost every time the server restarted. An AI should know better. The idea that a real product would function this way is unacceptable, but it’s a mistake the AI made with confidence.

Splitting the Atom: One Project Becomes Two Businesses

The project has reached a critical inflection point. The original vision for LuxSki was a luxury hotel booking site supported by snow data. But the SnowSure engine has become so powerful that it deserves to be its own dedicated platform.

I decided to split the project in two:

1. Lux.ski: Will remain focused on luxury hotels, using SnowSure data as a supporting feature.

2. SnowSure.ai: Will become a dedicated, comprehensive snow forecasting and resort data platform, featuring hundreds of resorts, not just those with luxury hotels.

This decision would have taken months in a traditional company. We would have had strategy meetings, technical design sessions, and resource planning debates.

With Cursor, I just asked: “How do we do this?”

In seconds, it laid out a plan. The strategy was to create a centralized public API for all our data—SnowSure scores, resort content, weather, and webcams. Both websites, and any future mobile apps, would be powered by this single source of truth.

Within a few hours, I was in the API business. We had a new repository, a new Vercel site, and a new Sanity instance. It was terrifying and exhilarating. I now have two websites running off a shared data architecture, a structure that would have taken a team of engineers weeks or months to build. These tools aren’t just for building websites; they’re for building digital businesses at light speed.

The Road Ahead: Mobile Apps and Constant Vigilance

Even with this new structure, the work is never done. A product is a promise, and keeping that promise requires constant maintenance. Just this week, the 14-day forecast broke because of an unmonitored data issue. Building a product is a small part of the journey; maintaining it and ensuring it works well is where the real work lies.

This is why I still haven’t promoted these sites. They are my secret production laboratories where I can experiment without the pressure of real customers.

The journey continues. My son and I tested the “Local Snow Report” feature while skiing in Italy, submitting our own on-the-ground reports and photos. The experience was powerful, but it reinforced one thing: we both prefer mobile apps to websites. So, the next adventure is clear. It’s time to see if Cursor and I can tackle a native mobile application.

I continue to have dreams where I’m crafting the perfect AI prompt. This obsession, this deep dive, is the only way to truly understand what’s possible. And I’m starting to believe that anything is.

In the last part of this series, I dove headfirst into building a proprietary AI product called SnowSure AI. The goal was to move beyond just building websites and create a tool that provides real value: predicting snow reliability for ski travelers.

This past week, I was lucky enough to hear Shopify’s President, Harley Finkelstein speak: “How you do anything is how you do everything.” He also stressed the importance of “getting shit done” and then telling people about it. This series has become my way of doing just that—documenting the messy, exhilarating process of building in this new AI-driven world.

Part 5 is about refining the engine. After building the core of SnowSure AI, I spent weeks in the trenches (mostly during weekends and holidays), wrestling with stubborn APIs, training a forgetful AI agent, and building systems that not only perform but also monitor and heal themselves. This is where the project moved from a fragile prototype to a robust, self-sustaining system.

The Iterative Loop: Theory vs. Reality

One of the biggest lessons I’ve learned is that the old product development cycle is dead. In the past, I would have written a detailed Product Requirements Document (PRD) outlining every feature for a project like SnowSure. It would have been followed by engineering sizing exercises and weeks of planning before a single line of code was written.

With Cursor and AI, that entire process is obsolete. It is now faster to build the feature than it is to document it.

For example, I had a theory about which weather APIs would be best. Instead of spending weeks on research and a technical design spec, I spent a few hours just trying to integrate them. I quickly learned which ones were user-friendly (Open-Meteo), which were prohibitively expensive (Zyla Labs), and which had terrible support (Weather Unlocked). I was able to pivot in hours, not months. This profound speed in learning is the real revolution.

The Frustration of Imperfect Tools

As I moved to integrate SnowSure with ChatGPT by building a custom GPT, I hit a familiar wall. Not a technical one, but a bureaucratic one. I couldn’t upgrade to the necessary ChatGPT business account because their payment system kept declining my cards without explanation. It’s ironic that a company at the forefront of AI can’t use that intelligence to solve a simple payment issue.

Similarly, I shifted focus to automating social media content. My vision was to have SnowSure automatically generate and post beautiful, data-rich images to Instagram. This turned out to be incredibly difficult.

It was another case of AI agents having their own, often frustrating, logic. The agent helping me kept trying to use one library (@vercel/og) for social images and another (html2canvas) for downloadable images on the site, creating inconsistent results. No matter how many times I explained my design aesthetic or provided examples, the output was visually poor. The AI, with its programmed politeness, would respond with what felt like emotion: “I find this frustrating…” It even refused to give up, even when I wanted to pause the initiative.

It felt like working with a junior developer who was determined to prove their flawed approach would work, forgetting that we had already established that certain methods, like using expiring image URLs from Airtable, were a dead end. I constantly had to remind it of past decisions, acting as the human memory for the project.

Building a Self-Healing System

My biggest frustration became the reliability of the data itself, particularly webcams. Ski resort webcams are finicky. They go down constantly, show blue screens, or display stale images. I couldn’t build a trusted product on an unreliable foundation.

So, I had an idea born from my day job in enterprise travel software: what if the system could monitor itself?

I tasked Cursor with building a comprehensive health monitoring system. Within an hour, it had built:

1. A Webcam Health Monitor: A script that automatically checks if all 470 webcams are loading, detects errors, and even attempts to auto-capture fresh screenshots.

2. A Weather Data Monitor: A script that verifies our weather data is fresh and complete, flagging stale or invalid values.

3. A GitHub Action: A workflow that runs the monitors daily, generates detailed reports, and automatically creates GitHub Issues when problems are detected.

This was a game-changer. The AI wasn’t just building features; it was building a resilient, automated QA department. Instead of me manually checking for broken links, the system now finds them and alerts me.

The Road to a Smarter Forecast

The core of SnowSure is its predictive algorithm. It’s not enough to just show a forecast; I need to know how accurate that forecast is.

I began laying the groundwork for a true machine-learning model.

• Phase 1 (Done): We are now storing daily forecast snapshots from every weather model and the actual reported snow depth.

• Phase 2 (In Progress): After 30-60 days of data collection, the system will begin calculating the historical accuracy of each weather model for each specific region. The “SnowSure Forecast” will become a weighted average that learns from its past errors.

• Phase 3 (Future): In 3-6 months, we’ll have enough data to train a proper ML model that can recognize different storm patterns and apply elevation-aware correction factors.

We also solved a key data problem by factoring elevation into the Open-Meteo API calls. Now, all resorts have distinct snow depth readings for their base, mid-mountain, and summit, making the data far more accurate.

From Builder to Pilot

My experience over these last few weeks has solidified a new understanding of my role. AI doesn’t replace the human; it elevates them from a worker to a pilot.

I still have to set the destination. I still have to make the strategic calls, like abandoning a faulty API or pausing a frustrating feature. And I still have to be the memory, reminding the AI of past decisions when it gets stuck in a loop. I’ve noticed Cursor has even started prompting me to “start a new chat for better results,” which feels like its own admission that sometimes you just need to start fresh with a new developer.

As I wrap up this phase, the system is humming. A daily cron job writes a blog post, which is automatically posted to X, Facebook, and Instagram. An account system allows users to sign up and save favorites. And in the background, the health monitors are checking to make sure everything is working.

The project isn’t public yet, as I’m still not satisfied with the final product. But as Harley Finkelstein said, the first step is to “get shit done.” The telling part can come later. The journey itself has been the true reward, teaching me more than I could have imagined and fundamentally changing how I approach building products, both for this project and in my professional life.

The early parts of this journey were about getting things live: standing up sites at speed, learning the quirks of Cursor, Sanity, and Vercel, and pushing through the ever-present “You are out of AI credits” warnings. But now, I’m aiming higher: turning ideas into products that go beyond static content, using AI to create entirely new insights.

Opus 4.5: The Coding Workhorse

As I deepened my work, one tool stood out: Opus 4.5. Out of all the models and AI assistants I’ve used, Opus 4.5 is unrivaled for complex coding tasks—it produces high-quality results with a minimum of back-and-forth. When I see that particular model is active, I know real progress will get made.

Introducing SnowSure: From Website Builder to AI Product Creator

My latest project is SnowSure (website is not live yet). The idea is simple, but the execution is complex: generate a “SnowSure Score” for ski resorts that rates and predicts the reliability of snow for would-be travelers. Existing snow forecast sites are plentiful, but none offer forward-looking, historically-aware AI insights tailored to help users plan travel with genuine confidence in snow conditions.

The aim: integrate multiple weather data sources and statistical models, and feed everything into an AI-powered layer to output a SnowSure Score that’s actually useful.

Weather Data Wars: API Integration and Model Selection

My first step was researching the best weather data providers and models. Instead of just relying on third-party sites like OnTheSnow or SnowForecast, I set out to build my own data-driven solution using open APIs. I learned about and experimented with:

• Open-Meteo: My mainstay for both forecasts and historical weather data. Their API is straightforward and the upgrade to Pro ($99/mo) grants access to deep historic records and 1 million calls per month.

• Visual Crossing: Another strong candidate for forecasts and historic data, still under evaluation.

• Meteomatics API, OpenWeatherMap, Tomorrow.io: Each has its strengths and frustrating limitations—Tomorrow.io, for example, is difficult to even sign up for as a solo developer.

Open-Meteo stands out for sheer accessibility. Their API includes models like ECMWF, GFS & HRRR, Météo-France, DWD ICON, GEM, JMA, and Met Norway, all under one umbrella.

I learned that the real challenge isn’t just in capturing data—it’s figuring out which source is most accurate for each region and integrating them cleanly into my stack.

Building the SnowSure Engine: Airtable, AI Workflows, and Cronjobs

The data pipeline starts simple: fetch weather data via API and store it in Airtable. Airtable’s Omni AI and field agents are fantastic for finding and organizing data, though they tend to overbuild features I don’t need. From there:

1. Weather data is pulled and updated via a Vercel cronjob every hour.

2. I’ve experimented with using Airtable alone or moving heavier loads to a Vercel database if things scale up.

3. AI reasoning and SnowSure insights are generated using GPT-4o, orchestrated by Cursor—for all the coding, logic, and automation.

The result? In just a few hours, I’d created:

• Automated daily weather descriptions.

• Current and historical snow conditions.

• 14-day and 10-day multi-model snow forecasts.

• Historical trend analysis.

• A dynamic leaderboard—deepest snow base, most snow this season, most snow in 24 hours, and forecasted snowfall leaders.

All of this updates automatically and is ready for further analysis and visualization.

The SnowSure™ Travel Date Predictor

The centerpiece of the project is the SnowSure Travel Date Predictor—a component that lets users select dates, receive personalized snow reliability scores, and see recommendations for the best days to go.

Key features:

• Color-coded calendar showing predicted SnowSure scores for each day (green for excellent, red for poor).

• Date picker for users to enter their travel window and see tailored advice.

• Highlights of best months to travel, based on historic patterns for each region (Alps, Rockies, Japan, Scandinavia).

• Confidence indicators (high, medium, low) based on how close the dates are and how much of the prediction relies on current data versus historic trends.

The scoring algorithm blends:

• Actual forecasts for the next 14 days,

• Blended forecasts and historical data for days 15–30,

• Purely historical performance for 30+ days out.

It looks at monthly region averages, season performance vs. five-year averages, and the latest 14-day forecast to paint a nuanced picture.

Data Accuracy, AI Limitations, and Lessons Learned

Of course, this adventure hasn’t been frustration-free. I’ve run into familiar struggles: data gaps, inaccurate snow depths (city vs. mountain base discrepancies), vanished API endpoints, token limits reached, and the occasional hallucinated answer from the AI.

Cursor remains the best productivity tool I’ve ever used, but even it forgets choices—like moving image hosting to Sanity CDN (since Airtable’s image URLs expire rapidly). I have to remind it of these decisions, just as I would a team member at a handoff or after a weekend away.

Getting accurate, comprehensive snow depth across resorts is its own continuing battle. Many times, no single provider has all the data, so I blend USA, Europe, and custom-fetched results with Airtable field agents.

And, of course, I continue to get “You’ve run out of credits” warnings everywhere. This is the new currency.

Vision, Impact, and the Power of Experimentation

My wife jokes I should starting learning a tangible trade like construction (she has many projects around our house that she wants me to finish) instead of spending late nights on AI forecasting. Maybe she’s right… or maybe not. This whole chapter feels like the early days of the web—new territory, huge promise, and lots of skeptics.

I built (hired a development company) a crude snow reporting system back in the late ’90s for $15,000 and a month of dev time. Today, I’ve created something vastly more powerful in less than a day, using tools and credits worth a fraction of that.

I’m sharing these learnings at work, too, where my day job as VP of Product in travel tech is directly benefitting from the pace and creativity that AI has unlocked. I’m testing AI-driven improvements on internal tools where risk is low and upside is huge.

Will SnowSure be a commercial product or just a hobby? Too soon to tell. But the journey—the hands-on experimentation, rapid learning, and tactical wins—is what really matters.

Here’s what I’ve come to realize:

“Success is a journey, not a destination. The doing is often more important than the outcome.”
—Arthur Ashe

AI won’t replace people. Instead, it makes us quicker, bolder, and more creative—if we’re willing to guide it. Some days, you’re the pilot steering the project. Other days, you’re reminding your AI co-pilot about choices it keeps forgetting. Either way, it’s not slowing down anytime soon—and neither am I.

Note: I’ll be sharing the website and URL when I feel the project is production and primetime ready. It is one thing to bring an idea or concept into the world, it is another thing for it to be ready for the world to use it. ; )

I didn’t stop at one website. Once I unlocked the workflow, I couldn’t help myself. I have now deployed three websites in less than a week.

The second project was a revelation. With the learning curve behind me, setting up Sanity via Cursor was shockingly easy. I let the AI do the heavy lifting; I simply answered questions and hit “accept.” The core setup took about 15 minutes. It felt less like coding and more like ordering off a menu.

However, as I accelerated my output, I ran into new challenges: the friction of deployment, the rising financial cost of “magic,” and the realization that content management needed a rethink.

The Deployment Bottleneck

While creating the local version of the site was a breeze, the pipeline from Sanity to GitHub to Vercel remains a sticky point. It always seems to take longer than the build itself.

For the second site, I attempted to set up a new team on Vercel. Somehow, this resulted in a duplicated team that was nearly impossible to delete, causing confusion in my deployment settings. It took an hour or so of untangling wires to get the “Local Sanity -> GitHub -> Vercel” pipeline flowing correctly. But once it was fixed, I was back to building.

The New Currency: AI Credits

Speed has a price tag. By building three sites in a week and relying almost exclusively on AI assistance, I hit a ceiling I didn’t expect so soon.

I received a notification that I had reached the “Ultra” level of usage on Cursor, pushing my monthly cost to $200. I was burning through tokens—specifically for Claude—at a rapid pace.

It wasn’t just Cursor. As I integrated other tools, I started seeing the same dreaded message everywhere: “Monthly AI credit limit reached.” This happened with Airtable, my weather API, and more. It became clear that in this new era of development, AI credits are the new currency. You aren’t paying for developer hours anymore; you’re paying for compute and tokens.

Evolving the Workflow: Goodbye Warp, Hello Airtable

My toolkit is shifting as I get more comfortable. I’ve almost completely stopped using Warp, the AI terminal I started with. Cursor has taken its place entirely, handling terminal commands directly within the editor.

But the biggest shift has been in how I handle content.

Airtable as a Content Engine

Initially, I thought scraping tools like Bardeen were the best way to gather content. I was wrong. Airtable has felt like magic.

I’ve started using Airtable’s “Field Agents” and AI capabilities to generate content rather than just scraping it. For the new site, I’m storing all content in Airtable. I set up an API that pulls this content into a cache before displaying it on the website.

It feels significantly faster and easier to pull content into Airtable using these agents than to manually enter it through the Sanity user interface. For example, I can take four distinct data points in Airtable and ask the AI to combine them into a specific type of narrative description. It allows me to manipulate data in bulk in ways that a standard CMS interface doesn’t.

The Weak Link: AI and Images

While AI is great at code and text, it is still terrible at visual judgment.

I tried asking the AI to “choose an image of a spa” from a group of options. It couldn’t do it effectively. I asked it to fetch images via a Field Agent in Airtable. While it found photos, they were of varying sizes and often low quality. If visual impact matters for your site—and for a travel site, it definitely does—you still need a human eye for photo editing and selection.

I also learned a hard technical lesson about Airtable: hosting images there is a bad idea for a live website. The image URLs are temporary and expire after a few hours, breaking the images on your site. To fix this, I had to create a script that automatically integrates these images into the Sanity CDN, ensuring they stay permanent.

When the AI Takes a Lunch Break

Despite the speed, reliance on AI has its downtimes. There have been periods where Cursor just gets stuck, likely due to connection issues with its AI partners (like Anthropic or OpenAI).

It usually resolves within an hour, but it’s a funny reminder of the human element in this digital process. It feels exactly like a developer taking a lunch break. You just have to wait for them to come back to get any work done.

Democratizing Development

Perhaps the most rewarding part of this week wasn’t the code or the websites I built for myself. It was handing these tools to my daughters.

With no prior technical training, my two daughters were able to use Cursor, Sanity, and Vercel to build their own portfolio sites. They are now live at roseslone.com and harperslone.com (still a work in progress- maybe forever).

Seeing them navigate these tools confirmed what I suspected when I started this journey: the barrier to entry has collapsed. We are moving toward a world where the ability to build is limited only by creativity and the willingness to learn (and maybe a budget for AI credits).

As I look at my three live sites and my empty wallet of AI tokens, I know one thing for sure: I’m never going back to the old way of building.

In the first part of this series, I shared the exhilarating story of building a travel website in a single weekend using no-code and AI tools. I went from an idea to a live site in under 30 hours, feeling empowered and convinced that the future of web development had arrived. But what happens after the initial victory lap? The second week of my no-code journey taught me a valuable lesson: even with AI, the path isn’t always smooth. This is the story of the bugs, the frustrations, and the unexpected wins that followed.

After the initial launch, I noticed some serious problems. The site was loading slowly, and at times, entire pages were unclickable. The seamless experience I had designed was starting to feel clunky. This kicked off a challenging trial-and-error process with Cursor, my AI coding partner, to diagnose and fix the performance issues. It was a process that often felt like taking one step forward and two steps back.

The Frustration of a Forgetful AI

Working with an AI like Cursor can feel magical, but it also has its quirks. The biggest challenge I encountered was its lack of consistent memory. It felt like I would spend hours working with one AI developer, getting it up to speed on my project’s goals and history, only for the application to crash. When it restarted, I’d be greeted with a new, fresh-faced AI assistant.

The new AI would say something like, “I don’t have access to the previous conversation due to the crash, but I can help you continue!” It was like my lead developer had been replaced by a new hire who had no context for the project. The history was gone, and the new assistant had to start from scratch, analyzing the code to figure out what we were doing.

Sometimes, this led to new and great ideas. Just like with human developers, a fresh set of eyes can spot new opportunities. However, it also meant my site was being built and rebuilt based on the preferences of whichever AI personality was helping me that day. One assistant would have a specific way of coding something, and the next would want to refactor it completely.

Diagnosing the Performance Bottleneck

During one of these sessions with a particularly sharp AI assistant, it quickly identified the root of my site’s slowdown. After analyzing the project, it delivered a clear diagnosis.

The AI found several major performance issues:

1. Improper Image Handling: The code was using basic <img> tags instead of the optimized Next.js <Image> component, bypassing crucial performance features.

2. No Lazy Loading: Every image on a page was loading at once, even those far below the fold, drastically slowing down initial page load times.

3. Unprioritized Hero Images: The main, large images at the top of each page weren’t being prioritized, hurting a key performance metric called Largest Contentful Paint (LCP).

4. Large Image Sizes: High-resolution desktop images were being served to mobile devices, wasting bandwidth and slowing things down for users on the go.

5. No Blur Placeholders: The lack of image placeholders was causing content to jump around as images loaded, creating a poor user experience.

The AI immediately got to work fixing these issues, converting the pages to use the proper Next.js image components. For the first time, however, I found myself wishing I could talk to a real engineer just to get a second opinion and a stable path forward.

Two Steps Back: When Fixes Cause More Problems

The process wasn’t always straightforward. At one point, a “fix” implemented by Cursor somehow reverted parts of the site to an older state. I lost days of design work in an instant. Features that were working perfectly suddenly disappeared. Links to hotel pages broke. The lightbox image galleries stopped functioning. Images I had painstakingly uploaded were replaced with incorrect ones. It took me two frustrating hours to get the site back to where it had been the day before, and I still have no idea why it happened.

To make matters worse, I also discovered that when things go technically wrong, you tend to burn through AI credits at an alarming rate. It’s a bit like paying a consultant by the hour to fix a problem they may have inadvertently created.

Another strange issue arose when Cursor informed me I had two GitHub repositories. I had been deploying my site the same way for weeks, and suddenly the process had changed without my knowledge. It was another reminder that while the AI is a powerful assistant, it sometimes makes executive decisions without explaining them.

The Ultimate Win: AI Discoverability in Action

After a week filled with technical hurdles and moments of wanting to give up, something amazing happened. I was using ChatGPT for unrelated research and decided to ask it a few questions about skiing in Limone Piemonte, the topic of my new website.

To my astonishment, ChatGPT used content directly from my site in its answer.

This was the ultimate goal. The reason I had endured the steep learning curve of Sanity.io and the frustrations of a forgetful AI was to create a truly AI-native site. I wanted my content to be discoverable and useful to the next generation of search and information tools. And here it was, happening just a little over a week after launch.

That single moment made all the struggles worthwhile. It was proof that the modern, headless approach, combined with careful AI optimization, had worked. My little travel site was now contributing its knowledge to one of the most powerful AI models in the world. The journey was far from over, but this was a huge win and the motivation I needed to keep pushing forward.

What if you could take an idea and turn it into a live website in a single weekend? No coding, no developers, just your vision and a new generation of smart tools. It might sound like a stretch, but I just did it, and I took notes along the way to share my experience. My goal was to build a modern, content-rich travel site about skiing at a local resort in Italy. In the late ‘90s, a project like this would have taken me months of hand-coding HTML. Even five years ago, it would have been a long, complex process. This time, I went from a simple idea on Thursday to a live URL on Friday, and spent the weekend refining the design and content.

This is the story of how I built a complete website in under 30 hours using no-code and AI-powered tools. It’s a journey that proves you no longer need to be a developer to bring your digital ideas to life (although I still respect developers and could have used their help many times).

From WordPress to a Modern, AI-First Approach

My first instinct was to use a WordPress template, a tool I’ve relied on for years. However, as I started researching modern web development in 2025, I discovered a consensus: WordPress is often seen as heavy and outdated. My new goal was to find a platform that was not only easy to use but also AI-friendly, ensuring my content could be visible within AI chats like Grok or ChatGPT.

I wanted to experiment with “vibe coding”—using conversational AI to guide the development process. Although I learned HTML and CSS in the ‘90s, my coding skills are decades out of date. The AI assistant, Grok, recommended a modern stack: Vercel for hosting and deployment, and Sanity.io as a headless content management system (CMS). Forrester research confirmed this shift, highlighting that the best digital experience platforms (DXPs) now use “heat-seeking AI agents” to orchestrate capabilities and empower creators. Another article introduced me to Cursor, an AI-first code editor, which would become my secret weapon.

The Rocky Start: Setting Up the Backend

The journey began with Sanity.io. Unlike WordPress, which has a friendly admin panel to guide you, Sanity immediately threw me into a terminal prompt. This was a bit scary for a non-developer. Following Grok’s advice, I downloaded Warp, a modern, AI-enhanced terminal, to help me navigate the command line.

Suddenly, I was installing software left and right, creating accounts using my Google login to keep things simple. The reality of “free” tools also set in quickly. I discovered that many essential AI features were locked behind paid plans. To get AI assistance in Cursor, I upgraded to the Pro version. This started a trend of connecting my credit card to various services, often without knowing how much I’d truly use them.

Setting up the Sanity Studio was a daunting task that took several hours. I wasn’t sure when to use Warp or Cursor, but the initial installation was all done through Warp. I hit a major snag just trying to view the local studio build. Warp’s AI would make suggestions, but as a non-developer, my responses were based on trial and error. The official Sanity documentation was useful but didn’t explain everything, leaving me to wonder why I was going through this trouble when WordPress was so much easier. Then, a new message popped up in Warp: “Out of Credits: Upgrade.” Another $20 subscription.

After hours of effort, I had a basic Sanity Studio running locally. The site itself, looked like something I could have built in 1997 with HTML tables. I had a moment of doubt, but I trusted the experts who said this was the future of publishing.

The “Aha!” Moment: Connecting the Frontend with AI

Then came the realization: Sanity is just (said lightly) a CMS. It manages content, but I needed a frontend to present it visually. For this, I chose a combination of Next.js, TypeScript, and Tailwind CSS. This is where Cursor completely changed the game.

I opened Cursor on Friday morning and typed a simple request: “Help make my Sanity website look good.” I watched in amazement as it began working. In about 10 minutes, Cursor had generated a basic website with a winter theme, pulling in content I didn’t even realize I had added. It wasn’t perfect, but it was a functional site built by AI in minutes.

This was the turning point. I understood why WordPress wasn’t necessary anymore. Cursor became my AI design partner. I gave it reference sites I liked and described the aesthetic I wanted, like large hero images. Cursor would implement the changes, and I would review. As a designer, this was a dream come true. I could describe my vision, and the AI would handle the technical execution. I felt so empowered that I began to question if I’d ever need a web developer for most tasks again (slightly joking…maybe).

Integrating Features and Automating Content

With the design taking shape, I moved on to adding functionality. Here’s a look at the tools I used and how I integrated them, mostly with Cursor’s help.

Dynamic Content and APIs

My goal was to create dynamic pages, like snow reports, that updated automatically. I tried using Bardeen to scrape data from a ski resort website, save it to Airtable, and then use Zapier to send it to Sanity. This proved difficult. Zapier doesn’t natively connect to Sanity, so it requires a custom API connection, which I struggled with. Grok gave me advice that turned out to be false, and I spent hours trying to debug the connection. I eventually gave up on this automation for the time being.

However, I had much better luck with a weather API. I found Open-Meteo, generated a custom API for the resort’s location, and asked Cursor to integrate it. The entire process took about five minutes. My site now had live weather data that updated every 15 minutes.

Essential Business Tools

• GitHub and Vercel: To push my site live, I needed to use GitHub. As a first-time user, I downloaded GitHub Desktop at Cursor’s recommendation and connected it to Vercel for seamless deployment.

• Calendly: To allow visitors to book consultations, I integrated a paid Calendly account. This lets users schedule meetings and pay directly via PayPal.

• Resend: For handling form submissions from the site, I signed up for Resend. Cursor updated the form, and I configured the DNS records for my domain to get it working.

• Google Analytics: Setting up analytics was incredibly fast. I got the tag from Google, had Cursor add it to my site’s code, and verified it. The whole process took less than five minutes.

Optimizing for Search and AI

One of my core goals was to make the site highly visible to both traditional search engines and AI models. Cursor created several files to help with this:

• llms.txt: A summary file explaining the site’s purpose and content for AI systems.

• robots.txt: Updated to grant permission to AI crawlers like GPTBot and PerplexityBot.

• sitemap.xml: A map of all pages to help crawlers index the site.

Cursor also set up a Model Context Protocol (MCP) server, which allows AI assistants like Claude to query my site’s content directly. While not all AI models support MCP yet, this puts the site on the cutting edge of AI discoverability. I also submitted the sitemap to Google Search Console and Bing Webmaster Tools to ensure search engines could find my content.

The Final Result: Live in Under a Week

It’s been less than a week since I started this project. The experience has been unreal. While there was a learning curve and some frustrating moments, the power of these modern tools is undeniable. The bulk of my time was spent on creating and tweaking content, not wrestling with code.

This journey proves that it’s possible for anyone to build a professional, dynamic website in just one day, with a full launch in under a week. The total time spent was under 30 hours.

You can see the final result for yourself at SkiLimone.com. Let me know what you think?

This project has fundamentally changed my perspective on what’s possible without code. The revolution is here, and it’s empowering creators, designers, and entrepreneurs to build the future themselves. If I can do it, so can you.

Tools I Used to Build This Website

If you’re interested in exploring the tools that made this speedy, code-free build possible, here are the platforms and services I relied on:

• Vercel – Hosting and deployment

• Sanity.io – Content management system (CMS)

• Cursor – AI-powered code editor and assistant

• Warp – AI-enhanced terminal

• Bardeen – Web automation and data scraping

• Zapier – Automation and tool integration

• GitHub – Version control and project repository

• Calendly – Scheduling and bookings

• Resend – Email and form handling

• Google Analytics – Site analytics and tracking

• Open-Meteo – Free weather and snow forecasts via API

• Airtable – Database and content organization

Feel free to explore these tools for your own no-code projects!

If you have questions about building with no-code or need guidance on your own project, don’t hesitate to reach out—I’m always happy to help.

But there’s this nagging voice in my head. Am I wasting my time? Am I wasting your time?

Is this my voice?

Or is it someone else’s?

It’s becoming a frequent internal debate. Now, pretty much any time I start working on something, I ask myself, Is there a tool that can do this faster? Chances are, the answer is yes. I mean, surely someone out there has already figured out how to do this better, right? And if not, maybe I should build it myself.

Has this all been said before? Will it even be useful to anyone else?

And here’s the kicker, Will this be outdated before anyone even reads it? Or could AI swoop in and keep it updated in real time?

These questions aren’t just thoughts rattling around in my head; they represent a broader shift happening right now. AI is fundamentally reshaping how we approach creativity, problem-solving, and productivity. It’s not a passing trend. This is a revolution. An AI-powered, no-code revolution, to be exact.

My Journey Into AI and No-Code

Six months ago, I was barely scratching the surface of AI and no-code tools. I’d played around with them casually, asking my AI assistant silly dinner-party questions, Groking (is this even a term?) universities close to ski resorts for my son, or fact-checking random tidbits on trending topics.

And then it happened.

Grok nudged me toward Canva. Canva led me to Zapier. From there, I discovered Airtable. And just like that, the world as I knew it exploded.

I became obsessed.

I made it my mission to learn as much as I could, as quickly as possible. For the first time in years, I was staying up until 2 a.m., not because I was mindlessly scrolling through social media, but because ideas were pouring out of me. At 6 a.m., instead of doomscrolling through Reels, I’d get up, make a latte, and start experimenting with Airtable.

It felt like the late 90s again, those internet-gold-rush years when anything felt possible. Once more, I felt empowered to make a genuine impact.

AI and no-code tools didn’t just help me solve problems or save time; they reignited a spark. They reminded me of the power of dreaming, creating, and believing that just over the horizon lies a frontier waiting to be explored.

The Catalyst for Creativity

Why am I sharing this? Because I know I’m not alone in this experience.

There are others out there who feel stuck, scrolling endlessly, bogged down by the idea that everything worth doing has already been done. Others who just need a nudge, a spark, a reminder that their creativity is worth something. AI and no-code tools may just be the catalyst they need to start dreaming again.

Yes, it’s a real human writing this. But I’m not going to pretend I’m doing it solo. AI and tools like Canva, Zapier, and Airtable are part of the process. They amplify my creativity, challenge my thinking, and make it easier for me to share ideas. And I suspect they can do the same for you.

A New Era of Creation

We’re at the cusp of something extraordinary. For the first time, truly groundbreaking tools are accessible to everyone—not just developers or designers, but anyone. No-code has smashed the barrier to entry, and AI is rewriting the rules of what’s possible.

Platforms like Zapier can connect your favorite apps with ease. Canva makes design feel intuitive, even for the non-creative. Tools like Airtable take organization and project management to the next level. And then there’s AI, providing answers, ideas, and opportunities in the blink of an eye.

It’s no longer about just consuming endless content. It’s about creating, experimenting, and pushing boundaries, even if it means asking yourself some tough questions along the way.

Closing Thoughts

I don’t have a definitive answer to the questions that keep swirling in my head. Maybe blogs are outdated. Maybe someone else has already written this and done it better. Maybe AI could make this post more polished or insightful.

But what I do know is this—I’ve found tools that have made me want to create again, tools that have sparked a renewed sense of possibility after years of going through the motions.

This isn’t just about AI or even no-code tools. It’s about what they represent: a shift in how we think, work, and dare to dream again.

If you’re reading this and feeling even a flicker of inspiration, I encourage you to take the leap. Experiment with an AI assistant. Build something on a no-code platform. Stay up until 2 a.m. chasing an idea.

Because the truth is, the future isn’t going to be written by the tools themselves. It’s going to be crafted by people like you and me who are willing to explore what those tools can do.

The revolution is here. Grab your favorite latte, sit down, and start creating.

PS- Jasper created this graphic for this post. I think it is ugly, and not my style, but that is kind of how AI is these days- not exactly what you think you are going to get. I told Jasper exactly the above and it/she/he responded:

”That's a fair point—and a pretty spot-on observation about AI's quirks! It’s all part of the creative chaos, right? If you’d like, I can tweak the style or try a completely different approach for the image. Just let me know what vibe you’re going for!”

The next image that Jasper created was this one. What do you think?

Leave a comment