Claude Code practice questions

Add the directory path to the .gitignore file.

Why it fails: While Claude Code often respects .gitignore, it is not the primary mechanism for overriding agent-specific indexing behavior. The tool requires a dedicated configuration file to ensure that the agent ignores files that might be necessary for git version control but should remain hidden from the AI analysis engine.

Use the --exclude-path flag during every execution.

Why it fails: CLI flags are transient and prone to human error if not included in every session. A declarative configuration file like .claudeignore provides a persistent and reliable way to enforce directory exclusions without relying on memory or command history, making it the preferred method for consistent workspace security.

Modify the global Claude API key permissions.

Why it fails: API key permissions control access to models and usage limits, not local repository indexing behavior. Restricting access to local directories is a client-side responsibility handled by the CLI configuration, as the API key has no visibility or control over which local files the CLI process decides to read.

Delete the .claude directory to reset the cache.

Why it fails: Deleting the local cache directory will not impact server-side API rate limits. Rate limits are enforced on the backend based on account status, and clearing local configuration files will only cause the CLI to re-initialize without resolving the underlying account-based restriction preventing further API calls.

Switch to a different local machine.

Why it fails: Rate limits are tied to the user's account and API credentials, not the local hardware. Moving to a different computer will not bypass the limits, as the backend will still recognize the same user account and apply the identical usage restrictions based on the active subscription tier.

Disable the .claudeignore file.

Why it fails: Configuration files like .claudeignore affect how the agent scans the local filesystem, not the API throughput limits. Disabling these files would simply expose more code to the agent, potentially consuming tokens faster and exacerbating the rate limit issue rather than resolving it.

Upload the entire codebase to an external cloud IDE.

Why it fails: Claude Code is designed to run locally. Uploading code to an external cloud IDE is counterproductive and defeats the purpose of using a local agent. The tool relies on reading local filesystem changes directly, and centralizing files in a cloud IDE adds unnecessary latency and complexity.

Disable the system shell for the terminal.

Why it fails: The agent's power comes from its ability to use the shell. Disabling the shell would render the tool unable to run tests, compile code, or perform system-level diagnostics, which are key components of its utility. Keeping the shell functional is mandatory for the agent to operate effectively.

To initialize the local repository.

Why it fails: Initialization commands, such as those that might create config files, are different from version-check commands. Running the version flag does not create or modify files; it simply queries the binary for its metadata, leaving the local repository and its configuration completely unaffected by the request.

To list all available AI models.

Why it fails: Listing models requires a different command or API query, as the current CLI version does not output model availability through the version flag. The --version flag is strictly limited to identifying the CLI binary's own version number, not the status of external services or models.

To authenticate with the Anthropic API.

Why it fails: Authentication is handled through environment variables or initial login commands. The version command does not initiate network traffic to the API and therefore does not perform authentication, ensuring that the tool remains useful even in environments where the user is not currently logged in.

Run the command with the --restricted-mode flag set to true.

Why it fails: Claude Code does not provide a native --restricted-mode flag for directory scoping. While CLI flags exist for model selection or tool management, file-system boundaries are primarily managed through project-level configuration files rather than ad-hoc execution flags during the startup process.

Use the --whitelist flag followed by the path 'src/core'.

Why it fails: There is no --whitelist flag available in the Claude Code CLI. Relying on non-existent flags results in an error, preventing the session from starting. Developers must utilize the established .claudeignore mechanism or session-based context scoping to control file interactions effectively.

Invoke the agent using the --directory 'src/core' argument.

Why it fails: The --directory flag is not a supported feature for isolating execution context in Claude Code. Changing the working directory via the CLI does not inherently create a security boundary or prevent the agent from navigating outside the specified path during complex refactoring tasks.

Use the /help command to view current session capabilities.

Why it fails: The /help command provides documentation about available commands, but it is not a mechanism for providing context or feedback on the code being generated. It is an informational tool rather than an input mechanism for influencing the agent's reasoning or code implementation style.

Edit the system-prompt.txt file located in the project root.

