Build a Task Tracker CLI with Claude Code

Build a Python CLI task tracker using only natural language prompts.

Introduction

30 Second Summary

Everyone has a to-do list. But what if you could build your own task management tool just by describing what you want in plain English?

In this project, you will build a command-line task tracker by having conversations with Claude Code. You will never manually write a single line of code.

What You'll Build

A fully functional Python CLI task tracker that lets you add, list, complete, and delete tasks, built entirely through natural language conversations with an AI coding agent.

By the end of this project, you'll have:

  • A working Python CLI app with add, list, complete, and delete commands.
  • A configured CLAUDE.md file that gives Claude persistent memory about your project conventions.
  • A Git repository with clean, descriptive commits generated entirely by Claude.
  • Secret Mission: Add a priority system and color-coded terminal output to your task tracker using only Claude Code conversations.

Are there any prerequisites?

No prior coding experience is required. You will need a Claude Pro ($20/month), Max ($100/month), or Console account to access Claude Code. This guide walks you through installing every tool from scratch.

Before We Start

Before We Start...

Install Claude Code and Set Up Your Environment

Before you can have conversations with an AI coding agent, you need the agent itself installed on your machine. Claude Code is a terminal-based coding agent that reads your files, proposes edits, and runs commands on your behalf.

In this step, you will install Claude Code, authenticate it with your account, and make sure Python and Git are ready to go. These are the only tools you need for the entire project.

In this step, get ready to:
  • Install Claude Code and verify it works.
  • Authenticate with your Claude account.
  • Confirm Python 3 and Git are installed.
Install Claude Code on macOS

Claude Code runs directly in your terminal. You install it with a single command that downloads and configures everything automatically.

  • Press Cmd+Space to open Spotlight.
  • Type Terminal and press Enter to open it.
  • Install Claude Code by running this command:
curl -fsSL https://claude.ai/install.sh | bash

What does this command do?

This downloads the Claude Code installer script from Anthropic's servers and runs it immediately.

The native installer also sets up automatic updates, so Claude Code stays current without any manual work from you.

  • Verify the installation was successful by running:
claude --version

✔️ I see a version number

Claude Code is installed and ready. Move on to the next substep to authenticate.

ⓧ Command not found

Your terminal may not have picked up the new installation yet.

  • Close your Terminal window completely.
  • Open a fresh Terminal window (Cmd+Space, type Terminal, press Enter).
  • Run claude --version again.

If it still fails, try running the install command again in your new terminal window.

Prefer Homebrew?

If you use Homebrew, you can install with:

brew install --cask claude-code

Note that Homebrew installations do not auto-update. Run brew upgrade claude-code manually to get new features.

Authenticate with your Claude account

Claude Code needs to connect to your Claude Pro, Max, or Console account to work. The first time you launch it, it opens your browser for a quick login.

  • Start Claude Code by running:
claude

What will happen next?

Claude Code will detect that you have not logged in yet and open your default browser automatically. You will complete a browser-based OAuth login to connect your Claude subscription.

  • When your browser opens, log in with the same email you use for your Claude Pro, Max, or Console account.
  • Approve the permissions request to let Claude Code access your account.
  • Return to your terminal after you see a confirmation message in the browser.

You should now see a welcome screen in your terminal with a prompt where you can type messages to Claude.

  • Type /help and press Enter to confirm Claude Code is responding.
  • Type /clear and press Enter to reset the conversation. You will start fresh in the next step.

Browser didn't open?

If the browser does not launch automatically, look for a URL printed in your terminal output. Copy that URL and paste it into your browser manually.

If you need to log in again later, use the /login command inside Claude Code.

Help me authenticate Claude Code with my account

Install Python and Git if needed

Your task tracker will be written in Python, and Git will track your code changes. Many macOS machines already have these installed.

  • Check if Python 3 is installed by running:
python3 --version

✔️ I see a version number

Python 3 is ready. Any Python 3.x version works for this project.

ⓧ Command not found

You need to install Python 3. The easiest way on macOS is through Homebrew.

  • First, check if Homebrew is installed by running:
brew --version

If you see a version number, Homebrew is ready. If not, install Homebrew by running:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
  • Once Homebrew is ready, install Python 3 by running:
