Skip to main content

Module 6 — Assessment

What you should have produced

By completing this module, you should have the following artifacts:

#ArtifactSource
1Metric contract set with 5-8 metrics, metric chains, and quality scorecardLesson 1 practice activity
220-case eval suite with four test case types, scoring rubrics, and release gateLesson 2 practice activity
3Operational monitoring design with traces, decision events, alerts, runbook, and triage matrixLesson 3 practice activity
450+ case quality suite with automated summary and quality scorecardApplication A
5Regression drill report with baseline, controlled change, detection, mitigation, and post-incident reviewApplication B

Assessment rubric

Each dimension is scored 0, 1, or 2. Total possible: 10 points. Passing threshold: 8/10.

Dimension 1: Metric relevance (0-2)

ScoreDescription
0Metrics are arbitrary or disconnected from business value. No metric chains exist. The metrics tracked don't tell you whether the system is actually serving its purpose.
1Some metrics are connected to business KPIs, but the chains are incomplete or some metrics lack clear thresholds. The metric set is either too small (fewer than 4) or too large (more than 12) to be practical. Both metric families (objective and semantic) are present but not balanced.
2All metrics trace from business KPIs through quality indicators to technical signals via complete metric chains. The set is appropriately sized (5-8 metrics) with a balanced mix of objective and semantic families. Each metric has a contract with green/yellow/red thresholds, a measurement method, and an owner. The pain-of-failure test has been applied to prioritize metrics. Potential alignment traps are identified.

Dimension 2: Eval suite quality (0-2)

ScoreDescription
0Fewer than 20 test cases. Cases are mostly happy path with no adversarial or uncertainty testing. Expected outputs are vague ("a good response"). No scoring rubrics. No release gate.
120-50 test cases with some variety, but distribution is unbalanced (e.g., 80% happy path). Scoring rubrics exist but lack calibration examples. Expected outputs are specific for some cases but vague for others. A release gate exists but has only 1-2 checks.
250+ test cases with intentional distribution across all four types (happy path, edge, adversarial, uncertainty). Expected outputs are specific and unambiguous for every case. Scoring rubrics include calibration examples at multiple score levels. Automated and human/LLM-as-judge evaluation methods are both represented. Release gate has mandatory and warning checks covering the most critical quality dimensions. The suite is documented well enough for someone else to run it.

Dimension 3: Monitoring effectiveness (0-2)

ScoreDescription
0No trace architecture. No alerts defined. No incident runbook. The monitoring design would not detect a quality degradation until users complain.
1Trace architecture exists but doesn't capture decision events or context snapshots. Some alerts are defined but lack sustained thresholds or have no owners. An incident runbook exists but is too generic (not specific to the system's failure modes). The triage process is mentioned but not formalized.
2Complete trace architecture with stage-level detail, decision events, and context snapshots for at least one end-to-end request. Alerts are designed at multiple levels (critical, high, medium, low) with sustained thresholds, contextual messages, owners, and runbook references. At least one detailed incident runbook covers immediate actions, diagnosis steps, mitigation options, and post-incident review. A triage matrix with priority levels and response times is defined.

Dimension 4: Decision readiness (0-2)

ScoreDescription
0The quality infrastructure produces data but doesn't support decisions. There's no clear process for what happens when a metric goes red. No release gate. No mitigation playbook.
1Release gates exist and would catch major regressions, but the mitigation process is unclear. The quality scorecard shows metrics but doesn't include trends or action items. Decision processes exist for some scenarios but not others. The regression drill was completed but the mitigation was superficial.
2The quality infrastructure directly supports operational decisions. Release gates are well-designed with mandatory and warning checks. The quality scorecard includes trends, status indicators, and specific action items. The regression drill demonstrates a complete cycle: detect, diagnose, mitigate, verify. The mitigation resolves regressions without introducing new ones. A reader can look at the scorecard and know exactly what action to take next.

Dimension 5: Learning loop maturity (0-2)

ScoreDescription
0No evidence that monitoring findings feed back into system improvement. The eval suite is static. Incidents are resolved but not analyzed for prevention. No post-incident review process.
1Some feedback exists — the regression drill identifies new test cases to add, or the monitoring design mentions updating alerts. But the loop is incomplete: findings are identified but not acted on, or actions are taken but not verified. Post-incident review exists but lacks concrete prevention measures.
2The learning loop is fully demonstrated. The regression drill produces specific improvements: new test cases added to the eval suite, alert thresholds refined, runbooks updated, and prevention measures identified. The post-incident review connects the incident to broader system improvements. It's clear that every incident makes the system stronger, not just fixed. The eval suite, alerts, and runbooks are treated as living documents that evolve with each finding.

