The argument in one line.
Six free configuration habits — model selection, CLAUDE.md, Plan Mode, context compaction, .claudeignore, and idle MCP pruning — separate Claude Code users who burn through credits in days from those who run the same workload at half the cost.
Read if. Skip if.
- You use Claude Code regularly and credit burn feels disproportionate to what you actually shipped.
- You are a freelancer, agency owner, or solo builder using Claude Code for client work and want predictable costs.
- You are new to Claude Code and want to establish correct defaults before bad habits compound.
- You manage a small team on Claude Code and want sensible session hygiene before per-developer costs scale.
- You already use /model, CLAUDE.md, Plan Mode, and .claudeignore as standard practice — this will not surprise you.
- You want advanced architectural or prompt engineering guidance; this is entry-level setup optimization.
The full version, fast.
Claude Code's defaults are optimized for capability, not cost — it ships with Opus as the default model, starts every session context-blind, and silently loads massive directory trees and idle MCP tool definitions before you type a word. Six habits address every major leak: use Sonnet as the default and escalate to Opus only when reasoning demands it; write a CLAUDE.md under 200 lines so the agent arrives oriented; engage Plan Mode before execution on complex tasks; run /compact every 15 minutes to keep history lean; add a .claudeignore to block node_modules and build artifacts; and disconnect MCP servers not used that week. Together these eliminate the largest sources of unnecessary token spend without touching real capability.
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.

01 · Hook + channel intro
Pain-point mirror open: credits gone, no idea why. Promise: 5 setup steps nobody talks about. AI avatar disclosure and masterclass pre-sell.

02 · What Claude Code is and why setup costs money
Quick primer on Claude Code as an agentic coding tool. Growth stats: $1B ARR in 6 months. Poor habits cost $13/developer/day ($150-$250/month).

03 · Mistake #1: Running Opus for everything
Claude Code defaults to Opus. Model tier breakdown: Haiku (simple), Sonnet (bulk work), Opus (complex reasoning). Switching to Sonnet saves ~60% tokens.

04 · Mistake #2: No CLAUDE.md file
Without CLAUDE.md, every session re-explains the whole project. One file under 200 lines gives Claude persistent context. One-hour setup, perpetual savings.

05 · Mistake #3: Building without Plan Mode
80/20 workflow: 80% planning in Plan Mode, 20% execution. Plan Mode reads codebase first, proposes a plan before touching files. 50-70% token reduction on complex tasks.

06 · Mid-roll: AI Cashflow Masterclass
Sponsored segment promoting free on-demand training on using AI workflows for income.

07 · Mistake #4: Context window overload
Every message resends full history. /compact compresses, /clear resets, /usage tracks spend in real time. Run /compact every 15 minutes, not at 95% full.

08 · Mistake #5: No .claudeignore
.claudeignore blocks node_modules, build folders, lock files from being read. One setup, 80-90% exploration waste cut on medium projects.

09 · Bonus: Idle MCP servers
Each connected MCP server loads full tool definitions into context even when unused. One idle server = 14,000+ tokens before work starts. Run /mcp and disconnect unused servers.

10 · The bigger picture
This is not just for developers. Freelancers, agency owners, entrepreneurs using Claude Code correctly have a genuine competitive advantage.

