Building
With Claude
The tool I use to build everything in this guide. Chat, Code, Desktop, Projects, Skills — and how to scale your usage up and down as your needs change. This is a living document that updates as Claude evolves.
Claude's capabilities change fast — new models, new features, new pricing every few months. This chapter reflects what works as of April 2026. When something major changes, this page updates. The principles stay constant. The specific tools and pricing may not. Check the "last updated" date above.
Claude is not one tool — it is a kitchen full of specialists. The chat interface is your executive chef who discusses strategy and plans menus. Claude Code is the line cook who executes recipes directly in the kitchen. Projects is the recipe binder that keeps everything organized. You use all three, but for different jobs at different times.
Three Interfaces, Three Jobs
Each Claude product serves a different role in your workflow. Using the wrong one for the job wastes time and money.
Claude Chat
The conversation interface at claude.ai or the mobile app. This is where you think out loud — discuss architecture, debug logic, write documentation, plan features, analyze data, draft content. It sees what you paste into it. Best for strategy, analysis, and any task where you need to talk through the problem before writing code.
Claude Code (CLI)
A command-line tool that reads your entire codebase, understands your project structure, and makes changes directly from the terminal. It runs commands, edits files, creates new files, and tests its own work. This is your hands-on builder — it operates like a junior developer with full access to your repo. Best for multi-file changes, refactoring, and implementation.
Claude Projects
A persistent workspace where you upload documentation, schemas, style guides, and instructions that Claude remembers across every conversation in that project. Instead of re-explaining your stack every time, you load it once. Every new chat in the project starts with full context. This is your institutional memory — the thing that makes conversation 47 as informed as conversation 1.
When to Use Which
The right tool for the right job — using all three together is the system.
| Task | Best Tool | Why |
|---|---|---|
| Plan a new feature | Chat | You need to think through the approach before writing code |
| Debug a complex issue | Chat | Paste the error, the code, and the context — talk through it |
| Implement a feature across 5 files | Claude Code | It reads your codebase and makes coordinated changes |
| Refactor a component | Claude Code | It sees all the imports and usages, not just the one file |
| Write a database migration | Chat (Project) | Your schema docs are loaded — it knows your actual columns |
| Draft API documentation | Chat (Project) | Project context includes your existing docs and patterns |
| Quick one-off question | Chat | No setup needed, just ask |
| Deploy and test a function | Claude Code | It can run the deploy command and check the result |
| Organize files on your machine | Desktop (Cowork) | Cowork accesses local files and executes multi-step tasks autonomously |
| Automate a workflow in a native app | Desktop (Computer Use) | Computer Use controls your screen for apps without APIs or integrations |
| Search your Drive or draft an email | Chat (Connectors) | Connectors reach into Gmail, Drive, Slack, Calendar without leaving chat |
The Models — Which Brain for Which Job
Same principle as model routing in your product (Chapter 2) — use the right model for each task.
| Model | Best For | Speed | API Cost |
|---|---|---|---|
| Opus | Complex architecture, nuanced analysis, long multi-step reasoning, content that requires deep understanding | Slower | Highest |
| Sonnet | Daily coding, documentation, debugging, feature planning — the workhorse for 80% of tasks | Fast | Mid |
| Haiku | Quick classification, simple transforms, batch processing, summarization — high volume, low complexity | Fastest | Lowest |
In your product's API calls: Haiku for cheap, fast tasks (classification, short summaries). Sonnet for the core product (conversations, analysis). Opus when quality matters more than speed (investor reports, complex reasoning). Most products run 70% Haiku, 25% Sonnet, 5% Opus by volume.
Projects — Your Institutional Memory
The feature that makes the 47th conversation as informed as the first.
Without Projects, every new Claude conversation starts from zero. You explain your stack, your database schema, your coding patterns, your business context — again. With Projects, you upload that context once and every conversation in the project starts with it loaded.
What to put in your project: your database schema reference, your edge function architecture doc, your brand and design system, your pricing and business logic, your coding conventions. Basically — your documentation from Chapter 6. The same docs that help future-you also help every Claude conversation.
Project instructions are the most powerful feature. Write a set of rules at the top of the project: "Always check the schema before writing SQL. Never guess column names. Always distinguish sandbox vs production. Never add features not explicitly requested." These instructions apply to every conversation in the project automatically. They are your guardrails — the ones from Chapter 17, baked into every interaction.
Organize by function: one project for backend/database work, one for frontend/app work, one for content and marketing, one for business and investor prep. Each project has different docs loaded and different instructions. This mirrors the multi-conversation workflow from Chapter 4 but with persistent context that survives across sessions.
Claude Code — The Agentic Builder
It reads your repo, runs commands, edits files, and tests its own work.
Claude Code runs in your terminal. Point it at your project directory and it understands your entire codebase — file structure, imports, dependencies, patterns. You describe what you want in plain English and it makes the changes directly in your files.
The workflow: "Add a phone number field to the user profile screen. It should validate the format and save to the database." Claude Code reads your existing profile component, checks the database schema, creates the migration, updates the component, adds validation, and runs the tests — all in one command.
When Claude Code shines: multi-file changes where coordination matters. Refactoring a component used in 12 places. Adding a new API endpoint with the handler, the route, the types, and the tests. Tasks where seeing the whole codebase at once produces better results than pasting snippets into a chat window.
When to use chat instead: when you need to discuss the approach before implementing. When you are not sure what the right solution is. When the task is more about thinking than coding. Claude Code is an executor — it does what you ask. Chat is a collaborator — it helps you figure out what to ask.
$ claude
Claude Code v1.x — reading project from /Users/you/your-app
Found: 847 files, package.json, supabase config
> Add a created_at column to the characters table
with a default of now(), then update the admin
dashboard to show it in the character list.
Reading schema... characters table found.
Creating migration: add_created_at_to_characters.sql
Updating: admin/CharacterList.tsx — adding column
Updating: admin/types.ts — adding field to interface
Running migration in sandbox... ✓
3 files changed. Ready for review.Claude Desktop + Cowork
The desktop app is not just a wrapper — it unlocks capabilities the browser cannot touch.
The Claude Desktop app runs natively on Mac and Windows. It gives you everything the browser version has plus direct access to your local files, desktop extensions, and Cowork — an agentic mode where Claude executes multi-step tasks on your machine without you hovering over every action.
Cowork is where Claude stops being a chat partner and starts being an operator. Hand it a task — "organize these 30 PDFs into folders by client name" or "scan my inbox and draft replies to anything about the investor meeting" — and it works through the steps on its own, accessing your local files and connected apps. You review the results, not every intermediate step.
Computer Use (research preview) takes this further: Claude can control your mouse, keyboard, and screen to interact with any application — even ones without APIs or integrations. Automate a workflow in a legacy app, fill out a form in a proprietary tool, or test your app in a mobile simulator. It runs on your actual desktop, so grant permissions carefully.
Dispatch lets you assign tasks from your phone that Claude completes on your desktop. Walking to get coffee? Send "organize the downloads folder and delete anything older than 30 days" from your phone and it happens while you are away. The desktop app needs to be running.
Skills, Connectors & MCP
How Claude reaches beyond the chat window into your actual tools and workflows.
Connectors
Web-based integrations that let Claude read and act on your external services — Google Drive, Gmail, Slack, Calendar, and more. Enable them in any conversation and Claude can search your Drive, draft emails, read Slack threads, or check your calendar. Work across web, desktop, and mobile.
Desktop Extensions (MCP)
Locally installed integrations that connect Claude to your desktop environment — file systems, databases, browsers, native apps. Built on the Model Context Protocol (MCP), an open standard. The desktop app has a curated directory of verified extensions. This is how Claude reads your local project files without you uploading them.
Skills & Plugins
Pre-built capabilities that extend what Claude can do — from creating Word docs and spreadsheets to generating presentations and working with Excel. The Customize section in Claude Desktop groups skills, plugins, and connectors in one place. Think of them as specialized tools Claude picks up when the task requires them.
Why this matters for solo founders: connectors mean Claude can draft an investor email in Gmail using context from your pitch deck in Google Drive, without you copy-pasting between tabs. Desktop extensions mean Claude Code can read your local codebase while Claude Chat discusses the architecture. Skills mean Claude produces a polished pitch deck or financial model directly, not just the text content.
The ecosystem is expanding fast. New connectors and extensions ship regularly. Check the Customize section in Claude Desktop and the connectors menu in claude.ai to see what is currently available — it will be more than what is listed here by the time you read this.
Cost Management — Scaling Up and Down
Your Claude spend should match your building intensity. Not every month is a heavy coding month.
Your Claude costs are not fixed — they flex with your building rhythm. A month where you are shipping a major feature, refactoring your backend, and building new content might cost $150-200 in API usage through Claude Code plus your Pro subscription. A month where you are maintaining, fixing small bugs, and mostly doing marketing might cost $20 — just the Pro subscription with minimal API usage.
This is a feature, not a problem. Unlike hiring a developer at $8,000/month whether you need them or not, Claude scales to zero when you are not coding. The heavy months feel expensive. Averaged across a year, the cost per hour of productive output is a fraction of any alternative.
Heavy Build Month
Shipping features, refactoring, new content pipeline
Maintenance Month
Bug fixes, small updates, mostly marketing and content
The Max plan ($100/mo) makes sense when you are in sustained heavy building mode — multiple hours per day, every day, for weeks. The higher message limits and priority access pay for themselves in time saved waiting for rate limits. If you hit rate limits on Pro more than twice a week, upgrade. If you go two weeks without hitting them, downgrade.
Watch your API dashboard. Anthropic's usage dashboard shows exactly what you are spending and on which model. Check it weekly during heavy build months. The pattern is consistent: the first month on Claude Code, you overspend because you are learning efficient prompting. By month two, the same output costs 40-60% less because you waste fewer tokens on vague requests.
Extended Thinking — When to Turn It On
Claude can "think" before responding. It costs more tokens but produces dramatically better results for complex tasks.
Extended thinking lets Claude reason step-by-step before answering — like giving someone time to think through a problem on a whiteboard before presenting their solution. It uses more tokens (and therefore costs more) but the quality difference on complex tasks is significant.
Use extended thinking for: architecture decisions involving multiple tradeoffs. Debugging a complex issue where the root cause is not obvious. Planning a migration that touches multiple systems. Analyzing a business problem with competing factors. Any task where "think carefully about this" would be your instruction to a human.
Skip it for: quick questions with straightforward answers. Code formatting. Simple CRUD operations. Anything where speed matters more than depth. Most daily coding tasks do not need extended thinking — Sonnet without thinking handles them well.
Prompt Patterns That Actually Work
These are not tricks — they are communication patterns that produce better output consistently.
Show, Do Not Describe
Instead of "make the button look better," paste the actual CSS and say "change the button background to use the gradient from the header." Instead of "fix the layout," paste a screenshot and the code. Specificity produces specificity. Vagueness produces generic output.
Explain the Constraint
"Build a pricing page" gets generic output. "Build a pricing page using only my CSS variables, Outfit font, 8px spacing scale, and Heroicons — no other icons, no other fonts, no gradients I have not defined" gets on-brand output. The constraints are the instructions.
Ask for the Plan First
"Before writing code, explain your approach: which files you will change, what the changes are, and what you expect to happen." This catches bad approaches before they become bad code. Five seconds of planning prevents twenty minutes of reverting.
Scope Aggressively
"Fix ONLY the button color. Do not modify anything else. Do not add features. Do not refactor." Without explicit scope, Claude will "improve" adjacent code — breaking patterns you spent hours getting right (Chapter 17). Explicit scope is not rude. It is clear.
What Claude Gets Wrong
Knowing the failure modes prevents the most expensive mistakes.
Fabricated APIs and Methods
"Just use .autoSync()" — there is no autoSync method. Claude invents APIs that sound plausible but do not exist. If a method sounds too convenient, verify it in the actual documentation before building on top of it. One fabricated method becomes an hour of debugging.
Column Name Guessing
Claude writes customerId when your column is user_id. The query runs without errors — it just returns nothing. Always verify column names against your schema reference. This is the most common AI hallucination in database work (Chapter 9).
Context Decay in Long Sessions
By message 30, Claude has forgotten constraints you set in message 5. "Do not touch the header" gets violated in message 35 when fixing an unrelated layout issue. Re-state critical constraints every 10-15 messages, or use Projects to bake them in permanently.
Scope Creep
You ask for a button fix. You get a button fix, a tooltip, an animation, and a refactored component. Every unrequested addition is an untested change. Reject responses that include "I also improved..." and re-ask with explicit scope constraints (Chapter 17).
Claude is not a replacement for understanding. It is a force multiplier for people who understand what they are building. The builder who knows why the code works will always outperform the builder who only knows that it works.
Putting It All Together — The Daily Workflow
Morning: open your Claude Project for today's focus area. The context is already loaded — your schema, your docs, your coding rules. Start a new conversation for the day's task. Describe what you want to build.
Planning: use Chat to discuss the approach. "Here is what I want to build. Here are the constraints. What is the best architecture?" Get alignment before writing code.
Building: switch to Claude Code for implementation. "Implement the approach we discussed — add the new endpoint, update the component, create the migration." It reads your codebase and makes coordinated changes.
Verifying: test in sandbox. Check the changes. If something is wrong, go back to Chat to debug — paste the error and the relevant code. Fix it. Verify again.
Documenting: before closing, ask Chat to update your project docs with what changed. "We added a phone field to the user profile. Update the schema reference doc." Your documentation stays current because Claude writes the updates as part of the workflow.
This is the system. Chat for thinking. Code for building. Desktop for operating. Projects for memory. Connectors for reaching into your tools. Documentation for compounding. It is not magic — it is discipline applied through tools that make discipline easier.