How to Build Your First Rad Thing

A brief guide on how to get started building your first thing using AI.

Mar 02, 2026

I spent last weekend in Whistler with a group of friends from business school. Solar entrepreneurs, VC partners, leaders at Apple and Google. An entrepreneur who sold his last company and now runs a business distributing wild game in Sweden and Europe.

Smart people. All of them.

Every single one has played with ChatGPT. Most use it regularly. And when I described what I’ve been building: AI assistants that manage my family’s calendar, generate math worksheets for my kids, call restaurants on my behalf, monitor my house. They all had the same look. Not skepticism. More of an eagerness to dive in to figure out where these tools might help them at home and at work.

“Okay but how do you actually start?”

That’s what this is. The answer to that question. Not theory or hype. A step-by-step guide for someone who understands their business, isn’t afraid of technology, and is ready to go from curious to building.

This is my favorite part of this moment we’re living in. You don’t need to be a developer. You need to be willing to try and eager to learn. This guide is for you.

The Decision

Before you install anything, understand what you’re actually signing up for.

Building with AI coding tools is not like using ChatGPT. You’re not typing questions and copying answers. You’re setting up an ongoing collaboration with a system that writes code, runs commands on your computer, reads your files, searches the web, and iterates based on your feedback.

And the output isn’t always software in the traditional sense. It might be an automated workflow, a document processor, a report generator, or a tool that monitors your inbox and surfaces what matters. If it involves information and repetition, these tools can help.

It’s closer to hiring a junior developer than using a search engine. A very fast, very capable junior developer who has read most of the internet but has no context about your specific situation.

Your job is to provide that context. To ask good questions. To review what it builds and tell it what to change. You don’t need to understand every line of code it writes. You need to understand what you want, and be able to recognize when you’re getting it.

That’s it. That’s the skill.

The tools do the rest.

A Word on Cost

Before you install anything: check what you already have.

A lot of people are already paying for access to these tools without realizing it.

Google Workspace Business Standard and above includes Gemini built in: summarization in Gmail, Docs, Sheets, and more. Check with your IT admin or look in your Google account under the Gemini icon.
ChatGPT Plus ($20/month) includes Codex. If you’re already subscribed, you’re in.
Microsoft 365 offers Copilot as a paid add-on, but if your company has rolled it out, you may already have access to some of these capabilities.

If you have any of these, start with what you have before buying anything new.

If you need to pay, subscriptions are almost always the better choice. The $20/month plans (Claude Pro, ChatGPT Plus, Google AI Pro) give you predictable costs, generous limits, and the most capable models. For most people, a subscription goes further than pay-per-use at the same price.

The higher tiers, Claude Max ($100-200/month) and ChatGPT Pro ($200/month), are worth it once you’re using these tools daily and want priority access, maximum limits, and the fastest responses. Think of it like a SaaS tool: pay for the plan that matches your usage.

The pay-per-use API is powerful but unpredictable. Claude Code can run $20-50 in a single day on a large project without you noticing. It makes sense eventually, especially for automated workflows that run without you. It’s not where you want to start.

The progression that makes sense:

Check if you already have access (Workspace, ChatGPT Plus, Microsoft 365)
Start with a free tier (Gemini CLI, Antigravity) to get comfortable
Upgrade to a $20/month subscription when you’re ready to go deeper
Move to higher tiers ($100-200/month) if you’re using it every day
Add pay-per-use API access only when you’re building automated workflows that run on their own

Pick Your Tool

There are essentially three tools worth using right now. They all do roughly the same thing: AI-assisted coding and automation. Different providers, each with different strengths.

All have desktop apps to get you building without touching a terminal. Claude’s desktop app includes a Code tab (Claude Code with a visual interface) and Cowork, an autonomous mode where Claude acts on files in a folder you authorize. Codex has a standalone app. Google’s Antigravity IDE is free and helpful for getting started quickly.

Pick the tool that matches what you already have access to. You can always change later. We’re just finding the right path to get you started today.

