Engineering methodology for deploying AI systems with operational discipline.

A system that ships predictably beats one that demos brilliantly.

Flagship:Animus — AI operating environment. Local-first, multi-agent, evidence-graded maturity. 13,500+ public package tests plus internal coverage ratchets, six-layer architecture, autonomous improvement via Citizens (Architect, Conversation Designer, Knowledge Curator, Session Steward, Test Oracle).

Shipped tools:

• ai-spend — htop for AI spend. Cross-provider cost aggregation (Anthropic, OpenAI, OpenRouter). pip install ai-spend
• mcp-manager — MCP server lifecycle manager across Claude Code, Cursor, Windsurf. pip install arete-mcp
• ai-skills — Production-ready skills for agent orchestration and Claude Code personas

Methodology:the-human-stack — Evidence-graded engineering reference (E0–E5), benchmark methodology, failure taxonomy

Infrastructure:

• arete-evals — LLM eval suites with bootstrap A/B comparison and rubric-based scoring
• agent-lint — Workflow YAML cost estimator + anti-pattern linter for agent orchestration
• context-hygiene — Heuristic context-window analyzer with position-decay scoring

How the pieces fit. Solid lines = active integration. Dashed lines = methodology guidance or historical extraction.

flowchart TB
subgraph Flagship["FLAGSHIP"]
Animus[Animus<br/>AI Operating Environment]
end
subgraph Ring1["CORE TOOLS — orbit Animus"]
direction LR
AISPEND[ai-spend<br/>Cost Observability]
MCPMGR[mcp-manager<br/>MCP Lifecycle]
EVALS[arete-evals<br/>Eval Pipeline]
LINT[agent-lint<br/>Workflow Governance]
HYGIENE[context-hygiene<br/>Context Quality]
SKILLS[ai-skills<br/>Agent Capabilities]
end
subgraph Ring2["METHODOLOGY — governs all"]
direction LR
THS[the-human-stack<br/>Evidence-graded reference]
NOTES[notes<br/>Cross-session memory]
CI[ci-templates<br/>Reusable CI]
end
subgraph Ring3["HISTORICAL — extracted into Animus"]
direction LR
MEMBOOT[memboot<br/>→ AST chunking]
ANCHOR[anchormd<br/>→ Pattern extraction]
end
AISPEND -->|"spend data"| Animus
MCPMGR -->|"server registry"| Animus
EVALS -->|"benchmark results"| Animus
LINT -->|"workflow checks"| Animus
Animus -->|"orchestrates"| SKILLS
THS -.->|"guides"| Animus
THS -.->|"guides"| AISPEND
THS -.->|"guides"| LINT
MEMBOOT -.->|"upstreamed"| Animus
ANCHOR -.->|"patterns archived"| NOTES

Most AI projects ship as demos and die in production. The failure modes are boringly consistent: costs spiral because no one tracks token spend, pipelines break halfway through and restart from scratch wasting compute, and multi-agent systems bottleneck on a single supervisor that burns tokens just watching. These aren't capability problems — they're operational problems.

The Human Stack is my response: a living engineering methodology that treats AI systems as operational systems. Every claim is evidence-graded (E0–E5). Every architectural choice is append-only, dated, and cross-referenced in an ADL. Every tool carries adversarial tests before it ships. The methodology is public in the-human-stack.

The Arete Stack is its implementation — the tools I actually build and maintain. Each repo maps to a layer of the methodology: skills for session discipline, cost observability for spend anomalies, governance linting for workflow anti-patterns, orchestration for autonomous improvement, and the methodology reference itself. This profile is arranged as an onion — start at the outer layer and peel inward.

Before software I spent 17 years in manufacturing and logistics (IBM, Toyota Production System). That discipline shows up in every codebase: standard work, visual management, error-proofing, continuous improvement.

Substack · LinkedIn · jamesyng79@gmail.com

Every post is grounded in a repo. Every repo is explained in a post.

