Replicating My Claude Code Workflow

A practical setup guide for anyone who wants to run AI-augmented development the way I've been running it during the 10K Commit Challenge.

April 21, 2026·~12 min read

This is the "how" to the month-one recap's "what." If you've seen my numbers and want to get to something similar, this is the shortest path I can write down. Nothing here is proprietary — it's all standard Claude Code features, stitched together in a way that happens to be very productive.

I'll assume you have a Mac and a terminal. Linux works the same; Windows is close enough.

1. Install and authenticate

# Install Claude Code
curl -fsSL https://claude.ai/install.sh | sh

# Or via npm
npm install -g @anthropic-ai/claude-code

# First run — it'll walk you through auth
claude

Pick the Pro or Max plan if you're going to live inside this tool. Usage adds up fast when you run sessions in parallel, and the subscription pricing is the right choice over pay-per-token once you're committing daily.

Verify:

claude --version

2. Set your global defaults

Claude Code reads a global config at ~/.claude/CLAUDE.md. This is where you put rules that apply to every project — preferences, guardrails, tool habits. Mine includes things like "auto-commit and push after every change" and "use the smallest image size when taking screenshots."

Open it and write down your own defaults:

$EDITOR ~/.claude/CLAUDE.md

Good starter content:

# Global Rules

## Git
- After every change, commit and push with a concise message.
- Never force-push to main.

## Communication
- Prefer direct edits over asking. Ask only when the answer is unclear
  or the action is irreversible.

## Screenshots
- Request the smallest possible resolution (640x480 or less).
- Do not retain captured images in context — save to disk if needed later.

You'll grow this file over time. The 15 minutes it takes to write down your preferences pays back every single session.

3. One CLAUDE.md per project

Inside each repo you work in, add a CLAUDE.md at the root. This is Claude's briefing doc for that project — architecture, conventions, where things live, how to run the thing, what to avoid.

To generate a first draft automatically, open Claude Code in the project and run:

/init

It'll read the repo and propose a starter CLAUDE.md. Accept it, then edit it by hand. The file should be short — a page or two — and living. Update it whenever you discover something worth remembering.

4. Tune permissions to reduce prompt fatigue

By default, Claude Code asks before every tool call. That's safe but slow once you trust the pattern. Open ~/.claude/settings.json (or the project-scoped .claude/settings.json) and allowlist the commands you run constantly:

{
  "permissions": {
    "allow": [
      "Bash(npm test:*)",
      "Bash(npm run build:*)",
      "Bash(git status)",
      "Bash(git diff:*)",
      "Bash(git log:*)"
    ]
  }
}

There's a /fewer-permission-prompts skill that will scan your recent transcripts and suggest additions based on what you actually ran. Use it once a week — your allowlist will grow into exactly your workflow.

Don't allowlist destructive commands (rm -rf, git push --force, git reset --hard). Let those always prompt.

5. The parallel-terminals pattern

This is the unlock. Open one terminal tab per project, and run claude in each one. You end up with something like:

You give one session a task ("add a leaderboard scene, write the tests"), switch to the next tab while it works, give that one a task, switch again. By the time you loop back, the first session has a diff waiting for you to review.

The review step is where you pay attention. Always look at the diff. 15 seconds per diff is the cost of keeping quality up, and it catches the vast majority of AI hallucinations before they compound.

Practical tips:

6. Auto-commit and push on every change

The single highest-ROI habit I've adopted. In ~/.claude/CLAUDE.md:

## Git: Auto-Commit and Push
- After every change (file edits, new files, deletions), immediately
  commit and push to the remote.
- Use concise, descriptive commit messages.
- Do not wait for the user to ask — commit and push proactively on
  every change.

Two effects:

  1. Natural checkpointing. You never lose work, and every commit is a reviewable unit.
  2. The scoreboard ticks. If you're doing the 10K Challenge, this is where the numbers come from. Not from gaming it — from actually pausing at every natural stopping point and saving.

If your team has a PR-based workflow, swap "push to main" for "push to the feature branch." Same principle.

7. Track it

Two trackers I run side-by-side:

Commit heatmap (macro): Fork the 10K tracker, point it at your GitHub username and a start date, deploy free to Cloudflare Pages. You get a live page showing your daily/weekly/monthly pace. Takes 20 minutes to set up.

Menu-bar tracker (micro): GitPulse sits in your menu bar and shows today's commit count, color-coded against your goal. Red when you're behind, green when you're on pace. Glancing at it every hour is surprisingly effective.

The macro tracker keeps you honest across months. The micro tracker keeps you honest today.

8. Add MCP servers for the tools you actually use

Model Context Protocol servers let Claude Code reach outside the filesystem — Gmail, Calendar, Google Drive, Linear, Slack, databases, your own APIs. If you have a tool you check constantly, there's probably an MCP server for it.

Start with one or two. Don't install every server you can find — each one adds surface area. I use Gmail and Calendar because email triage and meeting prep are the workflows I do most; a trading-specific one for my own infra; and the Roblox Studio MCP for Studio-connected work.

# List currently configured servers
claude mcp list

# Add one (example — Anthropic docs for each server vary)
claude mcp add <server-name> <transport-config>

9. Use skills for repeatable workflows

Skills are named workflows you invoke with /skill-name. A few I use constantly:

You can write your own skills too. If you find yourself giving Claude the same multi-step instruction more than twice, turn it into a skill and save it under ~/.claude/skills/.

10. Use the memory system

Claude Code has a per-project auto-memory at ~/.claude/projects/<project>/memory/. It stores facts about you, your preferences, project context, and external-system pointers across conversations. You don't manage it manually — Claude writes to it when it learns something durable.

You can nudge it: "remember that we deploy via Cloudflare Pages and never via GitHub Pages" and it'll save that. Over weeks, the memory file becomes a compact summary of "how we work here" without you having to write docs.

11. Review discipline

This is the one I come back to, because without it everything else collapses into slop:

  1. Never accept a diff you didn't look at. Even if it's 5 lines.
  2. Run the tests. Or let Claude run them — but verify the result, don't just trust the "done."
  3. For anything touching production, explicitly ask Claude to walk you through what the change will do before you merge.
  4. If something feels off, say so. Claude is good at correcting course when you push back. It's bad at noticing you should have pushed back.

The 10K number is meaningless if a meaningful fraction of those commits is garbage. Keep the bar up.

12. A minimal daily rhythm

This is roughly what a productive day looks like for me once the setup above is in place:

Nothing heroic. It's the consistency, not the intensity, that makes the chart work.

The short version

If you only take four things from this:

  1. Global + per-project CLAUDE.md. Write down your rules once.
  2. One Claude Code session per project, run in parallel tabs. This is the multiplier.
  3. Auto-commit and push on every change. Checkpoint aggressively.
  4. Review every diff. Non-negotiable.

Everything else is optimization on top of those four. Get those right first and the rest comes naturally.

Good luck. If you build something cool, tell me about it.

Related: Month 1 recap · The 10K Commit Challenge · Fork the tracker: github.com/brentvincent/10k-commit-challenge