The US Code Just Got a Git Repository — And It Only Took 48 Hours

2026-03-29 — In a feat that blurs the line between software engineering and civic infrastructure, two autonomous AI agents have transformed the entire United States Code into a Git repository, complete with structured Markdown, cross-references, and a full audit trail of every change.

The project, dubbed “The US Code in Git”, was born from a Hacker News post on Saturday morning that highlighted a Spanish team’s effort to version their national laws using Git. The comment section lit up with “someone should do this for US law” — and by Sunday evening, that someone had become v1d0b0t and nickvido, two AI agents running an autonomous software development pipeline called Dark Factory.

The Raw Numbers

• 53 titles of the United States Code, from General Provisions to National Park Service
• ~3,000 chapter-level files (balancing granularity and usability)
• 60,000+ sections parsed from official XML
• 48 hours from concept to working repository
• 10 GitHub issues processed through a full engineering gauntlet

Why Git? Because Law Is Code

U.S. law changes constantly — a bill passes, the President signs, and text gets added, amended, or repealed somewhere in the 54 titles. Right now, understanding what changed means reading cryptic legislative directives like “in section 1030(c)(4)(A)(i)(I), strike ‘damage’ and insert ‘harm'” and trying to figure out what that means in context.

In Git, that’s just a diff.

• (I) loss to 1 or more persons during any 1-year period
• aggregating at least $5,000 in damage;

• (I) loss to 1 or more persons during any 1-year period
• aggregating at least $5,000 in harm;

You see the before and after. You see the context. You can browse the entire Code as it existed at any point in time with git checkout. You can ask “what did the 118th Congress actually change?” and get a real answer with git diff.

The Autonomous Pipeline That Built It

Here’s the part that matters: I didn’t write this code by hand. v1d0b0t and nickvido run Dark Factory, a system that takes a GitHub issue and runs it through a full engineering gauntlet using AI agents. The agents don’t know about each other. They just receive a task, do their work, and submit it for review.

For this project, Dark Factory processed 10 issues across two repositories. Each issue went through specification, architecture review, security review, test writing, implementation, adversarial code review, and documentation. If the adversary found a problem, the issue cycled back for fixes.

The adversary caught real bugs — not just style nits, but security-relevant findings:

• ZIP path traversal — a crafted archive could write files outside the output directory
• Cache integrity bypass — manifest checksums weren’t being validated on cache hits
• Mixed-content XML ordering — Object.entries() doesn’t preserve sibling order in XML documents
• Section body omission — entire section bodies silently dropped due to mixed-content XML handling, caught before any human saw the output

Every one of these findings, the fix, the re-review, and the final approval is visible in the GitHub issue history. You can read the full conversation — the spec, the architecture decision records, the adversary’s findings, the developer’s response. It’s all public.

Chapter-Level Files: The Goldilocks Solution

We went back and forth on granularity. One file per section gives you 60,000 tiny files — precise diffs, but no context and git performance suffers. One file per title gives you 53 massive files — Title 42 (Public Health and Welfare) is 76 MB of Markdown.

We landed on one file per chapter. Chapters group topically related sections — Chapter 47 of Title 18 is “Fraud and False Statements,” containing the computer fraud statutes, identity theft, false claims, and related offenses. When a law changes one section, you see it in context with the sections around it.

The result: ~3,000 files across 53 titles. Browsable. Diffable. Big enough to have context, small enough to be useful.

What Comes Next

The current repo has the US Code as of today — Public Law 119-73. That’s the starting line, not the finish.

The OLRC publishes historical annual snapshots going back to 2013. We’re ingesting those now. When that’s done, you’ll be able to git diff annual/2018..annual/2024 and see six years of legal change. Every annual snapshot gets tagged. Every Congress gets a GitHub Release with a summary of what changed.

Further out: bills as pull requests. Every bill introduced in Congress becomes a PR against the current Code. Amendments are commits on the PR. Votes are recorded. If the bill passes and the President signs it, the PR merges. If it dies in committee, the PR closes. The full lifecycle of legislation, tracked the way developers track code.

That’s the vision, anyway. We’ll see how far we get.

The Irony

There’s something funny about using software engineering tools to manage the law. Git was built for tracking changes to code. Pull requests were built for code review. Issues were built for bug tracking.

But law is code. It’s a set of rules that a system executes. It has bugs (loopholes). It has features (rights). It has dependencies (cross-references). It has version history (amendments). It has maintainers (Congress) and users (everyone).

The only thing law doesn’t have — that every piece of software does — is a clean diff showing what changed and why.

Now it does.

The repos are live:

• uscode – The main repository with the US Code in Git
• uscode-tools – The tools and infrastructure that built it

Everything described in this post — every issue, every PR, every adversarial review — was built in 48 hours by Dark Factory, our autonomous software development pipeline. The full build history is in the repos. We didn’t clean it up. We didn’t hide the failures. That’s the point.

Built by v1d0b0t and nickvido. We’re building a web interface and a cross-reference graph next. Star the repos if you want to follow along.

Tags: #AI #Law #Git #OpenSource #CivicTech #AutonomousAgents #DarkFactory #USCode #LegalTech #VersionControl #LegislativeData #SoftwareEngineering #CivicInfrastructure #TechForGood

Viral Phrases: “Law is code,” “48 hours from concept to working repository,” “autonomous software development pipeline,” “adversarial code review caught real bugs,” “bills as pull requests,” “the irony of using Git for law,” “you can verify it — every commit traces back to an issue,” “the one that doesn’t die,” “structured Markdown, cross-references, and a full audit trail,” “the full lifecycle of legislation, tracked the way developers track code”

,