Boost Developer Productivity in 2025 with Claude Code - Settings, Custom Commands, Stack Guides and Tips and Tricks#

Published on June 19, 2025

Claude Code, the terminal-native, agentic coding assistant, gets exponentially more useful when you give it a concise project guide (CLAUDE.md), set sensible permissions & environment via settings.json, and automate routine actions with slash-command files. This guide packs all three into copy-ready snippets: stack-specific CLAUDE.md templates, a JIRA-driven custom workflow, permission hygiene tips, and a reflection command that continuously sharpens your guide.

🚀 Plug these examples in verbatim or tweak a line or two and you'll boost both solo and team productivity in minutes.

Project & Team Foundation#

Folder Layout#

repo/
├─ .claude/
│  ├─ settings.json          # shared defaults (VCS)
│  ├─ settings.local.json    # personal overrides (git-ignored)
│  └─ commands/              # shared slash commands
├─ CLAUDE.md                 # root project guide
└─ code/ …

This hierarchy mirrors Anthropic's example repo layout while matching the precedence order in Atlassian Remote MCP docs.

Minimum settings.json#

{
  "permissions": {
    "allow": [
      "Edit",
      "Write",
      "Bash(npm run *)",
      "Bash(go test ./...)",
      "Bash(mkdir *)",
      "Bash(cat *)",
      "Bash(ls *)",
      "Bash(git checkout *)",
      "Bash(git log *)"
    ],
    "deny": [
      "Bash(curl:*)"
    ]
  },
  "env": { "DISABLE_TELEMETRY": "1" },
  "includeCoAuthoredBy": false
}

Team tip: Many teams whitelist the entire npm run * pattern so every present or future script runs without extra prompts.

Co-authoring note: Many engineers aren't yet ready to include Claude Code as a co-author in their commits. The "includeCoAuthoredBy": false setting disables the automatic addition of Claude Code's co-author attribution in git commits. You can also disable this globally with claude config set includeCoAuthoredBy false.

A personal settings.local.json can raise max_thinking_tokens or add experimental commands you alone trust - Git ignores it by default.

High-Level CLAUDE.md Skeleton#

# Goals & Definition of Done
- Ship tested, lint-clean code; follow style rules.

# Commands  (see @.claude/commands.md)
    npm run build      # build JS/TS
    npm run test       # run JS tests
    go test ./...      # run Go tests

# Git Workflow  (see @.claude/git.md)
- Branch: `feature/<slug>`
- Commits: Conventional format; ticket key at end.

# Testing Guide  (see @.claude/testing.md)
- Jest under `__tests__/`; Go tests end `_test.go`.

# FAQ / Gotchas  (see @.claude/faq.md)
- DB is SQLite dev; seed with `./scripts/seed.sh`.

Short, imperative lines keep token size low and recall high.

Custom Command Workflow Example - JIRA-First Development#

work-jira.md#

Place under .claude/commands/work-jira.md - invoke as /work-jira:

You are my engineering assistant.
### Context
We are focusing **exclusively** on JIRA task **$ARGUMENTS**.

1. Ensure branch `feature/$ARGUMENTS` exists and is checked out.
2. Pull the ticket via `jira.get_issue`.
3. Ask me clarifying questions until scope is unambiguous.
4. Draft a **non-destructive** description update by *inserting* the following task template at the **end** of the ticket description (preserve existing text). Populate every field you can; if multiple sources conflict, exercise best judgment to merge them into a single, clear description:

   # [Task Title]

**JIRA Ticket:** $ARGUMENTS

   ## What needs to be done
   - Brief description of feature or fix

   ## Why it's needed (optional)
   - Context or problem statement

   ## Acceptance Criteria
   - [ ] Condition or result defining "done"
   - [ ] Edge case or scenario to cover

   ## Additional Information (optional)
   - **Input** – data or params
   - **Output** – expected result
   - Key logic steps or workflow notes
   - UI/UX pointers (design links, screenshots)

5. Await my approval; then apply update with `jira.update_issue`. 
6. Produce a step-by-step implementation plan; prompt me to challenge it.
7. After I reply **APPROVED**, call `/finish-work`.

