0Pricing
Claude Architect · 강의

시나리오 문제 채점 방식

100~1000점으로 환산하며, 720점이면 합격하고 추측 오답 감점은 없습니다

시나리오 문제 채점 방식은(는) CoddyKit의 무료 Claude Architect 강의입니다. 이것은 4개 중 1번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Claude Architect 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Claude Architect 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

What "Scoring" Really Measures

Every question on the Claude Certified Architect exam is a scenario-based multiple-choice item: 4 options, exactly 1 correct. Scoring is the process that turns your pattern of right and wrong answers into a single number the certification body can pass or fail you on.

This lesson is about that machinery: how raw answers become a scaled score, what the 720 threshold means, and why the no-guessing-penalty rule changes how you should behave on every single item.

Raw Score vs. Scaled Score

Your raw score is simply how many items you answered correctly. The exam does not report that number to you. Instead it converts your raw performance onto a fixed scaled range of 100 to 1000.

Scaling exists so that different exam forms — which may draw different scenarios of slightly different difficulty — remain comparable. A 720 on an easier form and a 720 on a harder form represent the same demonstrated competence. You never compute the scale yourself; you just need to clear the line.

# Conceptual model: raw correctness -> fixed scaled band
SCALE_MIN, SCALE_MAX = 100, 1000
PASS = 720

# Two forms, different raw difficulty, same scaled bar
for form, scaled in [("easy form", 725), ("hard form", 718)]:
    print(form, "->", "PASS" if scaled >= PASS else "FAIL")

The 720 Pass Line

The pass mark is 720 on the 100-1000 scale — not 72%. Because the score is scaled rather than a raw percentage, you cannot reliably translate "720" into "answered N of M correctly."

The practical consequence: aim for a comfortable margin above 720. Treating 720 as your target leaves you one or two unlucky items away from failing. Architects who pass consistently are operating well clear of the line, not flirting with it.

PASS = 720

def result(scaled_score: int) -> str:
    margin = scaled_score - PASS
    status = "PASS" if margin >= 0 else "FAIL"
    return f"{status} (margin {margin:+d})"

print(result(745))  # comfortable
print(result(721))  # razor-thin
print(result(715))  # just under

Each Item Is Scored Independently

Items are scored independently: each question contributes on its own. There is no partial credit within a 4-option item — you either selected the single correct option or you didn't.

Crucially, 4 of the 8 scenarios are shown on any given sitting, and every question on those four scenarios is scored. None of them is a throwaway. There is no "only the hardest count" rule and no dropped-lowest-item mechanic to rely on.

No Penalty for Guessing

This is the single most important scoring rule for your behavior: a wrong answer and a blank both score zero. Wrong answers are not subtracted from your raw score.

That makes leaving an item blank strictly inferior to answering it. A blank guarantees zero points; any answer — even an uninformed one — has a non-zero chance of being correct. The rule is simple and absolute: answer every question.

# Why a blank is never optimal under no-penalty scoring
blank_ev = 0.0                 # blank: guaranteed zero
blind_guess_ev = 1 / 4         # 4 options, 1 correct
print("Blank EV:", blank_ev)
print("Blind guess EV:", blind_guess_ev)
print("Always answer:", blind_guess_ev > blank_ev)

Elimination Multiplies Your Odds

Because there's no penalty, every option you can confidently rule out raises the expected value of guessing. A blind guess on four options is worth 1/4; eliminate one and it's 1/3; eliminate two and you're at 1/2.

On this exam the easiest options to eliminate are the anti-patterns — parsing model text for words like "done" to end a loop, using iteration caps as the primary stop mechanism, enforcing critical business rules with prompts instead of hooks, or requiring schema fields that may be absent. Spot one and you've usually found a wrong answer.

# Expected value rises as you eliminate distractors
def guess_ev(remaining_options: int) -> float:
    return 1 / remaining_options

for remaining in (4, 3, 2):
    print(f"{remaining} options left -> EV {guess_ev(remaining):.2f}")

Scoring Reaches Across All 5 Domains

The scored items span the five weighted domains, and the weights describe how the exam is composed:

  • D1 Agent Architecture & Orchestration — 27%
  • D2 Tool Design & MCP — 18%
  • D3 Claude Code Config & Workflows — 20%
  • D4 Prompt Engineering & Structured Output — 20%
  • D5 Context Management & Reliability — 15%

D1 carries the heaviest weight, so points there move your scaled score the most. But a weak domain you skip is points permanently lost — there's no domain you can safely ignore.

