FEFreeExamDumps.in

CCA-F Practice Questions — Page 4

Question 31

Open question ↗

Scenario: Code Generation with Claude Code

You asked Claude Code to implement a function that transforms API responses into an internal normalized format. After two iterations, the output structure still doesn’t match expectations—some fields are nested differently and timestamps are formatted incorrectly. You described requirements in prose, but Claude interprets them differently each time.

Which approach is most effective for the next iteration?

  • A.Write a JSON schema describing the expected output structure and validate Claude’s output against it after each iteration.
  • B.Provide 2–3 concrete input-output examples showing the expected transformation for representative API responses.
  • C.Rewrite requirements with more technical precision, specifying exact field mappings, nesting rules, and timestamp format strings.
  • D.Ask Claude to explain its current understanding of the requirements to identify where interpretations diverge.

Question 32

Open question ↗

Scenario: Code Generation with Claude Code

You need to add Slack as a new notification channel. The existing codebase has clear, established patterns for email, SMS, and push channels. However, Slack’s API offers fundamentally different integration approaches—incoming webhooks (simple, one-way), bot tokens (support delivery confirmation and programmatic control), or Slack Apps (two-way events, requires workspace approval). Your task says “add Slack support” without specifying integration method or requiring advanced features like delivery tracking.

How should you approach this task?

  • A.Start in direct execution mode using incoming webhooks to match the existing one-way notification pattern.
  • B.Switch to planning mode to explore integration options and architectural implications, then present a recommendation before implementation.
  • C.Start in direct execution mode by scaffolding a Slack channel class using existing patterns, deferring the integration method decision.
  • D.Start in direct execution mode using a bot-token approach to ensure delivery confirmation is possible.

Question 33

Open question ↗

Scenario: Code Generation with Claude Code

Your CLAUDE.md file has grown to 400+ lines containing coding standards, testing conventions, a detailed PR review checklist, deployment instructions, and database migration procedures. You want Claude to always follow coding standards and testing conventions, but apply PR review, deploy, and migration guidance only when doing those tasks.

Which restructuring approach is most effective?

  • A.Move all guidance into separate Skills files organized by workflow type, leaving only a brief project description in CLAUDE.md.
  • B.Keep everything in CLAUDE.md but use `@import` syntax to organize into separately maintained files by category.
  • C.Split CLAUDE.md into files under `.claude/rules/` with path-bound glob patterns so each rule loads only for the relevant file types.
  • D.Keep universal standards in CLAUDE.md and create Skills for workflow-specific guidance (PR review, deploy, migrations) with trigger keywords.

Question 34

Open question ↗

Scenario: Code Generation with Claude Code

You’re tasked with restructuring your team’s monolithic application into microservices. This impacts changes across dozens of files and requires decisions about service boundaries and module dependencies.

Which approach should you choose?

  • A.Switch to planning mode to explore the codebase, understand dependencies, and design the implementation approach before making changes.
  • B.Start in direct execution mode and switch to planning only after encountering unexpected complexity during implementation.
  • C.Start in direct execution mode and make incremental changes, letting implementation reveal natural service boundaries.
  • D.Use direct execution with detailed upfront instructions that specify each service structure.

Question 35

Open question ↗

Scenario: Code Generation with Claude Code

Your team created a `/analyze-codebase` skill that performs deep code analysis—dependency scanning, test coverage counts, and code quality metrics. After running the command, team members report Claude becomes less responsive in the session and loses the context of the original task.

How do you most effectively fix this while keeping full analysis capabilities?

  • A.Add `context: fork` in the skill frontmatter to run the analysis in an isolated subagent context.
  • B.Add `model: haiku` in frontmatter to use a faster, cheaper model for analysis.
  • C.Split the skill into three smaller skills, each producing less output.
  • D.Add instructions to the skill to compress all results into a short summary before displaying them.

Question 36

Open question ↗

Scenario: Code Generation with Claude Code

Your team uses a `/commit` skill in `.claude/skills/commit/SKILL.md`. A developer wants to customize it for their personal workflow (different commit message format, extra checks) without affecting teammates.

