Build 1 — AI-Built TODO API (Track Your Usage)

# Build 1 — AI-Built TODO API > 🎯 **Hands-on Portfolio Deliverable:** Build a complete production-grade FastAPI TODO API with auth, CRUD, tests, and Docker containerization using AI pairing. Track your time across each phase to baseline your AI velocity. --- ## The brief Build a TODO API with auth, CRUD, tests, and Docker deploy — entirely AI-assisted. Track your time per phase. Goal: get baseline data on your AI-coding speed. ## Requirements - POST /signup, POST /login (JWT auth). - CRUD /todos (per-user; only own todos accessible). - Filter, paginate, sort todos. - Mark complete/incomplete. - Tests (>80% coverage). - Dockerfile. - README with setup + curl examples. ## Setup (5 min) ```bash mkdir todo-api && cd todo-api git init ``` Create a CLAUDE.md (or .cursorrules): ```markdown # TODO API ## Stack - Python 3.12, FastAPI, SQLAlchemy 2.0, Pydantic v2. - SQLite for dev, Postgres-ready. ## Conventions - src/ layout. - Separate models.py (SQLAlchemy), schemas.py (Pydantic), routers/. - JWT auth via Depends(get_current_user). - pytest with TestClient. ## Style - Type hints on all functions. - Pydantic v2 syntax (model_config, not class Config). - Logging via structlog with extra={}. ``` ## Time-tracking template Throughout the build, log time per phase: ``` | Phase | Time | AI usage | |--------------------|------|-------------------| | Setup | __ | minimal | | Models + schemas | __ | scaffold then review | | Auth | __ | review mode (boilerplate) | | CRUD endpoints | __ | review mode | | Tests | __ | review mode | | Docker | __ | review mode | | README | __ | review mode | | Total | __ | | ``` ## Step 1: Scaffold (15 min target) Prompt your AI: > "Scaffold a FastAPI TODO API: User model with email/password_hash; Todo model with title/description/completed/owner_id. Pydantic schemas for create/update/response. Files: src/todo_api/main.py, models.py, schemas.py, db.py, auth.py, routers/auth.py, routers/todos.py. Just signatures and TODO comments — no implementations yet." AI generates structure. Review: - All files in the right places? - Signatures match patterns? - Pydantic v2 syntax (per CLAUDE.md)? ## Step 2: Implement auth (20 min target) > "Implement auth.py and routers/auth.py based on the scaffold. Use bcrypt via passlib for password hashing; python-jose for JWT. /signup and /login endpoints. Use Depends pattern." AI implements. You verify: - Bcrypt used correctly. - JWT signed and verified. - 401 on bad creds (don't leak user existence). ## Step 3: Implement TODOs CRUD (25 min target) > "Implement routers/todos.py. All endpoints require auth (use get_current_user). User only sees own todos. Endpoints: list (with filter completed, pagination), create, get, update (PATCH partial), delete. Use Mapped style for SQLAlchemy." AI implements; you verify ownership checks, pagination, error responses. ## Step 4: Tests (30 min target) > "Generate pytest tests for all endpoints. Use a TestClient + test DB fixture with transaction rollback. Override get_current_user for protected endpoints with a test_user fixture. Cover: happy path, missing auth, accessing other user's todos (403), 404 on missing todo, validation errors." AI generates tests. Run them; verify pass. If pass: great. If fail: that's a bug — investigate (AI vs your code). Target: >80% coverage. ## Step 5: Dockerfile + README (10 min target) > "Generate a multi-stage Dockerfile using uv. And a README with: project description, setup steps (uv sync), env vars needed, run instructions, example curl commands for each endpoint." AI generates. Test the Docker build locally. ## Step 6: Reflect After completion: ```markdown # Reflection ## Total time: __ hours ## What AI was great at: - ... ## What AI struggled with: - ... ## Things I had to manually fix: - ... ## My speed vs estimate: Without AI, this would have taken __ hours. With AI: __ hours. Speedup: __x. ## What I'd do differently next time: - ... ``` This reflection is the actual learning. Tracking baselines reveals where AI shines and where it doesn't. ## Deliverables - Working TODO API. - All endpoints respond correctly. - Tests pass with >80% coverage. - Dockerfile builds and runs. - README with setup. - Time-tracking table. - Reflection markdown. ## What you'll learn - The full AI-coding cycle on a real project. - Where AI accelerates (scaffolding, tests, boilerplate) vs slows you (subtle business logic). - Your personal baseline speedup. - Habits of effective prompts. ## Stretch - Add tags to TODOs (many-to-many). - Add sharing (users can share TODOs with others). - Deploy to Fly.io / Railway (use Build 6 of FastAPI course). --- ## 📊 100-Point Evaluation Rubric | Evaluation Dimension | Weight | Target Standard (Pass ≥ 80%) | |---|:---:|---| | **1. Functional Endpoints & Auth** | 25 pts | Complete JWT auth flow (`/si