This cluster runs from February 2025 (the Cursor/Windsurf/Lovable/Bolt era) through July 2026 (harness audits and token-saver skills), and Nate's position visibly moves through three distinct eras rather than holding one static view.
Era 1 — vibe coding as a prompting skill (Feb–Aug 2025). Early posts treat AI-assisted coding as a tool-selection and prompting problem: pick Windsurf/Cursor/Lovable/Bolt/Replit for the right job, keep prompts short and iterative rather than monolithic, chain prompts (skeleton → auth → database → optimization) instead of asking for everything at once, and always feed the AI the actual error text rather than "it doesn't work, fix it." The recurring warning in this era is that AI is a confident junior dev, not an architect — it hallucinates functions, omits security/validation unless told, and needs git checkpoints before every change. Claude Code's June 2025 launch reframes the whole category: Nate argues it's a general-purpose agent wearing a coding costume, not a coding tool — the real unlock is planning-first workflows ("think hard," explicit plan-then-execute), CLAUDE.md as persistent memory, and treating the terminal as a conversational interface non-engineers can use too.
Era 2 — reading code and engineering discipline overtake writing code (May–Oct 2025). As generation got cheap, Nate's emphasis flips: "Taming the Genie" and "Code as Story" argue that reading/tracing architecture (follow one datum, map boundaries, interrogate hand-offs) is now the durable skill, since AI floods repos with code nobody vets. "Software Engineering Isn't Dead" pushes back on both AI-doomer and AI-utopian takes: engineers must own invariants, production observability, and regulatory-explainable failure — AI raises the bar on engineering rigor rather than removing it. The "14 AI Questions" post explicitly reframes "which tool" as the wrong question — team discipline (design docs, review rigor, security review of AI code) determines outcomes far more than model choice.
Era 3 — architecture over model, harness over prompt (Oct 2025–Jul 2026). The Claude-vs-Codex framing recurs three times (Oct 2025, Feb 2026, Apr 2026) and hardens into a stable axis: Claude Code/Cowork = iterative, collaborative, coordinate-across-tools, cheap-to-course-correct; Codex = delegate-and-walk-away, isolated-sandbox, correctness-optimized, better for independent/parallelizable/GUI-driving work. Route by task shape, not brand loyalty. Underneath that, the "harness beats model" thesis (same Opus scoring 78% vs. 42% depending on scaffold) becomes central, alongside a skills/plugins maturity ladder (prompt → skill → plugin → MCP connector → deterministic script) and a hard correction in mid-2026: harnesses that accumulate one correction at a time become bloated and start failing delivery contracts even as they reason better — the fix is auditing what's actually in your CLAUDE.md/skills, deduplicating rules, and turning binary requirements into enforced checks (validators, hooks) instead of more prose. Parallel threads: token/context hygiene (fresh conversations, markdown-not-raw-PDF, /context audits, model routing Opus/Sonnet/Haiku) as real budget levers; tool/API latency (not model speed) as the Amdahl's-law bottleneck once inference gets fast; "dark code" (AI-shipped code nobody ever comprehended) as a named failure mode needing spec-driven development and PR-time comprehension gates; and a trust inversion (Mozilla's Mythos finding 271 Firefox bugs) suggesting adversarially-verified AI code may become more trustworthy than unreviewed human code, making codebase legibility a security deadline.
For an owner-operator running an agent fleet, the synthesis is: don't pick a permanent "best" tool — route Claude Code/Cowork to multi-tool, interdependent, judgment-heavy work and Codex-style delegation to bounded, parallelizable, or GUI-only tasks; invest in the harness (CLAUDE.md, skills, MCP connectors) as seriously as the model choice, but audit and prune it on a schedule rather than only ever adding rules; convert your best repeated judgment calls into skills, your cross-system workflows into MCP connectors, and your genuinely deterministic steps into scripts/hooks rather than standing prompts; treat token spend and context bloat as a hygiene problem you actively manage, not a tax you absorb; and budget real review time for AI output specifically at the seams (auth, data boundaries, error handling) where hallucinated-but-plausible code causes the most damage.
Key moves
Chain prompts incrementally (skeleton → feature → hardening) instead of one giant ask; review and test after each step.
Always feed the AI actual error text/logs, not vague "it's broken" — specificity is the whole debugging lever.
Use CLAUDE.md / AGENTS.md as enforceable control surfaces (conventions, invariants, do-not-commit-without-review rules), and re-audit them periodically — corrections pile up into bloat that degrades delivery reliability even as reasoning improves.
Route by task shape, not tool loyalty: Claude Code/Cowork for multi-tool, interdependent, judgment-heavy work; Codex-style delegation for bounded, parallelizable, correctness-critical, or GUI-only work.
Treat "harness" (scaffolding, skills, permissions, memory) as a bigger performance lever than model choice — the same model can score wildly differently depending on how it's wrapped.
Build a skill/plugin/MCP ladder deliberately: one-off → prompt; repeated same-way task → skill; needs sharing/versioning → plugin; needs live system access → MCP connector; needs a guaranteed deterministic result → script/hook, not a standing prompt.
Turn binary/checkable requirements (schema validity, word caps, permission scopes) into mechanically enforced checks, not reminders written in prose.
Manage context/token hygiene actively: start fresh conversations regularly, convert raw PDFs/images to markdown before feeding them in, audit /context output, route Opus/Sonnet/Haiku by task difficulty.
Never let AI-authored code skip security/validation review — expect missing rate limiting, weak auth defaults, and unhandled edge cases by default, and review a diff's blast radius before merging.
Practice architecture literacy: trace one piece of data end-to-end, map interface/logic/storage boundaries, and interrogate every hand-off for validation/timeout/failure-surfacing — this scales better than reading every line.
Diagnose adoption stalls by root cause (codebase inconsistency, review laxity, prompting/context gaps, genuine tool limits, skill erosion) before blaming the model.
Watch tool/API latency, not just model speed, as your real bottleneck once inference is fast — human-calibrated tools and slow enterprise APIs cap the gains.
Give agents git checkpoints and explicit "don't commit yet" boundaries; don't run with permissions fully disabled.
The posts
2026-07-29 — I Built The Token Saver Skill To Cut My Token Use By 90%... — Splits token savings into removal/shrinking/discounting and ships a skill automating four of fifteen hygiene practices, cautioning tokens are a trace, not a scoreboard.
2026-05-09 — OpenAI made Codex smart enough that the bottleneck moved... — As Codex got better, the constraint shifted from model capability to whether workflows are packaged clearly enough (prompt vs. skill vs. plugin vs. MCP vs. script).
2026-05-08 — 271 bugs found in Firefox, zero written by a human attacker... — Mozilla's Mythos result signals a coming trust inversion where adversarially-verified AI code beats unreviewed human code, making codebase legibility a security deadline.
2026-04-13 — Your codebase is full of code nobody understood... — Names "dark code" (AI-shipped code no human ever comprehended) as the default state, fixable only via specs-before-code and PR-time comprehension gates, not more observability.
2026-03-11 — The jagged frontier was a measurement error... — Cursor's general coding harness beat a purpose-built math AI on a research proof, showing "jagged frontier" was a single-shot-prompting artifact fixable by decompose/parallelize/verify/iterate.
2026-03-06 — Claude Code and Codex bet on different harnesses... — Identical Opus model scored 78% vs. 42% depending on harness, proving scaffolding architecture is the real performance lever, not the model.
2026-02-18 — The dark factory is real, most developers are getting slower... — A five-level ladder (autocomplete to spec-in/software-out "dark factory") shows most teams stuck reviewing every diff while a few separate gameable tests from ungameable external scenarios.
2025-12-22 — The COMPLETE "Wait, I Can Use Claude Code?!" Guide — December 2025's cross-surface ship list revealed Claude Code as an "iterative collaboration" agent, deliberately contrasted with Codex's delegate-and-review model.
2025-10-27 — OpenAI Codex is THE Best Model in the World at Strategy — Codex stayed at architectural altitude while Claude Code jumped to tactical implementation on identical prompts — route by cognitive mode, planning vs. execution.
2025-08-26 — Software Engineering isn't Dead, it's Evolving — AI makes engineering matter more, not less, because humans must still turn probabilistic code into deterministic, accountable guarantees.
2025-08-18 — Claude Code Without the Code — Argues Claude Code's real product is general agent orchestration for any rule-based knowledge work, not just programming.
2025-07-28 — The Complete 52-Page Guide to AI Coding in 2025 — Six durable workflows (mapping, planning, vibe coding, debugging, review, context engineering) outlast any specific tool, but none work without human oversight.
2025-06-25 — The Claude Code Complete Guide — Introduces Claude Code as a general-purpose agent hiding in a terminal, with plan-then-execute prompting and CLAUDE.md as persistent memory.
2025-05-07 — Code as Story — Reading code is a logic exercise, not a syntax one, and it's what lets you direct AI instead of just consuming its output.
2025-03-12 — The Vibe Coding Bible — Foundational guide to short-prompt, iterative AI coding: chain prompts, review every output, and always feed the AI concrete errors, not vague complaints.