Self-assessment checklist

Lessons

  • I can build a metric chain from business KPI to quality indicator to technical signal
  • I understand the difference between objective metrics (accuracy, latency, cost) and semantic metrics (coherence, policy adherence, usefulness, trust)
  • I can write a metric contract with thresholds, measurement methods, and ownership
  • I can identify alignment traps where improving one metric degrades another
  • I can design test cases across four types: happy path, edge, adversarial, and uncertainty
  • I can write scoring rubrics with calibration examples for subjective quality dimensions
  • I understand how LLM-as-judge evaluation works and when to use it vs. human review
  • I can design release gates with mandatory and warning checks
  • I can design stage-level traces with decision events and context snapshots
  • I can design alerts with sustained thresholds, contextual messages, and clear ownership
  • I can write an incident runbook with diagnosis steps and mitigation options
  • I understand the triage process for prioritizing multiple simultaneous issues

Application A — SSA quality suite

  • My suite has 50+ test cases with proper distribution across all four types
  • Expected outputs are specific and unambiguous for every test case
  • Scoring rubrics have calibration examples at multiple levels
  • Metric contracts trace from business KPIs to technical signals
  • The release gate has at least 3 mandatory checks and 2 warning checks
  • The automated summary template shows all key information at a glance
  • The quality scorecard shows metric status, trends, and action items

Application B — Regression drill

  • Baseline is established with all metrics documented
  • The controlled change is realistic and clearly described
  • I predicted the impact before measuring it
  • Regressions are detected with case-by-case root cause analysis
  • The mitigation strategy is appropriate and verified with a re-run
  • Post-incident review identifies concrete improvements to the eval suite, alerts, and runbooks
  • The learning loop is closed — the system is demonstrably stronger after the drill

What passing means

Scoring 8/10 or higher means you can:

  • Design quality metrics that connect directly to business outcomes, with clear thresholds and ownership
  • Build comprehensive evaluation suites that catch regressions before they reach users
  • Implement operational monitoring that makes system behavior visible and problems detectable
  • Execute a complete incident response cycle: detect, diagnose, mitigate, verify, and learn
  • Close the learning loop so that every incident makes the system stronger

If you don't pass

  • Low on metric relevance: trace each of your metrics back to a business KPI. If you can't explain why the business cares about a metric, remove it. If a stakeholder would ask about something your metrics don't cover, add it. The metric chain exercise in Lesson 1 is the key tool.

  • Low on eval suite quality: check your test case distribution. If more than 50% of your cases are happy path, add more edge and adversarial cases. If your expected outputs say "a good response," rewrite them with specific criteria. Add calibration examples to your rubrics — they're what make scoring consistent.

  • Low on monitoring effectiveness: go through the trace template from Lesson 3 and fill it in for one real request path. Identify 3-5 decision events where the system makes choices that could go wrong. For each one, define what a "wrong" decision would look like and what alert would detect it. Then write the runbook for that alert.

  • Low on decision readiness: ask yourself: "If the quality scorecard showed a red metric right now, what would I DO?" If the answer isn't clear and specific, your infrastructure is measuring but not supporting decisions. Add action items to the scorecard, define the mitigation options in your runbook, and make the release gate specific enough to be automated.

  • Low on learning loop maturity: review your regression drill report. For each finding, write: (1) what specific test case you would add to prevent this regression from recurring, (2) what alert threshold change would detect it faster, and (3) what runbook update would help resolve it more efficiently. These three actions close the loop.


Bridge to Module 7

You now have a system that is designed (Modules 1-4), instrumented with context (Module 5), and measured with quality infrastructure (Module 6). But one critical dimension remains: what happens when someone deliberately tries to break it? What happens when the stakes involve not just quality but safety, privacy, and ethics?

Module 7 — Security, Governance and Ethics addresses the adversarial reality of production AI systems. You'll learn to defend against attacks, implement governance frameworks that ensure accountability, and design ethical guardrails that prevent your system from causing harm — even when it's technically working as designed. If Module 6 proves the system works correctly, Module 7 proves it works responsibly.