Capstone: Task Manager + GitHub Agent HQ

Welcome to your capstone project! This is where everything you've learned in Lessons 1-6 comes together. You'll manage a complete Git workflow for an AI-generated multi-file project, then peek into GitHub's multi-agent orchestration future.

What You'll Accomplish:

Write a specification FIRST (before any code exists)
Ask AI to generate a complete Python CLI task manager from your spec
Manage the entire Git workflow: init → commit → branch → test → merge → push → PR
Apply your git-workflow.md patterns from Lesson 6 automatically
Document AI assistance transparently in your pull request
Understand GitHub Agent HQ as the platform evolution foundation

Why This Matters: This is proof you can manage AI-generated projects safely and professionally. You'll walk away with a portfolio-ready project on GitHub demonstrating both technical skills and transparent AI collaboration.

Part A: The Capstone Project (90 minutes)

Project Overview: Personal Task Manager CLI

You'll create a command-line task manager that:

Adds tasks to a list
Displays all tasks
Marks tasks as complete
Deletes tasks
Persists tasks to JSON file

Key Constraint: You write the specification first, then AI generates code. This is Stage 4 (Spec-Driven Integration)—the highest level of AI-native development.

Step 1: Write Specification BEFORE Code (20 minutes)

In AI-native development, the fundamental skill shifts from writing code to writing specifications. Specifications define WHAT your program does (intent, success criteria, constraints) WITHOUT saying HOW to implement it.

Understanding Specification-First Development

Traditional Approach (Pre-AI):

Think about implementation details
Write code directly
Test if it works
Debug and refine

AI-Native Approach (Stage 4):

Write specification defining intent and success criteria
AI generates code from specification
Validate code against specification
Refine specification if needed

Why Spec-First Wins:

Clear specifications → Quality AI output
Vague specifications → Poor AI output
Specifications are reviewable BEFORE code exists
You validate AI's work against YOUR intent (not AI's assumptions)

Create spec.md

Create a new directory for your project and write this specification:

# Create project directory
mkdir task-manager-capstone
cd task-manager-capstone

# Create specification file
# (Use your text editor - VS Code, Cursor, Zed, nano, or vim)

File: spec.md

# Project: Personal Task Manager CLI

## Intent
Create a command-line task manager demonstrating Git workflow with AI-generated code. Students will manage real project using Git safety patterns learned in Lessons 1-6.

## Features
1. **Add Task**: User types task description, program adds to list
2. **View All Tasks**: Display numbered list of all tasks with completion status
3. **Mark Complete**: User provides task number, program marks as done
4. **Delete Task**: User provides task number, program removes it
5. **Persist to JSON**: All tasks saved to `tasks.json` file (survive program restart)

## Success Criteria
- ✅ All features work without errors
- ✅ Tasks persist across program runs (stored in tasks.json)
- ✅ Program shows help text explaining commands
- ✅ User-friendly: clear prompts, handles invalid input gracefully

## Technical Constraints
- **Language**: Python 3.8+
- **Data Storage**: JSON file (no database)
- **Interface**: Command-line only (no GUI)
- **Error Handling**: Validate user input, display helpful messages

## Non-Goals (What This Project Is NOT)
- ❌ Web interface (CLI only)
- ❌ Database integration (JSON sufficient)
- ❌ User authentication (single-user tool)
- ❌ Cloud sync (local storage only)
- ❌ Advanced features (priorities, due dates, categories deferred to v2)

## Validation Tests
After implementation, verify:
1. Add 3 tasks → Close program → Reopen → All 3 tasks still present
2. Mark task complete → Status changes
3. Delete task → Removed from list
4. Run with no tasks.json → Program creates file automatically
5. Type invalid command → Program shows helpful error (not crash)

What You Just Did: You defined WHAT the program does WITHOUT saying HOW to implement it. This is the specification that AI will use to generate code.

Reflection: Notice how much clarity this specification provides:

AI knows exactly what to build
You can validate AI's code against these criteria
Specification is reviewable BEFORE any code exists
Changes to specification are easier than changes to code

