Pass Your Anthropic CCA-F Exam Easy!

A stronger instruction can reduce accidental requests but is not an enforcement boundary. An agent can still attempt to modify a tracked generated artifact through Edit, Write, or shell commands despite the reminder. The observed failure is a write that should have been prevented, so the project needs host-side deny rules, filesystem restrictions, or CI checks against protected output paths. Prompt guidance can accompany those controls but cannot replace them.

Git ignore rules govern whether untracked files are offered for version control; they do not make existing tracked files read-only, and they do not prevent a process from changing bytes on disk. If the generated dist/app.js file is already tracked or writable, an agent can still modify it. Enforce the protected output boundary through file permissions, tool-policy restrictions, or CI verification, and regenerate artifacts only through an authorized build pipeline.

Post-build deletion may hide a modified generated artifact from the package, but it does not prevent the unauthorized edit to the working tree or the possibility that other tasks already consumed the changed file. It also risks deleting legitimate build output. The boundary should reject or detect writes to the protected generated directory before acceptance, with a clean rebuild and version-aware review where necessary. Removing a file after the fact is not equivalent to enforcing the no-edit path policy.

The length of an example does not determine whether a file rule applies. A perfectly detailed SQL migration policy cannot affect its target when the frontmatter glob selects only Markdown paths. The reviewer should compare the intended filename patterns and actual repository files, then test the rule against representative migration paths. Adding more prose to the examples would leave the mismatch unresolved. Scope is established by the effective matcher, not by the amount of explanatory text embedded in the rule.

The number of comments in a path rule may affect readability but does not explain why it selects Markdown instead of SQL migration files. Even a concise instruction can have the wrong file pattern. The test is to determine whether the configured path matcher includes the intended .sql or migration paths and excludes unrelated documentation. Repair the glob and verify its real matches. Comments are useful for documenting intent but do not change the file types to which the rule is applied.

Using Git as a version-control system has no inherent connection to which file glob a Claude Code path rule matches. Git may record the rule's revision but does not convert *.md into a pattern for migration scripts. The actual defect is in the rule's targeting logic: examples refer to SQL files while the matcher selects Markdown. Evaluate this against the repository's real directory layout and supported glob semantics rather than changing version-control tools, which would not fix the missing coverage.

