Pass Your Anthropic CCA-F Exam Easy!

Model confidence is not an approval record from the production deployment owner. A tool description can encourage selection of a capability, but cannot override a mandatory review or change-management gate. If a model bypasses the operator because it believes a deployment is safe, the executor would be accepting untrusted language as authority. Preserve the host's authenticated permissions and required approval evidence even when the tool advertises a broad administrative action.

Being able to connect to an MCP server says only that a transport and interface are available, not that every method has administrator privileges or user consent. A server-provided description may be inaccurate or compromised, and its claim that it can approve deployment cannot override organizational release gates. The host must independently authorize the exact side effect, account and environment, checking required operator approval before dispatch. Trust in a tool implementation is distinct from authority to approve production changes.

A description claiming that a tool approves deployment is ordinary capability metadata supplied by its server, not proof that the caller is authorized to promote production code. The backend must check the real authenticated principal, release target, required approvals and current policy before any consequential action. A model can quote an attractive tool description and still lack permission to run it. Executing from advertised wording would make an untrusted catalog entry an authority escalation path.

Consistent names for similar tool roles can improve discoverability and does not by itself create a tenant-boundary violation. The real risk in copying project-scoped MCP configuration is carrying credentials, endpoints or resource IDs that still refer to the old tenant. Preserve role naming where meaningful, but bind the connection to the new repository's approved tenant, verify permissions and keep secrets scoped. A naming convention is not a replacement for those checks, nor is it the prohibited mistake.

Using distinct per-project environment values is a protective practice, not the mistake in this scenario. Each repository may represent a different tenant, identity and default target, so its credentials and identifiers must match that scope. The risk is copying an earlier tenant's live token and destination unchanged into the new project. Validating project-scoped settings and connection permissions prevents an apparently successful tool call from accessing the wrong customer's resources.

A harmless connection test is useful after migrating an MCP definition, but it cannot substitute for replacing credentials and target identifiers that belong to a different tenant. The connection may succeed precisely because the copied old token still has access to the previous customer's server. Before any tool call, inspect the resolved project environment, principal and tenant-scoped endpoint. Test a safe operation only after those values are confirmed, and record which tenant the observed result actually came from.

Writing a new listing file into every directory changes the repository just to answer a read-only question. It can clutter source control, trigger file watchers and create permissions problems without improving discovery. The built-in Glob capability is designed to enumerate paths matching a filename pattern such as '*.test.ts' without altering files. A filesystem listing operation is the appropriate first step; only inspect contents if the user later asks for matching text or code behavior.

A recursive delete command has destructive side effects unrelated to identifying test filenames. It could remove all files that fail a pattern match, and glob expansion or quoting errors could widen the damage. The user requested only a list of existing paths, which a read-only filename-pattern tool can provide. Use Glob and preserve the repository untouched; never substitute a broad shell deletion for a simple discovery operation.

Grep searches file contents for matching text; it is not the most direct way to list filenames that match a suffix pattern when the user has not requested content inspection. Searching for a secret string also introduces an unrelated data-exposure concern and can omit files whose names match but contents do not. Use the filename-matching Glob capability with the intended path scope, then report the discovered paths without opening their contents. The tool choice should reflect the requested operation rather than an arbitrary available query.

Glob identifies paths based on filename patterns rather than arbitrary symbols contained inside a file. Matching only *.py may find Python sources but misses whether they mention the deprecated API and might overlook JavaScript, configuration or documentation references. The initial discovery needs a content search for the exact name across authorized repository files. Use Glob later if file-type scoping is necessary, and inspect candidate matches before any edit.

Running a blanket deletion command would mutate source files without knowing where the deprecated identifier appears. A discovery task does not authorize destructive cleanup, and deleting paths cannot reveal the code references that need migration. Use read-only content search and inspect hits before planning targeted changes. Tool choice should match the requested observation, not leap from a search question to an irreversible edit.

Writing a marker into every file would alter the repository merely to locate text that can be found by search. It creates unrelated diffs, may trigger builds or deployment hooks, and makes the original evidence harder to inspect. A content-aware Grep call can report matching files without changing them. Reserve editing tools for explicit, scoped modifications after the result locations have been reviewed.

Glob is suited to discovering file paths that match a pattern, particularly when the file name or location is unknown. Here the developer has supplied an exact path and needs the function body, not a list of candidate filenames. Running a broad search under src may return hundreds of irrelevant entries and still not show the definition or nearby imports. A targeted Read of src/auth/session.ts is the narrower way to inspect the actual source lines, subject to workspace permissions and a sensible output window.

Downloading an unrelated network resource cannot establish the contents of the known repository file and introduces unnecessary access to external data or a remote command source. The requirement is local inspection of a particular function. If Bash is used for a bounded read, it should be restricted to that path, but a dedicated Read tool already expresses the task more directly and avoids shell parsing risks. A network transfer provides neither the expected file content nor a reason to expand execution privileges.

Writing proposed function content over src/auth/session.ts would mutate the source before the developer has inspected the existing implementation, its callers or tests. The user requested a read, so introducing a write crosses the permission boundary and can destroy relevant evidence about the bug. A code-edit tool may later be appropriate after an authorized change plan, but the immediate inspection step should retrieve the current file and relevant lines without altering its bytes or claiming that a patch was requested.

Glob can enumerate filenames matching a pattern, but it does not change a known literal inside an existing configuration file. The developer already identified a precise target and expected old text, so another broad filename search is not the completed fix. Read the relevant file, apply a scoped Edit against the known span and confirm the result. This preserves unrelated settings and allows the patch to fail safely if the expected source text is no longer present.

