Chapter 14: Ten Axioms of Agentic Development Quiz
Test your understanding of the ten axioms that govern effective agentic software development — from shell orchestration through production observability. These questions follow James's journey building an order management system, the same running example from the chapter lessons.
Answer Key
| Question | Correct Answer | Axiom Tested |
|---|---|---|
| 1 | D | Axiom I: Shell as Orchestrator |
| 2 | B | Axiom I: Shell as Orchestrator |
| 3 | A | Axiom II: Knowledge is Markdown |
| 4 | C | Axiom II: Knowledge is Markdown |
| 5 | B | Axiom III: Programs Over Scripts |
| 6 | A | Axiom III: Programs Over Scripts |
| 7 | C | Axiom IV: Composition Over Monoliths |
| 8 | D | Axiom IV: Composition Over Monoliths |
| 9 | A | Axiom V: Types Are Guardrails |
| 10 | C | Axiom V: Types Are Guardrails |
| 11 | D | Axiom VI: Data is Relational |
| 12 | B | Axiom VI: Data is Relational |
| 13 | C | Axiom VII: Tests Are the Specification |
| 14 | A | Axiom VII: Tests Are the Specification |
| 15 | B | Axiom VIII: Version Control is Memory |
| 16 | D | Axiom VIII: Version Control is Memory |
| 17 | A | Axiom IX: Verification is a Pipeline |
| 18 | B | Axiom IX: Verification is a Pipeline |
| 19 | C | Axiom X: Observability Extends Verification |
| 20 | D | Axiom X: Observability Extends Verification |
Scoring Guide
| Score | Proficiency Level | Interpretation |
|---|---|---|
| 18-20 | B2 (Advanced) | Strong understanding of all ten axioms and their practical application |
| 14-17 | B1 (Intermediate) | Good understanding with some gaps in applying axioms to real scenarios |
| 10-13 | A2 (Elementary) | Basic understanding of axioms but needs more practice with application |
| 0-9 | A1 (Beginner) | Review the lessons and work through the "Try With AI" exercises |
Next Steps
Based on your performance, focus on the group where you missed the most questions. The ten axioms fall into three groups (the same groups introduced in the chapter overview):
- Axioms I-IV (Structure): If you missed questions 1-8, review shell orchestration (the complexity threshold between shell and program), markdown knowledge (complete reasoning, not just decisions), the Python discipline stack (uv, pyright, ruff, pytest), and composition patterns (composable monolith vs. microservices). These axioms govern how your code is organized.
- Axioms V-VI (Data): If you missed questions 9-12, study the three-layer type stack (hints, Pyright, Pydantic) and relational data modeling (SQLite vs. PostgreSQL). These axioms make sure information stays correct as it moves through your system.
- Axioms VII-X (Verification): If you missed questions 13-20, revisit Test-Driven Generation (the $12,000 discount bug and the Green Bar Illusion), git as memory (atomic commits, the Permanent Record trap), CI/CD pipelines (the verification pyramid and the Shallow Pipeline trap), and observability practices (the three pillars and the Log Avalanche). These axioms create a chain of verification — from writing the first test to monitoring the live system.
Remember: The ten axioms build upon each other — shell orchestrates programs (I, III), programs are composed (IV) with types (V) and relational data (VI), tested via TDG (VII), tracked in git (VIII), verified in CI (IX), and monitored in production (X). Master each group before advancing to the next.