DOMAIN_WEIGHTS = {
    "D1 Agent Architecture & Orchestration": 27,
    "D2 Tool Design & MCP": 18,
    "D3 Claude Code Config & Workflows": 20,
    "D4 Prompt Engineering & Structured Output": 20,
    "D5 Context Management & Reliability": 15,
}
assert sum(DOMAIN_WEIGHTS.values()) == 100
print("Heaviest:", max(DOMAIN_WEIGHTS, key=DOMAIN_WEIGHTS.get))

Only the Single Best Option Scores

Many scenario items have more than one technically valid-looking option. Scoring credits only the single best answer for the stated context — the one that reflects sound Claude architecture for that exact situation.

That's why surface plausibility isn't enough. "It could work" loses to "it's the correct production practice here." The exam is testing the applied judgment of an architect with 6+ months of production Claude experience, not your ability to recognize a defensible-sounding option.

How a Scenario Question Tests You

A scored item drops you into a real situation and asks what to do next. The correct option maps to a fact-sheet principle; the distractors map to anti-patterns. Example shape: an agentic loop returns stop_reason == "tool_use" — what's the right control flow?

The credited answer terminates on stop_reason, runs tools, appends results to the full history, and repeats until end_turn. Distractors would parse the assistant's text for "done" or hard-stop on an iteration cap. Recognizing the principle behind the scenario is what earns the point.

# The credited control flow on a scored loop item
while True:
    resp = client.messages.create(
        model=MODEL, max_tokens=1024, messages=history, tools=tools
    )
    if resp.stop_reason == "tool_use":
        history.append({"role": "assistant", "content": resp.content})
        history.append(run_tools(resp))   # append results, continue
        continue
    break  # end_turn / max_tokens / stop_sequence -> stop on stop_reason

Pacing Protects Your Score

Since blanks score zero and every item is independent, a slow pace is a scoring risk: time spent agonizing over one item is time stolen from items you could answer correctly. Don't let a single hard scenario starve the rest of the exam.

A disciplined loop: read the scenario, eliminate the anti-patterns, commit to the strongest remaining option, and flag-and-move if you're stuck. You can revisit flagged items, but you must never run out of time with answers left blank — that's points you forfeited for free.

# A simple per-item triage you can run in your head
def triage(seconds_spent, eliminated):
    if eliminated >= 3:
        return "answer now (1 option left)"
    if seconds_spent > 90:
        return "commit best guess, flag, move on"
    return "keep eliminating anti-patterns"

print(triage(120, 1))  # commit best guess, flag, move on

Turning the Scoring Rules Into a Plan

The scoring model rewards a specific strategy:

  • Answer 100% of items — no penalty means a blank is pure forfeited expected value.
  • Eliminate anti-patterns first to push each guess from 1/4 toward 1/2.
  • Pick the single best option for the context, not merely a workable one.
  • Spread prep across all 5 domains, weighting D1 (27%) most, since you can't choose which 4 of 8 scenarios appear.
  • Build margin above 720 — treat 720 as the floor, not the goal.

Quick Check: Scoring Mechanics

Apply what you've learned about how scenario questions are scored.

Recap: How Scoring Works

Key takeaways on how scenario questions are scored:

  • Scaled, not raw: performance is mapped onto a fixed 100-1000 scale so forms stay comparable.
  • Pass = 720 on that scale (not 72%) — aim for margin above it.
  • Independent items: 4 of 8 scenarios shown, every question scored, no partial credit, single best option only.
  • No guessing penalty: blanks and wrong answers both score zero, so answer everything.
  • Eliminate anti-patterns to raise each guess from 1/4 toward 1/2.
  • Cover all 5 domains (D1 27%, D2 18%, D3 20%, D4 20%, D5 15%) and pace yourself so nothing is left blank.

자주 묻는 질문

“시나리오 문제 채점 방식” 강의는 무료인가요?

네 — “시나리오 문제 채점 방식” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Claude Architect 강의 전체를 잠금 해제할 수 있습니다. Claude Architect 강의에는 총 4개의 강의가 포함되어 있습니다.

“시나리오 문제 채점 방식”에서 뭘 배우나요?

100~1000점으로 환산하며, 720점이면 합격하고 추측 오답 감점은 없습니다 브라우저에서 직접 실행하는 실습 코드로 Claude Architect을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

Claude Architect을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 Claude Architect은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 1번째 강의입니다.

“시나리오 문제 채점 방식” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 Claude Architect 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 Claude Architect 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

  1. 시나리오 문제 채점 방식
  2. 시나리오 프롬프트 읽기
  3. 오답 제거하기
  4. 모의시험 전체 풀이
← Claude Architect(으)로 돌아가기