• I Oversaw Scaling a Portland Ice Cream Line to 4,800 Pints Per Hour. AI Engineers Keep Making the Same Mistakes. — Manufacturing discipline applied to production AI: waste visibility, checkpoint/resume, and error-proofing before error-catching. (Methodology: the-human-stack · Implementation: Animus Session Controller)
• The Eval Is the Product — Why evaluation infrastructure matters more than model choice. (Tool: arete-evals · Integration: Animus Forge)
• Local-First AI Stack — Zero-cost inference with Ollama on consumer hardware. (Stack: RX 7900 XTX + 4-model tier · Budget tool: ai-spend)
• Decision Logging as Operational Memory — The ADL methodology: append-only, evidence-graded, revisit-conditioned. (Practice: notes/decisions)

These are the repos I keep closest to release quality — evidence, tests, and documentation first.

Hobby projects (EVE Online lore, personal context servers) are kept private. What you see here is what I ship.

The fastest way to understand the methodology is to use it. These repos are arranged as an onion — start at the outer layer and peel inward.

Animus is the primary reference implementation — a personal AI operating environment with local-first control and evidence-graded maturity tracking.

Key design decisions (visible in the code):

• Evidence Framework — Six-stage maturity model (Concept → Self-improving) with Coverage KPI. Makes "documented but unverified" into "inspectable evidence."
• ADL-governed architecture — Every major decision is append-only, dated, and cross-referenced. No tribal knowledge.
• Quality gates before merge — Deterministic scoring (tool/completeness/structure) with adversarial test harness. Features don't ship without gate passage.

• Decision logs, not memory. Every architectural choice is an ADL entry — rationale, rejected options, tradeoffs, kill criteria.
• Tests are deliverables. Not an afterthought. Adversarial tests prevent regression of quality-gate contracts.
• Local-first where possible. RX 7900 XTX inference stack (Ollama, 4-model tiered) for zero-cost eval calibration.
• Ship, measure, error-proof, repeat. Kaizen learned from scaling an ice-cream line 6× — applied to software.

I develop primarily with Claude Code (Anthropic's CLI for Claude). Think of it as pair programming with a fast, literal pair — not autonomous AI.

What that means:

• Every commit is human-reviewed. The claude contributor in git history is the application, not a person.
• Every test is human-verified. Coverage numbers reflect assertions I wrote and ran.
• Every architectural decision is logged in the ADL with rationale, rejected options, and tradeoffs.
• AI accelerates implementation; humans own validation, integration, and shipping.

Why this matters: AI-assisted development is becoming standard. What differentiates engineering discipline from cargo-culting is the verification layer: adversarial tests, evidence-graded maturity, and append-only decision logs. The code works because I test it. The methodology holds because I revisit it.

Direct entry points for "what does the code actually look like":

• Animus Kernel — bitemporal memory + adversarial tests — v2.3 scaffold: valid-time / transaction-time axes, quality-gate contracts enforced before any feature ships. Architect Citizen produces ImprovementProposals from codebase observation.
• ai-spend — OpenRouter provider — GET /api/v1/generations pagination with native_cost fallback to token-based estimates. Pattern: provider registry ABC with side-effect registration.
• Animus Session Controller — Token-budgeted session lifecycle (96% utilization trigger), graceful finalization with model-generated summary, checkpoint + auto-restart. 22 focused tests, with head-core regression coverage.
• Animus P5 Discovery — MCP scanner, OpenAPI ingestion, annotated script discovery, 4-dimension schema validator, hash deduplication. 41 focused tests, with P0-P5 regression coverage.

17 years in manufacturing and logistics operations (IBM, Toyota Production System). Scaled an ice-cream production line from 740 pints/day to 4,800/hour using Kaizen. Now apply the same discipline to AI infrastructure: standard work, visual management, error-proofing, continuous improvement.

See it through. Do it better. Leave something real.