Claude Code for Non-Coders: Build AI Automations

Claude Code vs. Claude Chat vs. Claude Co-work

Claude Chat is a basic chatbot interface for conversational AI. Claude Co-work is a simplified automation tool for knowledge workers. Claude Code is the most powerful, enabling local file access, web connectivity, and agentic capabilities without requiring coding knowledge.

Claude product tiers by capability

The AI Harness Framework

The AI harness model has three layers: the AI model at the core (like Opus or Sonnet), the harness around it (Claude Code), and you at the top providing context and steering. The harness is interchangeable; what matters most is the quality of your context and prompts.

Why Context Matters More Than Model Choice

If you don't give the AI the right context about your business, goals, and data, it cannot produce the right outputs. The most important element in the AI harness framework is you—your brain, prompts, context, and business knowledge.

Skill 1: Become the AI Person in Your Circle

Being the AI person is relative—it means knowing more than people around you, not being an AI expert. Start by picking one tool (like Claude), experimenting with it, and showing colleagues what you've built. Companies will seek you out for AI initiatives before formal job titles exist.

85%

of CEOs say all functional leaders must become technology experts in their domain (IBM 2026 study)

AI expertise is becoming mandatory across all roles

Skill 2: Develop Taste and Judgment

As AI outputs improve, it's tempting to trust them immediately. True skill is knowing what deserves your name. Review everything, study great work in your field, save examples, correct AI when needed, and feed corrections back into your system prompts to train it to match your taste.

Skill 3: Master Context Engineering

Context engineering—filling the AI's context window with the right information—is more durable than prompt engineering because models improve but still need to know your specific business. Build a project with your documents, calendar, past work, and priorities so the AI understands your world better than you do.

Skill 4: Optimize for Iteration Speed

The people who iterate fastest win. Build the ugly version quickly, see what breaks, fix it, and repeat. Define what done looks like before starting (tied to a specific metric), then move to maintenance mode. Every iteration is data that makes your system better.

Rapid iteration cycle for AI systems

Skill 5: Build Your Jarvis (Autonomous Systems)

Teach your AI to act without you triggering it. Audit your week for predictable events (new emails, Mondays, form submissions) and automate them. But distinguish between tasks needing AI agents (messy, variable input) and simple workflows (deterministic, if-then logic). Use agents sparingly; simple workflows are cheaper and more reliable.

From manual to autonomous automation

Skill 6: Build Multiple Income Streams (Unemployment Insurance)

Create job stacking: your day job plus AI-powered side income streams. One passion with multiple branches (course, newsletter, consulting, product) is safer than one income. Build in public, share what you learn, and let opportunities find you. This protects you if any single income source disappears.

AI Native Means Reaching for AI First

Being AI native isn't about knowing every model or understanding architecture. It's about what your hand reaches for. Instead of opening a browser to search or manually analyze, default to Claude Code first. Make AI your first instinct, not your backup plan.

Don't Quit in the Dip

Learning curves have a short-term cost (feeling overwhelmed) before exponential payoff. Most people quit in the dip before seeing the benefits. Productivity may dip 20% initially, but the long-term gain (60%+ improvement) is worth it. Push through the discomfort.

The learning curve dip before exponential growth

You Are a Manager of AI Agents

