CCAR-P domain - 7% of the exam

Developer Productivity & Operational Enablement

Developer Productivity & Operational Enablement is 7% of the CCAR-P exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

23
Practice questions
3
Objectives
7
Easy
16
Medium

Where people go wrong

  • Putting configuration at the wrong layer

    The wrong answers place settings where they do not reach the sessions that need them. Personal allow lists follow the engineer, so they give 12 different policies, and user-level settings return the main-branch test command on a release branch. Neither reaches build agents. Committed project configuration travels with the repository and its branches and can be reviewed. A centrally managed policy is the layer for a rule that no repository or engineer may loosen.

    See it in a sample question
  • Reading line coverage as evidence that tests catch defects

    The wrong answers treat rising line coverage as proof the tests work and push for more of it, such as a 95 per cent gate. Coverage records which lines ran, not whether the assertions are right: a suite at 86 per cent caught 14 of 50 seeded faults. Tests generated from the source file alone take their expected values from the code, so they confirm its current behaviour, defects included. The correct answers supply an independent source of truth, the pricing rules or the marking-scheme specification, and gate on seeded faults caught.

    See it in a sample question
  • Blaming the model for a value its input already carried

    The wrong answers place the fault in the model: one that remembers other sessions, one that invented details, one that misread a valid record, or one the provider changed. The evidence says otherwise. The other applicant's record was already in the prompt, the tool result already read available: null, and the pinned model still scores 94 per cent on the fixed June eval. The fault sits upstream, in a response cache keyed too coarsely, an adapter that drops the quantity, or a new collector that changed the live payloads.

    See it in a sample question

Objectives in this domain

What to study

The official documents this domain's practice questions cite most.

Sample questions from this domain

Free sampleDeveloper Productivity & Operational Enablementmedium

A state revenue agency is rolling Claude Code out to 140 engineers who work across 40 repositories. Its information security branch requires that Claude Code's built-in web search and web fetch tools be unavailable in every session on agency machines, that neither a repository's maintainers nor an individual engineer can remove that restriction, and that it be in force on the first day of rollout without a change to each of the 40 repositories. What should the architect recommend?

  • ACommit a deny rule for web tools to each repository's shared project settings and require code review on any change to it
  • BAdd an instruction to every repository's CLAUDE.md telling Claude Code that use of the web search and fetch tools is prohibited
  • CAllow the web tools, log every fetched address to a central store, and have the security branch review that log each week
  • DDeploy a centrally managed policy to agency machines that denies the web tools and takes precedence over project and user settings Correct
When a tooling restriction must hold across every repository and resist removal by maintainers or engineers, enforce it through centrally managed policy rather than per-repository settings. Claude Code merges settings from several layers, and a centrally managed policy deployed by administrators takes precedence over both the project settings committed to a repository and each engineer's personal settings. That makes it the only layer here that repository maintainers and individual engineers cannot override, and because it is installed on machines it covers all 40 repositories at once with no repository changes. Project settings remain the right place for team policy that a repository's own maintainers are trusted to own.

Why A is wrong: This is tempting because committed project settings are shared and reviewable, which is the right home for most team policy. It fails two stated constraints: it needs a change in all 40 repositories before rollout, and a repository's maintainers can approve a later commit that removes the rule.

Why B is wrong: Shared project instructions do reach every session, which makes this look like a team-wide control. An instruction is guidance to the model rather than an enforced permission, so it is a weak sole control for a security requirement, and it still needs edits to all 40 repositories that maintainers could later revert.

Why C is wrong: Central logging gives the security branch visibility, which feels like governance. It is a compensating control after the fact: the requirement is that the tools be unavailable, and a weekly review only detects use that has already happened.

Why D is correct: An administrator-managed policy sits above project and user settings in Claude Code's precedence order, so no repository commit or personal setting can loosen it. Because it is deployed to machines rather than to repositories, it applies to all 40 repositories from day one without touching any of them.

Free sampleDeveloper Productivity & Operational Enablementeasy