Why it fails: There is no 'system-prompt.txt' file that influences Claude Code's behavior in real-time sessions. The agent's instructions are governed by the tool's core configuration and the conversational context provided by the user during the session, not by arbitrary external text files placed in the project root.

Use the --force flag to override the agent's previous decisions.

Why it fails: The --force flag is not a valid parameter for the Claude Code CLI and does not exist. Controlling the agent's decision-making process should be done through clear conversational prompts rather than non-existent CLI flags, which could cause execution errors or invalid session configurations.

Hardcode sensitive API keys directly into the project's main script.

Why it fails: Hardcoding secrets is a severe security risk. Even if the agent needs access to these services, they should be managed via secure environment variables or secret management tools. Exposing keys in plain text makes them susceptible to accidental leakage and compromises the entire project's security posture.

Give the agent sudo permissions to allow unrestricted tool usage.

Why it fails: Granting sudo permissions to an AI agent is extremely dangerous. It provides unnecessary elevated access that could lead to catastrophic system damage if the agent makes an error. Always operate the agent under a restricted user profile to minimize the potential impact of any accidental actions.

Force close the terminal window using the OS kill command.

Why it fails: Killing the terminal process is an abrupt termination that may prevent the agent from finishing clean-up tasks. It is not the recommended way to interact with the tool and should only be used as a last resort if the process becomes unresponsive during execution.

Delete the project directory to clear all traces.

Why it fails: Deleting the project directory is extreme and destructive. It removes all your code and project files, which is never the correct way to stop an agent session. This action would result in irreversible data loss, making it a completely inappropriate method for exiting a software tool.

Just start a new project in another folder.

Why it fails: Starting a new project does not stop the existing Claude Code process. You would end up with multiple active sessions consuming system resources and potentially trying to manage the same environment, leading to conflicts and unpredictable behavior across your terminal sessions.

Automated code documentation and style guide generation.

Why it fails: While the agent can write comments and docstrings, it does not have a dedicated, automated feature for generating style guides. Style guides are typically human-defined and project-specific, requiring domain expertise that exceeds the role of a general-purpose coding assistant.

Automated, persistent cloud-based code hosting.

Why it fails: Claude Code is not a hosting provider. Its purpose is to assist in local coding, not to serve as an infrastructure platform. Mixing hosting with coding agent functionality would lead to a confusing toolset that drifts far from its core objective of assisting in software development.

Hardware-level debugging of physical devices.

Why it fails: Claude Code is designed for software development within a terminal environment. It has no capabilities for physical hardware debugging or interacting with embedded hardware interfaces. Such tasks require specialized tools and are completely outside the scope and design intent of an AI coding agent.

Restart the CLI process and manually delete the modified files.

Why it fails: Manually deleting files after restarting the CLI process is inefficient and error-prone. This approach risks losing the current session context and the conversation history, which are essential for understanding why the agent made those specific changes. Using built-in recovery commands is always preferred over manual file system manipulation.

Execute the 'reset' command to clear the entire session history.

Why it fails: The 'reset' command clears the conversation history and potentially the state, which is counterproductive when you want to refine the task. Clearing history forces the agent to lose the context of the previous attempt, making it impossible to iterate effectively on the specific refactoring task you were performing.

Use git checkout . to revert all changes in the repository.

Why it fails: While 'git checkout .' is a valid Git command to revert changes, it is not the most efficient method within the Claude Code interface. It acts globally on the repository, potentially reverting changes you wanted to keep, and it does not interact with the agent's internal state management.

Create a `.claudeignore` file listing `legacy/` and rely on Claude Code to skip those files during edits.

Why it fails: Claude Code does not natively support a `.claudeignore` file for excluding directories from modification. While it respects `.gitignore` for file discovery, that does not prevent edits. The agent could still modify files in `legacy/` if instructed, so this approach does not enforce the restriction.

Use a `CLAUDE.md` file with a rule: 'Do not edit files in legacy/'. Claude Code will enforce this rule automatically.

Why it fails: `CLAUDE.md` provides context and instructions, but it does not enforce hard restrictions. The agent may still edit files if it deems it necessary. For strict enforcement, you need permission settings. Relying solely on `CLAUDE.md` is not robust for security or compliance requirements.

