The Non-Technical Founder's Guide to Shipping a Website With AI

Six months ago, I had a Figma file and a dream. No coding experience. No computer science degree. No technical co-founder on speed dial. What I did have was an opinion about how a website should feel and a stubborn refusal to let "I'm not a developer" stop me from building it.

Today that site is live, running on Astro, powered by Sanity CMS, deployed on Cloudflare, and updated through a pipeline I built entirely by talking to an AI. This is the story of how that happened, and more importantly, what I learned about the mindset it requires.

You don't need to become a developer to ship a product. You need to become someone who is comfortable being confused, and then doing the next thing anyway.

The Mindset Shift

The biggest barrier to shipping wasn't technical. It was psychological. I spent years assuming that building websites required understanding every layer of the stack, from DNS records to JavaScript bundlers to server configurations. That assumption kept me in Figma, designing things that never got built.

The shift happened when I started thinking about AI not as a magic button that writes code for me, but as a collaborator who happens to be fluent in languages I don't speak. The same way I might work with a developer on a team -- briefing them, reviewing their output, asking them to explain their decisions -- I started working with Claude Code.

The difference is Claude doesn't get annoyed when I ask "what does that mean" for the fourteenth time.

Choosing the Stack

I didn't know what a "stack" was when I started. Now I have opinions about one. Here's what I landed on and why:

• Astro -- a framework that ships minimal JavaScript by default. My site is mostly content, so I don't need a heavy framework. Astro gives me fast pages without the bloat.
• Sanity Studio -- a headless CMS that lets me edit content in a clean interface and delivers it through an API. I write in Sanity, the site pulls from Sanity. No touching code to update a blog post.
• Cloudflare Pages -- hosting at the edge. The site loads fast everywhere because it's literally served from the closest data center to whoever's reading it.
• Claude Code -- the AI that helped me wire all of this together. Not a code generator. A thinking partner.

I arrived at this stack after three false starts. I originally tried Next.js (too complex for what I needed), then plain HTML (too tedious to maintain), then WordPress (too everything). Each failure taught me what I actually needed: simplicity, speed, and separation between content and code.

AI as Collaborator, Not Replacement

Let me be direct about something: AI did not "build my website for me." That framing misses the point entirely. I built my website with AI, and the distinction matters.

When I'm working with Claude Code, I'm making every design decision. I'm choosing the layout. I'm writing the copy. I'm deciding how navigation should work, what the reading experience should feel like, where the visual weight should land. The AI handles the implementation -- the syntax, the file structures, the configuration -- but the vision is mine.

Think about it this way: a film director doesn't operate the camera, adjust the lights, or edit the footage themselves. But nobody questions whether the director "made" the film. The director has the vision. That's the job.

The Moments It Clicked

There were a few specific moments where this whole approach went from "interesting experiment" to "this is genuinely how I work now."

The schema moment

I was setting up content models in Sanity, and I told Claude: "I want each article to have a title, a body, a category, a publish date, and a list of tags. The category should be one of five options." Claude generated the schema file. But then I looked at it and said: "Actually, I want the tags to be reusable documents, not just strings. And I want a reference to an author document."

That conversation -- where I was revising the architecture based on how I wanted the content to work -- that was the moment I realized I wasn't just prompting. I was designing a system.

// The schema that emerged from conversation
export default {
  name: 'article',
  title: 'Article',
  type: 'document',
  fields: [
    { name: 'title', type: 'string' },
    { name: 'slug', type: 'slug', options: { source: 'title' } },
    { name: 'category', type: 'reference', to: [{ type: 'category' }] },
    { name: 'author', type: 'reference', to: [{ type: 'author' }] },
    { name: 'tags', type: 'array', of: [{ type: 'reference', to: [{ type: 'tag' }] }] },
    { name: 'publishedAt', type: 'datetime' },
    { name: 'body', type: 'blockContent' },
  ],
}

The deploy moment

The first time I pushed to GitHub and watched the site automatically build and deploy to Cloudflare -- without me doing anything -- I literally said "what" out loud to my empty apartment. The pipeline worked. Content went from my Sanity Studio to the live site in under two minutes. I set that up. Me. A designer.

The debugging moment

My site broke at 11pm on a Tuesday. An Astro build error I'd never seen before. I pasted the error into Claude, got an explanation ("your GROQ query is returning null because the document isn't published yet"), fixed it in two minutes, and went to bed. Six months earlier, that error would have ended my week.

Mistakes I Made

I'm writing these down because I want you to make different ones:

• Starting too big. My first attempt was a full multi-page site with authentication, user accounts, and a payment system. I should have started with a single static page.
• Not reading error messages. For the first month, I'd see red text in the terminal and immediately paste it to Claude without reading it myself. Half the time, the error message literally told me what was wrong in plain English.
• Ignoring version control. I didn't use Git for the first two weeks. When something broke, I couldn't go back. Learn git commit on day one. It's your undo button.
• Treating the AI like a search engine. Asking "how do I deploy to Cloudflare" gets you a generic answer. Saying "I have an Astro site with these dependencies, here's my current config, and I want to deploy to Cloudflare Pages with automatic builds from GitHub" gets you a solution.

What Surprised Me

The thing nobody tells you about building with AI is how much you learn by accident. I didn't set out to understand how DNS works, but when my custom domain wasn't resolving, I spent 30 minutes with Claude learning about A records and CNAME records and now I just... know that. It happened organically, in service of a real problem I was trying to solve.

I also didn't expect to have opinions about code architecture. But after working through enough decisions -- "should this be a component or a layout?" "should I fetch data at build time or runtime?" -- I developed intuitions. I can't write a React hook, but I can tell you when a page should be server-rendered versus statically generated, and I can explain why.

---
// Astro page — fetching at build time from Sanity
import { sanityClient } from '../lib/sanity';

const articles = await sanityClient.fetch(`
  *[_type == "article"] | order(publishedAt desc) {
    title,
    slug,
    "category": category->title,
    publishedAt
  }
`);
---

<ul>
  {articles.map(article => (
    <li><a href={`/articles/${article.slug.current}`}>{article.title}</a></li>
  ))}
</ul>

That code block above? I can read every line of it now. I can explain what it does. I couldn't have written it from scratch, but I understand it deeply enough to modify it, debug it, and make decisions about it. And honestly, that might be the more valuable skill.

The gap between "can't code" and "can ship" is smaller than you think. It's not about learning to code. It's about learning to collaborate with something that can.

If you're a designer, a writer, a founder, or anyone with a vision and no technical background -- you can build. Not someday. Not when you "learn to code." Now. The tools exist. The approach works. The only thing stopping you is the belief that you need permission from a gatekeeper who was never actually standing there.

Ship the thing. Figure out the rest along the way.