{"id":7025138,"date":"2026-08-03T14:05:15","date_gmt":"2026-08-03T14:05:15","guid":{"rendered":"https:\/\/peraltafinancing.com\/analytics\/5-hidden-claude-code-cli-commands-you-need-to-know\/"},"modified":"2026-08-03T14:05:15","modified_gmt":"2026-08-03T14:05:15","slug":"5-hidden-claude-code-cli-commands-you-need-to-know","status":"publish","type":"post","link":"https:\/\/fivemor.com\/?p=7025138","title":{"rendered":"5 Hidden Claude Code CLI Commands You Need to Know"},"content":{"rendered":"


\n<\/p>\n

\n

I used Claude Code daily for months before realizing that claude --help<\/code> hides many of its most useful capabilities. I kept restarting fresh sessions, repeatedly explaining the same project structure, simply because I did not know a better workflow existed.<\/p>\n

While debugging an unrelated issue, I discovered the full CLI reference: dozens of commands and flags that completely changed how I use the tool<\/em>. In this article, I walk through the hidden features that mattered most in practice and how they can make Claude Code significantly more productive.<\/p>\n

Note:<\/strong> This article skips installation and beginner setup. If you are new to Claude Code, start with Getting Started with Claude Code<\/a> for installation and first-run setup, and Claude Code: Master it in 20 Minutes<\/a> for a quick overview of the tool. Everything below focuses on the less obvious CLI features and is verified against Claude Code v2.1.209 and later; version-specific flags are noted where relevant.<\/p>\n

1. The First Thing That Changed: I Stopped Losing My Sessions<\/h2>\n

Claude Code saves every session automatically. It always has. I just never knew how to get back into one. Three flags fix the entire problem:<\/p>\n

# Continue the most recent session in this directory\nclaude -c\n\n# Name a session when you start it\nclaude -n \"auth-refactor\"\n\n# Come back to it by name, days later\nclaude -r \"auth-refactor\" \"finish the PR description\"<\/code><\/pre>\n
The naming part is what makes this actually usable. Without a name you get an auto-generated ID like 7c5dcf5d, which works fine but is impossible to remember. With a name, resuming a piece of work three days later takes one command and Claude already knows everything about it.<\/p>\n
There is a fourth flag here worth knowing. If you want to pick up an old session but you are about to try something risky, \u2013fork-session branches it so the original transcript stays untouched:<\/p>\n
claude -r auth-refactor --fork-session<\/code><\/pre>\n
\n\n\n\n\n\n\n\n\n\n
Flag<\/strong><\/th>\nWhat it actually does for you<\/strong><\/th>\n<\/tr>\n<\/thead>\n
claude -c<\/code><\/td>\nPicks up your last session in this folder. Full context, no re-explaining.<\/td>\n<\/tr>\n
claude -n \"name\"<\/code><\/td>\nNames the session so you can find it later without hunting for an ID.<\/td>\n<\/tr>\n
claude -r \"name\"<\/code><\/td>\nResumes a specific session by name or ID.<\/td>\n<\/tr>\n
claude --fork-session<\/code><\/td>\nResumes but branches, so the original session stays as it was.<\/td>\n<\/tr>\n
claude --from-pr 123<\/code><\/td>\nOpens the session picker filtered to sessions tied to a specific pull request.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
Try this now:  Open a project you were working on yesterday and run <\/em>claude<\/em> -c. If you have ever used Claude Code in that folder, it will pick up exactly where you left off. This one command is the difference between a tool you restart every day and one that remembers your project.<\/em><\/p>\n
2. The One That Changed My Whole Working Day: Background Agents<\/h2>\n
If you take one thing from this article, take this one.<\/p>\n
Adding --bg<\/code> to any command starts the task as a background agent and hands your terminal straight back to you. Claude keeps working. You keep working. You check on it when you feel like it.<\/p>\n
$ claude --bg \"investigate why payments.test.js is flaky\"\nSession started: 7c5dcf5d\nTo attach:    claude attach 7c5dcf5d\nTo view logs: claude logs 7c5dcf5d\nTo stop:      claude stop 7c5dcf5d<\/code><\/pre>\n
The moment this clicked for me was a Monday morning. I kicked off a background agent to audit an unfamiliar codebase for security issues, then spent the next forty minutes doing my actual planned work in a second terminal. When I came back, it had a full report waiting. I had not been sitting there watching a spinner.<\/p>\n
You can run several at once. My usual pattern now looks like this:<\/p>\n
# Fire off two long jobs\nclaude --bg \"audit the API surface for missing auth checks\"\nclaude --bg \"find every TODO comment older than six months\"\n\n# Get on with your own work, then check in\nclaude agents<\/code><\/pre>\n
Managing them<\/strong><\/h3>\n
\n\n\n\n\n\n\n\n\n\n\n\n\n
Command<\/strong><\/th>\nWhat it does<\/strong><\/th>\n<\/tr>\n<\/thead>\n
claude agents<\/code><\/td>\nLive view of every session, running and finished.<\/td>\n<\/tr>\n
claude agents --json<\/code><\/td>\nSame thing as JSON, so you can parse it in a script.<\/td>\n<\/tr>\n
claude attach <\/code><\/td>\nPull a background session into your current terminal.<\/td>\n<\/tr>\n
claude logs <\/code><\/td>\nPrint recent output without attaching.<\/td>\n<\/tr>\n
claude stop <\/code><\/td>\nStop a running session.<\/td>\n<\/tr>\n
claude rm <\/code><\/td>\nRemove it from the list. The transcript stays on disk.<\/td>\n<\/tr>\n
claude respawn <\/code><\/td>\nRestart a session with its conversation intact.<\/td>\n<\/tr>\n
claude respawn --all<\/code><\/td>\nRestart everything. Useful right after a Claude Code update.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
One more that took me a while to notice. The \u2013exec flag runs a plain shell command as a background job instead of a Claude session, which is surprisingly handy for long test runs:<\/p>\n
claude --bg --exec 'pytest -x tests\/'<\/code><\/pre>\n
If parallel agents interest you at a bigger scale, Anthropic pushed this much further with Dynamic Workflows, which can coordinate hundreds of parallel subagents in a single session. We covered that in our Claude Opus 4.8 article<\/u><\/a>.<\/p>\n
3. The Flag I Should Have Learned on Day One<\/h2>\n
-p<\/code>, short for --print<\/code>. It runs your query, prints the answer, and exits. No interactive session, no waiting for follow-up.<\/p>\n
On its own that sounds boring. What makes it interesting is that it turns Claude Code from a thing you sit inside into a thing you can pipe into:<\/p>\n
# Ask one question, get one answer, back to your shell\nclaude -p \"what does auth.js actually do\"\n\n# Pipe a file straight in instead of asking Claude to find it\ncat error.log | claude -p \"summarise these errors by root cause\"\ncat changes.diff | claude -p \"review this diff for security issues\"\n\n# Continue your last session but just get one answer\nclaude -c -p \"any type errors left?\"<\/code><\/pre>\n
The piping is the part I lean on most now. Feeding a log file or a diff directly into Claude is faster than describing where the file is and waiting for it to read from disk, and it works on files outside your project folder.<\/p>\n
Try this now:<\/strong>  Find any log file on your machine and run: cat thatfile.log | claude -p \u201cwhat is going wrong here\u201d. It takes about ten seconds and it is the fastest way to understand what -p is for.<\/p>\n
Output formats, once you start scripting<\/h3>\n
Once -p is in your toolkit, output formats become relevant. Text is the default. JSON gives you something parseable. Stream JSON gives you an event stream for real-time pipelines:<\/p>\n
claude -p \"list all API routes\" --output-format json\nclaude -p \"query\" --output-format stream-json --verbose<\/code><\/pre>\n
And if you are calling Claude Code from a script a lot, --bare<\/code> is worth knowing. It skips auto-discovery of hooks, skills, plugins, MCP servers, and CLAUDE.md<\/strong> so the call starts faster. Claude still has Bash and file tools, nothing else loads:<\/p>\n
claude --bare -p \"quick question about this one file\"<\/code><\/pre>\n
4. Where I Was Quietly Burning Money<\/h2>\n
This section exists because of a bill I did not enjoy looking at.<\/p>\n
Claude Code has an effort setting that controls how much reasoning it applies to a task. I had never touched it, which meant every trivial task got the same deep-thinking treatment as a hard architecture problem.<\/p>\n
claude --effort low       # small edits, quick questions\nclaude --effort medium    # standard day-to-day coding\nclaude --effort high      # complex refactors, architecture work\nclaude --effort ultracode # xhigh effort with ultracode on (v2.1.203+)<\/code><\/pre>\n
Matching effort to the task is the single easiest cost lever in the tool. A one-line fix does not need max effort.<\/p>\n
Hard limits for anything automated<\/h3>\n
For scripted or automated runs, two flags stop things getting out of hand. I now treat both as mandatory in any pipeline:<\/p>\n
# Stop once API spend hits two dollars\nclaude -p --max-budget-usd 2.00 \"large refactor task\"\n\n# Stop after five agentic turns\nclaude -p --max-turns 5 \"investigate this bug\"<\/code><\/pre>\n
As of v2.1.217, spend from subagents counts toward \u2013max-budget-<\/em>usd<\/em>, and once the cap is hit Claude Code stops background subagents that are still running. Before that version, subagent spend could quietly overshoot the cap.<\/em><\/p>\n
There is a lot more depth on cost control than I can fit here. If this is your concern, 23 Tips for Claude Code Token Saving<\/u><\/a> goes properly deep on model choice, effort tuning, and reusable subagents, and it is where I picked up most of my own habits.<\/p>\n
5. The Setting I Had Wrong for Months<\/h2>\n
Permission modes control how much Claude Code does without checking with you first. I ran on the default for a long time, approving every single file edit by hand, and assumed that was the only safe option.<\/p>\n
It is not. There are six modes, and picking the right one for the task removes a lot of friction without giving up control where it matters:<\/p>\n
\n\n\n\n\n\n\n\n\n\n\n
Mode<\/strong><\/th>\nWhat it allows<\/strong><\/th>\nWhen I use it<\/strong><\/th>\n<\/tr>\n<\/thead>\n
default<\/code><\/td>\nPrompts before every edit and tool use<\/td>\nUnfamiliar codebases<\/td>\n<\/tr>\n
acceptEdits<\/code><\/td>\nAuto-accepts file edits, still asks before Bash<\/td>\nMost of my actual work<\/td>\n<\/tr>\n
plan<\/code><\/td>\nPlans only. Writes nothing, runs nothing.<\/td>\nUnderstanding a change before allowing it<\/td>\n<\/tr>\n
auto<\/code><\/td>\nDecides for itself what is safe to allow<\/td>\nProjects I know well<\/td>\n<\/tr>\n
dontAsk<\/code><\/td>\nSuppresses prompts but keeps safety checks<\/td>\nLonger trusted tasks<\/td>\n<\/tr>\n
bypassPermissions<\/code><\/td>\nSkips all permission prompts<\/td>\nCI only, in a sandbox<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
claude --permission-mode plan\nclaude --permission-mode acceptEdits\n\n# Same as bypassPermissions, deliberately verbose so you notice it\nclaude --dangerously-skip-permissions<\/code><\/pre>\n
Plan mode was the real find for me. When I am about to let Claude touch something I do not fully understand yet, I start in plan mode, read what it intends to do, then switch modes and let it run. It costs one extra step and has caught flat-out wrong assumptions more than once.<\/p>\n
Restricting tools instead of modes<\/h3>\n
Separately from permission modes, you can limit which tools Claude has at all:<\/p>\n
\n\n\n\n\n\n\n\n\n\n
Flag<\/strong><\/th>\nEffect<\/strong><\/th>\n<\/tr>\n<\/thead>\n
--tools \"Bash,Edit,Read\"<\/code><\/td>\nOnly these built-in tools are available this session.<\/td>\n<\/tr>\n
--tools \"\"<\/code><\/td>\nNo tools. Claude can only produce text.<\/td>\n<\/tr>\n
--allowedTools \"Bash(git log *)\"<\/code><\/td>\nAuto-allow matching calls without prompting.<\/td>\n<\/tr>\n
--disallowedTools \"Bash(rm *)\"<\/code><\/td>\nAlways deny matching calls, tool stays otherwise usable.<\/td>\n<\/tr>\n
--disallowedTools \"mcp__*\"<\/code><\/td>\nDeny every MCP tool for this session.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
6. MCP From the Terminal<\/h2>\n
MCP is what lets Claude reach into your database, GitHub, Slack, and anything else you connect. I am not going to re-explain the setup here because we have a full walkthrough in How to Connect MCP Servers with Claude<\/u><\/a>, covering both Claude Desktop and Claude Code. What I do want to flag are the CLI commands that are easy to miss.<\/p>\n
The three I actually use<\/h3>\n
# Check what is connected and what is broken\nclaude mcp list\n\n# Authenticate a server showing 'needs authentication'\nclaude mcp login sentry\n\n# Bring over everything already set up in Claude Desktop\nclaude mcp add-from-claude-desktop<\/code><\/pre>\n
That last one saved me a tedious afternoon. I had five servers configured in Claude Desktop and was halfway through adding them to Claude Code by hand before I found out one command copies the lot across, on macOS and WSL.<\/p>\n
The mcp login and mcp logout commands are newer, from v2.1.186. Before them you had to open the interactive \/mcp<\/code> panel to run an OAuth flow, which was awkward over SSH. Now you can do it from the shell, and --no-browser<\/code> prints the URL for you to paste instead of trying to open a browser on a remote box:<\/p>\n
claude mcp login sentry --no-browser<\/code><\/pre>\n
Reading the status output<\/h3>\n
When claude mcp list shows something other than connected, the status tells you what to do next:<\/p>\n
\n\n\n\n\n\n\n\n\n\n
Status<\/strong><\/th>\nWhat it means and how to fix it<\/strong><\/th>\n<\/tr>\n<\/thead>\n
connected<\/code><\/td>\nWorking. Nothing to do.<\/td>\n<\/tr>\n
needs authentication<\/code><\/td>\nReachable but not authorised. Run claude mcp login .<\/name><\/td>\n<\/tr>\n
connected, tools fetch failed<\/code><\/td>\nConnected but could not list tools. Run claude mcp get  for the error.<\/name><\/td>\n<\/tr>\n
failed to connect<\/code><\/td>\nDid not start. Run the install command in your own terminal to see the real error.<\/td>\n<\/tr>\n
pending approval<\/code><\/td>\nA project-scoped server you have not approved in this session yet.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
7. System Prompts: Append or Replace, and Why It Matters<\/h2>\n
There are four flags for changing the system prompt. Two replace it entirely, two add to it. I got this wrong the first time and it took me a while to work out why the results felt off.<\/p>\n
\n\n\n\n\n\n\n\n\n
Flag<\/strong><\/th>\nBehaviour<\/strong><\/th>\n<\/tr>\n<\/thead>\n
--append-system-prompt \"text\"<\/code><\/td>\nAdds your text after the default prompt.<\/td>\n<\/tr>\n
--append-system-prompt-file f.txt<\/code><\/td>\nAdds file contents after the default prompt.<\/td>\n<\/tr>\n
--system-prompt \"text\"<\/code><\/td>\nReplaces the entire default prompt.<\/td>\n<\/tr>\n
--system-prompt-file f.txt<\/code><\/td>\nReplaces the default prompt with file contents.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
Here is the rule I now follow. Use append when Claude should still behave like a coding assistant but also follow an extra rule of yours. Use replace only when the task is not coding at all, like a data extraction step in a pipeline nobody is watching.<\/p>\n
Replacing drops everything in the default prompt, including tool guidance and safety instructions. That is the part I had not appreciated. My replaced prompt was shorter, so the model had less to work with, and I could not understand why it had stopped following conventions it had followed all week.<\/p>\n
# Extend without changing what Claude is\nclaude --append-system-prompt \"Always write a test for any new function\"\n\n# Replace, for a non-coding pipeline step\nclaude --system-prompt \"You are a JSON extraction agent. Output only valid JSON.\"<\/code><\/pre>\n
For rules you want on every session in a project, do not pass flags every time. Put them in CLAUDE.md, which loads automatically. And if you find yourself repeating a whole workflow rather than a rule, that is what Skills are for: Claude Skills Explained<\/u><\/a> covers building them, and there is a good collection of ready-made ones in these GitHub repositories<\/u><\/a>.<\/p>\n
8. When Something Breaks<\/h2>\n
These are the commands I reach for when Claude Code is behaving strangely, in the order I try them.<\/p>\n
Start here<\/h3>\n
# Read-only diagnostic: install health, settings errors, auth state\nclaude doctor<\/code><\/pre>\n
claude doctor runs without starting a session and tells you whether your install is healthy, whether your settings files have validation errors, and whether you are authenticated. It has caught a malformed settings.json for me twice, which is not something you would ever guess from the symptoms.<\/p>\n
If a customisation is the problem<\/h3>\n
# Start with every customisation disabled\nclaude --safe-mode<\/code><\/pre>\n
Safe mode disables CLAUDE.md, skills, plugins, hooks, MCP servers, custom commands, output styles, keybindings, and auto-memory. Authentication, model selection, and built-in tools all still work. If the problem disappears in safe mode, you know it is something you configured rather than the tool itself.<\/p>\n
Note:<\/strong> Safe mode and bare mode are not the same thing. Bare mode skips auto-discovery for speed in scripts. Safe mode disables customisations for troubleshooting, and goes further, covering output styles and keybindings that bare mode would still load.<\/em><\/p>\n
If a background session is stuck<\/h3>\n
claude daemon status\n\n# Stop the supervisor but leave the sessions running\nclaude daemon stop --any --keep-workers<\/code><\/pre>\n
Updating<\/h3>\n
claude update\n\n# Or pin a specific version\nclaude install 2.1.195\n\n# Restart background sessions so they pick up the new binary\nclaude respawn --all<\/code><\/pre>\n
That last line is easy to forget. Background sessions keep running on the old binary until you respawn them, which produces some very confusing behaviour where a new flag works in a fresh terminal but not in a session you started before updating.<\/p>\n
A small quality-of-life thing:<\/strong> if you mistype a subcommand, Claude Code suggests the closest match rather than failing oddly. claude udpate prints \u2018Did you mean claude update?\u2019 and exits.<\/em><\/p>\n
Quick Reference<\/h2>\n
Everything above in one place, for when you know what you want and just need the syntax.<\/p>\n
Sessions<\/h3>\n
\n\n\n\n\n\n\n\n\n\n\n\n
Command<\/strong><\/th>\nDescription<\/strong><\/th>\n<\/tr>\n<\/thead>\n
claude<\/code><\/td>\nStart interactive session<\/td>\n<\/tr>\n
claude \"query\"<\/code><\/td>\nStart with an initial prompt<\/td>\n<\/tr>\n
claude -p \"query\"<\/code><\/td>\nOne answer, then exit<\/td>\n<\/tr>\n
claude -c<\/code><\/td>\nContinue most recent session here<\/td>\n<\/tr>\n
claude -n \"name\"<\/code><\/td>\nStart and name the session<\/td>\n<\/tr>\n
claude -r \"name\"<\/code><\/td>\nResume by name or ID<\/td>\n<\/tr>\n
claude --fork-session<\/code><\/td>\nResume into a new branch<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
Background agents<\/h3>\n
\n\n\n\n\n\n\n\n\n\n\n\n
Command<\/strong><\/th>\nDescription<\/strong><\/th>\n<\/tr>\n<\/thead>\n
claude --bg \"task\"<\/code><\/td>\nRun as a background agent<\/td>\n<\/tr>\n
claude agents<\/code><\/td>\nView all sessions<\/td>\n<\/tr>\n
claude attach <\/code><\/td>\nAttach to a session<\/td>\n<\/tr>\n
claude logs <\/code><\/td>\nPrint session output<\/td>\n<\/tr>\n
claude stop <\/code><\/td>\nStop a session<\/td>\n<\/tr>\n
claude respawn --all<\/code><\/td>\nRestart all running sessions<\/td>\n<\/tr>\n
claude --bg --exec 'cmd'<\/code><\/td>\nRun a shell command as a background job<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
Cost and limits<\/h3>\n
\n\n\n\n\n\n\n\n\n
Command<\/strong><\/th>\nDescription<\/strong><\/th>\n<\/tr>\n<\/thead>\n
claude --effort low|high<\/code><\/td>\nSet reasoning depth<\/td>\n<\/tr>\n
claude -p --max-budget-usd 2.00<\/code><\/td>\nCap API spend<\/td>\n<\/tr>\n
claude -p --max-turns 5<\/code><\/td>\nCap agentic turns<\/td>\n<\/tr>\n
claude --bare -p<\/code><\/td>\nSkip auto-discovery for faster scripted calls<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
Permissions<\/h3>\n
\n\n\n\n\n\n\n\n\n
Command<\/strong><\/th>\nDescription<\/strong><\/th>\n<\/tr>\n<\/thead>\n
claude --permission-mode plan<\/code><\/td>\nPlan only, change nothing<\/td>\n<\/tr>\n
claude --permission-mode acceptEdits<\/code><\/td>\nAuto-accept edits<\/td>\n<\/tr>\n
claude --dangerously-skip-permissions<\/code><\/td>\nSkip all prompts (CI only)<\/td>\n<\/tr>\n
claude --tools \"Bash,Edit,Read\"<\/code><\/td>\nRestrict available tools<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
MCP<\/h3>\n
\n\n\n\n\n\n\n\n\n
Command<\/strong><\/th>\nDescription<\/strong><\/th>\n<\/tr>\n<\/thead>\n
claude mcp list<\/code><\/td>\nList servers and status<\/td>\n<\/tr>\n
claude mcp login <\/code><\/td>\nRun OAuth for a server<\/td>\n<\/tr>\n
claude mcp add-from-claude-desktop<\/code><\/td>\nImport servers from Claude Desktop<\/td>\n<\/tr>\n
claude mcp remove <\/code><\/td>\nRemove a server<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
Diagnostics<\/h3>\n
\n\n\n\n\n\n\n\n\n\n
Command<\/strong><\/th>\nDescription<\/strong><\/th>\n<\/tr>\n<\/thead>\n
claude doctor<\/code><\/td>\nInstall and settings diagnostic<\/td>\n<\/tr>\n
claude --safe-mode<\/code><\/td>\nStart with all customisations off<\/td>\n<\/tr>\n
claude daemon status<\/code><\/td>\nBackground supervisor state<\/td>\n<\/tr>\n
claude update<\/code><\/td>\nUpdate to latest<\/td>\n<\/tr>\n
claude project purge --dry-run<\/code><\/td>\nPreview deleting project state<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
What I Would Tell Myself Six Months Ago<\/h2>\n
Three things, in order of how much time they would have saved me.<\/p>\n
    \n
  1. name your sessions and resume them. claude -n<\/code> on the way in, claude -r<\/code> on the way back. This alone removes the daily re-explaining tax.<\/li>\n
  2. use --bg<\/code> for anything that will take more than a couple of minutes. There is no reason to sit and watch a long task finish when you could be doing something else in another terminal.<\/li>\n
  3. set --effort<\/code> to match the task, and put --max-budget-usd<\/code> on anything automated. Both take five seconds and both directly affect what you pay.<\/li>\n<\/ol>\n
    One last thing, and it is the reason this article exists. Run claude --help<\/code>, then go and read the actual reference. The help output is not the full list, and the gap between the two is where most of the useful stuff lives.<\/p>\n
    Frequently Asked Questions<\/h2>\n
    \n
    Q1. Why does claude \u2013help not show every flag?<\/strong> <\/p>\n
    A. The documentation says it directly: \u2013help does not list every flag, so a flag\u2019s absence from help output does not mean it is unavailable. Always check the official reference if you are looking for something specific.<\/p>\n<\/p><\/div>\n
    Q2. What is the difference between claude -c and claude -r?<\/strong> <\/p>\n
    A. -c continues the most recent session in your current directory without asking. -r resumes a specific session by name or ID, or shows an interactive picker if you do not pass one. Use -c when you just want the last thing you were doing, -r when you have several pieces of work going and need a particular one.<\/p>\n<\/p><\/div>\n
    Q3. Can I run Claude Code in CI without any interactive prompts?<\/strong> <\/p>\n
    A. Yes. Combine -p for non-interactive mode, --dangerously-skip-permissions<\/code> to skip approvals, and a token from claude setup-token for auth. Add --max-budget-usd<\/code> and --max-turns<\/code> so a bad run cannot spiral. claude -p \u2013dangerously-skip-permissions --max-budget-usd 5.00 \"run the test suite and report failures\"<\/code><\/p>\n<\/p><\/div>\n<\/p><\/div>\n
    \n
    Hi , I am Sree Vamsi a passionate Data Science enthusiast currently working at Analytics Vidhya. My journey into data science began with a curiosity for uncovering insights from complex data and has evolved into building end-to-end Generative AI applications, RAG pipelines, agentic AI workflows, and multi-agent systems that solve real-world business problems.<\/p>\n<\/p><\/div>\n<\/p><\/div>\n
    Login to continue reading and enjoy expert-curated content.<\/h4>\n