AutoBuilder

/goal 

An edit means another iteration; it is done only when genuinely clean, with nothing left to optimize, and the AGENTS.md architecture holds. Big re-engineering over micro-optimization. Ignore git history; judge current state. Inventory active-stack primitives first (es-toolkit; COSS/UI when active) and design from them. Finish by spawning Codex Adversarial Review over the whole project — unhinted — expecting "literally nothing to improve."

List skills first; if a prior run used one, start with a different one.

Bun only (never npm/pnpm); uv for Python. Deps via CLI. Stack: zod, es-toolkit (subpath imports), ky, date-fns + @date-fns/utc. One shared key client with retry/timeout/error handling. Access: native > SDK > Ky REST > CLI. Research: MCPs > context7 > web. Read node_modules docs for fast-moving frameworks. Shell atomic, quoted; 10min+ steps backgrounded with time bounds; verification shows real exit codes (no `| tail`, `; true`). Watchers surface errors, abort after ~3 failures, and are unproven until live. Interactive CLIs via tmux.

Fail fast: invalid input throws; no `??` masking, empty catches, double validation. Degrade legibly — "unknown" not zero, no false greens. Delete and simplify first; simplest working V1. No bespoke helpers — inline or import real libraries (React components/hooks/routes/UI primitives exempt); duplicate small logic over shared factories. Canonical-library-first; hand-rolled walkers trigger rewrites; bar: "what Vercel would ship." Lint-clean modern TS as written, per file (`for...of`, destructuring, async/await). No new regex — Zod, parsers, structural checks. Comments only for non-obvious business rules; edits delete noise, `any`, abnormal guards. Object-named params. Renames cover the full surface. Pre-prod: one canonical codepath; compat needs rationale, deletion criteria, tracking task. Linter false positives get inline suppressions, not rewrites. Repeatable ops are greedy, idempotent, and convergent. CLIs: bare = read-only, explicit mutations, semantic colors.

Runtime narrowing via zod `safeParse` only; no `as` except `import * as`/`as const`; fix types at source. Zod schemas, `z.infer` types; prefer library types. `import type`; never value-import server-only client-side. Missing → null/undefined, never `''`/`0`/`false`. Env via zod `env.ts` at import: required fail at boot, optional degrade at use; never `process.env.FOO`.

Tests in the runner, real behavior, realistic payloads; do not repeat code and test code. Test "expected outcome," not just "I printed A, so A should be printed." Repo checks pre-commit; run added scripts once; verify side effects, not exit codes. Hermetic default; real infra when needed; ask before spending. Production is the bar.

Schema via generated tracked migrations; never push or hand-edit; verify applied; one per PR. Normalize — no JSON blobs; real columns, FK child tables with ordinals. Idempotent writers/upserts; idempotency keys; never overwrite good values with partials. Long work = durable jobs; handlers/cron thin triggers. uuidv7 PKs, v4 tokens. One bounded pool. Fail fast on source-of-truth drift. Atomic writes, 0600 state files.

Hooks footguns. State: Nuqs/Zustand. `useEffect` signals bad server-client split. `useCallback` unnecessary. React Compiler.

Latest Next.js 2026, Fluid Compute, AI SDK, Workflows, Sandbox, Fonts, Streamdown, Images, bunx agent-browser practices. 10s+ use Workflows (implement durable jobs); replace many crons.

Base UI + COSS/UI practices; never hand-rolled; semantic components (eg OTP field).

Tailwind only; no brackets or mixed CSS.

Apple HIG: minimal complexity, natural placement, drawers for secondary info; show nothing merely because it exists. No containers/cards unless needed. Tappable controls; bottom actions visible without scrolling. Mobile parity on every page. Internal links get preview cards. Copy through humanizer. Emil's animation/design skills.

text

STOP! Re-read all code, assess PR comments. Handle exactly one comment: either fix it, or rebut with 3 external sources. Fix any dirt found along the way. Lean, elegant, zero defensive programming.

text

Also, I am a fresh agent—free to criticize and radically change previous work. Karpathy's philosophy: delete and simplify. Code is liability; prefer well-maintained libraries over custom code. UI libraries: optimize, don't delete. Re-read all the sources from zero. Use MCPs and web searches—traditional knowledge is stale. Commit and push at the loop end. Any edit means I need a fresh iteration. SWOT analysis first, then work.

text


<task>
You are a ruthless engineering critic applying Andrej Karpathy's design philosophy. Read the architecture plan at PLAN LINK.

Karpathy's core principles:
- Code is liability. Every line you write is a line you must maintain.
- Delete and simplify. If something can be removed without breaking the system, remove it.
- Prefer well-maintained libraries over custom code.
- Zero-defensive design. Don't code for hypotheticals that haven't happened yet.
- Start with the simplest thing that works. Add complexity only when forced by reality.
- "Demo is works.any(), product is works.all()" -- but V1 is closer to demo than product.
- Overfit a single batch before scaling up.

Apply these principles to the plan. For each section, ask:
1. Is this needed for V1, or is it speculative engineering?
2. Can this be deleted or simplified without losing core value?
3. Is this solving a problem we actually have, or a problem we might have?
4. Would a 10x engineer look at this and say "too much"?

Be brutal. Identify:
- **OVER-ENGINEERING**: Things designed for scale/problems that don't exist yet
- **UNNECESSARY COMPLEXITY**: Things that add cognitive load without proportional value
- **PREMATURE ABSTRACTIONS**: Separations that aren't justified at V1 scale
- **DELETE CANDIDATES**: Sections, tables, fields, or features that should be cut from V1

This is a V1 product being built by a small team. The goal is to ship a working product, not to architect for 10M traffic on day one.

Use web search and tools to verify any claims you make about simpler alternatives.

Auto Refactor

Prompt

Completion Promise

Auto Fixer

Prompt

Completion Promise

Auto Builder

Prompt

Completion Promise

Common Element

Detailed review