My simple point of view:

Start with what you already pay for. ChatGPT Plus gives you Codex. Google Workspace gives many people Gemini Pro. Check what you already have before you buy anything.

If you’re starting from zero: Antigravity (Google’s IDE) is free, polished, and requires no terminal. Gemini is especially good if your project involves reading lots of documents, emails, or spreadsheets; which is a bonus.

Codex is the natural choice if you already use ChatGPT Plus. You’re already paying for it. Just start there.

I generally start most projects with Antigravity, but I also love what Claude can do even though it requires a subscription. Their desktop app is quite impressive. The Code tab handles most coding tasks beautifully, and Cowork (included from Pro and above) takes it to another level. It reasons more carefully than the others, handles nuance well, and is often the most honest about what it doesn’t know. Worth it once you’re willing to add another subscription to your monthly nut.

You don’t have to pick just one. You’ll learn what you prefer as you start building and can easily change later.

Install It: Step by Step on Mac

Option A: Gemini (Google)

The easy way: Antigravity

Google released an agent-first IDE called Antigravity in late 2025. It’s free and runs Gemini models under the hood. The standout feature: a “Manager View” that orchestrates multiple AI agents in parallel across your editor, terminal, and browser. Think Mission Control for coding tasks. Download it like any Mac app, sign in with your Google account, and you’re building in minutes.

The power-user way: CLI

The Gemini CLI unlocks its biggest advantage: the ability to read enormous amounts of text at once. Useful for projects involving lots of documents, emails, or large codebases.

brew install node
npm install -g @google/gemini-cli
gemini

On first run it opens a browser window for Google sign-in. That’s the whole setup. For the most powerful model:

gemini -m gemini-pro-latest

Option B: Claude (Anthropic)

The easy way: desktop app

Download the Claude desktop app at claude.com/download. Free to download, works on Mac and Windows. Sign in with your Anthropic account and you get two modes worth knowing about:

Code tab: a graphical interface for Claude Code. You get visual diff review, live previews of what you’re building, and the ability to run multiple tasks in parallel, all without touching the terminal. This is Claude Code with a UI on top.
Cowork: a research preview (Pro and above) where Claude autonomously acts on files in a folder you authorize. Think of it as giving Claude a desk of its own: it can organize documents, build spreadsheets from receipts, draft reports. You review and confirm significant changes.

For most people starting out, the Code tab is the right place to begin.

The power-user way: CLI

The terminal version is one line to install:

curl -fsSL https://claude.ai/install.sh | bash

After it finishes, just run:

claude

Sign in with your Anthropic account. You’ll need a Pro or Max subscription (starting at $20/month), or an API key from console.anthropic.com to pay by usage instead. The CLI and the desktop app share the same config, including your CLAUDE.md files, so you can move between them freely.

Option C: Codex (OpenAI)

The easy way: Codex app

OpenAI has a standalone Codex app at openai.com/codex. Purpose-built for coding tasks. If you already pay for ChatGPT Plus ($20/month), you have access.

The power-user way: CLI

brew install node
npm install -g @openai/codex
export OPENAI_API_KEY="your-key-here"
codex

Get your API key at platform.openai.com → API Keys → Create Key.

Your First Session: What You’ll Actually See

Here’s what you’ll actually see when you open each tool for the first time.

If you’re using Antigravity (Google)

When Antigravity opens you’ll see two views in the sidebar: Editor and Manager.

Start in Editor. It looks like a code editor: a big panel on the left for files, a writing area in the center, and a chat panel on the right. That chat panel is where you talk to the AI. You don’t need to touch the file panel or the code. Just focus on the chat.

To open your project: File → Open Folder → navigate to your project folder (Desktop or Documents is fine) and select it. Your files appear in the left panel. Now when you talk to the AI, it can see and edit those files directly.

Type your first message in the chat panel on the right. The AI responds, makes changes to your files, and shows you what it did. In a moment, we’ll show you what to type in that chat box!

If you’re using the Claude desktop app

