Back to Lab

How to Set Up Claude Code Like a Pro in 2 Minutes

The default Claude Code install gives you a terminal and a prompt. That's it. No structure, no memory, no awareness of your projects or rules. It's like getting a powerful car with no GPS, no mirrors, and the seat adjusted for someone else.

This tutorial walks through the exact setup I use daily. Folder structure, CLAUDE.md configuration, gitignore, custom commands, and deployment workflow. Each step takes about 30 seconds. The entire process, under 5 minutes.

Step 1: Create Your Workspace

Everything starts with a single root directory. Open your terminal and run:

mkdir -p ~/CLAUDE
cd ~/CLAUDE

This is your workspace root. Every project, every reference file, every command lives under this directory. Claude Code will use it as the anchor for all your work.

Now create the core subfolders:

mkdir -p projects
mkdir -p _local-assets
mkdir -p references

projects/ holds one folder per project. If you're running a Shopify store, that gets its own folder. A web app? Its own folder. A content pipeline? Same.

_local-assets/ is for large files that should never touch Git. Videos, PSD files, raw footage, high-res images. The underscore prefix keeps it sorted at the top of your file browser.

references/ holds templates and style guides. Copywriting rules, brand voice documents, platform formatting specs. Claude reads these when it needs to match your voice.

Your workspace now looks like this:

~/CLAUDE/
  projects/          # One folder per project
  _local-assets/     # Large files (gitignored)
  references/        # Style guides, templates

Step 2: Write Your CLAUDE.md

This is the most important file in your entire setup. Claude Code reads CLAUDE.md automatically at the start of every session. It's your operating system: identity, rules, workflows, installed tools.

Create the file:

touch ~/CLAUDE/CLAUDE.md

Open it in your editor and start with the basics. Here's a minimal structure that works:

# [Your Brand] Business OS

You are the operating system for [Your Brand].
Load this once. Never ask to repeat instructions.

## Who

**[Your Name].** [Your role]
[One line about what you do]

## Workspace

~/CLAUDE/
  projects/          Your project folders
  _local-assets/     Large files (gitignored)
  references/        Templates, style guides
  CLAUDE.md          This file

## Rules

1. [Your most important rule]
2. [Second rule]
3. [Third rule]
4. Do it without asking. Optimize independently.
5. After corrections, update memory.

## Content Voice

- Short sentences. No filler.
- Numbers beat adjectives.
- Lead with outcome, not process.
- Sound human. If it reads like AI, rewrite.

## Decision Framework

| Task              | Use                    |
|-------------------|------------------------|
| New feature       | feature-dev workflow   |
| Blog post         | content skill          |
| Bug fix           | debugging skill        |
| Content planning  | /brief command         |
| Repurpose content | /repurpose command     |

A few things to notice. The "Who" section tells Claude your experience level so it calibrates responses. A 15-year designer gets different suggestions than a junior developer.

The "Rules" section enforces consistency. No em dashes? Put it here. Prices in EUR with number first (33 EUR)? Put it here. Author name should be your brand, not your personal name? Here.

The decision framework is the part most people skip. It maps tasks to tools. Without it, Claude doesn't know whether "make this look better" should trigger a design review, a CSS fix, or a redesign. With it, the routing is automatic.

Start minimal. Add rules when Claude makes a mistake you don't want repeated. After a few weeks, your CLAUDE.md will handle 90% of edge cases before they happen.

Step 3: Set Up Your .gitignore

If you're using Git (and you should be), you need a gitignore that prevents three categories of files from ever being committed: credentials, large media, and local-only work.

touch ~/CLAUDE/.gitignore

Here's a solid starting point:

# Credentials and secrets
.env
.env.local
.env.production
*.pem
*.key

# Large media (belongs in _local-assets)
_local-assets/
*.mp4
*.mov
*.psd
*.ai

# OS files
.DS_Store
Thumbs.db

# Node modules (if applicable)
node_modules/

# Local notes and drafts
_drafts/
_scratch/

