9 Claude Code Hidden Features Rescue Broken Repos Fast

You don’t need to treat Claude Code like a terminal chatbot. Set it up properly and it can remember your repo rules, roll back bad edits, run repeat workflows, connect to outside tools, and resume work without another long briefing.

That’s the practical gap in the Claude Code hidden features list from Tom's Guide: the product looks simple at first, but its best gains come from features that sit below the obvious prompt box. Use them carefully. You still need to review diffs, inspect tests, and stay alert around risky shell commands.

Before vs. after:

• Before: You re-explain stack choices, style rules, test commands, and project structure every session.
• After: Claude reads project instructions, uses shortcuts for repeat tasks, and can recover when an experiment breaks the repo.
• Watch out for: Automation only helps when the rules are sharp. Vague instructions create vague edits.

Related XOOMAR context: this is the same agentic-workflow tension we covered in Approval Fail Sinks ChatGPT Work, Claude Cowork Wins, and it also matters for readers tracking Anthropic’s developer-tool value in Kimi K3 Forces Anthropic’s AI Price Premium Into Doubt and its copyright settlement.

Before you start, open Claude Code inside a repo you actually use

Start in a real codebase, not a toy folder. The payoff from Claude Code hidden features comes from project context: build commands, tests, conventions, known landmines, and files that shouldn’t be touched.

Use a branch before testing automation-heavy workflows such as hooks, headless runs, or broad refactors. Tom’s Guide describes Claude Code as capable of building apps, debugging errors, explaining repositories, and automating repetitive workflows. That power cuts both ways.

Do this first:

1. Open the repo root: Launch Claude Code where it can see the project structure.
2. Ask for a map: “Inspect this repo and summarize the architecture, test commands, and risky areas.”
3. Check its read: If it misses key files or makes bad assumptions, correct it before asking for edits.

1. Create a CLAUDE.md file so Claude Code stops relearning your project

The fastest upgrade is CLAUDE.md, a project memory file that lives in your repo root. Tom’s Guide calls it “one of the single biggest time-savers in Claude Code” because it removes the need to repeat basic instructions every session.

“Claude automatically scans this file the moment you launch a session.”

Keep it short and operational. Don’t write a novel.

Put this in CLAUDE.md:

• Project overview: What the app does.
• Tech stack: Languages, frameworks, database, styling tools.
• Commands: Dev, test, lint, and build commands.
• Code style: Naming rules, architecture constraints, testing expectations.
• Danger zones: Files or directories Claude should avoid changing without explicit approval.

Watch out for token waste. Tom’s Guide recommends keeping the file under 200-300 lines because Claude reads it at the start of every session.

2. Use checkpoints before experimental edits get expensive

Bad AI edits are inevitable. Checkpoints are Claude Code’s escape hatch.

Tom’s Guide says Claude Code takes snapshots of your codebase while it works. If a feature attempt breaks the app or a bug fix spirals, you can move back to an earlier state instead of manually untangling every file.

Use it this way:

1. Let Claude attempt the change: Keep the task scoped.
2. Run tests or inspect the app: Confirm whether the result holds.
3. Rewind if needed: Type /rewind in the terminal, or hit Esc twice to open the history menu.
4. Select the earlier point: Return to the last clean state.

Watch out for false comfort. A checkpoint is not a replacement for git discipline. Use both.

3. Turn repeated prompts into custom Skills

If you keep typing the same long instruction, convert it into a custom Skill.

Tom’s Guide describes Skills as permanent workflows for recurring tasks. The example given is a /newsletter skill that can pull recent project updates, draft a summary, structure an email template, and suggest SEO improvements.

For coding teams, the same pattern works for repeat engineering chores:

• Test generation: “Write unit tests for the changed module, then list uncovered edge cases.”
• Release prep: “Draft release notes from recent changes and flag migration risks.”
• Review pass: “Review this diff for bugs, performance issues, and missing tests.”

A useful Skill should include:

• Role: What perspective Claude should take.
• Task: The repeat job.
• Inputs: Files, command output, or context it needs.
• Acceptance criteria: What “done” means.
• Output format: Patch, checklist, markdown summary, or test file.

Watch out for overbroad Skills. “Improve this project” is weak. “Review this diff for missing tests and risky state changes” is useful.

4. Break big work into subagents when one prompt is too wide

Large, multi-step requests can push AI tools into messy reasoning. Tom’s Guide says Claude Code can handle complex jobs by creating specialized subagents.

In the source example, a major feature overhaul may involve one subagent reviewing existing code, another writing new logic, and a third generating unit tests. They work in parallel and combine results.