Appending instead of overwriting prevents data loss, a pattern Atlassian highlights for remote MCP updates.

finish-work.md#

This tiny workflow helps push Claude Code to properly wrap up tasks and follow the complete development process. It's particularly useful when Claude Code says "all done!" but hasn't yet committed changes or opened a pull request.

1. Run all tests/lints.
2. Implement remaining tasks; ask if there are any technical blockers, missing requirements, or dependencies preventing completion.
3. Commit using Conventional Commits format.
   # Ticket key belongs at the tail per Conventional Commits + JIRA guidelines
   # Example: feat(auth): add OAuth2 integration JIRA-1234

4. Push branch and open PR; comment JIRA with link.
5. Notify me via `terminal-notifier -title "Claude Code" -message "$ARGUMENTS ready for review"`. 

Slash-Command System#

How Commands Work#

Claude Code has a powerful command system that lets you create reusable workflows. Commands are markdown files containing instructions that Claude Code executes when you type a slash command.

Command locations:

• Personal commands: ~/.claude/commands/ - Available in all projects
• Project commands: .claude/commands/ - Shared with your team via git

When you create a file like .claude/commands/reflection.md, you can invoke it by typing /reflection in Claude Code. The $ARGUMENTS placeholder lets you pass dynamic input to commands.

Most Important Built-in Commands#

Core workflow commands:

• /clear - Clear conversation history (essential between tasks)
• /review - Request code review of current changes
• /memory - Edit CLAUDE.md memory files quickly
• /init - Initialize project with CLAUDE.md guide
• /help - Get usage help and command reference

Development utilities:

• /model - Select or change the AI model
• /config - View/modify configuration
• /cost - Show token usage statistics
• /bug - Report bugs (sends conversation to Anthropic)

Reflection Command#

Study the current CLAUDE.md. Suggest **specific deletions or rewrites** that would:
- Reduce token count.
- Clarify ambiguous rules.
- Merge duplicate sections.
> ⚠️  After applying, double-check the updated docs for any accidentally-dropped details you still rely on.
Return a diff-style patch.

This is an extremely valuable tip for projects with long contexts, extensive rules, and detailed documentation. The reflection command helps prevent documentation bloat that can overwhelm Claude's context window and reduce performance.

Important caveat: Before applying reflection suggestions, test the same task you just completed but after the reflection changes. This comparison helps you catch what the LLM might have accidentally deleted that was actually important for your specific workflows.

Reflection loops are praised in HN for keeping guides lean.

Bulk-Fix & Codemod Workflow#

The bulk-fix workflow targets many micro fixes or small changes that typically happen after implementing a large feature. LLMs usually lose focus and forget something when handling long lists of minor tasks - this approach solves that problem by breaking work into systematic phases with validation at each step.

For more global changes across your codebase, consider using codemods instead of relying on LLMs for repetitive transformations. Codemods excel at consistent, programmatic changes while LLMs are better for contextual, targeted fixes.

bulk-fix.md#

You are my engineering assistant.

### Phase 1 – Collect
Ask me to paste a checklist of minor fixes (label tweaks, missing tests, edge cases).

### Phase 2 – Plan
Write PLAN.md with:
- 🔍  Search pattern / codemod name
- 📂  File glob(s)
- ✅  Validation step (tests, lint)
Ask me to **approve** the plan.

### Phase 3 – Execute
For each entry in PLAN.md:
1. If `codemod:` prefix → run relevant codemod (`jscodeshift`, `bowler`, `go fix`).
2. Else → preview with `rg`, patch via `sed -i` or Edit tool.
3. Run test suite.
4. `git commit -m "chore($TASK_SCOPE): $SUMMARY [$JIRA_KEY?]"`.

### Phase 4 – Wrap-Up
Push branch, notify with:
`terminal-notifier -title "Claude" -message "$ARG ready for review"`
Then run `/clear`.

codemod-rename.md#

Run codemod to rename React prop `label` → `textLabel`.

