Phase 5 — The Python Object Model
Chapters 58-61: OOP -- Designing Systems for AI to Implement
Your role: Modeler -- "I can design systems for AI to implement"
You have spent four phases learning to read, specify, test, iterate, debug, and drive TDG independently. Every skill so far has worked with individual functions: one stub, one test, one implementation. But SmartNotes is growing. A flat list of functions is not an architecture. You need objects that model your domain: Notes with behavior, Collections that manage them, Protocols that define interfaces.
Phase 5 teaches object-oriented programming -- classes, inheritance, composition, special methods, decorators, and protocols -- after you already know how to test and debug everything. This ordering is deliberate. Every OOP concept you learn, you immediately verify with the same TDG cycle you mastered in Phase 4. The method does not change. The specifications become class interfaces instead of function signatures.
OOP requires a different way of thinking: instead of "what steps should the program take?" you ask "what objects exist and what can they do?" Every programmer finds this shift challenging the first time. If a concept does not click immediately, that is normal. Read it, try the exercises, move on, and come back later. The TDG cycle you already know is your anchor: when the concepts feel abstract, the cycle keeps you grounded in concrete code.
Pacing: Plan 2-3 weeks for this phase at a few hours per day. Chapters 58-60 are the core (1-2 weeks). Chapter 61 is advanced and can be revisited after Phase 6 if needed. Take a break between chapters; each one introduces a new layer of thinking.
The TDG connection: You already know the cycle: specify with types, write failing tests, prompt AI to implement, verify with pytest, debug failures. In Phase 5, "specify" means defining class interfaces with typed method signatures. "Test" means creating instances, calling methods, and asserting state. The loop is the same. The building blocks are bigger.
| # | Chapter | Lessons | Key Focus |
|---|---|---|---|
| 58 | Classes and Instances | 5 | From dataclass to full class, init, self, methods, class vs dataclass decision |
| 59 | Inheritance, Composition, and Design | 5 | is-a vs has-a, super(), ABC, composition-first principle, design decision framework |
| 60 | Special Methods | 5 | repr, eq, iter, len, hash, bool, making objects Pythonic |
| 61 | Decorators, Properties, and Advanced Patterns | 6 | @property, @staticmethod, @classmethod, custom decorators, Protocols, dependency injection |
The SmartNotes Object Model
Each chapter transforms SmartNotes from a collection of functions into a proper object system:
| Chapter | SmartNotes evolution |
|---|---|
| Ch 58 | @dataclass Note becomes class Note with .summarize(), .add_tag(), .word_count property |
| Ch 59 | TextNote, CodeNote, LinkNote hierarchy + NoteCollection with composition |
| Ch 60 | Note.__repr__(), Note.__eq__(), NoteCollection.__iter__(), NoteCollection.__len__() |
| Ch 61 | @validate_input decorator, @property for computed fields, Repository Protocol for storage abstraction |
Deliverable: Refactored SmartNotes with a proper object model. All previous tests still passing. New tests verify class behavior, inheritance, special methods, and protocol compliance.
Your PRIMM-AI+ starter kit from Chapter 42 works throughout Phase 5. The /predict, /investigate, /bug, /debug, and /tdg commands continue here. /tdg cycles now specify class interfaces instead of function signatures. /investigate is used to explore class behavior, inheritance, and special methods.
What You Need Before Starting
Phase 5 assumes you can:
- Drive the full TDG cycle independently (Ch 57)
- Debug AI-generated code systematically (Ch 56)
- Write dataclasses with typed fields and defaults (Ch 51)
- Write comprehensive test suites with fixtures and parametrize (Ch 52)
- Handle exceptions and validate data with Pydantic (Ch 54-55)
If any of these feel shaky, revisit the specific chapter before starting Phase 5.
Mid-Phase Checkpoint (After Chapter 59)
After completing Chapters 58-59, you should be able to:
- Write a class with
__init__, typed attributes, and methods - Explain why
selfis the first parameter in every method - Decide between dataclass and full class using the three ceiling patterns
- Choose inheritance vs composition using the one-question framework
- Write a
NoteCollectionthat uses composition (contains a list, not inherits from list)
If you can do all five, you are on track. Chapters 60-61 build on this foundation. If any feel shaky, revisit the specific lesson before continuing.
Core path (Ch 58-60): These three chapters are essential. Take your time with them. Every lesson has remedial differentiations in the frontmatter that suggest a simpler starting point.
Advanced path (Ch 61): Decorators, properties, and protocols are powerful but not required for Phase 6. If Phase 5 is exhausting, complete Ch 58-60, do the Ch 61 L1-L2 lessons (properties and static/class methods), then move to Phase 6. You can return to Ch 61 L3-L6 (custom decorators, protocols, capstone) later when you need them.
Phase 5 Complete: What You Can Do Now
By finishing Phase 5, you have:
- Object modeling (Ch 58): You can design classes with typed state and behavior, and know when to use a dataclass vs a full class.
- Architecture decisions (Ch 59): You can choose between inheritance and composition, and defend your choice with concrete reasoning.
- Pythonic objects (Ch 60): Your objects work with
len(),for,in,==,print(), and f-strings because you implemented the right special methods. - Advanced patterns (Ch 61): You can use decorators, properties, and Protocols to build clean, testable, extensible code.
In Phase 6, you apply these patterns to real-world Python: files, databases, modules, and functional programming. The objects you built here become the data layer that persists, serializes, and processes real data.