Step 2: Initialize Git Repository (5 minutes)

Before AI generates code, create your Git safety net.

Apply Pattern 1 from Lesson 6: "Commit Before Experiment"

# Initialize Git repository
git init

# Create initial commit with specification
git add spec.md
git commit -m "Initial: project specification for task manager"

Why This Order Matters:

Specification exists and is committed
AI generates code based on this committed spec
If AI code is terrible, you can revert to specification-only state
Specification is source of truth (never lost)

Verify:

git log --oneline
# Should show: abc1234 Initial: project specification for task manager

Step 3: AI Generates Code from Specification (15 minutes)

Now ask AI to implement your specification.

The AI Generation Prompt

Open ChatGPT (chat.openai.com) and use this specification-based prompt:

I need a Python command-line task manager. Here's my complete specification:

[Paste your entire spec.md file here]

Generate complete working code following this specification exactly.
Include:
- Main program file (task_manager.py)
- All features listed in specification
- Error handling for invalid input
- Help text explaining commands

Understanding AI's Role

AI as Co-Worker:

You provided clear intent (specification)
AI handles implementation details (code)
You validate output against YOUR success criteria

AI should generate something like:

File: task_manager.py

#!/usr/bin/env python3
"""
Personal Task Manager CLI
Manages tasks with add, view, complete, delete operations.
Data persists to tasks.json.
"""

import json
import os
from typing import List, Dict

TASKS_FILE = "tasks.json"

def load_tasks() -> List[Dict]:
    """Load tasks from JSON file."""
    if not os.path.exists(TASKS_FILE):
        return []
    try:
        with open(TASKS_FILE, 'r') as f:
            return json.load(f)
    except json.JSONDecodeError:
        print(f"Warning: {TASKS_FILE} corrupted. Starting fresh.")
        return []

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

def add_task(tasks: List[Dict], description: str) -> None:
    """Add new task to list."""
    task = {
        "id": len(tasks) + 1,
        "description": description,
        "completed": False
    }
    tasks.append(task)
    save_tasks(tasks)
    print(f"✓ Added task #{task['id']}: {description}")

def view_tasks(tasks: List[Dict]) -> None:
    """Display all tasks with completion status."""
    if not tasks:
        print("No tasks yet. Add your first task!")
        return

    print("\nYour Tasks:")
    print("-" * 50)
    for task in tasks:
        status = "✓" if task["completed"] else " "
        print(f"[{status}] #{task['id']}: {task['description']}")
    print("-" * 50)

def mark_complete(tasks: List[Dict], task_id: int) -> None:
    """Mark task as completed."""
    for task in tasks:
        if task["id"] == task_id:
            task["completed"] = True
            save_tasks(tasks)
            print(f"✓ Marked task #{task_id} as complete")
            return
    print(f"✗ Task #{task_id} not found")

def delete_task(tasks: List[Dict], task_id: int) -> None:
    """Delete task from list."""
    for i, task in enumerate(tasks):
        if task["id"] == task_id:
            tasks.pop(i)
            save_tasks(tasks)
            print(f"✓ Deleted task #{task_id}")
            return
    print(f"✗ Task #{task_id} not found")

def show_help() -> None:
    """Display help text."""
    print("""
Personal Task Manager - Commands:
  add <description>     Add new task
  list                  View all tasks
  complete <id>         Mark task as done
  delete <id>           Remove task
  help                  Show this help
  quit                  Exit program
""")