What do you recommend?

  • A.Create a personal version under `~/.claude/skills/` with a different name, e.g., `/my-commit`.
  • B.Add conditional logic based on username in the project skill frontmatter.
  • C.Create a personal version at `~/.claude/skills/commit/SKILL.md` with the same name.
  • D.Set `override: true` in the personal skill frontmatter to prioritize it over the project version.

Question 37

Open question ↗

Scenario: Code Generation with Claude Code

Your team has used Claude Code for months. Recently, three developers report Claude follows the guidance “always include comprehensive error handling,” but a fourth developer who just joined says Claude does not follow it. All four work in the same repo and have up-to-date code.

What is the most likely cause and fix?

  • A.The guidance lives in the original developers’ user-level `~/.claude/CLAUDE.md` files, not in the project `.claude/CLAUDE.md`. Move the instruction to the project-level file so all team members receive it.
  • B.The new developer’s `~/.claude/CLAUDE.md` contains conflicting instructions overriding project settings; they should delete the conflicting section.
  • C.Claude Code learns per-user preferences over time; the new developer must repeat the requirement until Claude “remembers” it.
  • D.Claude Code caches CLAUDE.md after first read; original developers use cached versions. Everyone should clear the Claude Code cache.

Question 38

Open question ↗

Scenario: Code Generation with Claude Code

You find that including 2–3 full endpoint implementation examples as context significantly improves consistency when generating new API endpoints. However, this context is useful only when creating new endpoints—not when debugging, reviewing code, or other work in the API directory.

Which configuration approach is most effective?

  • A.Add endpoint examples and pattern documentation to the project CLAUDE.md so they are always available.
  • B.Manually reference endpoint examples in every generation request by copying code into the prompt.
  • C.Configure path-specific rules in `.claude/rules/api/` that include endpoint examples and activate when working in the API directory.
  • D.Create a skill that references the endpoint examples and contains pattern-following instructions, invoked on demand via a slash command.

Question 39

Open question ↗

Scenario: Code Generation with Claude Code

Your team created a `/migration` skill that generates database migration files. It takes the migration name via `$ARGUMENTS`. In production you observe three issues: (1) developers often run the skill without arguments, causing poorly named files, (2) the skill sometimes uses database schema details from unrelated prior conversations, and (3) a developer accidentally ran destructive test cleanup when the skill had broad tool access.

Which configuration approach fixes all three problems?

  • A.Use positional parameters `$1` and `$2` instead of `$ARGUMENTS` to enforce specific inputs, include explicit schema file references via `@` syntax for context control, and add a frontmatter description warning about destructive operations.
  • B.Add `argument-hint` in frontmatter to request required parameters, use `context: fork` to isolate execution, and restrict `allowed-tools` to file-write operations.
  • C.Split into `/migration-create` and `/migration-apply` skills, add validation instructions to request migration name if missing, and use different `allowed-tools` scopes for each.
  • D.Add validation instructions in the skill SKILL.md to ensure `$ARGUMENTS` is a valid name, add prompts to ignore prior conversation context, and list prohibited operations to avoid.

Question 40

Open question ↗

Scenario: Code Generation with Claude Code

Your codebase contains areas with different coding conventions: React components use functional style with hooks, API handlers use async/await with specific error handling, and database models follow the repository pattern. Test files are distributed across the codebase next to the code under test (e.g., `Button.test.tsx` next to `Button.tsx`), and you want all tests to follow the same conventions regardless of location.

What is the most supported way to ensure Claude automatically applies the correct conventions when generating code?

  • A.Put all conventions in the root CLAUDE.md under headings for each area and rely on Claude to infer which section applies.
  • B.Create skills in `.claude/skills/` for each code type, embedding conventions in each SKILL.md.
  • C.Place a separate CLAUDE.md file in each subdirectory containing conventions for that area.
  • D.Create rule files under `.claude/rules/` with YAML frontmatter specifying glob patterns to conditionally apply conventions based on file paths.