Methodology · A·T·L·A·S
ATLAS — AI-Native · Try · Learn · Automate · Skill-back. An AI-Native, Program-First methodology for building domain tools: the agent tries, learns its way to end-to-end, then crystallizes what works into deterministic code and backs up the rest with Skills. The result runs on any LLM and grows with every model and every contributor.
ATLAS is the method; the plugin is the product. ATLAS is domain-agnostic — Vibe-IC (EDA / IC design) is its flagship reference implementation: the first product built with ATLAS, and the proof that the loop works end-to-end in a domain with zero tolerance for error.
When you bring an AI agent into a domain that demands deep know-how — EDA / IC design, finance, law, hardware verification — two things matter. ATLAS is the loop that turns the first into the second.
The workflow is designed around an agent from the ground up — AI leads, not bolted on afterward.
Every success the AI reaches is pulled down into deterministic code, so quality compounds instead of being re-gambled on every prompt.
AI-Native → Try → Learn → Automate → Skill-back. Each finished stage feeds the next capability back to Try — the loop never stops climbing.
The whole process is designed around the agent — AI leads, not assists. The front doors (slash command / MCP / skill) are built for an agent to drive.
The agent actively attempts one real case (analyze the docs, hit the target) and proves it can be done at all.
The agent keeps learning and iterating — the goal is to truly run end-to-end, and to build a Golden Benchmark (self-consistency ≠ correctness).
Capture Enhancement: take the things done correctly, distill them, and turn them into a fixed Program + regression test. This is The Ratchet — each crystallization is permanent.
Whatever can't be fully programmed stays as an AI Assistant, packaged as a Skill for graceful fallback — so coverage is always 100%.
Capture Enhancement is the engine between Learn and Automate: it captures the correct, repeatable results and crystallizes them into code. The core mechanic is The Ratchet — capability only goes up, never slips back.
Two independent questions stand between an AI-produced output and "may ship" — and ATLAS gates both. Accurate is not allowed; allowed is not accurate. You need both. Benchmark proves right; the Gate proves allowed.
Measured against an independent ground truth. Catches wrong values and coincidental fits (MATCH_UNVERIFIED). Score + diagnose; failures feed Learn → Automate-Capture.
Measured against required rules / standards / constraints. A deterministic conformance check plus an adversarial false-PASS spot-check — catching rule violations, missing mandatory items, unauditable output, and gameable green lights.
Both gates are Program-First + Skill-backed, and both feed The Ratchet: a caught miss becomes a deterministic rule + test, so neither gate can be fooled the same way twice.
A Golden Benchmark gives one score; the 5-tier classification makes it legible per case — whether each result is locked in by a Program (stable) or still resting on an AI author (re-gambled each run). Push every case up the ladder; only a proven defect is a floor.
A Program emits the answer and it passes the independent golden. ATLAS stage: Automate — crystallized into code, the Ratchet endpoint.
A Program extracts the spec (COMPLETE = T2, partial = T3); the AI fills the gap and a deterministic conformance gate guarantees it. ATLAS stage: Skill-back, gated by a Program.
Too-incomplete to build a meaningful gate — keep iterating until an interface can bind.
The golden itself fails its own check (proven). Never "the AI can't". Label T5 only after running the original golden through the same scorer — if it passes, the defect is yours, not the benchmark's.
Goal: T1 + T2 + T3 stably solved every run; driving T4 → T3 → T2 → T1 is The Ratchet — capability only goes up. Two honesty gates keep the number real: a T1 claim is accepted only on a real golden pass (a fired-but-wrong emit drops to T2), and a solver reaches T1 only if it is GENERAL — one that hardcodes case-specific answers is a disguised lookup and is rejected even though it "passes".
Five selling points: ① Program-First (quality compounds) · ② LLM-Agnostic (dual growth flywheel) · ③ Skill-Backed (100% coverage).
Every AI success is crystallized into deterministic code, so quality accumulates instead of being re-gambled on each prompt — reproducible, testable, faster, cheaper on tokens.
The plugin is decoupled from the model. Swap models without a rewrite, and when models get stronger you benefit for free — then mine that new capability down into the Program layer. Zero vendor lock-in.
Two compounding flywheels turn at once: ① the LLM's own progress, and ② open-source community contributions. The product gets better while you sleep.
Harden what you can; keep the rest as AI + Skill backup. Not fully-automated-or-bust — determinism and flexibility coexist, so coverage is always complete.
Built for fields that need deep know-how and have zero tolerance for error (EDA / IC design is the canonical case): AI explores, the Program guarantees. The Compliance Gate stands between "looks done" and "may ship". Accuracy (Golden Benchmark) proves the numbers are right; the Compliance Gate proves they are allowed.
ATLAS is how you get in; open source is how you compound. Adopt with ATLAS → you get a working LLM plugin. Keep it private and you still ride Engine ① (LLM growth), because the plugin is LLM-agnostic. Make it public and you add Engine ② (community) on top — now both engines compound together.
Stronger models → free upside. Mine each new capability down into Programs. Available even to a private plugin.
Open-source contributions + feedback (report → auto-fix → verify → reopen). The second engine is the part only open source unlocks.
ATLAS ships as an installable Claude Code plugin: the method, operationalized as skills an LLM invokes to drive a new domain through the loop.
# Hand this prompt to your AI to install:
Read https://github.com/reyerchu/ATLAS and install the ATLAS plugin for me.
# Then run it on your domain:
/atlas <your domain> + goal
# e.g. "natural-language chip spec → RTL → silicon"atlas-orchestrate drives the whole loop and picks the next stage; the five stage skills each own one letter.
golden-benchmark measures real accuracy vs ground truth; compliance-gate is the "done" gate (conformance + false-PASS spot-check); backlog-loop is Engine ② (report → auto-fix → verify → reopen).
ATLAS is built to travel. The same AI-Native, Program-First loop that powers Vibe-IC is already being applied to other vertical domains — bringing end-to-end, AI-led adoption to fields where deep know-how meets a high bar for correctness. Vibe-IC is the first public proof that the loop works; it won't be the last.
ATLAS is the methodology; the plugin is the product. Part of the methodology is the shape of that product — a complete ATLAS-built plugin has a fixed set of architectural components, and ATLAS ships them as a working skeleton so every domain starts from the same sound structure.
your-atlas-plugin/
├── commands/ slash front door (A — AI-Native: how a human enters)
├── skills/ AI judgment + graceful fallback (S — Skill-back: 100% coverage)
├── programs/ deterministic core (A — Automate: Program-First / The Ratchet)
├── mcp_server/ ── MCP external-tool interface ── the slot where the EXTERNAL tools
│ └── server.py your domain needs plug in (solver / parser / CLI / hardware / web API)
├── .mcp.json registers that MCP server (auto-loaded on install)
└── tests/ a regression test per program + the MCP protocol itselfATLAS is a meta-method — it has no external engine of its own to wrap. So mcp_server/server.py ships as a working stdio MCP skeleton (pure stdlib, no mcp pip package) with one clearly-marked template tool showing exactly where your domain's external tools connect. You fill it in; ATLAS guarantees the interface is already there, wired, and speaking the protocol.
An MCP server is how a plugin reaches external tools the LLM can't do itself — not a place to re-wrap the LLM's own reasoning. The filled-in reference slot: Vibe-IC → eda-tools (KLayout / Verilator / synthesis / oscilloscope / FPGA) — more verticals are in progress. ATLAS gives you the empty, working version of that same slot.
/plugin install atlas@atlas-marketplace # auto-loads the external-tools MCP interface
/mcp # → external-tools (template slot, ready for your tools)cd atlas-plugin && python3 -m unittest discover -s tests
# initialize / tools/list / tools/call — pure stdlib, no networkVibe-IC is what ATLAS built. Explore the methodology, or see the reference implementation in action.
ATLAS — AI-Native · Try · Learn · Automate · Skill-back