def main():
    """Main program loop."""
    tasks = load_tasks()
    print("Personal Task Manager (type 'help' for commands)")

    while True:
        try:
            command = input("\n> ").strip().lower()

            if not command:
                continue

            parts = command.split(maxsplit=1)
            cmd = parts[0]

            if cmd == "quit":
                print("Goodbye!")
                break
            elif cmd == "help":
                show_help()
            elif cmd == "list":
                view_tasks(tasks)
            elif cmd == "add":
                if len(parts) < 2:
                    print("✗ Usage: add <task description>")
                else:
                    add_task(tasks, parts[1])
            elif cmd == "complete":
                if len(parts) < 2:
                    print("✗ Usage: complete <task id>")
                else:
                    try:
                        task_id = int(parts[1])
                        mark_complete(tasks, task_id)
                    except ValueError:
                        print("✗ Task ID must be a number")
            elif cmd == "delete":
                if len(parts) < 2:
                    print("✗ Usage: delete <task id>")
                else:
                    try:
                        task_id = int(parts[1])
                        delete_task(tasks, task_id)
                    except ValueError:
                        print("✗ Task ID must be a number")
            else:
                print(f"✗ Unknown command: {cmd} (type 'help' for commands)")

        except KeyboardInterrupt:
            print("\nGoodbye!")
            break
        except Exception as e:
            print(f"✗ Error: {e}")

if __name__ == "__main__":
    main()

Save this code to task_manager.py in your project directory.

Step 4: Commit AI-Generated Code (5 minutes)

Apply Pattern 1 from your git-workflow.md: Commit before testing (creates restore point).

# Stage AI-generated files
git add task_manager.py

# Commit with AI attribution
git commit -m "feat: AI-generated task manager skeleton

AI: ChatGPT generated complete task manager from spec.md
Features: add, list, complete, delete tasks with JSON persistence
Validation: Not yet tested (next step)"

What This Commit Message Shows:

Type: feat: (new feature using conventional commits)
What: AI-generated task manager skeleton
Attribution: Clear AI transparency (ChatGPT generated from spec)
Status: Validation pending

Git History Now:

* abc5678 feat: AI-generated task manager skeleton
* abc1234 Initial: project specification for task manager

Step 5: Test & Create Improvement Branch (15 minutes)

Test all features from your specification.

Validation Against Spec

# Make executable (macOS/Linux)
chmod +x task_manager.py

# Run program
python3 task_manager.py

Test Checklist (from spec.md success criteria):

> help
[Should show command list]