Replacing an entire repository to alter one config literal is far beyond the requested mutation. It can overwrite valid changes, delete unrelated files and make review almost impossible. A small targeted Edit is appropriate because the old value and file are known, while a full Write is better suited to creating or wholly replacing a specific authorized file. Verify a minimal diff afterward to ensure the single intended setting changed.

Grep can locate a literal's occurrences but does not apply the requested configuration change. A search result alone leaves the old value in place, and simply reporting the match as completion would mislead the maintainer. Once the exact file and expected old text are identified, use the scoped Edit operation with a matching precondition and inspect the resulting diff. This minimizes unrelated changes and catches a stale or unexpectedly different configuration instead of blindly replacing entire files.

Glob can identify files with matching names, but it does not create a README that does not yet exist. A path search may confirm absence or find a similar existing document, which is useful preparation. The user specifically needs a new small file at an approved target path. Once the destination is verified, use the writing operation rather than treating a filename search as artifact creation.

Grep searches text in existing files; it cannot generate the requested new document. Looking for the intended README content elsewhere may reveal examples, but it does not satisfy the create operation. The workflow must choose a tool that writes a new file at a specific authorized location, with a suitable existence check to avoid overwriting another contributor's work. Search is not a substitute for a saved artifact.

Repeated reads of a path already known to be nonexistent merely produce the same not-found result. They cannot create data or discover content that has not been written. The host should verify the intended destination and use a scoped Write operation once, then read back the file if confirmation is needed. Looping on a terminal absence wastes budget and may conceal that the requested creation step never occurred.

Finding the word passed in source files, comments or old logs does not execute the current project's test suite. A repository can contain many historical success strings while its present code fails. The requested action requires running an approved test command in the correct working directory and recording its actual exit status. Grep can help locate the test runner configuration, but it cannot replace observed execution or justify a claim that new tests passed.

Read can reveal the commands and assertions that would run, but inspection cannot demonstrate execution or produce observed test results. The task explicitly requires running an existing local suite, so a bounded authorized Bash command is the relevant action. Source inspection can precede execution for safety; the pass/fail outcome must still come from the actual process and its exit status.

Editing the test runner's source file is a mutation, not a way of observing whether the existing test suite passes. The engineer asked to execute the configured tests in their present form; changing the command first could alter coverage or hide a failure. Select an approved bounded Bash command invoking the project's documented test runner, capture its real exit code and output, and report results tied to the current revision. Do not modify tests merely to create a green status.

A more narrowly matched Grep result is useful for locating a symbol, but the first matching line may be inside a comment, generated file or overloaded function. Editing it without inspecting nearby definitions risks modifying the wrong occurrence. After search, Read the enclosing code region and verify the relevant call path, file revision and user-approved scope. Word-boundary matching reduces false positives; it does not replace contextual analysis.

The first search hit is ordered by the search tool's traversal, not by its relevance to the requested behavior. It might be a test fixture or old documentation rather than the actual implementation. Editing it automatically could leave the real defect unchanged or introduce a regression. Use search to identify candidates, then inspect the intended file and surrounding code before issuing a scoped Edit tied to the correct revision.

Overwriting every matching file confuses discovery scope with mutation authorization. Hundreds of occurrences can include legitimate references, read-only generated assets and unrelated packages. A broad replacement may damage interfaces or remove necessary migration compatibility. First identify the specific intended change, read representative target regions, and edit only approved locations with validation. Source search results are evidence of occurrence, not permission to change all occurrences.

Glob selects files by path or filename pattern, not by a symbol found inside a file. It can identify TypeScript candidates, but an inventory of paths does not establish which lines call the unsafe helper. In this investigation the immediate missing evidence is the occurrence and its location. A Glob-only result would still require a separate content search to find and inspect actual callsites, so it is not the most direct first operation.

Read is appropriate when the path is already known and surrounding source context is needed. Here the locations are unknown, so reading all TypeScript files in full needlessly expands the model context and costs more tool work. It can also truncate relevant material or cause the investigator to overlook a late match. Content search first provides a bounded set of actual candidate paths and lines; Read can follow for a small number of matches requiring semantic inspection.

A global replacement changes repository content before the suspected occurrences are confirmed and classified. The same helper name may appear in tests, documentation, unrelated scopes, or quoted text, so an unreviewed replacement can silently break legitimate code. Bash may be useful for scripted operations in some workflows, but using it here to mutate all matches skips the requested evidence-gathering step. Search the contents and inspect actual callsites before choosing a precise change.

Editing an arbitrary unrelated line cannot produce a known full replacement of the requested artifact. It also risks modifying a file outside the approved scope while leaving the target unchanged. A line editor is appropriate for precise localized changes after confirming context, not for replacing a complete generated output whose intended bytes are already known. Verify the exact target and use an authorized whole-file write.

Grep can locate text and support inspection but it does not replace a file's contents. Stopping after the first matching line also says little about the destination's identity, content hash or whether the whole artifact must be rewritten. Use discovery and read operations to verify the path first, then perform the designated Write with the known content. Reporting success after search alone would be a false mutation claim.

Glob can suggest matching paths but a similar basename is not proof of the intended target. Blindly overwriting the first match might destroy a backup, template or neighboring customer's artifact. The user specified one known generated deliverable, so resolve the exact path and confirm authorization before writing. Broad discovery can help the maintainer identify candidates, but it cannot authorize the destructive choice on its own.