Use this feature when the job has separable parts:

Your prompt should make the split obvious: “Treat this as three independent workstreams: inspect current behavior, propose the implementation, and identify required tests.”

Watch out for hidden assumptions. Ask Claude to show the affected files before accepting broad changes.

5. Connect MCP only when Claude needs outside context

Model Context Protocol, or MCP, is Anthropic’s way to connect Claude Code to external systems. Tom’s Guide lists examples including GitHub repositories, enterprise databases, Slack channels, and web search APIs.

In plain terms, MCP gives Claude controlled access beyond the local repo. That can save copy-and-paste work when the answer depends on tickets, docs, API references, or internal service information.

Good MCP use cases:

• Docs: Pull current API documentation into the coding session.
• Issues: Read ticket context before implementing.
• Repos: Inspect related code outside the current folder.
• Internal references: Check service behavior before changing integration code.

Watch out for data exposure. Only connect trusted servers, and don’t expose private data unless your organization allows it.

6. Run Claude Code in headless mode for background jobs

Interactive prompting is not the only mode. Tom’s Guide says headless mode lets Claude Code run in the background without you sitting at the keyboard.

That makes sense for repeatable, lower-risk tasks:

• Documentation: Generate fresh docs from current code.
• Audits: Review code for bugs on a schedule.
• Release notes: Draft summaries for a team workflow.

This is advanced usage. Start with read-heavy tasks before allowing background edits. A nightly documentation draft is lower risk than an unattended rewrite across core application files.

Watch out for silent drift. Any headless workflow should produce a reviewable output, not quietly mutate critical code.

7. Replace long requests with built-in slash commands

Slash commands are the fastest way to stop typing the same instruction in paragraph form.

Tom’s Guide highlights three built-in commands:

• /bugfix: Scans the active file for errors and fixes them.
• /review: Runs a code review and suggests optimization strategies.
• /test: Writes and executes tests for recently completed code.

Use them when the task is obvious and local. If the work spans architecture, data models, or production behavior, add constraints first.

Example workflow:

1. Edit or generate code.
2. Run /test.
3. Run /review.
4. Ask Claude to explain only the risky changes.
5. Review the diff yourself.

Watch out for command autopilot. A slash command is a shortcut, not a sign-off.

8. Add hooks when checks should happen automatically

Hooks are automation triggers around Claude Code actions. Tom’s Guide describes them as checks that can run before or after major actions.

Useful hook ideas include:

• Formatting: Run a formatter after Claude writes a file.
• Tests: Run the project’s test suite before committing changes.
• Guardrails: Catch minor formatting or typo issues before they spread.

Hooks are best when they enforce rules you already trust. If your formatter is standard and your test command is reliable, automating them removes friction.

Watch out for noisy hooks. If every action triggers a slow or irrelevant warning, people will ignore the system. Start with one or two checks that clearly protect the repo.

9. Resume old sessions when the reasoning still matters

Claude Code can preserve conversation history across sessions, according to Tom’s Guide. That matters when a bug hunt, feature branch, or refactor spans more than one work block.

Use resume when you need prior context:

• Bug trails: What files were inspected.
• Rejected fixes: What didn’t work.
• Architecture reasoning: Why a certain approach was chosen.
• Partial implementation: What remains unfinished.

If the repo changed heavily since the old session, ask Claude to re-scan the relevant files before editing. Old reasoning can become stale fast.

The safest rollout order for these Claude Code hidden features

Don’t turn on every advanced workflow at once. Build the setup in layers.

Start here:

1. CLAUDE.md: Give Claude stable repo instructions.
2. Checkpoints: Make experimentation recoverable.
3. Slash commands: Cut repeat typing for bugfixes, reviews, and tests.
4. Custom Skills: Save workflows your team repeats.
5. Subagents: Split big jobs into focused workstreams.
6. MCP: Add outside context only when needed.
7. Headless mode: Automate low-risk background tasks.
8. Hooks: Enforce checks at the right moments.
9. Session resume: Continue long investigations without rebuilding context.

The practical takeaway: Claude Code hidden features matter because they move the tool from one-off prompting toward repo-aware execution. The next step is simple. Add a tight CLAUDE.md, try /rewind on a safe branch, and turn one repeated prompt into a Skill before you automate anything riskier.

Key Takeaways

• Claude Code can become more useful when it is configured around a real repository instead of used like a basic terminal chatbot.
• Project instructions, shortcuts, rollback, and workflow automation can reduce repeated setup work for developers.
• Readers still need to review diffs, inspect tests, and be cautious with risky shell commands.