Most of the people who reach out to Wield Systems for AI consulting have already tried Claude once, gotten useful output, and then put it down because they couldn't figure out how to actually integrate it into their day. This post is the setup we'd hand you on day one — install path, the GitHub repos worth your time, and the token discipline that keeps the tool usable past noon.
Part 1 — Installing Claude
There are three ways to use Claude, and they each fit a different kind of work. Pick the one that matches what you actually need to do, not the one that sounds most impressive.
Option A — Claude.ai (browser)
The web app at claude.ai is where most people start. It's free for light use, has a Pro tier at $20/month for heavier workloads, and you can paste in files, screenshots, and code. If you're not a developer, this is probably enough for 80% of what you want to do — drafting, research, summarizing, planning.
Option B — Claude Code (CLI)
Claude Code is the command-line tool that runs Claude inside your terminal, in your actual project directory, with the ability to read and edit your files. This is the version that does real work — building features, refactoring code, running tests, fixing bugs end-to-end. It's what every developer client of ours is running.
# Install Claude Code globally
npm install -g @anthropic-ai/claude-code
# Or via Homebrew
brew install anthropic-ai/tap/claude-code
# Run it from any project directory
cd ~/your-project
claudeOn first run it'll prompt you to log in. If you have a Claude.ai Pro or Max subscription, log in through the browser flow and Claude Code rides on your subscription — no separate API key needed for most personal use.
Option C — Anthropic API (programmatic)
If you're building Claude into your own app — say, an internal tool for your team — you'll use the Anthropic SDK directly. It's pay-per-token, no subscription, and starts at $0 with a $5 credit. This is what's behind every Claude-powered product we ship for clients.
Starting June 15 2026, Anthropic is splitting interactive Claude Code use (still covered by your Pro/Max plan) from programmatic / headless / Agent SDK use (moves to a separate $200/month credit pool on Max 20x). If you're running cron jobs or background agents that hit Claude, plan to move them to a direct API key after that date or you'll hit the new ceiling fast.
Part 2 — The 10 GitHub Repos Worth Installing First
These are the repos we actually use on client work. Not 'top trending,' not 'hottest in AI Twitter' — the ones that earn their disk space week after week.
The official CLI. This is the install you start with — everything else builds on top of it.
Why it matters: Built-in file reading, editing, and shell execution. Tight loop between you and the model. Subagent support for parallel work.
Anthropic's official example library — recipes for tool use, agents, RAG, prompt caching, vision, batch processing.
Why it matters: When you're stuck on 'how do I get Claude to do X programmatically,' the answer is usually a 50-line example here. Saves hours of trial-and-error.
Official MCP (Model Context Protocol) servers — filesystem, GitHub, Slack, Google Drive, Postgres, and dozens of others.
Why it matters: MCP is how Claude connects to outside systems cleanly. Install the servers you need once, and every Claude session can read your Slack, query your database, or pull from Drive without one-off plumbing.
Terminal-based AI pair programmer. Works with Claude, GPT, Llama, and others — picks the right model for the task.
Why it matters: The 'commit-then-undo' workflow is unmatched for experimentation. Git-aware: every change Aider makes lands as a commit you can roll back atomically.
Open-source AI coding assistant for VS Code and JetBrains. Bring your own model — works with Claude through Anthropic API.
Why it matters: If you're an IDE-bound developer and don't want to live in a terminal, Continue gives you Copilot-style inline completion + chat with a model you control.
Open-source AI prompt-pattern library — a curated set of named prompts for common knowledge work.
Why it matters: Stop reinventing prompts. fabric gives you a CLI with 100+ tested patterns — summarize, extract-wisdom, write-essay, analyze-claims — that work consistently across models.
Simon Willison's command-line interface for talking to LLMs. Multi-provider — Anthropic, OpenAI, Google, local models.
Why it matters: The 'plumbing layer' you didn't know you needed. Pipe shell output into a prompt, save responses to a SQLite log, set up templates. Best tool for AI-augmenting your existing shell workflow.
Autonomous coding agent that runs inside VS Code. Reads your repo, plans changes, edits files with your approval at each step.
Why it matters: When you want a more agentic, multi-step workflow than chat but inside your IDE rather than a terminal. The approval-at-each-step pattern keeps you in control.
Plan-and-execute coding agent designed for larger, multi-file changes. Sandbox-based — proposes changes, you review, then apply.
Why it matters: Built for the 'this would take Cursor 12 prompts to get right' kind of work. Lets you decompose a feature into a plan, then execute it sequentially with a clear audit trail.
Our own published library of agent-callable tools — wrappers around common APIs (Pexels, Google Places, ElevenLabs, etc.) priced for the x402 agent-commerce protocol.
Why it matters: If you're building agents that need to do useful things in the world — search images, find businesses, generate voice — these are battle-tested wrappers we use in production. Free to clone and adapt.
Part 3 — Token Optimization (or, How to Not Hit the Wall by Tuesday)
Claude is generous on the Pro and Max plans, but if you start running agents and long sessions, you can absolutely hit the daily limit by 2pm. Here's the discipline we run internally — pulled straight from our team's OPTIMIZATION.md, which we update every time we burn a budget.
Pick the right model for the job
Anthropic ships three model tiers and they're not interchangeable. Use the right one for the work:
- Haiku — fast and cheap. Default for: file reads, summaries, formatting, CRUD operations, test runs, anything where the answer is short and the question is well-specified.
- Sonnet — mid-tier. Use for: production code review, complex multi-step debugging, prompt-writing, anything that needs real reasoning but doesn't require Opus.
- Opus — slow and expensive but smartest. Reserve for: architecture decisions, security analysis, strategic coordination, anything where being wrong is expensive.
The mistake we see most often: people default to Opus for everything because it's 'the best.' It's the best at thinking. It's the worst at being affordable when 80% of your queries don't need that level of thought.
The brain-and-hands split
If you're using Claude Code with subagents, treat the main session as the brain and subagents as the hands. The main session makes architectural decisions, reads the diff at the end, and writes the tight spec. Subagents — on Haiku or Sonnet — do the file reading, the search, the bulk refactoring, the test runs.
We burned 38K tokens in a single Opus session once because the main thread was reading full files itself instead of asking a Haiku subagent to do it. Same outcome, ~10% of the cost. The split is the discipline.
Cache what's stable
Anthropic's prompt caching is free money if you use it right. Cache the things that don't change — your project's CLAUDE.md or spec, your system prompt, your shared knowledge base. Don't cache things that do change — recent messages, fresh tool outputs, ephemeral memory.
Cached tokens cost 90% less. A 50K-token spec that gets cached costs 5K to read on every subsequent request. Set this up once and forget it.
Batch instead of looping
If you have 20 emails to classify, don't fire 20 prompts. Send one prompt with all 20 emails and ask for a structured response. Same applies to code review across multiple files, content generation for multiple slugs, anything where the unit of work is similar. One round-trip with 20 items costs a fraction of 20 round-trips with one item.
RAG before file reads
If you're working in a large codebase, install a local RAG layer (semantic search over your code) and query it before dumping whole files into the context. We use ChromaDB with about 20K chunks indexed across our projects. A typical query returns the right 5 chunks instead of the wrong 50 files. Massive savings.
Background agents for bulk work
Long-running work — research, large refactors, batch processing — should run in background subagents, not in your main interactive session. The main session is for decisions. The background is for labor. They can run in parallel, and the main session only pays the token cost of the decision, not the labor.
Where to Go From Here
If you read this and thought 'this is the kind of thing I want to learn but in long-form,' that's exactly what the AI Can Do It series is. Five volumes, each one a 90-minute read, covering the same kind of practical material as this post but at the depth you need to actually become operationally fluent.
Volume I is for people new to AI tools, with no developer background — get unstuck, get productive, save real hours every week. The later volumes go deeper for owners who want to build their own automations.
If you're more of a build-with-help person than a read-and-learn person, our $500 QuickScan audit is the fastest way to figure out where AI can move the needle in your business specifically. Refundable if we can't find savings that exceed the fee.