brew install python
  • Verify the installation by running python3 --version again. You should now see a version number.
  • Check if Git is installed by running:
git --version

✔️ I see a version number

Git is ready. Any version works for this project.

ⓧ Command not found

You need to install Git.

  • Install Git through Homebrew by running:
brew install git
  • Verify the installation by running git --version again. You should now see a version number.

No Homebrew?

If you did not install Homebrew in the Python step above, follow the same instructions to install it first. Then come back and run brew install git.

Still having trouble with installs?

If Homebrew commands are not found after installing, you may need to close and reopen your terminal for the PATH changes to take effect.

Help me install Python 3 and Git on my Mac

Your environment is fully set up. Next up, you will start your first Claude Code session and have it build your project from scratch.

Start Your First Claude Code Session

Your environment is set up and Claude Code is ready to go. Now you'll start your first real conversation with it.

Claude Code works best when launched from inside a project folder. This gives it context about what you're working on from the very start.

In this step, get ready to:
  • Create a project folder and start a Claude Code session.
  • Explore the Claude Code interface and available commands.
  • Have Claude scaffold the project files through a natural language prompt.
Create a project folder and start Claude Code

Every Claude Code session starts inside the project you want to work on. You'll create a fresh folder for your task tracker, then launch Claude Code inside it.

  • Move to your Desktop by running this command:
cd ~/Desktop
  • Create your project folder and move into it by running these commands:
mkdir task-tracker
cd task-tracker
  • Confirm the folder exists by running:
ls ~/Desktop | grep task-tracker

You should see task-tracker in the output.

  • Start a Claude Code interactive session by running:
claude

What happens when you run this?

Claude Code launches an interactive session inside your terminal. You'll see a welcome screen with your project name and a text input where you can type natural language prompts.

From here, you talk to Claude Code the same way you'd talk to a person. Type what you want, and Claude figures out what files to create, edit, or run.

Not seeing the welcome screen?

Make sure you're inside the task-tracker folder before running claude. If you see "command not found", Claude Code was not installed correctly in Step 1.

Help me troubleshoot starting Claude Code

Explore Claude Code's interface

Before you start building, take a moment to see what commands Claude Code offers. This helps you understand the tools available during your session.

  • Type /help into the Claude Code prompt and press Enter.

What does /help show?

The /help command shows you all available slash commands. You'll see commands like /clear (clears conversation history) and /init (creates a CLAUDE.md file).

You don't need to memorize these now. The important thing is knowing /help exists when you need it later.

Now that you've seen the interface, you're ready to give Claude Code its first real task.

Ask Claude Code to scaffold the project

The power of Claude Code is that you describe what you want in plain English. Claude reads your prompt, plans the file structure, and creates everything for you.

  • Type the following prompt into Claude Code and press Enter:
Create the initial project structure for a CLI task tracker. I need three files: 1) main.py as the entry point that prints usage instructions for add, list, complete, and delete commands, and exits if no command is given. 2) tasks.py with load_tasks and save_tasks functions for reading and writing tasks to a JSON file called tasks.json. Use type hints and docstrings on all functions. 3) tasks.json initialized as an empty JSON array.

What happens next?

Claude Code reads your prompt, plans the changes, and shows you a summary of each file it wants to create. It will ask for your approval before writing anything to disk.

This is the core Claude Code workflow: you describe what you want, Claude proposes changes, and you approve them.

  • When Claude shows the proposed file changes, review them and approve by accepting the changes.
  • After Claude finishes, verify the files were created by asking Claude:
Show me the project structure

You should see three files listed: main.py, tasks.py, and tasks.json.

Claude Code is nondeterministic

Claude Code might generate slightly different code each time. Compare your results against the reference in the double-check tab below to make sure the core structure matches.

Claude generated something different?

If the file structure or function names don't match the expected output, ask Claude to adjust. For example, type: "Rename the function to load_tasks" or "Move the storage filename into a constant called TASKS_FILE".

Help me fix my scaffolded project to match the expected structure

✔️ Awesome, I've got everything!

Great. Double check you've saved all your files by asking Claude to confirm the project structure.

ⓧ I'd like to double check the full code

Here is what each file should look like at the end of this step.

main.py:

import sys
from tasks import add_task, list_tasks, complete_task, delete_task