Set the `CLAUDE_CODE_READ_ONLY` environment variable to `true` for the entire project.

Why it fails: There is no `CLAUDE_CODE_READ_ONLY` environment variable in Claude Code. Read-only mode is not a global setting; it can be toggled per session or via permissions. Setting a non-existent variable would have no effect, and it would also block all writes, not just those in `legacy/`.

The `/permissions` command, which toggles between strict and permissive modes.

Why it fails: There is no `/permissions` command in Claude Code. Permission settings are accessed via `/config`. The `/permissions` command does not exist, so it cannot be used to control command execution. Developers should use the documented settings interface to manage allowed commands.

The `--dangerously-skip-permissions` flag, which disables all permission checks.

Why it fails: The `--dangerously-skip-permissions` flag bypasses all permission prompts, which is the opposite of controlling which commands can run. It is intended for isolated environments where safety is not a concern. Using it would not allow the developer to selectively permit commands; it would remove all safeguards.

The `CLAUDE.md` file, where commands can be listed with an `allow:` prefix.

Why it fails: The `CLAUDE.md` file is for providing project context, not for defining command permissions. While it can include instructions, it does not have a built-in syntax for allowing or denying specific commands. Command permissions are managed through the `/config` interface or settings files, not through CLAUDE.md.

Deny the current edit and re-prompt Claude Code to only edit source files.

Why it fails: Re-prompting may steer this particular turn, but it provides no durable protection. In a later session or a differently worded request, Claude Code could again attempt to rewrite the generated stubs, and nothing in the environment would stop it. The scenario explicitly requires protection that persists beyond the current interaction, which a one-time denial cannot guarantee.

Set the editor to read-only mode for the `gen/` directory before starting the session.

Why it fails: Editor-level read-only flags govern the human's editing surface, not the tools Claude Code invokes. Claude Code writes through its own file-editing and shell capabilities, which bypass editor UI settings. Relying on the editor leaves the generated stubs fully writable by the agent, so the requirement would not actually be met.

Commit the generated stubs so Claude Code treats them as read-only.

Why it fails: Version control status does not make files read-only to Claude Code; a committed file is still editable and the change would simply appear as a new diff. This option reflects a misconception that tracking a file in Git prevents agent modification. The scenario needs an enforced guard, not an incidental artifact of repository history.

Run Claude Code with the `--read-only` flag to prevent any modifications.

Why it fails: The `--read-only` flag is not a feature of Claude Code. Even if it existed, it would prevent the feature implementation entirely. The developer needs to allow edits while enforcing standards. Using configuration and context files is the correct approach to guide behavior without blocking all changes.

Manually review every edit before applying it and reject any that violate standards.

Why it fails: Manual review is always good practice, but it does not proactively enforce standards. It relies on the developer catching every violation, which is error-prone and time-consuming. The question asks for practices that help achieve adherence; manual review alone is reactive. Combining automated guidance with review is more effective.

Use the `--no-edit` flag to prevent Claude Code from making any file changes.

Why it fails: The `--no-edit` flag does not exist in Claude Code. Even if it did, preventing all edits would make it impossible to implement the feature. The goal is to guide edits, not block them entirely. Developers should use configuration and context files to steer behavior rather than disabling editing.

Relying on the `Read` tool, which shows the file contents before Claude Code edits it.

Why it fails: Reading a file only displays its current contents; it does not present the proposed change or require approval before writing. Claude Code may read a file and then edit it without a separate confirmation step in default modes. Since the developer wants to review each edit as a diff and approve it, a read operation alone does not provide the necessary gate.

Using the `--dangerously-skip-permissions` flag so edits are applied without interruption.

Why it fails: Skipping permissions does the opposite of what is needed: it applies actions without asking, removing the review step entirely. For a production-critical configuration file, that increases risk because edits land without any diff review. The developer explicitly wants to approve or reject each edit, so bypassing permission prompts is directly contrary to the scenario's goal.

Adding the file path to a `deny` list in `.claude/settings.json` so Claude Code cannot modify it at all.

