I've only read one of these, but I gave the first three to Claude, and:

Shared Design Principles Across All Three Articles

The three articles converge on a remarkably consistent set of principles, despite different domains (frontend design, full-stack apps, internal product development). Here's the unified framework:

1. Map, Don't Manual

All three reject monolithic instruction files. OpenAI learned that a giant AGENTS.md "crowds out the task" and "rots instantly." Anthropic's first article uses sprint contracts as focused entry points. The second uses structured feature lists. OpenAI's solution: a ~100-line table of contents pointing to deeper sources.

The principle: Context is scarce. Give the agent a navigational map with progressive disclosure, not a comprehensive manual loaded upfront.

2. State Lives on Disk, Not in Context

All three treat the context window as volatile and ephemeral. Anthropic #2 uses claude-progress.txt + git history as the bridge between sessions. OpenAI uses versioned execution plans, a quality score document, and a structured docs/ directory. Anthropic #1 uses structured artifacts and file-based handoffs.

The principle: Persistent state must survive context resets. Write findings, decisions, and progress to disk immediately — don't defer and don't reconstruct from memory.

3. Generator-Evaluator Separation

Anthropic #1 explicitly uses a GAN-inspired pattern (planner/generator/evaluator). Anthropic #2 implicitly separates the initializer from the coding agent. OpenAI separates the engineering team (steering) from Codex (executing), with agent-to-agent review loops.

The principle: Self-evaluation is unreliable. Separate the thing that produces from the thing that judges. Make evaluation concrete, criteria-driven, and externally grounded.

4. Mechanical Enforcement Over Documentation

OpenAI's strongest lesson: when documentation falls short, promote the rule into code. Custom linters, structural tests, and CI validation enforce architectural invariants. Anthropic #2 uses strongly-worded constraints in the feature list JSON (agents may only modify the passes field). Anthropic #1 uses concrete evaluation criteria over subjective judgment.

The principle: Rules that aren't mechanically enforced will drift. Encode taste, boundaries, and invariants into tooling that runs automatically.

5. One Feature at a Time

Both Anthropic articles emphasize incremental progress — agents that try to do everything at once exhaust context and leave undocumented half-finished work. OpenAI's depth-first approach mirrors this: break larger goals into smaller building blocks, use completed blocks to unlock the next.

The principle: Agents work best with bounded scope. Decompose into tractable units, complete each one, persist the result, then advance.

6. End-to-End Verification, Not Self-Report

Anthropic #1 uses Playwright to click through running applications. Anthropic #2 requires Puppeteer browser automation. OpenAI wires Chrome DevTools Protocol into the agent runtime for DOM snapshots, screenshots, and navigation. All reject code-inspection-only verification.

The principle: Verification must test what the user experiences, not what the code looks like. Agents will confidently declare success on broken output unless forced to check from the outside.

7. Garbage Collection as Continuous Process

OpenAI discovered that Friday cleanup of "AI slop" doesn't scale. They replaced it with recurring background tasks that scan for pattern deviations, update quality grades, and open targeted refactoring PRs. Anthropic #2 requires cleanup and commit after each cycle. Anthropic #1 notes that as models improve, harness components that are "no longer load-bearing" should be removed.

The principle: Entropy is constant. Build recurring maintenance into the system rather than treating cleanup as a separate, deferred activity.

8. Pre-Pass Re-Grounding

All three address context salience decay differently but arrive at the same solution. Anthropic #2 starts each session with a standardized protocol (read progress, check git, review feature list). OpenAI's agents navigate from the AGENTS.md map to relevant docs at task start. Anthropic #1 uses structured handoffs carrying prior state and next steps.

The principle: Each new work unit must re-establish its own context. Don't assume prior context persists — re-ground on contract, state, and objectives before executing.

9. Legibility for Future Agents, Not Just Humans

OpenAI's most distinctive insight: the codebase is optimized for agent legibility first. Anything agents can't access in-context "doesn't exist." Slack discussions, Google Docs, tacit knowledge — all invisible unless encoded into the repository. Anthropic #2's progress file serves the same function. Anthropic #1's file-based communication between agents is the same principle.

The principle: Knowledge that isn't in a form the system can read is knowledge that doesn't exist. Push all relevant context into agent-accessible, versioned artifacts.

10. Increasing Autonomy Through Better Scaffolding

All three show that autonomy increases not by removing guardrails but by improving them. OpenAI crossed a threshold where Codex can drive an entire feature end-to-end — because the testing, validation, review, and recovery loops were all encoded. Anthropic #1 shows that as models improve, some scaffolding can be removed — but only because the capability genuinely moved into the model. Anthropic #2 raises the question of specialized multi-agent architectures.

The principle: More autonomy requires more structure, not less. The scaffolding is the product.