The critical entries are the credential files. A leaked .env with API keys in a public commit is a nightmare. The gitignore prevents it from happening accidentally.

The _local-assets/ exclusion keeps your Git repo lean. Large binary files bloat the repo and slow down clones. If you're deploying to Vercel, it reads the gitignore when building, so your local assets and credentials stay local.

Step 4: Install Your First Custom Command

Commands live in your Claude Code commands directory. The exact path depends on your Claude Code version, but the standard location is:

mkdir -p ~/CLAUDE/.claude/commands

Each command is a single markdown file. Let's create a simple one to start. This command takes any content and turns it into a concise summary with key takeaways:

# Create the command file
touch ~/CLAUDE/.claude/commands/summarize.md

Open it and add:

---
description: Summarize content into key takeaways
argument-hint: "<paste article or content>"
---

Summarize the input content:

1. One-sentence summary (max 20 words)
2. 3-5 key takeaways (one sentence each)
3. One actionable next step for the reader

Rules:
- Be specific. Use numbers from the source.
- No filler phrases ("In this article" etc.)
- Match the voice defined in CLAUDE.md

Now open Claude Code and type /summarize. Paste any article. The output follows the exact structure you defined, every time.

The frontmatter block (between the --- markers) is what Claude uses to understand the command. The description appears in the command list. The argument-hint tells you what input the command expects.

The body is the actual instruction set. This is where you define the output format, the rules, and any constraints. Be specific. The more precise your command definition, the more consistent the output.

Once you've tested /summarize and it works, you can create more commands for your specific workflow: content repurposing, SEO audits, email drafts, code reviews. Each one eliminates a repetitive prompting cycle.

Step 5: Connect Your Deployment Pipeline

A setup that can't ship is a toy. The final step is connecting Claude Code to your actual production tools.

If you're running a Shopify store, your project folder should contain your theme files and any scripts for managing products, blog posts, or sections. Claude Code can edit Liquid templates, update product descriptions, and push changes through the Shopify API, all from the terminal.

If you're deploying a web app to Vercel, your project folder should be a Git repo. Claude Code commits changes, you push to the remote, and Vercel picks up the deploy automatically. A clean CLAUDE.md ensures commit messages follow a consistent format and the right checks run before every push.

If you're managing content distribution through Buffer, your /repurpose command produces the content, and you paste the outputs into your scheduling queue. The command already formats for each platform, so there's no reformatting step.

Your Claude Code workspace isn't isolated. It connects to Git, to your hosting platform, to your store, to your content tools. The setup you built gives Claude the context to work with all of them coherently.

What You Should Have Now

If you followed every step, your workspace looks like this:

~/CLAUDE/
  CLAUDE.md              # Your business OS
  .gitignore             # Secrets + large files excluded
  .claude/
    commands/
      summarize.md       # Your first custom command
  projects/              # One folder per project
  _local-assets/         # Large media (gitignored)
  references/            # Style guides, templates

Claude Code now has persistent context, knows your rules, can find your files, and has at least one reusable command. That's a functional setup.

From here you can add more commands, install skills, and build out your references folder. Each addition makes the system smarter. Each rule in CLAUDE.md prevents a class of mistakes from ever happening again.

The Shortcut

Everything above takes about 5 minutes from scratch. Writing a solid CLAUDE.md with a proper decision framework takes longer, maybe 20 minutes if you're thinking through your rules carefully. Building and testing production commands takes a few hours of iteration.

Claude Blueprint is the setup I wish I had on day one. 33 days of iteration distilled into a single install script. Run it, answer two questions, and you have a production workspace with 4 commands, 3 production skills (debugging, content audit, session start), copywriting rules, and a searchable dashboard. 33 EUR, one-time. That's 1 EUR for every day of mistakes you skip.

But the manual path works too. The steps above give you a solid foundation. Build on it, customize it, make it yours. The only wrong move is leaving Claude Code at its defaults and wondering why it doesn't perform.

This article contains affiliate links. If you sign up through them, I may earn a small commission at no extra cost to you. (Ad)

Back to all articles