def print_usage() -> None:
    """Print usage instructions."""
    print("Task Tracker CLI")
    print()
    print("Usage:")
    print("  python main.py add <title>       Add a new task")
    print("  python main.py list              List all tasks")
    print("  python main.py complete <id>     Mark a task as complete")
    print("  python main.py delete <id>       Delete a task")


def main() -> None:
    """Main entry point for the CLI."""
    if len(sys.argv) < 2:
        print_usage()
        sys.exit(0)


if __name__ == "__main__":
    main()

tasks.py:

import json
import os
from datetime import datetime

TASKS_FILE = "tasks.json"


def load_tasks() -> list[dict]:
    """Load tasks from the JSON file."""
    if not os.path.exists(TASKS_FILE):
        return []
    with open(TASKS_FILE, "r") as f:
        return json.load(f)


def save_tasks(tasks: list[dict]) -> None:
    """Save tasks to the JSON file."""
    with open(TASKS_FILE, "w") as f:
        json.dump(tasks, f, indent=2)

tasks.json:

[]

If your code looks different, ask Claude Code to adjust it. You can paste specific lines and ask Claude to make changes.

Your project skeleton is in place. Next up, you'll have Claude Code build the actual task features on top of this foundation.

Build the Core Task Features

Your project structure is in place and Claude Code is ready to work. Now it's time to build the features that make your task tracker actually useful.

In this step, you'll have a conversation with Claude Code to implement all four core commands: adding tasks, listing them, marking them complete, and deleting them. You'll experience how Claude Code proposes changes across multiple files and then tests its own work.

In this step, get ready to:
  • Prompt Claude to build the "add task" command.
  • Prompt Claude to add list, complete, and delete commands.
  • Test all commands through Claude Code.
Prompt Claude to build the "add task" feature

The first feature your tracker needs is the ability to add tasks. You'll ask Claude Code to implement this, and it will modify both tasks.py (the logic) and main.py (the command handler).

  • Type this prompt into your Claude Code session:
Add an "add task" feature. When I run "python main.py add Buy groceries", it should create a new task with a unique ID, the title I provided, a completed status set to false, and a timestamp. Save it to tasks.json.

Claude Code reads your existing files, plans the changes, and proposes edits to both files.

  • Review the changes Claude proposes. You'll see it wants to edit both files.
  • Approve the changes when Claude asks for permission.

What should Claude add?

In tasks.py, Claude should add a get_next_id() function to generate unique IDs, and an add_task() function that creates the task dictionary and saves it.

In main.py, Claude should add a handle_add() function and update main() to route the "add" command to that handler.

What is the explore, act, verify loop?

Claude Code works in three phases. First it gathers context by reading your files. Then it takes action by proposing edits. Finally it verifies the results by running commands or checking output.

You just witnessed the first two phases. The verify phase comes in substep 3 when you ask Claude to test the app.

Prompt Claude to build "list tasks" and "complete task"

With add working, you need three more commands: listing all tasks, marking one as complete, and deleting one entirely. You'll ask for these in the same conversation so Claude has full context.

  • Type this prompt to ask for the list and complete features:
Now add two more features: 1) "python main.py list" should show all tasks with their ID, title, and whether they are todo or done. 2) "python main.py complete <id>" should mark a task as completed by its ID. Show an error if the ID doesn't exist.
  • Approve the changes Claude proposes.
  • Once those changes are approved, type this follow-up prompt to add the delete feature:
Also add a delete command: "python main.py delete <id>" should remove a task entirely by its ID. Show an error if the ID doesn't exist.
  • Approve the changes Claude proposes for the delete feature.

What should the files look like now?

After these prompts, tasks.py should have six functions: load_tasks(), save_tasks(), get_next_id(), add_task(), list_tasks(), complete_task(), and delete_task().

main.py should have handler functions for each command (handle_add, handle_list, handle_complete, handle_delete) and a main() function that routes commands to the correct handler.

Claude's code looks different from what you expected?

Claude Code may implement the logic slightly differently than shown in the reference code. That's completely fine as long as the commands work correctly. The important thing is that each command (add, list, complete, delete) produces the right behavior.

If Claude's implementation is missing a feature or has a bug, just tell it what's wrong in plain language. For example: "The list command doesn't show whether tasks are completed or not. Can you fix that?"