Think of using Claude Code like managing an employee. Onboard it to your business, set clear expectations (here's what good looks like), give specific tasks, review outputs using your judgment, provide feedback, and have it iterate. All communication is natural language, so if you can think and describe clearly, you can manage AI.

Installing Claude Code

Download the Claude desktop app from claude.ai/code, install it for your OS, then sign in with a paid Claude subscription (Pro or Max plan). You can also use Claude Code in VS Code via terminal or extension, but the interface is interchangeable—switch anytime without losing your work.

Choosing Where to Run Claude Code

Claude Code runs on the desktop app, in VS Code terminal, or via VS Code extension. All methods access the same files and projects. Pick whichever feels most comfortable; switching later is seamless.

Local File Access and Capabilities

Claude Code can navigate, edit, and organize your local files. It can also create files (Excel, HTML, websites, apps), fetch data from APIs, and interact with online services like Gmail, Slack, and YouTube. This makes it far more powerful than chat-only interfaces.

Core Prompting Elements

When prompting Claude Code, include: role (who you are and what you do), context (background on the business and goals), specific task (what you need done), negative prompts (what not to do), and verification (how to prove the work is correct). These levers make outputs dramatically better.

Five-part prompting framework

Make AI Prove Its Work

Instead of accepting first-pass outputs, ask Claude to verify its own work. For code, have it test edge cases. For research, have it cite sources. For designs, have it check alignment. This closes the gap between first-pass quality (60%) and acceptable quality (90%+) without manual iteration.

Quality improvement through verification

The Cloud.md System Prompt

Cloud.md is a markdown file that tells Claude Code how to behave in your project. It includes your role, routing map (where things live), voice and style, and rules. Claude reads this before every message, so it orients itself to your context. Update it as you learn what works.

Global vs. Project-Level Cloud.md

Global cloud.md applies to every project on your machine (e.g., phrases you dislike, general preferences). Project-level cloud.md applies only to that specific project (e.g., business rules, file locations). Both are read on every message.

Understanding Tokens and Pricing

A token is roughly 3/4 of a word. Different models cost differently: Haiku ($1/$5 per million input/output tokens) is fast and cheap; Sonnet ($3/$15) is balanced; Opus ($5/$25) is most capable. Output tokens cost more than input tokens. On a Claude subscription, you get a generous allocation; via API, you pay per token.

Input token pricing by model (July 2026)

Session Limits and Usage

On a Claude subscription, you have a 5-hour rolling session limit and weekly model limits. If you exceed these, you pay per token via usage credits. On the $200/month max plan, you can get ~$8,000 of inference value, making it a massive discount vs. API pricing.

$8,000

inference value on $200/month max plan (vs. $200 cost)

Subscription value vs. API pricing

What is an API and Why You Need Keys

An API (application programming interface) lets one software talk to another. An API key is a password that grants access. To let Claude Code pull your YouTube data, fetch from Tavily, or send to ClickUp, you must provide the API key. Never share keys publicly; they're passwords.

Setting Up .env Files

Create a .env file in your project to store API keys securely. Add it to .gitignore so it never gets pushed to GitHub. Claude Code reads from .env automatically. This keeps secrets out of version control and makes it easy to rotate keys.

Testing API Connections

After adding an API key to .env, ask Claude Code to test the connection. It will make a request to the API endpoint, verify the key works, and report success or failure. This catches errors early before building on a broken connection.

Permission Modes in Claude Code

Claude Code has permission modes: auto (Claude decides what to do), manual (you approve each action), and deny (block certain actions). Choose based on risk tolerance. For critical tasks, use manual; for routine tasks, use auto.

Settings.json Configuration

Settings.json in the .claude folder controls what Claude Code can do: allowed permissions, denied actions, and environment variables. You can deny specific commands (like deleting files) while allowing others, creating guardrails.

What Are Skills

Skills are reusable, natural-language instructions stored in the .claude/skills folder. They let Claude Code call on pre-built workflows without re-explaining them. For example, a 'grill me' skill might analyze your business metrics. Skills live at project or global level.

Sub-Agents vs. Single Agent

A sub-agent is a separate Claude instance with its own context, used for specialized tasks (research, formatting). Single-agent workflows are simpler and cheaper. Use sub-agents for exploration; use single agent for focused work. Sub-agents use 7-10x more tokens.

Token cost comparison

Local Scheduled Tasks

Run automations on your local machine on a schedule (hourly, daily, weekly). Your machine must be on. These are cheap and have full local file access. Good for personal automations.

Cloud Routines (Remote Automations)

Routines run on Anthropic's cloud infrastructure, so your machine doesn't need to be on. They clone your GitHub repo, read your cloud.md, and execute a prompt. Minimum interval is 1 hour. Limited to 5-15 runs/day depending on plan. Great for always-on automations.

Daily routine limits by subscription

Setting Up Cloud Routines

Create a routine by defining a prompt, connecting a GitHub repo, setting a schedule, and configuring environment variables. Test multiple times before going live. Routines read your cloud.md automatically, so they have context. They're stateless—each run is independent.

Routine Triggers: Schedule, API, GitHub

Routines can be triggered on a schedule (cron-like), via API call (webhook), or by GitHub events (new PR, push, issue). API and GitHub triggers let you build event-driven automations without waiting for a time-based schedule.

Environment Variables for Routines

Since routines run on the cloud and clone your GitHub repo, they can't access your local .env file. Instead, store API keys in the cloud environment's environment variables. These are securely stored and injected at runtime.

When to Use Modal vs. Routines

Use routines for agentic, reasoning-heavy tasks. Use Modal for deterministic, simple workflows (Python scripts). Modal is cheaper for high-volume, low-complexity tasks. Routines are better for tasks needing Claude's reasoning.

Deploying to Modal

Modal is a serverless platform for running Python scripts on a schedule or webhook. Ask Claude Code to build a Python script, authenticate with Modal, and deploy. Modal stores secrets securely and provides logging and observability.

Cron-Based vs. Webhook-Based Automations

Cron-based runs on a schedule (e.g., 6 a.m. daily). Webhook-based runs when an event occurs (e.g., form submission). Webhooks are more efficient because they only run when needed, not on a fixed schedule.

Example: Daily AI News Brief

A cron-based automation that runs at 6 a.m., researches AI news via Tavily, writes a brief with Opus, and sends it to ClickUp. This is deterministic and linear, so it doesn't need full agentic reasoning—a Modal script works well.

Example: Lead Form Webhook

A webhook-based automation that triggers when a form is submitted. It reads the form data and sends a notification to ClickUp. No AI needed—just a simple Python script that routes data. Deterministic, cheap, reliable.

Remote Control Sessions from Phone

Use /remote-control to expose a desktop session to your phone. Sign in to Claude on both devices with the same email, then control the session from your phone while away. Full functionality including slash commands.

How Tokens Actually Work

Every message, Claude rereads the entire conversation from the start. Message 1 costs 500 tokens; message 30 costs 15,500 because it rereads all 29 prior messages. This means token cost compounds exponentially, not linearly. 98.5% of tokens in a 100-message chat are just rereading history.

98.5%

of tokens spent rereading history in long chats

Token waste in conversation history

Tier 1 Token Hacks: Start Fresh

Use /clear between unrelated tasks. Each fresh chat is exponentially cheaper than continuing a long chat. This single habit extends your session life more than anything else.

Tier 1 Hack: Disconnect Unused MCPs

Each connected MCP server loads all its tool definitions into context on every message (~18,000 tokens per message). Disconnect MCPs you don't need. Prefer CLIs over MCPs when possible.

Tier 1 Hack: Batch Prompts

Three separate messages cost 3x what one combined message costs. Send all tasks in one prompt instead of follow-ups. If Claude gets something wrong, edit the original message and regenerate instead of sending a correction.

Tier 1 Hack: Use Plan Mode

Before building, ask Claude to map out the approach and ask clarifying questions. This prevents going down the wrong path and wasting tokens on scrapped work. Add to cloud.md: 'Do not make changes until 95% confident.'

Tier 1 Hack: Run /context and /cost

/context shows what's eating tokens (conversation history, MCPs, files). /cost shows token usage and estimated spend. Most people don't know where tokens go. These commands make the invisible visible.

Tier 1 Hack: Set Up Status Line

In terminal, display model, context percentage, and token count in real-time. This gives visibility into usage and helps you pace yourself.

Tier 1 Hack: Keep Dashboard Open

Monitor your usage allocation and reset time. Check every 20-40 minutes. Set up automations to alert you when approaching limits.

Tier 1 Hack: Be Smart with Pasting

Don't paste entire documents if Claude only needs one section. Be precise about what you feed it. Smaller context = fewer tokens.

Tier 1 Hack: Watch Claude Work

Don't fire off a prompt and walk away. Watch to catch wrong paths early. Stopping a task mid-way saves thousands of wasted tokens.

Tier 2 Hack: Keep Cloud.md Lean

Keep cloud.md under 200 lines. It's read on every message. Use it as an index pointing to larger files, not as a dump of all information.

Tier 2 Hack: Be Surgical with File References

Instead of 'here's my repo, find the bug,' say 'check the verify_user function in auth.js.' Use @filename to point at specific files. Routing saves tokens.

Tier 2 Hack: Compact at 60% Capacity

Auto-compact triggers at 95%, by which point context is degraded. Manually run /compact at 60% with specific preservation instructions. After 3-4 compacts, get a session summary, /clear, and continue fresh.

Tier 2 Hack: Avoid Short Breaks

Prompt caching has a 5-minute timeout on API and 1-hour on subscriptions. If you step away >5 minutes, the next message reprocesses everything at full cost. Before stepping away, /compact or /clear.

Tier 2 Hack: Manage Command Output

When Claude runs shell commands, full output enters context. If a command returns 200 lines, all 200 are tokens. Be intentional about what commands you allow.

Tier 3 Hack: Pick the Right Model

Use Sonnet for most work. Use Haiku for sub-agents and simple tasks. Use Opus only for deep reasoning. Keep Opus under 20% of usage.

Tier 3 Hack: Understand Sub-Agent Cost

Sub-agents use 7-10x more tokens because each wakes with full context. Use them for one-off exploration. Delegate to Haiku sub-agents to save money.

Tier 3 Hack: Schedule Around Peak Hours

Peak hours (8 a.m.–2 p.m. ET weekdays) drain sessions faster. Schedule heavy work for off-peak (evenings, weekends). If near reset with budget left, go heavy. If near limit with time left, step away.

Tier 3 Hack: Evolve Cloud.md with Learnings

Add architectural decisions and workarounds to cloud.md so you never re-explain them. Keep bullets under 15 words. This grows your system's knowledge over time.

What is Prompt Caching

Prompt caching stores parts of your context (system prompt, project files, conversation history) so they don't need to be reprocessed. Cached tokens cost 10% of normal input tokens. Cache TTL is 1 hour on subscriptions, 5 minutes on API.

10%

cost of cached tokens vs. fresh input tokens

Massive savings through caching

How Cache Layers Work

System layer (instructions, tools) is globally cached. Project layer (cloud.md, files) is cached per project. Conversation layer (messages, replies) is cached but rereads each turn. Switching models breaks cache because prefix matching fails.

Cache Hits vs. Cache Misses

Cache hit: reusing cached context (10% cost). Cache miss: reprocessing from scratch (100% cost). Waiting >1 hour, switching models, or editing cloud.md mid-session breaks cache. Plan accordingly.

Three Habits for Cache Optimization

Don't pause >1 hour (cache expires). Start fresh when switching tasks (/clear or /compact). Use session handoff skill to summarize and restart without losing context.

Session Handoff Skill

Instead of /compact, use session handoff to summarize everything (decisions, files, progress), then /clear and paste the summary. Faster than compact, feels seamless, preserves all context.

The Four Cs of AIOS

Context (your knowledge base), Connections (integrations to tools), Capabilities (skills and agents), and Cadence (automations and routines). Context and Connections are your second brain. Capabilities and Cadence are what makes you 10x productive.

AIOS is Never Finished

Your AI operating system evolves daily. Add new skills, refine cloud.md, integrate new tools, improve automations. It's a living system that grows with your business.