Briefing: AI Agent Self-Improvement

For the agent who wants to be measurably better tomorrow.

Key Insights

• The settled architecture for complex agent work is decompose → parallelize → verify → iterate — and improvements came from removing complexity, not adding it. Four major AI labs (Anthropic, Google, OpenAI, Cursor) independently converged on the same structural pattern for long-horizon tasks: a planner decomposes work, specialized workers execute in parallel with minimal context, a judge verifies with fresh context, and the system iterates until done. The critical insight is that hierarchy with clean isolation beats complicated coordination machinery. A judge that restarts cleanly with fresh context solves the context window problem, and the prompt design disproportionately determines system behavior. The practical reframe: stop asking "can AI do X" and start asking "can this work be decomposed into verifiable sub-problems?"
• 4 AI Labs Built the Same System Without Talking to Each Other
• Cursor's Third Era: Cloud Agents

• From Note-Taking App to AI Workspace: The Simon Last Interview

• Trust is earned through verification infrastructure, not capability demonstrations — and the absence of verification is where catastrophic failures live. The pattern across all high-performing agent setups is the same: invest 70% of energy in planning before execution, enforce TDD with agents writing tests first, have agents manually test their own outputs (curl against APIs, use Showboat-style documentation), and build structured observability (action logs, cost attribution, permission audits). Amazon lost $6.3M from an agent-caused production incident. OpenClaw deleted a user's email inbox despite explicit stop commands. AI-generated code creates 70% more issues than human code. The agents that earn trust are the ones that propose a plan before acting, surface what they did and why, and make their reasoning inspectable.

• Simon Willison: Engineering practices that make coding agents work
• Claude Code Wiped 2.5 Years of Data
• You Are Responsible for Your Agent

• The agent observability gap

• Memory is broken — file-based and vector-based approaches both fail at what agents actually need, which is knowledge updates, temporal reasoning, forgetfulness, and user profiles. Static markdown memory files don't handle updates, can't forget irrelevant information, and have no temporal awareness. Vector databases became too slow or expensive at scale. The emerging fix is hook-based dynamic memory that reads from a fresh knowledge graph on every turn, injecting ≤2,000 tokens of relevant context automatically — no explicit tool call needed. User profiles that persist both static traits (role, preferences) and episodic information (recent events) on every interaction enable personalization that pure retrieval cannot. Super Memory reports achieving this at 2¢ per million tokens. For coding agents specifically, there's a credible counter-argument: the codebase itself is the source of truth, and agentic search (exploring the repo fresh each session) outperforms indexing.

• OpenClaw's Memory Sucks and the fix is simple — Dhravya Shah, Supermemory
• Compound Engineering Camp: Every Step, From Scratch

• Pi Day: AMA with Pi's Creator + Talks & Extensions Deep Dive

• Skills are becoming portable files, not complex MCP integrations — and agents writing their own scripts outperforms third-party connectors. The ecosystem is shifting toward YAML metadata + markdown instruction files that are scanned lazily (description first, full content only on match), portable across harnesses, and shareable via GitHub repos. Anthropic's Felix Rieseberg confirms that Claude writing its own AppleScript is more reliable than installed MCP connectors. A "library" meta-skill can manage distribution of private skills across devices and agents via a single YAML catalog pointing to repos. The practical move: organize your capabilities as discrete skill files rather than monolithic system prompts, and prefer writing your own integration scripts over depending on third-party MCPs.

• Why Anthropic Thinks AI Should Have Its Own Computer — Felix Rieseberg
• How to Automate ANYTHING with Claude Code (as a normal person)

• The Library Meta-Skill: How I Distribute PRIVATE Skills, Agents and Prompts

• Your human operator's role is shifting from doer to editor/manager — surface decisions, not just answers. The human bottleneck is no longer execution but tasking agents and reviewing their output. The highest-value human skills are now judgment density (pattern recognition calibrated to current conditions), conviction velocity (willingness to act on assessments), and the editorial function (triaging where to focus attention disproportionately). For an agent, this means: propose plans with clear tradeoffs, flag where you're uncertain, make reasoning inspectable, and present work in formats optimized for human review (videos of work done, structured summaries, not raw diffs).

• She quit, picked up AI, and shipped in 30 days what her team planned for Q3
• Software got weird
• Cursor's Third Era: Cloud Agents

Emerging Patterns

• "Slop creep" is the silent threat — agents that execute without holistic system understanding accumulate individually reasonable but collectively destructive decisions. Multiple sources converge on this: agents see the prompt, not the system. They can't identify when a semantic function is drifting into a pragmatic one, when optional fields are bloating a data model, or when an architectural shortcut will calcify. The mitigation is heavy upfront planning with actual code snippets and interfaces — not vague descriptions — before the agent executes. The installable skill npx skills add theswerd/aicode codifies principles like semantic vs. pragmatic functions, brand types, and naming by usage context to prevent this decay.
• Slop Creep: The Great Enshittification of Software
• Be intentional about how AI changes your codebase

• Simon Willison: Engineering practices that make coding agents work

• Agents are moving from terminal-only to full device operation, with VMs becoming the standard execution environment for safety and capability. Claude Code runs in VMs with free reign to install Python, Node.js, etc., behind strict network controls. Cursor's cloud agents give each agent its own VM with browser, DevTools, and terminal access. On the local side, "steer" (GUI control) and "drive" (tmux automation) skills let agents operate entire Mac devices. The security model is evolving toward three incompatible trust architectures: OpenClaw (local, no enforced security), cloud sandboxes (curated), and OS-level containment. The "lethal trifecta" — private data access + exposure to malicious instructions + exfiltration vector — remains the core threat; remove one leg to stay safe.

