Mythical Man-Month in the Age of AI: A Linux Workflow

What is Prerequisites and Setup and Mythical Man-Month Ai - and why does it matter for Mythical Man-Month in the Age of AI?

When exploring mythical man-month AI, this workflow assumes a Linux host running Ubuntu 24.04 LTS or Debian 12 (Bookworm). Both ship with the toolchain versions required to track AI-assisted development work using git notes and Python tooling. Verify your baseline before installing anything else. You may also find our guide on UFW vs IPTables: Rule Simplicity and Firewall Performance Co... helpful.

Check Required Versions

Git 2.43 or newer is needed for stable git notes behavior across merges, and Python 3.11 or newer is required for the orchestration scripts used later. Confirm both:

git --version    # expect 2.43.0 or higher
python3 --version  # expect 3.11 or higher

Ubuntu 24.04 ships git 2.43.0 and Python 3.12.3 by default. Debian 12 ships git 2.39.5 and Python 3.11.2, so upgrade git from backports if needed:

sudo apt update
sudo apt install -y git python3-venv jq

# Debian 12 only: pull git 2.43+ from bookworm-backports
sudo apt install -y -t bookworm-backports git

The gh CLI is optional but useful for pulling issue metadata into commit notes. Install it if you plan to link work items to AI-assisted commits:

sudo apt install -y gh
gh auth login

Create a Scratch Clone and Enable AI Notes

Work in a disposable clone so experiments with notes refs do not pollute your primary repository. The refs/notes/ai namespace keeps AI provenance separate from ordinary commit messages and review notes.

mkdir -p ~/mm-ai-lab && cd ~/mm-ai-lab
git clone https://github.com/torval

What is Instrumenting AI-Assisted Commits with Git Notes - and why does it matter for Mythical Man-Month in the Age of AI?

To measure whether AI tooling actually compresses delivery time, you need commit-level provenance that survives rebases, cherry-picks, and history rewrites. Git notes handle this cleanly: they live outside the commit object, so amending a commit does not destroy the annotation.

Step 1: Tag commits with a prepare-commit-msg hook

Save the following to .git/hooks/prepare-commit-msg and run chmod +x on it. The hook appends a trailer whenever the AI_ASSISTED environment variable is set, which your wrapper script or shell profile exports when an AI agent (Claude Code, Copilot CLI, Aider) staged the change.

#!/usr/bin/env bash
# .git/hooks/prepare-commit-msg
COMMIT_MSG_FILE="$1"
if [ -n "$AI_ASSISTED" ]; then
  grep -q '^AI-Assisted:' "$COMMIT_MSG_FILE" || \
    printf '\nAI-Assisted: %s\n' "$AI_ASSISTED" >> "$COMMIT_MSG_FILE"
fi

Export the model identifier before committing:

export AI_ASSISTED="claude-sonnet-4-20250514"
git commit -m "refactor: extract retry helper"

Step 2: Mirror the trailer into refs/notes/ai

Trailers are greppable but fragile across squashes. Mirror them into a dedicated notes ref with a post-commit hook:

#!/usr/bin/env bash
# .git/hooks/post-commit
TAG=$(git log -1 --format='%(trailers:key=AI-Assisted,valueonly)' | tr -d '\n')
[ -n "$TAG" ] && git notes --ref=ai add -f -m "$TAG" HEAD

Step 3: Export per-author and per-tag totals with jq

Measuring Coordination Cost Against Team Size

Brooks's Law is empirically testable. If adding contributors to a project inflates coordination overhead faster than it accelerates delivery, cycle time will rise with team size. Measure that slope directly.

Step 1: Export merged PR cycle times

Pull merged pull request data from your tracker into a CSV with two columns: merged_at and cycle_hours (time from first commit to merge). Most trackers expose this via API. For GitHub, use the gh CLI (v2.40+) with jq:

gh pr list --state merged --limit 500 \
  --json number,createdAt,mergedAt,commits \
  | jq -r '.[] | [.number, .createdAt, .mergedAt] | @csv' \
  > prs.csv

Step 2: Join cycle time with git notes counts

Git notes track review annotations and coordination touchpoints per commit. Count notes on each PR's merge commit and join them to the CSV:

import csv, subprocess

rows = []
with open("prs.csv") as f:
    for r in csv.DictReader(f):
        notes = subprocess.run(
            ["git", "notes", "list", r["merge_sha"]],
            capture_output=True, text=True).stdout.count("\n")
        rows.append({**r, "notes": notes})

with open("joined.csv", "w") as f:
    w = csv.DictWriter(f, fieldnames=rows[0].keys())
    w.writeheader(); w.writerows(rows)

Step 3: Plot and fit

Aggregate cycle time by the number of active contributors per week, then fit a linear regression with numpy (1.26+) and matplotlib (3.8+):

pip install numpy==1.26.4 matplotlib==3.8.4 pandas==2.2.2

Deciding When to Stop Scaling

Scaling contributors only pays off while coordination overhead stays flat. Define a threshold: when cycle time grows faster than contributor count, stop adding agents. Track both weekly with a simple git log metric.

# cycle time: median hours from first commit to merge, last 4 weeks
git log --merges --since="4 weeks ago" --pretty=format:"%ct %cI" \
  | awk '{print $1}' | sort -n | awk '{a[NR]=$1} END {print a[int(NR/2)]}'

# contributor growth: distinct authors per week
git shortlog -sn --since="4 weeks ago" | wc -l

If median cycle time rose 40 percent while contributors rose 15 percent, the curve has inverted. Redirect investment instead of adding parallel workers:

• Review automation: wire pre-commit and ruff into CI so human review handles design, not lint.
• Interface contracts: pin shared schemas with jsonschema or protobuf so parallel work cannot drift.
• Smaller

  Frequently Asked Questions

  Does the mythical man-month still apply when AI generates most of the code?

  Yes. AI reduces typing time but not integration, review, or specification time. Those costs scale with the number of parallel contributors, so coordination overhead still dominates past a small team size.

  How do I measure AI-assisted versus manual work in a Linux repo?

  Attach metadata to commits with git notes, tagging each commit as ai-assisted or manual, then aggregate with git log --format or a short Python script. This keeps the measurement inside the existing git history.

  What tooling do I need to test Brooks's Law on my team?

  Git, Python 3.11 or newer, and access to your issue tracker API for cycle-time data. No external SaaS is required; a CSV export from your tracker is sufficient.

  When should I add an AI agent instead of a developer?

  Add capacity only while merged cycle time stays flat as contributors increase. If cycle time rises faster than contributor count, adding agents or people worsens delivery, so invest in interfaces and review automation instead.

  What is Mythical Man-Month in the Age of AI?

  Track AI-assisted commits with git notes and a small Python script, then compare merged PR cycle time against team size. When cycle time grows faster than headcount, stop adding people or agents and fix communication paths instead.

  Key point 1: what should readers know about Mythical Man-Month in the Age of AI?

  Brooks's Law applies to AI agents as much as humans: communication paths grow as n(n-1)/2.

  Key point 2: what should readers know about Mythical Man-Month in the Age of AI?

  Instrument commits with git notes to separate AI-assisted from manual work before estimating.

  Key point 3: what should readers know about Mythical Man-Month in the Age of AI?

  Use cycle-time slope versus team size as the empirical test for when to stop scaling.