11 · Recap + final CTA
All 6 habits restated. Every one is free to set up. Final masterclass pitch with 30-day HighLevel trial offer.
Lines worth screenshotting.
- Claude Code defaults to Opus for every task, even renaming a file or fixing a typo.
- Switching to Sonnet as the default and escalating to Opus only when needed cuts token usage by roughly 60% with no real capability loss.
- Poor Claude Code setup habits cost approximately $13 per developer per active day, or $150-$250 per developer per month.
- A CLAUDE.md file under 200 lines gives the agent your full project context before a single prompt token is spent on orientation.
- Anthropic's own documentation caps CLAUDE.md at 200 lines — exceeding it degrades rule adherence and triggers compliance decay.
- Plan Mode reads the codebase and proposes a full plan before touching any file, cutting token costs on complex tasks by 50-70%.
- The 80/20 workflow — 80% planning in Plan Mode, 20% execution — is how the developers with the lowest token bills actually work.
- Every message in a long Claude Code session carries the full conversation history, making sessions exponentially more expensive over time.
- Running /compact every 15 minutes compresses history without losing context; waiting for the 95% auto-compact means you have already overpaid.
- A .claudeignore file blocks node_modules, build folders, and lock files — on a medium project this cuts exploration waste by 80-90%.
- One idle MCP server with its tool definitions loaded silently consumes over 14,000 tokens per session before you type a single word.
- Auditing connected MCP servers weekly with /mcp and disconnecting unused ones is one of the highest-leverage, lowest-effort cost habits.
- The video is narrated entirely by an AI avatar of the host — the real person does not appear on camera.
Six habits that cut Claude Code costs in half.
The default Claude Code install is optimized for capability, not cost — six free configuration steps fix the biggest leaks before they compound.
- Claude Code defaults to Opus for every task regardless of complexity; switching to Sonnet for routine work and escalating only for hard reasoning cuts token usage by roughly 60%.
- A CLAUDE.md file under 200 lines eliminates the per-session cost of re-explaining your project stack and rules — once written it saves tokens on every future session.
- Plan Mode forces the agent to read the codebase and propose a full plan before touching any file; skipping it means paying for failed attempts and do-overs on complex tasks.
- Every new message in a session carries the full conversation history; running /compact every 15 minutes keeps context lean rather than waiting for the 95% auto-compact threshold.
- A .claudeignore file prevents the agent from reading node_modules, build folders, and lock files — directories that can be massive and are almost never relevant to the actual task.
- Each connected MCP server loads its entire tool definition list into context even when idle; one unused server can consume over 14,000 tokens per session before any real work begins.
- The total cost reduction from applying all six habits compounds — model savings, context savings, and exploration savings each reduce the base the next one operates on.
Terms worth knowing.
- Opus
- Anthropic's most capable and most expensive Claude model tier, suited for complex multi-file reasoning and hard architectural decisions — overkill for routine coding tasks.
- Sonnet
- The mid-tier Claude model — significantly cheaper than Opus and sufficient for the vast majority of everyday coding work including writing functions, refactoring, and adding features.
- Haiku
- The fastest and cheapest Claude model tier, best suited for simple tasks like renaming files, fixing typos, or writing basic boilerplate.
- CLAUDE.md
- A markdown file placed in a project folder that Claude Code reads at the start of every session, providing persistent context about the stack, architecture, and rules without consuming per-message tokens.
- Plan Mode
- A Claude Code mode that reads the codebase and generates a full implementation plan for review before executing any file changes, reducing failed attempts and costly do-overs.
- /compact
- A Claude Code slash command that compresses the current session's conversation history to reduce context size and token cost while preserving important context.
- .claudeignore
- A file analogous to .gitignore that tells Claude Code which directories and file types to skip entirely during exploration, most commonly used to exclude node_modules and build artifacts.
- MCP server
- Model Context Protocol servers are external tool integrations connected to Claude Code; each one loads its full tool definitions into context even when idle, consuming tokens before any work begins.
- Context window
- The total amount of text (measured in tokens) that an AI model can process at once in a single session; in Claude Code, every new message resends the entire conversation history, making long sessions progressively more expensive.
- Token
- The unit Claude uses for billing; roughly 3-4 characters of text. Input and output tokens are priced separately, and cached input tokens cost about 10% of fresh input tokens.
Things they pointed at.
Lines you could clip.
“It wasn't the tool. It was the setup.”
“It's like packing for a weekend trip but dragging your entire house with you.”
“One unused MCP server can silently eat over 14,000 tokens per session before you've typed a single word.”
“With a clean Claude.md in place, Claude already knows everything before you type a single word.”
Word for word.
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
The bait, then the rug-pull.
Three days after install, the credits are gone and you have no idea why. That gap between excited first build and confusing budget drain is exactly what this video fills — not with more features, but with six setup steps that should have come before the first prompt.
Named ideas worth stealing.
The 6-Habit Claude Code Setup
- Use Sonnet as default; escalate to Opus only when needed
- Write a CLAUDE.md (under 200 lines)
- Use Plan Mode before building anything complex
- Run /compact every 15 minutes during long sessions
- Create a .claudeignore for every project
- Disconnect idle MCP servers weekly
Six free configuration habits that address the biggest sources of Claude Code token waste.
80/20 Workflow
80% of session time spent in Plan Mode reviewing the proposed approach; 20% in execution. Claimed to cut total token cost on complex tasks by 50-70%.
Model Tier Decision Rule
- Haiku: rename files, fix typos, write boilerplate
- Sonnet: write functions, refactor, add features
- Opus: complex architecture, multi-file reasoning, hard bugs
Simple task-to-model matching that prevents the most expensive mistake: defaulting Opus for everything.
How they asked for the click.
“That's exactly what my free AI cash flow masterclass is all about.”
Two mid-roll blocks (05:02 and 09:07) plus description links. Landing page shown on screen. Offers free 30-day HighLevel trial as the lead magnet. Fairly high-frequency pitch for a 9-minute video.





































































