Building a personal Claude Code workflow — the daily-driver setup

After six months of daily-driving Claude Code (Feb 2025 launch → Sep 2025 setup write-up), the workflow that earns its keep is more structured than the “just run claude” pattern people start with. The Sep 15 IndyDevDan video — “Agentic Prompt Engineering with Claude Code (For you, your team, and your AGENTS)” — codified the patterns I”d been arriving at independently: structured prompts, explicit context budgeting, project-level conventions, and team-shareable agent infrastructure.

The community arrived at the same patterns. The r/ClaudeAI “Claude Code is a Beast – Tips from 6 Months of Hardcore Use” thread (2,313 upvotes, late October) — published a month after this article — became the canonical community summary of the same workflow patterns. Top comment (353 upvotes) on the writeup: “Are we still on Reddit or is this Wikipedia 🤓” — captures the maturity of the discourse by Q3 2025. The “how should I use Claude Code” question now has a real answer.

This is the exact setup from my daily driver after six months of refinement.

The structural layers

The workflow has four layers:

1. Repo-level config — .claude/ directory committed to the repo
2. User-level config — ~/.claude/ for personal preferences
3. MCP server stack — connected tools the agent can use
4. Daily ritual — the actual session pattern

Each layer is documented; each is version-controllable; each is teachable to teammates.

Layer 1: Repo-level .claude/ directory

The structure that”s emerged across projects:

.claude/
├── settings.json          # Project-specific Claude config (model, hooks, etc.)
├── commands/              # Slash commands (project-specific)
│   ├── review.md
│   ├── test.md
│   ├── handover.md
│   └── refactor.md
├── agents/                # Sub-agent definitions (for multi-agent workflows)
│   ├── researcher.md
│   ├── implementer.md
│   └── reviewer.md
├── ARCHITECTURE.md        # The agent reads this for orientation
└── CONVENTIONS.md         # Project-specific patterns (code style, naming, etc.)

Critical: this directory is committed to the repo. Everyone on the team uses the same slash commands; project conventions are agent-readable; the setup travels with the codebase.

IDD”s “Elite Context Engineering” video (Sep 8) covers exactly this pattern — the .claude/ directory is where context engineering lives. Without it, every session restarts from zero.

Layer 2: User-level ~/.claude/ for preferences

The personal layer:

~/.claude/
├── settings.json          # Default model, default behavior preferences
├── commands/              # User-level slash commands (cross-project)
│   ├── git-summary.md
│   └── morning-standup.md
├── agents/                # Personal sub-agents you reuse across projects
└── output-styles/         # Output style preferences

IDD”s “Output Styles” video (Aug 18) covers the recent addition — output styles let you customize how Claude responds (terse vs verbose, code-only vs explanatory, etc.) without repeating instructions per session. Once you find a style that fits your brain, set it as default.

Layer 3: MCP server stack

The MCP servers I run by default:

• filesystem — read/write project files (built-in)
• git — git operations (built-in)
• github — issue / PR creation, comment, search
• postgres (when applicable) — direct DB queries during development
• playwright — browser automation when needed (covered in the 4-layer skill piece)
• fetch — HTTP requests (web research, API testing)
• search — Brave Search or Exa for live web context

Configuration lives in ~/.claude/settings.json. Each MCP server is one line of config + (sometimes) an API key.

Layer 4: Daily ritual

The session pattern that works:

Morning (15 minutes):

1. Open Claude Code in the project I”m working on
2. Run /handover to read the prior session”s handover doc
3. Run /morning-standup (user-level command) to summarize git log + recent issues
4. Identify the day”s 1-3 specific tasks
5. Pick one to start

During a task (2-3 hour blocks):

1. State the task clearly with explicit acceptance criteria
2. Use Plan Mode (/plan) for any non-trivial task
3. Let Claude execute; review diffs before accepting
4. Run tests after each significant change
5. Commit frequently with descriptive messages

End of session:

1. Run /handover (slash command) to generate next-session pickup doc
2. Push commits + handover doc
3. Close the loop

The r/ClaudeAI “automated Opus planning + Sonnet execution combo” thread (1,927 upvotes, Aug 12) captures the model-selection pattern: use Opus for planning hard tasks, Sonnet for execution. Claude Code automates this when configured correctly. Cost-quality balanced; throughput maintained.

The Boris setup signal