A university's learning platform team adopted Claude Code to generate unit tests for its assignment-grading service. Engineers prompt it with the source file alone; the marking-scheme specification, which defines the rounding and late-penalty rules, is not supplied. Over one term, line coverage measured on the grading module's own lines rose from 58 percent to 91 percent, CI records no retried or skipped tests, yet escaped grading defects held at about six per month, and every one sat on lines the new tests execute and assert against. What is the most likely cause?

  • ALine coverage counts the generated test files as covered code, so the real coverage of the grading module has not risen.
  • BThe model tier generating the tests is too small for grading arithmetic, so a larger tier would write tests that catch the defects.
  • CThe generated tests are flaky, so CI retries them until they pass and genuine assertion failures on grading logic are hidden.
  • DThe tests derive their expected values from the code under test, so they confirm its current behaviour, including its defects. Correct
Generated tests built from the implementation alone encode its current behaviour, so coverage rises without catching defects unless the specification supplies the expected results. A test only finds a defect when its expected value comes from somewhere other than the code under test. When the generator sees the implementation but not the marking-scheme rules, it reads the current outputs and asserts them, so a wrong rounding rule becomes the expected answer. Coverage measures which lines execute, not whether the assertions are right, so it can climb to 91 percent while defects on those same lines continue to escape. The fix is to supply the specification or human-written cases as the source of truth and have a reviewer check the expected values.

Why A is wrong: Inflated coverage from counting test files is a real measurement trap and would explain flat defect rates. It is wrong here because the stem says coverage was measured on the grading module's own lines, and every escaped defect sat on lines the tests already execute.

Why B is wrong: Reaching for a more capable model is tempting when output quality disappoints. It is wrong because the missing ingredient is the specification: any tier given only the implementation has no independent source for the correct expected values.

Why C is wrong: Retry-masked flaky tests do let real failures slip through and are worth ruling out. The stem rules this out directly: CI records no retried or skipped tests, so the tests are passing on their own assertions.

Why D is correct: With only the source file as input and no marking-scheme specification, the generator can only infer what the code should return from what it does return. The assertions therefore lock in the existing rounding and penalty behaviour, bugs included, which is why coverage rose while defects on covered lines kept escaping.

Free sampleDeveloper Productivity & Operational Enablementmedium

A software company's on-call team uses a Claude assistant to classify incoming alerts by probable cause and route them to the owning team. On the weekly offline eval, built from 400 alert payloads captured in June, accuracy has held at 94 percent for two months. Three weeks ago the observability team moved log shipping to a new collector, and since then on-call engineers have overruled the assistant's routing on 28 percent of live alerts, up from 9 percent. The model version and prompt are unchanged. What should the team investigate first?

  • AWhether the model provider has altered the model's behaviour, since the overrule rate rose with no change to the prompt
  • BWhether the eval set is too small to detect the drop, by enlarging it to 4,000 June payloads before other work
  • CWhether live alert payloads from the new collector differ from the June samples, by diffing the inputs the model receives Correct
  • DWhether a larger model tier would restore agreement, by rerunning last week's overruled alerts on a more capable model
When an offline eval stays flat but live quality drops after an upstream change, compare live inputs with eval inputs before touching the model. The two measurements differ in one way: the eval replays inputs captured before the collector migration, while live traffic passes through the new collector. Because the same model and prompt still score 94 percent on the old inputs, the model and prompt are effectively ruled out, and the drop must come from a difference in what the assistant now receives. Diffing a sample of live payloads against the June set identifies that difference directly. The fix may then be in the collector configuration, in a normalisation step before the prompt, or in refreshing the eval set so it represents current production traffic.

Why A is wrong: When quality drops with the prompt untouched, suspecting the model is an instinctive move. It is wrong because the same pinned model still scores 94 percent on the fixed June eval, which rules out a change in model behaviour and leaves the live inputs as the variable that moved.

Why B is wrong: A larger eval set is a sound habit, and 400 items can hide small regressions, so this sounds rigorous. It is wrong because ten times more June payloads still predate the collector change and would keep scoring well; the gap is between the eval distribution and live traffic, not sample size.

Why C is correct: The eval on frozen June inputs is stable while live agreement fell after the collector moved, which isolates the change to what the model is being sent. Comparing live payloads with the eval samples will show, for example, split multiline stack traces, renamed fields or dropped service tags, and it confirms the cause before any fix.

Why D is wrong: A more capable model sometimes copes better with messy input, so this can look like a quick win. It is wrong because it changes the model without identifying what changed in the inputs, so even a partial recovery would leave the cause unknown and the next format change free to repeat it.

Other domains in this exam

See also the CCAR-P cert hub, the study guide, and the cheat sheet.

Examworthy is not affiliated with or endorsed by Anthropic. Original, blueprint-aligned practice material only.