Appearance
Lesson 04 · Guardrails — When Not to Trust AI
Beyond the 1Z0-830 exam
The final lesson — and the course's closing argument. AI assistance is powerful precisely because you put guardrails around it: independent verification, your own tests, determinism, and human review. This is where everything you've learned converges into responsible practice.
Objectives
After this lesson you will be able to:
- Name the guardrails that make AI assistance safe.
- Identify where AI should not be trusted unaided.
- Avoid the co-generation blind spot (AI writes code and its tests).
- Keep AI-assisted changes deterministic, covered, and reviewed.
The guardrails
| Guardrail | What it enforces |
|---|---|
| Human review | a person who understands the code reads every line (Lesson 02) |
| Independent oracle | tests whose expected values come from the spec, not the code (Lesson 03) |
| Edge-case coverage | empty/null/boundary/overflow/concurrency, not just the happy path |
| Determinism | inject Clock, fix seeds/locale — repeatable runs (Module 14) |
| CI gates | the change must pass the full suite before merge (Module 20) |
| Small diffs | reviewable units, not sweeping generations (Lesson 01) |
| Provenance/security | no secrets, no vulnerable deps, no unvetted licenses (Module 19) |
None is new — they're the disciplines from the whole course, now pointed at machine-written code.
When not to trust AI unaided
Raise the bar (or write it yourself) for:
- Security-critical code — auth, crypto, input handling, access control.
- Concurrency — races pass tests by luck; reason about them yourself (Module 07).
- Money & correctness-critical math — rounding,
BigDecimal, overflow (Module 01). - Anything you can't review — if you don't understand it, you can't ship it responsibly.
- Novel algorithms where a subtle bug is costly — the lab's overflow is a one-character mistake.
The co-generation blind spot
The single most important guardrail for testing: don't let the model write both the implementation and its only tests, unreviewed.
mermaid
flowchart LR
A[AI writes buggy code] --> B[Same AI writes tests that assume the same bug]
B --> C[Tests pass]
C --> D[Bug ships]The fix is an independent oracle — a human, a spec, a reference implementation, or an invariant. The lab embodies the safe pattern: the buggy code exists, but the test was written to the spec and fails it, so the bug can't pass.
Verification beats trust
The throughline of the whole module — and course — is that verification, not trust, is what makes AI useful. AI lets you write more code faster; the earlier modules are what let you verify that code is correct. Speed without verification just ships bugs faster. The developer who knows Java, knows testing, and knows design is the one who can safely go fast with AI — because they can tell when it's wrong.
The closing trap — automation bias
The deepest risk is psychological: automation bias — the tendency to trust a confident machine over your own judgment. A fluent, well-formatted answer feels authoritative. Resist it. Your review, your oracle, your tests are the authority; the AI's output is a proposal awaiting verification.
SDET note
This is the project's thesis in one line: learn Java and testing deeply so you can use AI to go fast and be right. Everything from Module 00's bytecode to Module 20's pipelines is the judgment that turns a fast, fallible assistant into a genuine force multiplier. Use AI — and verify it.
Key Takeaways
- The guardrails are the course's own disciplines aimed at AI output: human review, independent oracles, edge-case coverage, determinism, CI gates, small diffs, security/provenance.
- Don't trust AI unaided for security, concurrency, money/correctness-critical math, or anything you can't review.
- Avoid the co-generation blind spot — never ship code and its only tests both written, unchecked, by the same model.
- Verification, not trust, is what makes AI assistance valuable — and resists automation bias.
- The whole course is the judgment that lets you go fast and be right with AI.
Lesson Quiz
The guardrails that make AI assistance safe are best described as…
Which is the WORST candidate to delegate to AI unaided?
The 'co-generation blind spot' is…
Automation bias refers to…
The course's thesis about AI is…
Next: You've reached the end of the course content. Revisit any module from the sidebar, or tackle the cross-module Mock Exam when it's available. This module's lab is in labs/src/main/java/com/jse21/m21_ai/.