Working with Claude Code: 6. Other Concepts and Tools

Here are the essential concepts and tools you must learn to fully complete projects using Claude Code:

1. The "Git Safety Net" Workflow

Claude Code is agentic and will execute file changes and terminal commands. Git is your ultimate undo button. You should master the rhythm of working with Claude and Git together.

• Commit before complex prompts: Before you ask Claude to "Refactor the authentication system," commit your current working state. If Claude goes down a rabbit hole and breaks everything, you can simply run git reset --hard or git checkout . and ask it to try a different approach.
• Ask Claude to write commit messages: After completing a feature, you can say: "Please review the current git diff and write a conventional commit message for these changes." Claude will read the diff and generate a perfectly formatted commit message.
• Fixing merge conflicts: If you pull from a branch and get conflicts, don't fix them manually. Ask Claude: "Resolve the git merge conflicts in src/utils.js. Keep my new changes but ensure the upstream changes are integrated."

2. Test-Driven Development (TDD) with Claude

To fully complete a project, you need confidence that your code works. Claude is exceptional at writing tests, but you should guide it using a TDD workflow.

• Write tests first: Ask Claude to write the test suite for a feature before writing the feature.
  • Prompt: "Write a pytest suite for a function that validates emails. Include edge cases for missing @ symbols, spaces, and invalid TLDs. Do not write the actual function yet."
• Run tests via Claude: Tell Claude to run the tests. It will see the failures in the terminal output.
• Implement to pass: Then say, "Now write the validate_email function in utils.py to make all the tests pass." Claude will iterate until the tests are green.

3. Plan Mode (Thinking Before Doing)

For complex features, if you just tell Claude to "build it," it might start writing files immediately without a coherent architecture. You need to force Claude to plan first.

• The "Plan First" Prompt: Start complex tasks by saying: "I need to implement [Feature]. Do not write any code yet. First, outline the files we need to create/modify, the architecture, and the step-by-step plan."
• Review the plan: Read Claude's plan. If you agree, say: "Perfect, proceed with Step 1." This keeps you in control of the architecture while Claude handles the implementation.
• The "Think" Keyword: Using phrases like "think step by step" or "think hard about the edge cases" in your prompts forces Claude to spend more tokens on reasoning before outputting code, drastically reducing bugs.

4. Debugging via Stack Traces

When an error occurs in your terminal, do not copy-paste the error into the Claude chat. Let Claude see it directly.

• Run failing code through Claude: If npm run dev crashes, run it via the Claude Code prompt.
  • Prompt: "Run npm run dev and tell me why it's failing."
• Attaching logs: If you have an error log file (e.g., error.log), tell Claude: "Read error.log, identify the root cause of the crash on line 42, and fix the corresponding file."
• Adding debug logs: If a bug is elusive, ask Claude: "Add console.log statements to userController.js so we can trace the flow of the req.user object. Then run the server."

5. Headless Mode & CLI Flags (Automation)

Claude Code isn't just an interactive chat; it can be used in scripts and CI/CD pipelines. This is crucial for automating project maintenance.

• The -p (print) flag: You can run Claude Code without the interactive UI.
  • claude -p "Review src/api.js for security vulnerabilities and output a markdown report."
• Piping inputs: You can pipe text into Claude Code.
  • cat error.log | claude -p "Explain the error in this log and suggest a fix."
• Use Case: You can add a step in your GitHub Actions or Git hooks that runs claude -p "Check if the code conforms to our ESLint rules and auto-fix formatting." before allowing a commit.

6. Code Review & Refactoring Workflows

Completing a project means polishing the code. Claude Code has native tools for analyzing code quality.

• Reviewing Diffs: Before committing, ask: "Look at the unstaged changes (git diff). Are there any performance issues or bugs in the code I just wrote?"
• Targeted Refactoring: Don't ask Claude to "refactor the app." Ask for specific improvements:
  • "Refactor database.js to use async/await instead of .then() promises."
  • "Extract the validation logic from userRoute.js into a separate userValidation.js file."
• Dependency Updates: You can ask Claude to update packages and fix breaking changes: "Update React to v18 in package.json, run npm install, and fix any TypeScript errors caused by the upgrade."

7. The .claudeignore File (Focus)

Just like .gitignore, you can create a .claudeignore file in your project root. This prevents Claude from reading or indexing certain files, which keeps its context focused and speeds up its file-searching tools.

• What to put in .claudeignore:
  • *.min.js (Minified files are useless to read)
  • package-lock.json or yarn.lock (Too large, no useful logic)
  • assets/images/* (Claude can't "see" images in code files effectively)
  • coverage/ (Test coverage reports)

Summary: The "Completion" Checklist

To guarantee a project is truly finished using Claude Code, run through this mental checklist:

1. Did I commit my work before asking Claude to make large changes?
2. Did I ask Claude to write tests for the new features?
3. Did I ask Claude to run the linter and fix all warnings?
4. Did I review the git diff with Claude to check for security or performance issues?
5. Did I update CLAUDE.md with any new commands or architectural changes?

ai

Back