1. jscodeshift -t codemods/rename-label.js "$ARGUMENTS"
2. npm run test
3. git commit -m "chore(ui): rename label prop to textLabel [minor]" --no-verify

Add these to .claude/commands/, then whitelist the tools in settings.json:

"allow": [
  "Bash(jscodeshift *)",
  "Bash(bowler *)",
  "Bash(go fix *)"
]

Why this matters: Planning + codemods delivers deterministic bulk edits while keeping commits reviewable, a pattern that's quickly become consensus best practice among experienced Claude Code adopters.

Stack-Specific CLAUDE.md Starters#

Below are minimal CLAUDE.md fragments for common stacks (and they can be as simple as that, really).

# Commands
- build: npm run build (or yarn build)
- test:  npm run test (or yarn test)
- lint:  npm run lint --fix

# Package Manager
Supports both npm and yarn workflows.

# Commands
- install: poetry install
- test: poetry run pytest -q
- format: poetry run black .
- lint: poetry run ruff check .

# Environment
poetry shell

# Commands
- build: ./gradlew build
- tests: ./gradlew test --tests "$ARGUMENTS"

# Framework
Spring Boot 3 · Java 23 · JUnit 5

# Commands
- build: go build ./...
- test:  go test ./...

# Concurrency
Cancel goroutines on ctx.Done().

# Commands
- build: cargo build
- test:  cargo test
- lint:  cargo clippy -- -D warnings

# Commands
- build: dotnet build
- test:  dotnet test --filter "$ARGUMENTS"

# Guidelines
Enable nullable reference types.

# Commands
- build: swift build
- test:  swift test

# Swift 6 Migration
- Enable strict concurrency checking
- Use sending keyword for isolation regions
- Add @MainActor for UI code
- Handle Sendable conformance warnings

# Framework
SwiftUI + async/await; strict concurrency.

# Commands
- build: ./gradlew :app:assembleDebug
- test:  ./gradlew test

# Android
Jetpack Compose; MVVM; coroutines + Flow.

# Commands
- serve: php artisan serve
- test:  php artisan test

# Security
Prefer Query Builder over raw SQL.

Permission Hygiene Quick Fixes#

Common pain points and solutions:

• Repeated prompts for any npm script - Add "Bash(npm run *)" to allow list
• Search() asks every time - Avoid blanket Edit(*) deny rules that shadow others
• Remove Co-Authored-By footer - claude config set includeCoAuthoredBy false or manually add "includeCoAuthoredBy": false in settings.json

2025 Developer Loop#

Here's what I think the developer loop will look like for the rest of 2025 (and maybe 2026, it's too distant future to guess).

A fast, repeatable inner-loop many teams follow. As commands become repeat fixtures, migrate them from your personal settings.local.json or ~/.claude/commands/ into the project-level .claude/ so the whole team benefits with Claude Code:

1. /clear - reset context after finishing any task or module.
2. Draft - run /plan "short goal"; Claude Code proposes subtasks.
3. Quest - it asks clarifying questions; you respond until requirements are crystal-clear.
4. Approve task - Approve to proceed; description updates in JIRA.
5. Plan execution & testing - Claude Code lists concrete edits, commands, and validation gates; you confirm.
6. Execute & test - the assistant edits files, runs npm run test / go test ./..., iterates until all green.
7. Finish work - /finish-work commits, pushes, opens a PR, triggers code review, pings Slack with terminal-notifier, etc.
8. /clear again - wipe context before the next ticket.

Most small and mid-sized tickets complete comfortably within this loop; explicit think / ultrathink escalations are rarely needed.

Wrap-Up#

As I've been learning Claude Code myself, I've found these approaches to be incredibly effective for boosting productivity. Drop these snippets into your repo, adjust a path or two, and Claude Code will feel like a senior dev who already knows your stack, rules, and ticketing system. Keep refining CLAUDE.md with the reflection command, share broad allow-lists to cut noise, and let custom slash commands automate the toil.

I hope this guide has been helpful! As we all continue to explore and push the boundaries of AI-assisted development, I'd love to hear about your own experiences and discoveries with Claude Code.