1. Introduction
  3. Core Methodology
  4. What is EXTREME TDD?
  5. The RED-GREEN-REFACTOR Cycle
  6. Test-First Philosophy
  7. Zero Tolerance Quality
  9. The RED Phase
  10. Writing Failing Tests First
  11. Test Categories
    1. Unit Tests
    2. Integration Tests
    3. Property-Based Tests
  13. Verification Strategy
  15. The GREEN Phase
  16. Minimal Implementation
  17. Making Tests Pass
  18. Avoiding Over-Engineering
  19. The Simplest Thing That Works
  21. The REFACTOR Phase
  22. Refactoring with Confidence
  23. Code Quality Improvements
  24. Performance Optimization
  25. Documentation
  27. Advanced Testing
  28. Property-Based Testing
    1. Proptest Fundamentals
    2. Strategies and Generators
    3. Testing Invariants
  30. Mutation Testing
    1. What is Mutation Testing?
    2. Using cargo-mutants
    3. Mutation Score Targets
    4. Killing Mutants
  32. Fuzzing
  33. Benchmark Testing
  35. Quality Gates
  36. Pre-Commit Hooks
  37. Continuous Integration
  38. Code Formatting (rustfmt)
  39. Linting (clippy)
  40. Coverage Measurement
  41. Complexity Analysis
  42. Technical Debt Gradient (TDG)
  44. Toyota Way Principles
  45. Overview
  46. Kaizen (Continuous Improvement)
  47. Genchi Genbutsu (Go and See)
  48. Jidoka (Built-in Quality)
  49. PDCA Cycle
  50. Respect for People
  52. Real-World Examples from Aprender
  53. Case Study: Linear Regression
  54. Case Study: Cross-Validation
  55. Case Study: Random Forest
  56. Case Study: Model Serialization
  57. Case Study: KMeans Clustering
  59. Sprint-Based Development
  60. Sprint Planning
  61. Sprint Execution
  62. Sprint Review
  63. Sprint Retrospective
  64. Issue Management
  66. Anti-Hallucination Enforcement
  67. Test-Backed Examples
  68. Example Verification
  69. CI Validation
  70. Documentation Testing
  72. Tools and Setup
  73. Development Environment
  74. cargo test
  75. cargo clippy
  76. cargo fmt
  77. cargo mutants
  78. proptest
  79. criterion
  80. pmat (Toyota AI Toolkit)
  82. Best Practices
  83. Error Handling
  84. API Design
  85. Builder Pattern
  86. Type Safety
  87. Performance Considerations
  88. Documentation Standards
  90. Metrics and Measurement
  91. Test Coverage
  92. Mutation Score
  93. Cyclomatic Complexity
  94. Code Churn
  95. Build Times
  96. TDG Score Breakdown
  98. Common Pitfalls
  99. Skipping Tests
  100. Insufficient Test Coverage
  101. Ignoring Warnings
  102. Over-Mocking
  103. Flaky Tests
  104. Technical Debt Accumulation
  106. Appendix
  107. Glossary
  108. References
  109. Further Reading
  110. Contributing to This Book