Day 29: Building a CLI Task Tracker with AI—and Recapping the Journey So Far
It's an hectic pace. So, how do you keep track with what you've learned?
The past few days have really accelerated.
Between decorators, testing, and object-oriented programming, you might be feeling like you’ve jumped a level—or ten. That’s not just you. It’s the nature of compound learning. So today, we’re doing two things:
Building a real command-line app with everything we’ve learned
Recapping the core concepts from Day 1 through 29
Let’s go.
🔧 Today’s Project: AI-Assisted Task Tracker (CLI App)
We’re creating a Python command-line task manager using:
Classes & objects
A custom decorator for logging
Unit tests to confirm it all works
🗂️ File: task_tracker.py
python
from datetime import datetime
def log_action(func):
def wrapper(*args, **kwargs):
print(f"[{datetime.now()}] Running: {func.__name__}")
return func(*args, **kwargs)
return wrapper
class Task:
def __init__(self, title, due_date=None):
self.title = title
self.due_date = due_date
self.completed = False
def mark_complete(self):
self.completed = True
def __str__(self):
status = "✔️" if self.completed else "❌"
due = f" (Due: {self.due_date})" if self.due_date else ""
return f"{self.title}{due} [{status}]"
class TaskManager:
def __init__(self):
self.tasks = []
@log_action
def add_task(self, title, due_date=None):
task = Task(title, due_date)
self.tasks.append(task)
@log_action
def list_tasks(self):
if not self.tasks:
print("No tasks yet!")
for i, task in enumerate(self.tasks):
print(f"{i + 1}. {task}")
@log_action
def complete_task(self, index):
if 0 <= index < len(self.tasks):
self.tasks[index].mark_complete()
else:
print("Invalid task number.")
🧪 File: test_task_tracker.py
python
import unittest
from task_tracker import Task, TaskManager
class TestTaskManager(unittest.TestCase):
def test_add_task(self):
manager = TaskManager()
manager.add_task("Test Task")
self.assertEqual(len(manager.tasks), 1)
def test_complete_task(self):
manager = TaskManager()
manager.add_task("Test Task")
manager.complete_task(0)
self.assertTrue(manager.tasks[0].completed)
def test_invalid_complete(self):
manager = TaskManager()
manager.complete_task(99) # Should not throw error
if __name__ == "__main__":
unittest.main()
🧠 What We've Learned So Far (Day 1–29 Recap)
It’s easy to forget just how far you’ve come, so here’s a quick recap of major concepts:
🧰 Tools
Python + IDE (Cursor, Replit, etc.)
Git + GitHub
AI coding assistants (ChatGPT, Copilot)
🧠 Core Python Topics
Day 1 kicked things off by getting our environment set up—Python, our IDE, and an AI assistant. We wrote our very first line of code with AI’s help.
Day 2 introduced the command line and Git. We learned how to track our code, commit changes, and publish projects to GitHub—laying the foundation for real-world workflows.
Day 3 explored Python variables and basic data types. We got comfortable with storing and handling user input, and started writing interactive scripts.
Day 4 added control flow: if-statements, logical conditions, and how to write code that makes decisions. This helped us start thinking like programmers.
Day 6 brought in functions—small, reusable chunks of code. We learned how to define them, pass information around, and return results.
Day 7 was all about debugging with AI. Instead of struggling with error messages alone, we learned how to use AI to diagnose and fix bugs—quickly and clearly.
Day 8 introduced lists and dictionaries. These data structures helped us start managing collections of items, a critical skill for building real apps.
Day 9 focused on strings and text processing—essential for building command-line interfaces and handling user input like titles and descriptions.
Days 11–12 introduced tuples and sets. These helped round out our understanding of Python’s core data containers and when to use each one.
Day 13 gave us an intro to algorithmic thinking. We used plain English (and AI) to explore how code performance is measured and optimized.
Day 14 tackled basic sorting and searching, teaching us how to manipulate and navigate data—a key part of building useful software.
Day 18 covered exception handling. We learned to write code that fails gracefully, giving users useful messages instead of crashing.
Day 19 showed us how to read and write files, giving us a glimpse into real-world data storage.
Days 21–23 introduced object-oriented programming. We built our own classes and objects, and started thinking in terms of responsibilities and behaviors.
Day 24 taught us how to organize code using modules and packages. This helped keep our projects clean and scalable.
Day 26 brought in decorators—an advanced but powerful feature to wrap behavior around functions. We used it for logging and automation.
Day 27 explored generators and how to handle data more efficiently. We learned about memory-friendly programming with
yield.Day 28 was all about testing. We wrote unit tests with AI’s help and saw how testing reinforces confidence in our code.
Find all the posts - https://zerotobuilder.substack.com/archive?sort=new
🚀 Today (Day 29): Bringing It All Together
With everything above, you now have the tools to build a real command-line app:
Define objects (like tasks)
Track and update them in a manager class
Use decorators for logging
And confirm it all works with automated tests
Even if you’re behind or need to revisit older concepts, that’s okay. Today’s project is a milestone, not a finish line. Use AI to revisit, reinforce, and rebuild your understanding as often as you need.
🤖 How AI’s Helped Us So Far
Debugged tricky logic and syntax errors
Auto-generated test cases
Explained decorators, loops, and classes in plain English
Suggested better code organization
Helped write docs and README files
Reminded us that learning isn’t linear—and that’s okay
🔁 Try This Prompt In Cursor or ChatGPT
“I’m building a command-line task tracker in Python. Remind me of the key concepts I’ve learned so far—including classes, decorators, and testing. Help me reflect on how I’ve improved.”
🧭 Tomorrow: Final Project Wrap for Phase 3
We’ll polish the CLI project and optionally:
Add saving/loading to a
.jsonfileConvert it to use
argparsefor command-line argumentsPush to GitHub with a README
Take your time. Revisit old lessons. Use AI to remind you why this journey is worth it.
You don’t have to master everything. You just have to keep going—with an AI partner by your side.