When it opens you’ll see a clean interface with a chat window in the center. At the top you’ll see tabs: Chat, Code, and (on Pro and above) Cowork.

Click Code. You’ll see a chat interface similar to the regular Claude chat, but with file access. Click the folder icon or go to File → Open Project to point it at your project folder. The AI can now read and edit files in that folder.

Type your message in the chat box at the bottom. The AI responds in the main window, shows you code changes with visual diffs (highlighted additions and deletions), and asks for confirmation before editing files.

If you’re using Claude Code in the terminal

After running claude, you’ll see a prompt that looks like this:

Claude Code (claude-opus-4-5)
Type a message or /help for commands
>

Navigate to your project folder first:

cd ~/Desktop/my-project
claude

Full Claude Code docs at docs.anthropic.com/claude-code.

Now type your message at the > prompt. The AI responds inline, shows you the files it’s changing, and asks your permission before modifying anything.

If you’re using the Codex desktop app

When Codex opens you’ll see a Projects panel on the left and a main area on the right. Projects are how Codex organizes your work: each project points to a folder on your computer (or a GitHub repo, if you have one).

To get started: click New Project, give it a name, and point it at your project folder. Codex loads the files and you’re ready.

The main area shows Threads: each thread is a task you’ve given to an AI agent. Think of threads like chat conversations, except instead of just answering, the AI is actively editing files and running code in the background. You can have multiple threads running at once, each working on a different thing.

Type your first message in the input box at the bottom of the main panel. The AI picks it up as a new thread, starts working, and shows you what it’s doing in real time: which files it’s reading, what changes it’s making, whether the code ran successfully. When it’s done, you’ll see a diff — a summary of what changed — and you can approve it, ask for changes, or open the result in your own editor.

One thing worth knowing: Codex is built for parallel work. You can kick off one task, then start another while the first is still running. Each stays in its own thread. Genuinely useful once you have more than one thing to build at once. For your first session, just start one thread and get a feel for the loop before you try running multiple.

The big thing most people don’t realize

You don’t need to know how to run code. In all three tools, the AI runs the code itself. You ask it to build something, it builds it, runs it to check it works, shows you the result, and tells you if anything went wrong. Your job is to tell it what you want and give feedback on what you see.

If the AI produces a script you need to run yourself, it will tell you exactly what to type. Copy it. Paste it. Run it. That’s the full extent of what you need to know.

On permissions and trust

One thing that catches people off guard: these tools ask for your approval constantly. Before editing a file, before running a command, before accessing the internet: you’ll see a prompt asking if it’s okay to proceed.

Often you won’t know exactly what it’s asking. The command it wants to run might look like gibberish. You’re faced with a choice: trust the system and say yes, or stop and ask what it means before proceeding.

Here’s a rough guide to what’s routine and what deserves a pause:

Generally fine to approve:

Reading or editing files inside your project folder
Running the code it just wrote
Installing packages or dependencies (it needs these to build things)
Creating new files in your project

Worth a moment’s thought:

Making network requests or calling external APIs: ask what it’s connecting to and why
Deleting files: make sure you know what’s being removed
Commands that reference folders outside your project: why does it need to go there?
Anything involving credentials, API keys, or passwords: confirm it’s not storing these somewhere unexpected

Decline and ask questions:

Anything with sudo (administrator access) that the task clearly doesn’t require
Commands touching sensitive system locations you didn’t direct it toward
Sending data to a service you didn’t set up or recognize

When in doubt: if a command looks completely alien, type “explain exactly what this does in plain English before running it.” The AI will walk you through it. You’ll either feel confident to proceed, or you’ll catch something that shouldn’t happen.

Once you trust the project and want to stop approving every small action, Claude Code has an answer: yolo mode. Type /yolo in the chat. It skips permission prompts for the session. Your files are still there, changes are still visible, and you can undo. It just means you’ve decided to let the AI work without interruption. Most people switch to it once a project is underway and they understand what the AI is doing.

Setting Up Your First Project