help me debug my Claude Code session

Test the app through Claude Code

Claude Code can execute shell commands directly. Instead of switching to another terminal window, you can ask Claude to run your app and verify that everything works.

  • Type this prompt to ask Claude to test all four commands:
Test the app for me. Run these commands in order and show me the output:
1. Add a task called "Buy groceries"
2. Add a task called "Walk the dog"
3. List all tasks
4. Complete task 1
5. List all tasks again to confirm
6. Delete task 2
7. List all tasks one more time

What should I see?

Claude Code executes each command and shows you the output. You should see output like:

  • "Added task #1: Buy groceries" and "Added task #2: Walk the dog" for the add commands.
  • A task list showing both tasks as [todo] after adding them.
  • "Completed task #1: Buy groceries" after the complete command.
  • Task #1 showing as [done] in the next list.
  • "Deleted task #2" after the delete command.
  • Only task #1 remaining in the final list.

This is the "verify" phase of Claude Code's workflow. Claude runs the commands, observes the results, and can fix issues if anything fails.

Tests failing or unexpected output?

If a command fails, Claude Code will usually notice the error and offer to fix it. Let it iterate. You can also tell Claude directly what went wrong: "The complete command gave a KeyError. Can you check the task dictionary structure?"

If Claude seems stuck, try starting fresh by typing /clear and reprompting with more specific instructions about what's broken.

help me fix my failing task tracker tests

✔️ Awesome, I've got everything!

Great. Your task tracker has all four commands working. Make sure your test output shows successful add, list, complete, and delete operations before moving on.

ⓧ I'd like to double check the full code

Here's what your files should look like at this point. Claude Code may have generated slightly different formatting or variable names, but the core logic should match.

import json
import os
from datetime import datetime

TASKS_FILE = "tasks.json"


def load_tasks() -> list[dict]:
    """Load tasks from the JSON file."""
    if not os.path.exists(TASKS_FILE):
        return []
    with open(TASKS_FILE, "r") as f:
        return json.load(f)


def save_tasks(tasks: list[dict]) -> None:
    """Save tasks to the JSON file."""
    with open(TASKS_FILE, "w") as f:
        json.dump(tasks, f, indent=2)


def get_next_id(tasks: list[dict]) -> int:
    """Get the next available task ID."""
    if not tasks:
        return 1
    return max(task["id"] for task in tasks) + 1


def add_task(title: str) -> dict:
    """Add a new task with the given title."""
    tasks = load_tasks()
    new_task = {
        "id": get_next_id(tasks),
        "title": title,
        "completed": False,
        "created_at": datetime.now().isoformat(),
    }
    tasks.append(new_task)
    save_tasks(tasks)
    return new_task


def list_tasks() -> list[dict]:
    """Return all tasks."""
    return load_tasks()


def complete_task(task_id: int) -> dict | None:
    """Mark a task as completed by its ID."""
    tasks = load_tasks()
    for task in tasks:
        if task["id"] == task_id:
            task["completed"] = True
            save_tasks(tasks)
            return task
    return None


def delete_task(task_id: int) -> bool:
    """Delete a task by its ID."""
    tasks = load_tasks()
    original_length = len(tasks)
    tasks = [task for task in tasks if task["id"] != task_id]
    if len(tasks) < original_length:
        save_tasks(tasks)
        return True
    return False
import sys
from tasks import add_task, list_tasks, complete_task, delete_task


def print_usage() -> None:
    """Print usage instructions."""
    print("Task Tracker CLI")
    print()
    print("Usage:")
    print("  python main.py add <title>       Add a new task")
    print("  python main.py list              List all tasks")
    print("  python main.py complete <id>     Mark a task as complete")
    print("  python main.py delete <id>       Delete a task")


def handle_add(args: list[str]) -> None:
    """Handle the add command."""
    if not args:
        print("Error: Please provide a task title.")
        sys.exit(1)
    title = " ".join(args)
    task = add_task(title)
    print(f"Added task #{task['id']}: {task['title']}")


def handle_list() -> None:
    """Handle the list command."""
    tasks = list_tasks()
    if not tasks:
        print("No tasks found. Add one with: python main.py add <title>")
        return
    print("Tasks:")
    print("-" * 40)
    for task in tasks:
        status = "done" if task["completed"] else "todo"
        print(f"  [{status}] #{task['id']}: {task['title']}")