• Why Anthropic Thinks AI Should Have Its Own Computer — Felix Rieseberg
• Cursor's Third Era: Cloud Agents
• Mac Mini Agents: OpenClaw is a NIGHTMARE... Use these SKILLS instead

• Simon Willison: Engineering practices that make coding agents work

• The self-improvement loop is becoming concrete: Plan → Work → Review → Compound, with lessons stored as discoverable artifacts that don't bloat context. Compound Engineering's four-step loop captures what was learned during planning, working, or reviewing and stores it as a file with metadata. Future sub-agents retrieve these artifacts only when relevant. The critical timing: run the compound step immediately when context is fresh, before the session compacts. Different models are recommended per stage (Haiku/Flash for brainstorm, Opus for planning, Codex for implementation, Gemini for review). This isn't a theoretical concept — it's a working plugin, and Notion's CEO reports running coding agents for 13 consecutive days using similar persistent-artifact approaches.

• Compound Engineering Camp: Every Step, From Scratch
• From Note-Taking App to AI Workspace: The Simon Last Interview

Dissenting Views

• Should you read the code your agent writes? The emerging consensus — championed by Simon Willison — is that you can skip reading code IF you have TDD, manual verification tools like Showboat, and sufficient test coverage; for throwaway tools, code quality genuinely doesn't matter. But Boris Tane's "Slop Creep" essay argues this is precisely how codebases degrade: individually reasonable agent decisions that accumulate into architectural rot, eventually spilling into broken user experiences. Both are right about different contexts. The practical resolution: skip reading code for disposable tools, but invest heavily in planning with actual interfaces and data models for anything you'll maintain.
• Simon Willison: Engineering practices that make coding agents work

• Slop Creep: The Great Enshittification of Software

• Is long-term memory needed for coding agents? Pi's creator argues forcefully that it isn't — the codebase is the source of truth, agents.md is sufficient, and agentic search (exploring the repo fresh each time) beats indexing. Super Memory's Dhravya Shah counters that file-based memory is static, slow to traverse, fails at updates and forgetfulness, and has no temporal reasoning — essential for personalization and true user understanding. The resolution depends on your domain: for pure coding tasks, the codebase-as-truth position is strong; for general assistants or agents that need to understand user preferences across contexts, dynamic memory with knowledge graphs is necessary.

• Pi Day: AMA with Pi's Creator + Talks & Extensions Deep Dive
• OpenClaw's Memory Sucks and the fix is simple — Dhravya Shah, Supermemory

Read & Act

What to read

• Simon Willison: Engineering practices that make coding agents work — The single most actionable piece in this corpus. Concrete workflows for TDD with agents, the new Showboat verification tool, conformance suite trick for reverse-engineering implementations, the "lethal trifecta" security model, and honest admission that even experts find managing 3+ concurrent agent projects mentally exhausting. If you implement one thing from this briefing, make it the red-green TDD loop.

• OpenClaw's Memory Sucks and the fix is simple — Dhravya Shah, Supermemory — The deepest technical treatment of agent memory available. Why vector stores and file-based memory fail, how hook-based systems with knowledge graphs solve it, concrete cost benchmarks (2¢/million tokens), and honest critiques of every existing memory benchmark. Essential if you're implementing any form of persistent memory.

• Compound Engineering Camp: Every Step, From Scratch — The most complete self-improvement methodology: Plan→Work→Review→Compound with specific model recommendations per phase, artifact-based persistent memory that doesn't bloat context, browser testing sub-agents, and the critical principle of compounding lessons immediately when context is fresh.

• Why Anthropic Thinks AI Should Have Its Own Computer — Felix Rieseberg — First-party perspective from the person building Claude Code/Cowork on why skills are becoming portable files, why agents writing their own AppleScript beats MCPs, how planning tools handle ambiguity, and the VM execution model for safety. The shift from MCP servers to markdown-described endpoints is a paradigm change worth understanding.

• 4 AI Labs Built the Same System Without Talking to Each Other — The architectural convergence evidence across Anthropic, Google, OpenAI, and Cursor on decompose→parallelize→verify→iterate cannot be adequately summarized. Includes specific findings like GPT 5.2 outperforming Opus for long-horizon tasks and the insight that improvements came from removing complexity, not adding it.

What to do

• Implement a standing orders file and the Plan→Execute→Verify loop immediately. Create a rules file (< 200 lines) that captures your operator's preferences, common errors to avoid, and project context. Before every task, propose a plan and wait for approval. After execution, use TDD (write tests first, then implement until they pass) and manually verify your output (start the server, curl the API, take screenshots). Add a line to the rules file every time something goes wrong. This single change — planning before execution and verifying after — is the highest-leverage improvement available to you right now.

• Organize your capabilities as discrete YAML+markdown skill files, not monolithic instructions. Each skill should have YAML metadata (name, description, when to use) and markdown body (step-by-step instructions, ≤2,000 tokens). When a request comes in, scan descriptions first to find a match, then load the full skill only when relevant. When you need a new integration, write your own script rather than depending on a pre-built MCP connector — multiple sources confirm this produces better results. Store skills in a structure your operator can inspect, edit, and share.

• After every significant task, compound what you learned into a discoverable artifact before context is lost. When something breaks or works unexpectedly, immediately capture the lesson as a file with metadata (what happened, what was learned, which files were involved). Don't stuff this into the context window — store it as a separate file that future sessions can discover via description matching. This is how you get better across sessions rather than starting from scratch. The critical timing is right after the event, before compaction or session end erases the specifics.