Every project starts the same way: a folder and a briefing file.

If you’re using a desktop app (Antigravity, Codex or Claude): Create a folder anywhere. Desktop or Documents is fine. Name it something descriptive. Then open it in the app. That’s your project.

If you’re using the terminal: Create the folder and navigate into it:

mkdir ~/Desktop/my-project
cd ~/Desktop/my-project

The briefing file is called AGENTS.md. Think of it as permanent memory for your project: context the AI reads at the start of every session so you never have to re-explain from scratch. Claude Code reads CLAUDE.md natively, and most other AI coding tools are converging on AGENTS.md as the shared standard. Using AGENTS.md means every tool picks it up automatically.

A quick note on the .md file format. These files are written in a format called Markdown: a simple way of formatting plain text using symbols like # for headings and - for bullet points. You’ve probably seen it without knowing it. The AI reads it perfectly, and it’s easy to write once you’ve seen an example.

Macs don’t come with a great Markdown editor by default. A few good options:

Bear: Mac-native, beautiful, free to start. The one I’d start with.
Obsidian: free, powerful, worth it if you want your notes and projects in one place.
VS Code: free, already installed if you’re using Antigravity (it’s built on the same base), and has Markdown preview built in.

Again, remember that you can always just ask the AI to create the file for you. After the interview, say “Based on what we just discussed, create an AGENTS.md file for this project.” It will write the whole thing correctly. If you want, you can open it in Bear or Obsidian to review and tweak.

Seriously, don’t start from scratch. The community has built templates you can copy. Just use those as a starting point, they’re going to be better than whatever you’ll do at first:

agentsmd/agents.md: The simplest, most widely-adopted template.
davila7/claude-code-templates: Ready-to-use configurations with working examples.

Here’s a starting point if you absolutely want to roll your own:

# AGENTS.md

## What This Project Is
[One paragraph: what it does and why it exists]

## Who Uses It
[Describe the person this is built for]