The r/ClaudeAI “Boris shares his setup with 13 detailed steps” thread (2,991 upvotes, January 2 2026) — from the Claude Code team lead — is the canonical “this is how serious users work” reference, published 3 months after this article. Worth noting because:

• Boris”s setup matches the pattern. Repo-level .claude/, slash commands, sub-agents, structured prompts. The patterns aren”t arbitrary.
• The Claude Code team explicitly validates this workflow. Not a community-invented hack; the canonical pattern.
• The setup converges across power users. IndyDevDan, Boris, and the r/ClaudeAI 6-month-hardcore-use thread all describe variations of the same architecture.

Slash commands worth having

Beyond the basics, the slash commands that earn their keep:

/review — runs structured code review against current diff

# .claude/commands/review.md
Review the current diff. Check for:
1. Security issues (injection, XSS, auth bypasses)
2. Performance concerns (N+1 queries, unnecessary allocations)
3. Style consistency with project conventions
4. Test coverage gaps
5. Edge cases not handled

Be specific. Cite line numbers. Propose fixes inline.

/test — runs TDD pattern for current feature

# .claude/commands/test.md
For the feature described:
1. Identify what should be tested (positive cases, edge cases, error cases)
2. Write failing tests first
3. Implement until tests pass
4. Refactor for clarity once tests pass

Show the test plan before implementing.

/handover — generates next-session pickup doc

# .claude/commands/handover.md
Generate a handover document covering:
1. What was accomplished this session
2. Outstanding TODOs and their priority
3. Open questions for next session
4. Specific files / functions that need attention
5. Test status

Save to .claude/handover-YYYY-MM-DD.md

/refactor — applies specific refactor patterns

# .claude/commands/refactor.md
For the file or function specified:
1. Identify the refactor opportunity (extract method, rename, restructure)
2. Show the before/after plan
3. Apply the refactor preserving behavior
4. Update tests if needed
5. Document any behavior changes in the diff

Creator POV vs Reddit dissent

IDD”s “5 Agent PATTERNS” video (Aug 25) and the “ADDICTED to Claude Code: RATE LIMITS” video (Aug 4) frame the broader operational discipline. Rate limits, context management, sub-agent orchestration are the constraints that shape advanced workflows. Without operational discipline, even great tools waste their potential.

The Reddit dissent through Q3 2025 splits productively:

The pro-structure majority — captured in the 2,313-upvote “6 months hardcore use” thread. The structured workflow pattern is increasingly the consensus default.

The “stop over-engineering” camp — present and pointed. Most projects don”t need 5-layer agent orchestration; a simple claude + manual review is enough. Counter: it”s enough for casual use; serious daily-driver work benefits from structure.

The “model-quality-only matters” camp — minority. Argues workflow patterns are incidental; what matters is which model you use. Counter: same model + better workflow consistently outperforms same model + ad-hoc usage in measurable ways.

The “Cursor/Windsurf is easier” camp — valid for users who prefer IDE-integrated AI. Different choice; the workflow patterns transfer.

What this means for working engineers in late September 2025

Three concrete starting positions:

1. Start with the .claude/ directory pattern. Commit it to your repo. Add 3-5 slash commands you”ll actually use. The setup investment pays back within a week.

2. Adopt Plan Mode by default. Don”t skip it. The “Claude generates a plan first” pattern catches misaligned tasks before you”ve burned tokens on them.

3. Write handover docs. Multi-session work without handover docs loses context. The 30-second commit at end-of-session saves hours next session.

The honest critique

What this workflow doesn”t address:

• It”s Anthropic-ecosystem-specific. The patterns translate roughly to Cursor / Windsurf / Codex CLI but the specific tooling is Claude Code-flavored.
• It assumes you have Claude Pro or Max subscription. API-only users can build the same patterns but cost-tracking matters more.
• It doesn”t solve the 85% problem. Even with great workflow, the model still hits walls on hard tasks. Workflow is amplifier, not replacement for engineering judgment.
• The “version-control your .claude/ directory” pattern has edge cases. Some content (API keys, personal preferences) shouldn”t commit; .claude/.gitignore matters.

For most working engineers reading this in late September 2025: the personal Claude Code workflow is now a teachable, documentable, version-controllable system. Stop treating it as ad-hoc tooling; invest the setup time once, get the productivity multiplier for months.

For broader context, see our Claude Code first-month dominance analysis, Pi CEO Agents multi-agent framework, and cursorrules best practices for adjacent agent-discipline patterns.