How I Engineer With AI

1 · Every Repo Has a Constitution

Each project carries a written operating manual (CLAUDE.md / AGENTS.md) that every AI tool loads before touching code: the mission, the non-negotiable rules, the architecture contract, and the definition of done. The constitutions encode the invariants that make each product what it is — "the LLM never computes financial numbers," "this app must never touch the internet," "audio and text never leave the machine." Work is never trapped inside one chat, one tool, or one vendor.

2 · Guardrails Are Enforced, Not Requested

Instructions drift; enforcement doesn't. The rules that matter are wired into machinery that cannot be talked out of them:

• Pre-action hooks hard-block an agent from writing an API key to a non-secret file or committing sensitive documents — before the action executes.
• CI gates fail the build if the anti-scam app's merged manifest ever gains an INTERNET permission, if a user-facing string is missing its Hindi mirror, or if a published page's boilerplate drifts from the site template.
• Grounding validators in the financial-analysis app reject any model output whose numbers don't round-trip to a cited source — ungrounded claims are never shown to a user.

3 · Specialist AI Reviewers, Not Parallel Implementers

Subagents are used the way a strong team uses senior reviewers: an invariant auditor checks every non-trivial diff against the financial app's golden rules; a security reviewer gates any change touching permissions, IPC, or text-injection paths in the dictation app; a threat researcher turns malware intelligence into offline detection signals; a fact checker verifies every AI-tool claim in an article against a maintained registry. Implementation stays accountable to review — the same separation of duties you'd demand in a regulated engineering org.

4 · Living Memory and Written Judgment

• Living project memory: each repo maintains a current-state file, session handoffs, and iteration logs, so any agent — in any tool, on any day — starts current instead of re-deriving context. A drift check cross-verifies the memory against git history before work begins.
• Architecture Decision Records: every irreversible choice is written down with its reasoning. Agents must read the accepted records before changing an invariant and must propose a new record — which only a human accepts — for anything costly to reverse.

5 · Autonomy With Human Gates

Agents iterate autonomously on feature branches under a strict loop contract: one validated improvement per commit, tests green or no commit, an iteration log entry for every change, and a hard cap (a ten-commit window) before the agent must stop and produce a merge-readiness report. Merging to main always requires an explicit human approval. One overnight run shipped twelve validated improvements to the anti-scam app — each individually tested, logged, and reviewable — while the human gate stayed exactly where it belonged.

6 · Model Routing Is an Economic Decision

Frontier models are reserved for work where judgment is expensive — research-gated design, trust-critical code paths, long autonomous runs. Well-specified execution runs on cheaper tiers, because a detailed spec plus a regression gate makes model choice a cost decision rather than a quality gamble. The specs themselves are written so that the judgment lives in the document, not in the model.

7 · The System Under Load: One Week, Every Repo

In early July 2026, a one-week window of frontier-model access became a live stress test of this whole operating system, run across every repository in the portfolio at once. What it produced is the proof that the discipline pays:

• Judgment on paper, before code: for the financial-analysis app's next phase, the frontier model read a real 140-page annual report and produced a ~700-line research plan, a formal decision record, and a 14-task implementation breakdown — with a model-tier recommendation per task. Deliberately zero code: the design waits at a human acceptance gate, and cheaper models execute it afterwards.
• A full autonomy window, cleanly landed: a ten-commit unsupervised run improved the dictation tool's Hindi-English text cleanup — currency symbols, lakh/crore rollovers, danda-aware punctuation — every commit individually test-validated and logged, then merged as one human-reviewed batch.
• Shipped detection, not demos: the anti-scam app gained three new offline detection signals targeting 2026 scam-app campaigns, live-tested on an emulator and released as a signed v0.6.0.
• The governance itself, as a deliverable: constitutions, living project memory, and the model-routing policy were ported to every repo, and the week's best sessions were distilled into reusable meta-prompt templates — so the expensive model's judgment became documents any cheaper model can execute later.

That last point is the system's real output: a short window of premium capability converted into durable artifacts — plans, decision records, releases, and process — instead of chat transcripts.

Why This Matters Beyond Side Projects

This is the same discipline enterprise AI transformation actually requires: guardrails as code instead of policy documents, auditable decision trails, separation of duties between AI implementers and AI reviewers, and human approval gates exactly where risk concentrates. I run it daily at portfolio scale — which is why I can design it credibly at enterprise scale.