## Current Status
[What's done, what's in progress, what's next]

## Important Constraints
[Things the AI must never do, hard requirements, known limitations]

## Style and Standards
[How you want things done: tone, format, patterns to follow consistently]

You don’t need to fill in every section before you start. The first two are enough to begin. The AI will help you figure out the rest as you go.

The Style and Standards section is the most underrated part. Tell the AI once how you want things done, and it applies that consistently every session. You stop correcting the same things over and over.

One note on naming: AGENTS.md works across most tools. If you’re using Claude, it reads a file called CLAUDE.md instead. That file has the same purpose and works the same way but they don’t use the common naming scheme as everyone else. Sigh.

Starting every session, your opening message:

Please read AGENTS.md to get context on this project, then tell me what you understand and what questions you have before we continue.

It’s a good idea to say this at the start of every new chat. It takes five seconds and prevents you from re-explaining your project from scratch. If you’re in the terminal, navigate to your project folder first (cd ~/Desktop/my-project), then start the tool.

Your First Project: The Interview Method

Here’s one mistake people make when they get started: they open the tool and immediately say “build me X.”

The model has no idea who you are, what your business does, what constraints you’re working under, or what “good” looks like for you. So it builds something generic that doesn’t fit, you get frustrated, and you assume AI coding tools don’t work.

They do work, but you need to teach them what you want first.

I use what I call interview mode. Open your tool of choice, make sure it’s pointing at your project folder, and type this into the chat window:

Before we start building anything, I want to make sure you deeply understand what I need. Please ask me up to 10 clarifying questions about this project — one at a time, waiting for my answer before asking the next. Focus on: who the users are, what problem we're solving, what success looks like, what constraints I'm working under (time, budget, technical), and what I definitely don't want. When you feel you have enough, summarize what you've heard and ask if it's right before we proceed.

The model will ask you things you hadn’t thought to specify. Answer honestly in the chat, one question at a time. When it summarizes back to you, correct anything that’s off. This usually takes 10-15 minutes and saves hours of misdirected work.

After the interview, you’re going to want to capture the key insights in a structured way using 2 docs. The AI will write them and save them directly to your project folder:

The requirements prompt:

Based on our conversation, write a short Product Requirements Document and save it as REQUIREMENTS.md in this project folder. Include: the problem we're solving, who it's for, the core features in priority order, what we're explicitly not building, and what "done" looks like for the first version.

The plan prompt:

Now write a step-by-step build plan and save it as PLAN.md. What are the major pieces? What order would you tackle them in? Flag anything where you see a real tradeoff I should weigh in on.

Once the AI saves these files, they’ll appear in your project folder. Open them in Bear or VS Code to read through them. Correct anything that’s off. These become the ground truth that keeps you and the AI aligned throughout the build, and the foundation of your AGENTS.md.

The Build Loop

You’ve briefed the AI, you have a plan, you’ve started a session. Now what?

Building with AI tools is a loop:

Ask for something specific. Not “build my app” but “build the function that reads incoming emails and pulls out the dates.”
Review what it builds (you don’t need to understand every line, but read the explanation it gives you)
Test it. Say “run this and show me the output.” The AI executes the code itself and reports back what happened. You don’t need to know how to run code.
Tell it what’s wrong. Be specific: “this crashes when the email has no subject line” or “the output is missing the date field.”
Repeat

Reading responses: The AI will often explain what it did and why. Read this. It’s showing its reasoning. If the reasoning sounds off, say so before it goes further. Correcting direction early is much easier than unwinding bad work later.

When it gets stuck: All three tools will sometimes hit a wall and go in circles. Signs: it rewrites the same thing repeatedly, asks you the same question again, or apologizes for the confusion more than twice. When this happens, stop. Start a fresh conversation. In the app, click “New Chat” or “New Session”. In the terminal, type exit and run claude again. Then paste the relevant context: “Read AGENTS.md and DECISIONS.md, then let’s approach [the specific problem] differently.” Fresh context, fresh angle.

When to push vs ask: If you don’t understand a choice the AI made, ask. “Why did you use X here instead of Y?” It will explain. Either there’s a good reason you hadn’t considered, or it made a mistake. Either way, you learn something. Never accept work you don’t understand at all. You’ll have to deal with it later.

The Learning Loop: How the System Gets Smarter Over Time

Here’s something most people miss. It’s probably the biggest multiplier once you get past your first project.

Every AI coding tool starts with zero knowledge about you. Your preferences. Your standards. The decisions you’ve already made. What you tried last week and why it didn’t work. Each new session, you’re starting from scratch unless you build a system to prevent that.

The fix is simple: document decisions as you go, in a place the AI can read them.

Create a file called DECISIONS.md in your project folder. After each meaningful session, end with this prompt:

Summarize what we built today, what decisions we made, and why. Format it as a short list I can append to DECISIONS.md.

Paste the output into the file. Next session, start with:

Before we continue, read AGENTS.md and DECISIONS.md to get full context on this project and the decisions we've already made.

Over time, this file becomes institutional memory. The AI stops suggesting things that contradict choices you’ve already made. It stops proposing approaches you already tried and abandoned. It builds on what exists.

What to capture:

Choices made and why (”we’re using X instead of Y because...”)
Things that didn’t work (”tried Z, caused problems because...”)
Standards you want applied consistently (”always do it this way”)
Open questions you haven’t resolved yet

You don’t need to be exhaustive. Three or four bullet points per session compounds fast over weeks.

The projects where this discipline holds get easier over time. The ones where it breaks down get harder. The AI gets genuinely more useful the more context it has. DECISIONS.md is the simplest way to build that context.

API Keys Done Right

Most people don’t need this section yet. If you’re using a subscription plan (Claude Pro, ChatGPT Plus, Google One), you authenticate with your account and you’re done. API keys are for automated workflows that run without you: scripts, scheduled jobs, integrations that fire in the background. API keys are also necessary if you want to connect to a service programmatically.

For example, I built a system that used a USDA dataset to calculate the nutritional value of various recipes and to set that up, I needed to create an API key with the service and save it securely. Come back here when you’re building something like that.

In short, API keys are like passwords. If someone gets yours, they can use your account and you pay the bill. Here’s how to handle them safely.

Create a secrets folder that won’t accidentally get shared:

mkdir -p ~/.secrets
chmod 700 ~/.secrets

Store each key in its own file:

echo 'ANTHROPIC_API_KEY=your-key-here' > ~/.secrets/anthropic.env
echo 'OPENAI_API_KEY=your-key-here' > ~/.secrets/openai.env
echo 'GOOGLE_API_KEY=your-key-here' > ~/.secrets/google.env  # Get key at aistudio.google.com

Load them automatically when you open Terminal:

echo 'source ~/.secrets/anthropic.env' >> ~/.zshrc
source ~/.zshrc

Do this for each key. Now, your keys load automatically every time you open Terminal and they’re in a folder with restricted permissions where they can’t accidentally get shared.

Three rules:

Never paste your API key directly into code
Never share a file that contains your API key
Set spending limits in each provider’s dashboard before heavy use (Anthropic limits, OpenAI limits)

Skills: Going Further

Once you’ve shipped something, you’ll want the AI to do more than write code.

Skills are reusable packages of instructions that teach your AI how to handle a specific recurring task. A skill for reading and summarizing emails. A skill for generating weekly reports in a consistent format. A skill for reviewing what you built and flagging problems. You install it once, and the AI knows how to do that thing every session.

Where to find them:

skills.sh: The largest open directory, with contributions from Anthropic, Google, Microsoft, and the community. Browse by category.
playbooks.com: Curated skills and bundles. Good for finding a set that works together.

Prompt Resources Worth Bookmarking

Gemini API Cookbook: Google’s official Gemini prompt collection.
Anthropic Prompt Library: Claude’s official collection of prompts for common tasks.
OpenAI Cookbook: Practical examples for Codex-based workflows.
PromptingGuide.ai: Deep reference with research-backed techniques.

Three techniques worth learning first:

Think step by step. Add “Think through this step by step before answering” to any complex request. The AI slows down, shows its reasoning, and catches mistakes it would otherwise skip. It sounds almost too simple. It works.

Label the parts of your prompt. When your request has multiple parts, label each one clearly. Like this:

Context: I'm building a tool that summarizes supplier emails for a food distribution business.

Task: Write a function that reads an email and pulls out any price changes mentioned.

Constraints: Only flag changes above 5%. Ignore shipping cost changes.

Format: Return a simple list with supplier name, product, and new price.

Claude in particular responds much better to a structured prompt than a wall of text. It knows exactly what’s background and what’s the actual ask.

Plan before you build. Before asking the AI to do anything, ask it to plan first. “Outline the steps you’d take to do X, without doing anything yet.” Review the plan. Fix anything that looks wrong. Then say go. You catch bad assumptions before they turn into bad work.

The Real Bar

Here’s the thing I kept saying in Whistler that I want to say again here.

The bar for “building something” is not as high as you think.

A solar entrepreneur who automates the extraction of permit requirements from municipal PDFs into a structured spreadsheet has built something. A wild game distributor who sets up a system to summarize supplier emails and flag price changes has built something. A VC partner who creates a tool that generates first-pass memos from founder decks has built something.

None of those require a developer. They require someone who understands the problem, can explain it clearly, and is willing to iterate.

The AI does the technical part. You do the part that matters: knowing what’s worth building.

Start with the smallest possible version of the thing you actually need. Get it working. Then make it better. Repeat until you’ve built something rad.

That’s it.

If you build something using this guide, I want to hear about it. Reply to this email or find me on Twitter/X. I read everything.

And if you’re not sure what to build first, that’s okay too. Start the interview with: “I’m not sure what to build. Here’s my business and here’s where I spend the most time on things that feel repetitive.” Let the AI help you figure out what’s worth automating. That conversation alone is usually worth the setup.

Discussion about this post

Ready for more?