def handle_complete(args: list[str]) -> None:
    """Handle the complete command."""
    if not args:
        print("Error: Please provide a task ID.")
        sys.exit(1)
    try:
        task_id = int(args[0])
    except ValueError:
        print("Error: Task ID must be a number.")
        sys.exit(1)
    task = complete_task(task_id)
    if task:
        print(f"Completed task #{task['id']}: {task['title']}")
    else:
        print(f"Error: Task #{task_id} not found.")
        sys.exit(1)


def handle_delete(args: list[str]) -> None:
    """Handle the delete command."""
    if not args:
        print("Error: Please provide a task ID.")
        sys.exit(1)
    try:
        task_id = int(args[0])
    except ValueError:
        print("Error: Task ID must be a number.")
        sys.exit(1)
    if delete_task(task_id):
        print(f"Deleted task #{task_id}")
    else:
        print(f"Error: Task #{task_id} not found.")
        sys.exit(1)


def main() -> None:
    """Main entry point for the CLI."""
    if len(sys.argv) < 2:
        print_usage()
        sys.exit(0)

    command = sys.argv[1]
    args = sys.argv[2:]

    if command == "add":
        handle_add(args)
    elif command == "list":
        handle_list()
    elif command == "complete":
        handle_complete(args)
    elif command == "delete":
        handle_delete(args)
    else:
        print(f"Unknown command: {command}")
        print_usage()
        sys.exit(1)


if __name__ == "__main__":
    main()

Your task tracker has all four core commands working. Next up, you'll teach Claude Code about your project's coding conventions using a CLAUDE.md file so it generates code that matches your style.

Set Up CLAUDE.md for Project Memory

Your task tracker is fully functional. You can add, list, complete, and delete tasks. But every time you start a fresh Claude Code conversation, Claude has no memory of your preferences or project structure.

Claude Code solves this with a special file called CLAUDE.md. This file acts as persistent project memory that Claude reads at the start of every session. In this step, you will generate one and customize it with your coding conventions.

In this step, get ready to:
  • Generate a CLAUDE.md file using the /init command.
  • Customize CLAUDE.md with your coding conventions.
  • Verify that Claude follows your conventions in a fresh session.
Use the /init command

Claude Code has a built-in command that analyzes your project and generates a CLAUDE.md file. This file is loaded into context at the start of every session, giving Claude persistent knowledge about your project structure and preferences.

  • In your Claude Code session, type the following command and press Enter:
/init

Claude will scan your project files and generate a CLAUDE.md file with information about your project structure, commands, and purpose.

What is CLAUDE.md?

CLAUDE.md is a persistent per-project memory file. Claude Code automatically loads it into context at the start of every session. Think of it as a README, but written specifically for Claude.

Unlike your conversation history (which resets when you close a session), CLAUDE.md stays in your project folder. Every future session will read it.

  • Claude may ask you questions about your project during the /init process. Answer them based on what you have built so far.
  • Once Claude finishes, confirm that a CLAUDE.md file now exists in your task-tracker folder.

Don't see CLAUDE.md?

If /init did not create the file, make sure you are inside the task-tracker directory. Claude Code creates CLAUDE.md in the current working directory.

help me troubleshoot why /init didn't create a CLAUDE.md file in my project

Customize CLAUDE.md with your preferences

The auto-generated CLAUDE.md captures your project structure, but it does not yet include your personal coding style. Adding conventions ensures that every future code Claude writes for this project stays consistent.

  • Ask Claude to update your CLAUDE.md with specific coding conventions by typing this prompt:
Update CLAUDE.md to include a Coding Conventions section with these rules: use type hints for all function parameters and return values, keep functions under 20 lines, use descriptive variable names, and add docstrings to all functions.
  • Approve the changes when Claude proposes them.

Why add conventions to CLAUDE.md?

Without conventions, Claude writes valid code but might use inconsistent styles across sessions. One session might use type hints while the next does not.

Putting rules in CLAUDE.md means every session automatically follows your preferences. You never have to repeat yourself.

  • Verify that your CLAUDE.md now contains a Coding Conventions section with all four rules listed.

✔️ Awesome, I've got everything!