Syntax highlighting is a presentation concern and does not determine which package a path glob matches. The pattern **/common/** can match multiple identically named directories in a monorepo, causing policy to apply to a wider set of files than the team intended. Inspect concrete path matches and narrow the rule to the specific package root. Changing editor colors would leave the overbroad scope unresolved.

A local filesystem glob is not automatically a network firewall rule. It selects paths to which project guidance applies, and using a broad **/common/** expression can inadvertently include two unrelated packages. A maintainer should verify pattern expansion against actual repository paths and specify package boundaries explicitly. Network rules operate at different layers and cannot be inferred solely from a directory matcher in a Claude Code instruction file.

Wildcard matching cannot guarantee the correct package when two packages share the name common. Both locations may satisfy the same glob, and the rule could impose a frontend policy on a backend package or vice versa. Test the actual matched paths and narrow the pattern to the intended directory hierarchy. A successful syntax parse does not prove that an instruction's scope is semantically correct.

Extension matching can locate Markdown files, but it cannot separate maintained project documentation from vendored files that share the same suffix. Applying changes broadly and reviewing afterward can modify external code or generated content unnecessarily. Define an explicit path include/exclude scope for the style rule and test representative paths before execution. The exclusion must operate at selection time, not only during review.

Marking every Markdown document as editable would include the vendored subtree whose contents the owner explicitly excluded. A tool could then reformat third-party docs, create noisy diffs or overwrite generated reference material. Match project-owned documentation paths while excluding vendor directories, and enforce write denial for protected paths rather than rely only on a prose warning. The result should be tested against examples inside and outside the allowed root so legitimate documentation remains editable.

Deleting vendored documentation would remove third-party material rather than exclude it from a project style rule. That can break references, license attribution or reproducibility, and does not teach the rule matcher which paths should be considered editable. Scope the rule to the intended first-party documentation paths and explicitly exclude the vendor directory using supported file patterns. Test representative included and excluded paths before allowing an automated formatter to modify content.

Directory depth can influence specificity but cannot alone resolve every policy conflict, especially a global prohibition against production SQL writes. The agent must inspect all applicable scoped instructions, identify the conflicting authorization rule and use the documented precedence or escalation path. Acting on an arbitrary depth heuristic may permit prohibited modifications or hide a genuine ambiguity in the configured policy.

Choosing the rule that permits deletion solely because it enables faster progress is unsafe when another applicable instruction forbids the change. The agent should resolve actual instruction scope and precedence, then seek clarification if the conflict affects a consequential write. Destructive permission cannot be inferred from convenience. Until authority is clear, keep the file unchanged and preserve the conflicting rule identifiers so the maintainer can correct the configuration.

One instruction says SQL files may be changed while another forbids them, so following both literally is impossible for the same requested mutation. Attempting the edit while simultaneously claiming compliance with a deny rule would hide an authorization conflict. Inspect effective rule precedence and scope, retain any higher-priority restriction and ask for clarification if the configuration remains ambiguous. An agent must not interpret contradictory rules as automatic permission to perform the risky operation.

A user's personal configuration is not universally higher priority than reviewed repository rules, and it may not even be present on teammates' machines. Placing a shared fixture policy only in one person's home directory leaves collaborators unaware of it. Store the approved rule in the project at the right scope and verify it loads for supported contributors. Preserve user-level files for individual preferences instead of treating them as a substitute for distributed project instructions.

Test filenames cannot recreate an absent project security instruction. A file named fixture.py may still contain sensitive production-like data, and a collaborator's Claude Code session cannot infer the original team's complete allowlist from names alone. Publish the policy through the supported shared project guidance and test representative matches. Inferred conventions do not replace an explicit, version-controlled contract that all contributors receive.

Separate developers ordinarily have their own home directories and may use independent machines or CI runners. A path rule stored only in one person's user-scoped configuration will not automatically be available to teammates working from the shared repository. The team should place common nonsecret rules in an appropriate project-controlled location and verify they load in a clean environment. Assuming a universal shared home directory confuses personal preferences with distributable project instructions.

Disabling shell safety checks because source files moved would remove protection just when the old path rule has become stale. A security guard should follow the actual supported directory structure, not vanish when a repository is reorganized. Update the matcher to cover tools/scripts while preserving exclusions for unrelated locations and verify the resulting path set. Deactivating enforcement avoids a configuration repair at the cost of leaving script execution less controlled.

A rule tied to the old scripts directory may no longer match the files it was intended to protect. Keeping it unchanged could create an invisible coverage gap where moved shell scripts execute without the desired safeguard. Inspect the repository's new paths, adjust the glob with minimal scope and run checks that show both allowed and prohibited samples. Configuration history is useful but does not justify leaving an ineffective current matcher in place.

Expanding a shell-safety rule to every file in the repository may cover the newly moved scripts, but it also applies restrictions to unrelated source and documentation files. That can create false positives and obscure the intent of the policy. Update the path matcher to include the actual tools/scripts subtree and test both positive and negative fixtures. Targeted location maintenance is more reliable than turning a scoped security rule into a blanket constraint whose applicability nobody can explain.

A JSON file matcher would not cover the .yml deployment configuration or repair the original .yaml pattern. File-extension matching is a property of the path glob; choosing an unrelated type bypasses the actual protected artifact. Keep the rule focused on the intended deployment subtree and include the extensions the project really uses. Check matches in the existing repository rather than assuming that a file's content or the model's interpretation can override a mismatched filename filter.

Renaming a live deployment file just to match a rule can break build scripts, deployment references, overlays and external tooling that expect its existing name. It is an unnecessary code/configuration mutation when the requirement is to apply an existing security rule to .yml. Correct the rule matcher and verify the original file remains covered in its actual location. Any genuine filename migration would need an independent change plan and tests, not be used as a shortcut around rule targeting.

Model inference from the contents of a .yml file does not make a path-matched rule that selects .yaml apply. Path-scoped instructions are loaded according to concrete matching behavior, which should be checked against the real filesystem. Assuming Claude will intuit the intended scope is unreliable, particularly for security constraints that prohibit editing deployment artifacts. Explicitly include the supported extensions and deployment subtree, then test coverage and complement critical rules with host-enforced write protections where needed.

Silently converting a path-scoped rule into a global one changes its authority and can affect unrelated files that were intentionally outside its scope. A zero-match result may be correct for a future directory or may expose an erroneous glob. QA should show the exact matcher and paths tested, distinguish intentional absence from a broken rule, and request a deliberate scope decision. Hiding a global fallback would make the rule harder to audit and could overconstrain ordinary work.

A rule file that parses cleanly proves only that its syntax is acceptable, not that the glob matches any current path or that Claude Code will apply the guidance in the intended context. Zero matches may be intentional for a future directory, but it may also reveal a misspelled prefix or unsupported pattern. Test representative paths and record whether the absence is expected. Marking the rule fully tested without checking applicability would hide a configuration bug.

Creating a fake source file solely to make a rule's matcher return one result changes repository contents without proving the rule covers any real production target. It can hide a typo or an outdated directory assumption behind an artificial success. Report that no current file matches, examine intended paths and decide whether zero matches are expected for a future folder. Test the rule against genuine representative paths or fixtures outside the authoritative tree.

Running every possible test suite blindly is expensive and can still miss the tests actually relevant to a changed frontend or backend path. Broad execution does not establish which directory-specific rules were applied to each edit. Map changed paths to their applicable guidance and test runners, run the required suites for both affected components and retain results by revision. Quality coverage should follow actual scope rather than tool volume.

A frontend test suite may pass while backend-specific type checks, database migrations or service tests fail. The task modifies two directories with distinct rules, so validation must respect each affected scope. Identify changed paths, apply their relevant commands and reconcile common project-level checks before claiming completion. A single green suite does not establish that the other subsystem was evaluated.

Using the instructions from only the first edited file assumes they govern every path in the diff. A frontend rule may prescribe a Node test runner, while backend changes may require migration checks or a different compiler. This can leave a second module untested even when the initial suite passes. Evaluate the effective instruction scope for each changed file, then reconcile shared constraints and run all relevant component checks. File ordering in a patch is not a rule-precedence mechanism.

Assuming dozens of dependent services share the same authentication version ignores differences in token format, refresh behavior and session lifetime. A change could disconnect one client population while appearing successful in a small test service. The migration should inventory callers and current contracts before implementation, so breakage can be evaluated and a staged transition designed. Skipping discovery turns a broad high-impact change into an uncontrolled experiment on users.

Changing production credentials first would make the users and services participating in the authentication migration an uncontrolled test environment. Sessions may fail abruptly, automated integrations may lose access and recovery could be difficult without a rollback plan. The team needs design and approval before any live mutation, including a caller inventory, compatibility tests and a clearly authorized release window. A destructive discovery technique is not a defensible preparation step.

Deleting session logs would remove the evidence needed to diagnose which users were logged out, which authentication flows failed and whether the rollout can be safely reversed. Secrets and personal data in logs may require redaction and restricted retention, but that is not equivalent to destroying operational history before a high-risk migration. Preserve suitable diagnostic traces and plan their handling under the organization's retention policy. A useful migration plan depends on observing outcomes, not making failures less visible.