Why it fails: Denying the file blocks all modifications, which prevents the developer from ever letting Claude Code make an approved change. The scenario wants the developer to review each edit and then approve or reject it, not to forbid edits entirely. A blanket deny removes the ability to accept a good change after review, so it does not match the requirement.

Autonomous deployment of code to production servers.

Why it fails: Claude Code is designed for local development assistance and does not have native, pre-configured permissions to perform production deployments. Such actions would require specific CI/CD integration and manual security approvals that are outside the scope of the CLI agent's default operational capabilities.

Persistent storage of user source code on Anthropic servers.

Why it fails: Claude Code does not persist user source code on Anthropic servers. Data sent to the API is processed according to Anthropic's enterprise privacy policies, which generally exclude using customer data to train models unless explicitly opted into, maintaining the confidentiality of the local codebase.

Automatic configuration of cloud infrastructure providers.

Why it fails: While Claude Code can edit configuration files like Terraform or Kubernetes manifests, it does not possess native plugins or autonomous capabilities to authenticate and provision cloud resources directly. Infrastructure provisioning remains a task requiring external tools and secure, managed credentials managed by the developer.

To host a web server for displaying AI documentation.

Why it fails: The CLI is not designed to function as a web server for documentation. It is an interactive tool for code manipulation and agentic assistance, focusing on the local development workflow rather than serving static web content or hosting documentation pages for external viewing.

To manage remote server configurations exclusively.

Why it fails: While it can edit configuration files, its primary design is to function within the local development environment. It is not intended as a dedicated remote server management platform; rather, it is a tool for developers to improve their immediate, local coding productivity and project navigation.

To replace the git version control system.

Why it fails: Claude Code is designed to work in tandem with Git, not replace it. It frequently interacts with Git to stage, commit, and branch code, but it does not provide the robust versioning, branching, and repository management capabilities inherent to Git itself.

It automatically guesses the correct input.

Why it fails: Guessing input for interactive prompts is dangerous and prone to failure. The agent is programmed to be cautious and will pause for human input rather than risk execution errors or system instability by providing incorrect, automated responses to interactive command-line prompts.

It terminates the process and reports an error.

Why it fails: Terminating the process is unnecessarily aggressive. The agent prefers to collaborate with the developer. It is designed to pause execution and request the developer's input, maintaining the flow of the task while ensuring that interactive steps are handled correctly by the human in the loop.

It forces the command with the -y or --force flag.

Why it fails: Blindly applying force flags can lead to unintended side effects, such as overwriting data or bypassing security checks. The agent avoids forcing commands unless explicitly instructed, preferring to wait for human guidance to ensure the action is intentional and safe for the current system state.

Deleting arbitrary user files without asking.

Why it fails: Deleting files without user authorization is a high-risk action that violates safety standards. The agent must always ask for explicit confirmation before removing files to prevent data loss, ensuring that the developer remains in control of their filesystem and can prevent accidental deletion of important assets.

Exfiltrating environment variables to remote servers.

Why it fails: Exfiltrating sensitive environment variables is a malicious action. Claude Code is designed to protect user privacy and does not send sensitive local environment data to external servers, prioritizing security and preventing potential credential leakage that could compromise the developer's infrastructure and system integrity.

It stores all conversation history in the git index.

Why it fails: The git index is for versioning code, not managing ephemeral AI conversation state. Storing chat history in Git would pollute the repository history with metadata that is irrelevant to the source code, making it an inappropriate and inefficient choice for maintaining conversational context during the development session.

It clears all history every time a command is run.

Why it fails: If the agent cleared history after every command, it would lose the ability to maintain context, making it impossible to perform multi-step refactoring or iterative debugging. Consistent memory is a requirement for the agent to behave as a reliable assistant rather than a stateless, disconnected command runner.

It relies entirely on the terminal scrollback buffer.

Why it fails: Terminal scrollback is for human visibility and cannot be parsed reliably by the agent to understand past interactions. The agent requires a structured, programmatic way to access conversation history, which is managed via its own internal logic rather than relying on external terminal-specific UI features.