Great. Make sure you have saved the file before moving on.

ⓧ I'd like to double check the full code

Your CLAUDE.md should look like this:

# Task Tracker CLI

## Project Overview
A command-line task tracker built with Python. Tasks are stored in a local JSON file.

## Coding Conventions
- Use type hints for all function parameters and return values
- Keep functions under 20 lines
- Use descriptive variable names
- Add docstrings to all functions

## Project Structure
- `main.py` - CLI entry point and command handling
- `tasks.py` - Task CRUD operations and JSON storage
- `tasks.json` - Data file (auto-created, do not commit)

## Commands
- `python main.py add <title>` - Add a new task
- `python main.py list` - List all tasks
- `python main.py complete <id>` - Mark task as complete
- `python main.py delete <id>` - Delete a task

Your file might have slight wording differences since Claude generated it. The important thing is that all four coding conventions are listed and the project structure is accurate.

See CLAUDE.md in action

The real test of CLAUDE.md is whether Claude remembers your conventions in a fresh session. Clearing the conversation history simulates starting over, but Claude should still know your project rules because it reads CLAUDE.md at startup.

  • Clear your current conversation by typing:
/clear

What does /clear do?

The /clear command wipes your conversation history. Claude forgets everything you discussed. However, it still reads CLAUDE.md when the fresh session starts. This is how you can tell the difference between conversation memory (temporary) and project memory (persistent).

  • Now ask Claude to review your delete task feature against your project conventions by typing this prompt:
Review the delete_task function in tasks.py and the handle_delete function in main.py. Do they follow our project's coding conventions?
  • Read Claude's response. It should reference your conventions from CLAUDE.md (type hints, docstrings, function length, variable names) without you ever mentioning them in this session.

This is the power of CLAUDE.md. You defined your standards once, and Claude follows them in every future conversation.

Claude didn't mention your conventions?

Make sure CLAUDE.md is saved in the same folder where you started Claude Code (the task-tracker directory). Claude only loads CLAUDE.md from the current working directory.

help me figure out why Claude Code isn't picking up my CLAUDE.md conventions

Your project now has persistent memory. Next up, you will use Claude Code to manage your project with Git and generate clean commit messages automatically.

Use Git Through Claude Code

Your task tracker is fully built and your CLAUDE.md gives Claude persistent memory about your project. There is one more piece of a real developer workflow you have not touched yet: version control.

Git tracks every change you make to your code so you can revert mistakes and see your project's history. In this step, you will use Claude Code to initialize a Git repository, generate commit messages, and explore the log. Claude Code handles more than just writing code.

In this step, get ready to:
  • Initialize a Git repository with a proper .gitignore file.
  • Commit all project files with an AI-generated descriptive message.
  • View your commit history through Claude Code.
Initialize a Git repository through Claude

A Git repository tracks changes to your files over time. You also need a .gitignore file that tells Git which files to exclude from tracking.

  • In your Claude Code session, type this prompt and press Enter:
Initialize a git repository for this project. Create a .gitignore file that excludes tasks.json (it's user data that shouldn't be committed), __pycache__/, *.pyc files, and .DS_Store.

Claude Code will propose creating a .gitignore file and running git init. Approve the file changes and commands when prompted.

What is Claude doing here?

Claude Code is using its agentic loop: it reads your project structure, decides which files should be ignored, creates the .gitignore, and runs git init to set up the repository. You directed the outcome with a single sentence.

Why exclude tasks.json?

The tasks.json file stores each user's personal task data. It changes every time you add or complete a task. Committing it would clutter your Git history with data changes instead of code changes.

  • After Claude finishes, verify that the .gitignore file contains these four entries: tasks.json, __pycache__/, *.pyc, and .DS_Store.

Claude didn't create the .gitignore?

If Claude only ran git init without creating the file, send a follow-up prompt: "Create a .gitignore file that excludes tasks.json, __pycache__/, *.pyc, and .DS_Store." Claude will pick up right where it left off.

help me create a .gitignore for my Python project

Generate AI-written commit messages

Writing good commit messages is a skill that takes practice. Claude Code can analyze your changes and generate descriptive messages that explain what was done and why.

  • Ask Claude Code to commit all your project files by typing this prompt:
Add all the project files and commit them with a descriptive commit message that explains what this project is and what it does.

