Unfollow the herd —
AI is a bad architect but a world-class builder.

The context package is the memory. How you deliver it evolves.

The AI has no memory between sessions. The context package — every source file, every document, every plan — is the memory. This rule has three eras.

Era 1 — The Zip File Era. It started as literal zip files. A context archive manually assembled at the start of every session, refined session by session. Clunky. Manual. And it worked well enough to build a production-grade Rust SDK with 2,150 passing tests. If you skip this step in Era 1, you spend the first twenty minutes correcting misunderstandings that would not have existed if you had just uploaded the files.

Era 2 — The GitHub Era. Once GitHub integration was established, the zip file became unnecessary. A GitHub token given at the start of a session lets the AI clone the full repository — complete history, all files, all commits — in seconds. GitHub becomes the persistent memory. Every commit becomes a checkpoint. The context package doesn't disappear — it becomes version-controlled, always current, always recoverable. New session: give the token, clone the repo, continue exactly where the last session ended.

Era 3 — The Enforcement Era. The first two eras were about memory — how the AI holds context. The third is about discipline that does not depend on the human remembering to apply it. In Era 1 and Era 2, the architect enforced the rules: you demanded the audit, you verified the docs, you caught the duplicate. It worked because one person was watching everything. But discipline that lives in one person's attention has a ceiling — it erodes under fatigue, it does not scale past one operator. So the rules were encoded into the toolchain. "Demand an audit" became a gate that runs on every commit. "Verify the docs match the code" became a check that fails the build when a claim outruns the code. "CI proves it compiles" became a rule that blocks non-compiling code from merging — for everyone, including the founder. 35 automated gates. A protected main branch nobody can bypass. The manual disciplines became machines. That is what lets ZipCoding survive its own success — a methodology enforced by attention is a solo act; a methodology enforced by structure is one others can join.

The constant across all three eras: the AI cannot reconstruct context it was never given. Whether you deliver it as a zip archive or a GitHub clone — deliver it. The context package is the system.

You decide. The AI executes.

Never ask the AI what to build. Always tell it precisely what to build. The AI is excellent at generating plausible-sounding architectural decisions. Plausible is not the same as correct. The specification is built before the first session precisely so that architectural decisions are already made when the session begins. The moment you ask open-ended questions, the quality drops. The methodology only works when the architect arrives with decisions already made.

The spec is the law. Always verify alignment.

The specification is not a suggestion. It is what the AI cannot override. At every session, outputs are verified against the spec — not just for technical correctness, but for constitutional alignment. When the code diverges from the spec, the code is wrong. Security audits were demanded regularly. The question was always the same: does this output align with the source of truth? If not, the session is not over.

How it matured. “Demand a security audit regularly” was a manual act. It is now automatic too. Standing gates check alignment on every commit — a claims-consistency gate that lets stated claims only shrink, never inflate; a version-consistency gate; an endpoint-classification gate. The human still demands audits; the machine demands them every time, unasked.

Push back when the AI says it can't

The AI sometimes declines. Recommends against proceeding. Says something isn't possible or isn't advisable. Treat it like a brilliant but conservative engineer — fast, capable, often right, but not the source of authority; prone to cautious defaults when pushed into unfamiliar territory. Sometimes it is right to push back. Sometimes it has already done the thing it claims it cannot do, in a previous session, and simply needs to be reminded. The discipline is to distinguish between genuine technical blockers and conservative defaults. Don't accept "can't" without examining whether it means "won't" or "hasn't tried."

Complete files only. Verify before accepting.

Every session ends with complete, deliverable files — not patches, not diffs, not "the changes you need to make." The whole file, verified, ready to use. For Rust: syntax check every file, count tests, check for duplicate function names. For documentation: verify against the code, not the spec. If the code does not have the feature, the documentation does not describe it as present. Partial handoffs accumulate invisible debt.

How it matured — the honest part. This is the rule most vulnerable to AI-assisted speed. Code arrives faster than a human can re-verify every document against it, and documentation drifts ahead of reality. That drift happened. It was caught, repeatedly, then engineered against: a gate now fails the build when documentation claims what the code does not deliver. The rule you are most likely to break under velocity earned its own machine to catch you.

Protect the toolchain. GitHub is the persistent memory.

The workflow must be compatible with what the AI can actually work with. ZipCoding is tool-agnostic — built entirely through a chat interface with no local development environment required. Every tool in the chain must be accessible within the session itself. CI/CD handles compilation automatically. The AI writes the code. The CI proves it compiles. The human verifies the output. Design the workflow so every step can be completed without leaving the session.

As the methodology evolved, GitHub became the backbone of the toolchain — not just for version control, but as the persistent memory layer that survives between sessions. A repository with a committed history, connected via a token, means a new session inherits the full context of every previous session instantly. No zip files. No manual assembly. Clone, continue, commit. The repo is the ground truth. Every commit is a verified checkpoint. This is what makes ZipCoding scale beyond a single project — the discipline of committing verified output after every session compounds into an auditable, recoverable, always-current system.

How it matured. “CI proves it compiles” became “CI blocks what doesn't.” Main is governed by a protection rule with a required check, an empty bypass list, and no force-push. Broken code cannot land — not “should not,” cannot — and the gate applies to everyone, the founder included.

Name everything once. No orphaned files.

File names, function names, crate names, API routes — establish them in the first session and do not change them without discipline. The AI finds things by name. Inconsistent naming means parallel implementations of the same thing appear without warning. If a file is in the context package, it is the authoritative current version. If it is not in the package, it does not exist. The context package is the ground truth.

How it matured. Naming is no longer held by attention alone. Duplicate-detection and version-consistency gates fail the build when parallel implementations or mismatched versions appear across surfaces. The parallel implementation that shows up without warning now shows up as a red check first.

Verify in a separate lane. The builder does not certify the build.

The most dangerous moment in AI-assisted development is not when the AI is wrong. It is when the same session that wrote the code also declares it correct. Confidence is not verification.

Separation of build and audit is old discipline — aviation, finance, and security engineering have always kept the two apart. ZipCoding adopts it against a specific new failure mode: an AI session that produces work and, in the same breath, vouches for it. So the lanes are split. One builds. A second, independent lane audits — reading the actual source, running the actual sequences, checking the claim against ground truth rather than against the story the first lane told.

This is not redundancy. It is the recognition that a self-certified build hides its own worst failures. On this project, an independent lane found a governance bypass a first pass had called minor — located only because a separate reviewer returned to the source and ran the exact case the first review skipped. Nobody grades their own homework. Not the human alone. Not the AI alone. Not the session that produced the work.