> add Buy groceries
[Should add task #1]

> add Finish homework
[Should add task #2]

> list
[Should show 2 tasks, both incomplete]

> complete 1
[Should mark task #1 done]

> list
[Task #1 should show ✓, task #2 should show  ]

> quit
[Exit program]

# Restart and verify persistence
python3 task_manager.py
> list
[Both tasks should still be there]

> delete 2
[Should remove task #2]

> list
[Only task #1 remains]

Validation Result: ✅ All success criteria met!

Apply Pattern 2: "Branch for Improvements"

Even though basic features work, you might want to add better error handling or improve the user experience. Create a branch to test improvements safely.

# Create improvement branch
git checkout -b feature/better-error-handling

# Make improvement (example: add input validation)
# [Edit task_manager.py to add more helpful error messages]

# Commit improvement
git add task_manager.py
git commit -m "feat: enhanced input validation and error messages"

Pattern Recognition: You just applied the branch-test-merge pattern from Lesson 6 automatically without referring back to lessons. This is intelligence accumulation!

Step 6: Merge and Push to GitHub (15 minutes)

Merge Feature Branch to Main

# Switch back to main
git checkout main

# Merge improvement branch
git merge feature/better-error-handling

# View history
git log --oneline --graph

Expected Output:

* def9012 feat: enhanced input validation and error messages
* abc5678 feat: AI-generated task manager skeleton
* abc1234 Initial: project specification for task manager

Apply Pattern 3: "Push for Backup"

# First time: Create GitHub repository
# 1. Go to github.com
# 2. Click "New repository"
# 3. Name: task-manager-capstone
# 4. Keep it Public (for portfolio)
# 5. DO NOT initialize with README (you already have commits)

# Connect local to GitHub
git remote add origin https://github.com/YOUR_USERNAME/task-manager-capstone.git

# Push to GitHub
git push -u origin main

# Also push feature branch (shows your process)
git push origin feature/better-error-handling

Verify on GitHub: Visit your repository page. You should see:

✅ 3 commits in history
✅ spec.md, task_manager.py, tasks.json
✅ Both branches visible
✅ Code viewable by anyone (portfolio ready)

Step 7: Create Pull Request with AI Transparency (10 minutes)

This is your professional documentation of the complete project.

Create PR on GitHub

On GitHub: Click "Pull requests" → "New pull request"
Compare: feature/better-error-handling → main
Create PR with this template:

Title: feat: Enhanced task manager with better error handling

Description:

## Summary
Improved user experience with better error handling and input validation for the task manager CLI.

## Changes Made
- Enhanced error messages for invalid commands
- Added input validation for task IDs
- Improved help text clarity

## AI Assistance
- **Initial Code Generation**: ChatGPT generated complete task manager from `spec.md` specification
- **What AI Generated**: Core functionality (add, list, complete, delete), JSON persistence, error handling structure
- **What I Modified**: Enhanced error messages, improved input validation, refined user prompts
- **AI Tool**: ChatGPT 4 (via chat.openai.com)

## Specification Compliance
All success criteria from `spec.md` validated:
- ✅ All features work without errors
- ✅ Tasks persist across program runs (tasks.json)
- ✅ Help text explains commands
- ✅ User-friendly error handling

## Testing Done
- Manually tested all commands (add, list, complete, delete, help, quit)
- Verified persistence: added tasks → closed program → reopened → tasks still present
- Tested error cases: invalid commands, invalid task IDs, empty input
- Verified tasks.json creation on first run

## Git Workflow Applied
Applied all patterns from Lesson 6 (git-workflow.md):
1. ✅ Committed specification before code generation
2. ✅ Created feature branch for improvements
3. ✅ Tested on branch before merging
4. ✅ Pushed to GitHub for backup
5. ✅ Documented AI assistance transparently

## Portfolio Ready
This project demonstrates:
- Specification-first AI-native development
- Complete Git workflow (init → commit → branch → merge → PR)
- Transparent AI collaboration
- Professional GitHub practices

Create Pull Request
Review Diff: Verify changes match what you intended
Merge PR: Click "Merge pull request" → "Confirm merge"

What You Just Demonstrated:

✅ 100% AI transparency (SC-008: All capstone PRs include attribution)
✅ Professional documentation
✅ Specification-driven validation
✅ Complete Git workflow from start to finish

Step 8: Validate Complete Workflow (5 minutes)

Verify you successfully orchestrated accumulated intelligence.

Git History Validation

git log --oneline --graph

Expected Structure:

*   ghi3456 Merge pull request #1 from YOUR_USERNAME/feature/better-error-handling
|\
| * def9012 feat: enhanced input validation and error messages
|/
* abc5678 feat: AI-generated task manager skeleton
* abc1234 Initial: project specification for task manager

This History Shows:

✅ Specification committed first (spec-driven)
✅ AI-generated code committed with attribution
✅ Feature branch for improvements
✅ Professional merge via pull request
✅ Complete project history preserved

Success Criteria Validation

From Spec (SC-002, SC-005, SC-007, SC-008):

✅ SC-002: Executed core workflow (init → add → commit → push) successfully
✅ SC-005: Committed AI-generated code within 30 seconds of generation
✅ SC-007: Completed branch workflow in under 5 minutes (create → test → merge)
✅ SC-008: Documented AI assistance in PR (100% attribution)

Portfolio Impact:

Your GitHub profile now shows:
- Complete project with meaningful commit history
- Professional pull request with AI transparency
- Demonstration of Git mastery
- Evidence of specification-driven development

Reflection: You just managed a complete AI-generated project from specification to production-ready code using Git as your safety system. This is AI-native development at the capstone level.

Part B: GitHub Agent HQ Awareness (30 minutes)

Now that you've mastered Git for single-agent development (you + ChatGPT), let's explore GitHub's evolution into a multi-agent orchestration platform.

Understanding GitHub Agent HQ: The Platform Evolution

What You Just Learned vs. What's Coming

What You Learned (Lessons 1-7):

You work with ONE AI at a time (ChatGPT, Claude, or Gemini)
You manually manage Git workflow (init, commit, branch, push, PR)
You coordinate AI's work through prompts
Git is YOUR safety system for managing AI's code

What's Emerging (GitHub Agent HQ):

GitHub orchestrates MULTIPLE AI agents on SAME project
Agents create branches, commits, and PRs automatically
GitHub coordinates which agent does what
Git becomes the coordination layer for agent collaboration

Key Insight: The Git skills you learned (branches, commits, PRs, remotes) don't change. GitHub is adding an orchestration layer on TOP of Git fundamentals.

GitHub Agent HQ: 5 Core Concepts

1. Mission Control: Unified Interface for Multiple AI Agents

What It Is: GitHub Agent HQ provides a mission control interface where you direct multiple AI agents from one place instead of switching between ChatGPT, Claude, Gemini, etc.

Analogy: Instead of texting three friends separately to plan dinner, you create a group chat where everyone sees the conversation.

How It Works:

You (mission control): "Implement authentication system"

GitHub Agent HQ dispatches:
- Agent A (Claude Code): Creates database schema on branch `db/auth-schema`
- Agent B (GPT-4): Implements login API on branch `api/login`
- Agent C (Gemini): Writes tests on branch `tests/auth`

All agents work in parallel, coordinated by GitHub.

Why This Matters: You describe intent ONCE. GitHub coordinates which specialized agent handles each piece. Faster than sequential single-agent work.

2. Multi-Agent Orchestration: Specialized Agents Working Together

What It Is: Different AI agents have different strengths (Claude excels at reasoning, GPT-4 at code generation, Gemini at multi-modal). Agent HQ lets them work on the SAME project simultaneously, each doing what it does best.

Analogy: Instead of one general contractor building your house, you have specialized electrician, plumber, and carpenter working in parallel.

How It Relates to Your Learning:

You learned: Create branch → AI generates code → You test → Merge
Agent HQ does: Create branches for multiple agents → Agents generate code in parallel → GitHub coordinates merging

The Branches You Learned = Agent Coordination:

You learned branches isolate experiments
Agent HQ uses branches to isolate agent work
Same Git concept, scaled to multiple agents

3. Branch Controls for Agent-Generated Code

What It Is: GitHub enforces policies on branches that agents create (e.g., "Agent-generated branches require tests before merge").

Analogy: Like having safety rails on agent work—agents can't merge directly to main without passing checks.

How It Works:

Agent creates branch: agent-a/new-feature
Agent commits code
GitHub automatically:
  - Runs tests
  - Checks code quality
  - Verifies security
  - Requires human approval if critical

Only then: Agent's PR can merge

Why This Matters: Agents get speed of automation + safety of human oversight. You stay in control.

4. Agentic Code Review: AI Reviewing AI

What It Is: GitHub's CodeQL engine automatically reviews agent-generated pull requests for security issues, bugs, and code quality BEFORE human review.

Analogy: Like spell-check catching typos before you send an email. CodeQL catches code issues before you review.

How It Works:

Agent creates PR → CodeQL reviews → Flags issues:
  - "SQL injection vulnerability detected"
  - "Unused variable on line 42"
  - "Function complexity too high"

Agent fixes issues automatically → Human reviews cleaned code

Why This Matters: You review fewer low-level bugs because AI reviewers catch them first. You focus on intent and architecture.

5. Platform Evolution: GitHub as AI Coordination Layer

What It Is: GitHub is transforming from "place to store code" to "platform that coordinates AI agents building software."

Historical Context:

2008-2020: GitHub = Code hosting + version control
2020-2023: GitHub = Code + CI/CD + Copilot (single-agent assistance)
2024+: GitHub = Code + Multi-agent orchestration (Agent HQ)

Analogy: GitHub evolved like AWS evolved:

AWS started as "rent a server"
AWS became "platform for building cloud applications"
GitHub started as "store your code"
GitHub becoming "platform for coordinating AI development"

Your Role Evolution:

Before AI: Write code yourself
Single Agent (Today): Write spec → AI generates code → You validate
Multi-Agent (Agent HQ): Write spec → GitHub coordinates multiple agents → You validate

What Stays the Same:

Git fundamentals (branches, commits, PRs, merges)
Specification-driven development (WHAT before HOW)
Human validation (you approve merges)
Safety via version control (can always undo)

What Changes:

Speed (multiple agents work in parallel)
Specialization (right agent for right task)
Scale (agents handle larger projects)

How This Relates to Your Learning

Foundation Skills Don't Change

What You Learned in Lessons 1-6:

Git repositories, commits, branches
Staging area, history, diffs
GitHub remotes, push, pull, clone
Pull requests, code review, merges

These Skills Apply to Agent HQ:

Agents use branches (you understand branches)
Agents create commits (you understand commits)
Agents create PRs (you understand PRs)
You approve agent merges (using PR review skills)

Key Message: You're learning the foundation that works FOREVER. Agent HQ is additive, not disruptive.

You're Prepared for the Multi-Agent Future

Skills You Have Now (that translate to Agent HQ):

✅ Specification Writing: Agent HQ needs clear specs (you practiced in this lesson)
✅ Branch Management: Agents create branches (you know how branches work)
✅ Code Review: You validate agent PRs (you know how to review diffs)
✅ Git Safety: You know undo operations (works same with agent-generated code)
✅ AI Transparency: You document AI assistance (critical for multi-agent workflows)

What You'll Add When Agent HQ Is Production-Ready:

Learn mission control interface (like learning GitHub's UI when you first started)
Configure agent policies (which agents can do what)
Orchestrate agent coordination (assigning work to specialized agents)

Estimate: If you're comfortable with Git now (Lessons 1-7), you'll be comfortable with Agent HQ in 2-3 hours of practice. Foundation is 90% of the work.

You're Prepared—Don't Let Platform Evolution Cause Anxiety

Common Fear: "Will My Skills Become Obsolete?"

Reality Check:

Git hasn't changed fundamentally since 2005 (20 years)
Branches, commits, merges, remotes still work identically
Agent HQ builds ON Git (doesn't replace it)
Your mental model of Git applies directly to agent coordination

Analogy: When smartphones added group chats, you didn't relearn texting. You applied texting skills to groups. Same concept here.

Timeline: When Does This Matter?

Today (2025):

Focus on mastering single-agent Git workflows (what you just did)
GitHub Agent HQ is in limited preview (not widely available)
Your skills are production-ready NOW

Near Future (2025-2026):

Agent HQ becomes generally available
You learn mission control interface (1-2 hours)
You start using multi-agent workflows for larger projects

Strategy: Master Git NOW (which you just did). Add Agent HQ layer WHEN it's production-ready. Sequential learning prevents overwhelm.

Key Confidence Message

What You Should Feel:

✅ Confident: You understand Git fundamentals that power Agent HQ
✅ Prepared: Skills you learned translate directly to multi-agent era
✅ Curious: Excited to see how GitHub evolves platform capabilities
✅ Not Anxious: Foundation doesn't change; platform adds convenience layer

What You Should NOT Feel:

❌ Obsolete: Your skills are the foundation (not outdated)
❌ Overwhelmed: Agent HQ is additive (not replacement)
❌ Behind: You're learning at the RIGHT time (foundation first)

Official GitHub Agent HQ Resources

Authoritative Source: GitHub Blog - Welcome Home, Agents

What GitHub Says:

"Agent HQ is mission control for AI agents. It provides a unified interface where developers can direct multiple AI agents working on the same codebase, with GitHub managing branch orchestration, code review policies, and merge coordination."

Key Features Confirmed by GitHub:

Mission Control Interface: Centralized agent orchestration
Multi-Agent Coordination: Multiple AI agents on same project
Branch Policies for Agents: Automated safety checks on agent-generated code
Agentic Code Review: CodeQL reviews agent PRs automatically
Platform Evolution: GitHub as AI coordination platform (not just code host)

Preview Status (as of January 2025):

Limited preview for select organizations
Expanding to more users throughout 2025
Generally available expected mid-2025

Your Action: Bookmark that GitHub Blog post. As Agent HQ becomes generally available, revisit the official documentation. The Git skills you learned in Lessons 1-7 will make onboarding effortless.

Capstone Reflection: What You've Accomplished

Technical Mastery

Complete Git Workflow:

✅ Wrote specification BEFORE code (spec-driven)
✅ Initialized repository and committed specification
✅ Generated AI code from specification
✅ Committed AI-generated code with attribution
✅ Created feature branch for improvements
✅ Tested changes on branch safely
✅ Merged feature branch to main
✅ Pushed to GitHub for cloud backup
✅ Created pull request with full AI transparency
✅ Portfolio-ready project on GitHub

Intelligence Accumulation:

✅ Applied git-workflow.md patterns from Lesson 6 automatically
✅ Referenced your own documentation instead of lessons
✅ Orchestrated accumulated skills without external guidance

Professional Practices

AI Transparency:

Documented exactly which AI generated which code
Specified what you modified vs. what AI created
Transparent attribution in commit messages AND pull request

Specification-Driven Development:

Intent defined BEFORE implementation
Success criteria measurable and clear
Validation against specification (not guesses)

Portfolio Building:

GitHub profile shows complete project
Commit history demonstrates professional workflow
Pull request demonstrates collaboration transparency

Platform Evolution Awareness

GitHub Agent HQ Understanding:

✅ Understand Agent HQ as multi-agent orchestration platform
✅ Recognize Git fundamentals as foundation for Agent HQ
✅ Aware of mission control, multi-agent coordination, branch controls, agentic code review
✅ Confident that foundation skills translate to multi-agent future
✅ NOT anxious about platform evolution (prepared, not obsolete)

Try With AI

Setup: Open ChatGPT (chat.openai.com) and explore the multi-agent coordination concept further.

Prompt Set:

Prompt 1: Foundational Understanding
"I just completed a Git capstone project where I managed an AI-generated task manager. I learned about GitHub Agent HQ. Can you explain how my Git skills (branches, commits, PRs) would apply if three AI agents were working on my project simultaneously?"

Prompt 2: Specification for Multi-Agent Scenario
"Here's a project specification: [paste your task manager spec.md]. If GitHub Agent HQ had three specialized agents (one for data handling, one for UI, one for testing), how would they divide this work using Git branches?"

Prompt 3: Future Preparation
"What should I focus on mastering NOW (in 2025) to be ready for GitHub Agent HQ when it becomes generally available? What skills are foundational vs. what can I learn later?"

Expected Learning Outcome:

After exploring with AI, you should understand:

Multi-Agent Coordination Benefits: Multiple AI agents working in parallel (Claude on database, GPT-4 on API, Gemini on tests) complete projects faster than sequential single-agent work. GitHub coordinates which agent works on which branch.
Git Fundamentals Transfer: The branches, commits, and pull requests you learned work identically with multiple agents. Agent A creates branch db/schema, Agent B creates api/endpoints, Agent C creates tests/integration—same Git concepts you practiced, scaled to multiple agents.
Your Role Evolution: You shift from "write specification → one AI generates code → you validate" to "write specification → GitHub coordinates multiple agents → you validate integrated result." Validation skills stay critical.
Mission Control Interface: GitHub Agent HQ provides unified dashboard where you assign work to agents, monitor progress, and approve merges—similar to how you review pull requests now, but with agent orchestration added.
No Obsolescence Anxiety: Git fundamentals (Lessons 1-7) remain unchanged. Agent HQ adds orchestration convenience on top. If you're comfortable with Git workflows now, you'll adapt to Agent HQ in hours (not months). Focus on mastering specifications and Git safety—these skills are permanent foundations.

Remember: Agent HQ is aspirational (not yet GA)—focus on mastering specification-driven development and Git workflows today. Agent HQ will be an evolution, not a revolution.

Optional Stretch: Ask AI to generate a multi-agent project plan for a more complex application (e.g., web app with frontend, backend, database, tests). Have AI specify which specialized agent would handle which component and how branches would coordinate their work. This thought experiment deepens your understanding of multi-agent orchestration benefits without requiring Agent HQ access.

Part A: The Capstone Project (90 minutes)​

Project Overview: Personal Task Manager CLI​

Step 1: Write Specification BEFORE Code (20 minutes)​

Understanding Specification-First Development​

Create spec.md​

Step 2: Initialize Git Repository (5 minutes)​

Apply Pattern 1 from Lesson 6: "Commit Before Experiment"​

Step 3: AI Generates Code from Specification (15 minutes)​

The AI Generation Prompt​

Understanding AI's Role​

Step 4: Commit AI-Generated Code (5 minutes)​

Step 5: Test & Create Improvement Branch (15 minutes)​

Validation Against Spec​

Apply Pattern 2: "Branch for Improvements"​

Step 6: Merge and Push to GitHub (15 minutes)​

Merge Feature Branch to Main​

Apply Pattern 3: "Push for Backup"​

Step 7: Create Pull Request with AI Transparency (10 minutes)​

Create PR on GitHub​

Step 8: Validate Complete Workflow (5 minutes)​

Git History Validation​

Success Criteria Validation​

Part B: GitHub Agent HQ Awareness (30 minutes)​

Understanding GitHub Agent HQ: The Platform Evolution​

What You Just Learned vs. What's Coming​

GitHub Agent HQ: 5 Core Concepts​

1. Mission Control: Unified Interface for Multiple AI Agents​

2. Multi-Agent Orchestration: Specialized Agents Working Together​

3. Branch Controls for Agent-Generated Code​

4. Agentic Code Review: AI Reviewing AI​

5. Platform Evolution: GitHub as AI Coordination Layer​

How This Relates to Your Learning​

Foundation Skills Don't Change​

You're Prepared for the Multi-Agent Future​

You're Prepared—Don't Let Platform Evolution Cause Anxiety​

Common Fear: "Will My Skills Become Obsolete?"​

Timeline: When Does This Matter?​

Key Confidence Message​

Official GitHub Agent HQ Resources​

Capstone Reflection: What You've Accomplished​

Technical Mastery​

Professional Practices​

Platform Evolution Awareness​

Try With AI​

Part A: The Capstone Project (90 minutes)

Project Overview: Personal Task Manager CLI

Step 1: Write Specification BEFORE Code (20 minutes)

Understanding Specification-First Development

Create spec.md

Step 2: Initialize Git Repository (5 minutes)

Apply Pattern 1 from Lesson 6: "Commit Before Experiment"

Step 3: AI Generates Code from Specification (15 minutes)

The AI Generation Prompt

Understanding AI's Role

Step 4: Commit AI-Generated Code (5 minutes)

Step 5: Test & Create Improvement Branch (15 minutes)

Validation Against Spec

Apply Pattern 2: "Branch for Improvements"

Step 6: Merge and Push to GitHub (15 minutes)

Merge Feature Branch to Main

Apply Pattern 3: "Push for Backup"

Step 7: Create Pull Request with AI Transparency (10 minutes)

Create PR on GitHub

Step 8: Validate Complete Workflow (5 minutes)

Git History Validation

Success Criteria Validation

Part B: GitHub Agent HQ Awareness (30 minutes)

Understanding GitHub Agent HQ: The Platform Evolution

What You Just Learned vs. What's Coming

GitHub Agent HQ: 5 Core Concepts

1. Mission Control: Unified Interface for Multiple AI Agents

2. Multi-Agent Orchestration: Specialized Agents Working Together

3. Branch Controls for Agent-Generated Code

4. Agentic Code Review: AI Reviewing AI

5. Platform Evolution: GitHub as AI Coordination Layer

How This Relates to Your Learning

Foundation Skills Don't Change

You're Prepared for the Multi-Agent Future

You're Prepared—Don't Let Platform Evolution Cause Anxiety

Common Fear: "Will My Skills Become Obsolete?"

Timeline: When Does This Matter?

Key Confidence Message

Official GitHub Agent HQ Resources

Capstone Reflection: What You've Accomplished

Technical Mastery

Professional Practices

Platform Evolution Awareness

Try With AI