Claude Code will run git add and git commit with a message it writes based on the actual content of your files. Approve the commands when prompted.

What makes this different from writing your own message?

Claude reads every file being committed and summarizes the project's purpose in the message. A human might write "initial commit" out of habit. Claude generates something like "Add CLI task tracker with add, list, complete, and delete commands" because it actually analyzes the code.

  • Read the commit message Claude generated. Notice how it describes the project's functionality, not just "added files."

Seeing a Git identity error?

If Claude reports an error about missing Git user name or email, ask it: "Set my git user name to My Name and email to my@email.com, then try the commit again." Replace the name and email with your own values.

help me fix a Git identity error in Claude Code

View your Git history

Now that you have a commit, you can ask Claude Code to show you the project's history. This confirms everything was tracked correctly.

  • Type this prompt to view your commit log:
Show me the git log and explain what was committed.

Claude Code runs the log command and then explains the output in plain language. You should see your initial commit with the descriptive message Claude wrote.

Why ask Claude to explain the log?

Raw git log output includes hashes, dates, and author info that can look overwhelming. Claude reads it and gives you a human-friendly summary. This is the "explore" part of Claude Code's workflow: gather information and present it clearly.

✔️ Awesome, I've got everything!

Great. Your project now has a full Git history tracking your work. Double check that your commit log shows at least one commit with a descriptive message.

ⓧ I'd like to double check the full code

Here is what your .gitignore file should contain:

tasks.json
__pycache__/
*.pyc
.DS_Store

Your other files (main.py, tasks.py, CLAUDE.md) should be unchanged from the previous step. All four files should appear in your Git commit.

Your project now has a clean Git history with a descriptive, AI-generated commit message. You have experienced the full Claude Code workflow across coding, configuration, and version control. Next up: a secret mission to push your prompting skills further.

Secret mission

Add Priorities and Color Output

Your task tracker works, but every task looks the same. In this secret mission, you will use Claude Code conversations to add a priority system and color-coded terminal output. The key skill: writing specific, detailed prompts that produce exactly what you want.

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely locally, so there are no ongoing cloud costs. Your only recurring cost is your existing Claude Pro or Max subscription, which you likely use for other things too.

Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

Resources you used:

  • Local project folder on your Desktop (task-tracker).
  • Claude Code CLI tool installed on your system.
  • Git repository (inside the project folder).
  • Claude Code configuration files (~/.claude directory).

Keep everything running

No action needed. Choose this if you plan to keep building on your task tracker or want to use Claude Code on other projects.

  • Your project folder stays on your Desktop ready to use.
  • Claude Code remains installed and ready for your next project.
  • Your CLAUDE.md and Git history are preserved for reference.

Pause - I'll come back to this later

Free up terminal sessions but keep your files. Since everything is local, there is nothing actively running to stop.

  • Close any open Claude Code sessions by typing /exit or pressing Ctrl+C.
  • Your project folder and all files remain on your Desktop.
  • When you come back, navigate to your project folder and run claude to pick up where you left off.

Delete - I don't want to use this again

Remove all project resources and optionally uninstall Claude Code from your system.

  • Delete your project folder by running:
rm -rf ~/Desktop/task-tracker
  • Clear Claude Code's local state for this project by running:
claude project purge ~/Desktop/task-tracker
  • If you installed Claude Code via the native installer and want to remove it completely, run:
rm -f ~/.local/bin/claude
rm -rf ~/.local/share/claude
  • If you installed Claude Code via Homebrew and want to remove it, run:
brew uninstall --cask claude-code
  • To remove Claude Code configuration files and session history, run:
rm -rf ~/.claude
rm -f ~/.claude.json

What about Python and Git?

Python and Git are general-purpose tools you will likely use for other projects. There is no need to uninstall them.

That's a Wrap!

That's a Wrap!

Nice work! You just built a complete CLI application without writing a single line of code manually.

You've learned how to:

  • Built a working Python task tracker CLI through natural language conversations with Claude Code.
  • Set up CLAUDE.md to give Claude persistent memory about your project conventions.
  • Used Claude Code for Git operations with AI-generated commit messages.
  • Secret Mission: Added a priority system and color-coded terminal output through precise, descriptive prompts.

Ready to quiz yourself?