The Claude Code team defines four loop patterns (turn-based, goal-based, time-based, proactive) with trigger, stop criteria, use cases, and token management tips. Concrete commands like /goal, /loop, /schedule and a SKILL.md example show how to make agents iterate, self-verify, and compose primitives into automated workflows. A practical guide for developers exploring agent engineering.
This article argues that continual learning for agents isn't limited to weight updates—agents using closed frontier models can improve via harness and context layers. Using Replit Agent as a case study, it details a three-layer evaluation system: ViBench, an offline benchmark for vibe coding that scores apps built from scratch against natural-language PRDs; online A/B tests to capture real user behavior; and Telescope, a trace analysis system that clusters failure patterns. These feed a self-improvement loop that automatically proposes patches (reviewed by engineers). A concrete example shows how a cold-start regression was detected, fixed, and shipped in one day. The piece is relevant for engineers building AI agents and evaluation infrastructure.
Anthropic engineers share practical lessons from maintaining hundreds of Claude Code skills internally. The post categorizes skills into nine types—library reference, product verification, data fetching, business process automation, code scaffolding, code quality, CI/CD, runbooks, and infrastructure ops—and offers concrete writing tips: focus on non-obvious hints, build gotchas sections, use the filesystem for progressive disclosure, avoid over-constraint, design setup flows, treat the description field as a trigger for the model, store memory (logs, JSON, SQLite), and bundle scripts/libraries to reduce token waste. It also covers distribution strategies (in-repo vs. marketplace), skill composition, and usage measurement via PreToolUse hooks. A must-read for anyone building agent-centric workflows.
This article covers the v1.1 release of the skills repository, a toolset for AI agents. Key changes: /to-prd renamed to /to-spec to unify the term 'spec'; /to-plan and /to-issues merged into /to-tickets with blocking edges for both local files and real trackers. Grilling skills now prevent multiple simultaneous questions, add a confirmation gate, and avoid self-grilling. A new /wayfinder skill decomposes large tasks into GitHub issues with dependency graphs, accompanied by /research and /prototype skills. Code review skill integrates Fowler's ten code smells (e.g., mysterious name, duplicated code) with just 10 lines of guidance. TDD skill becomes reference-only, moving refactoring to code review. The recommended workflow: Grilling → Spec → Tickets → Implement → Code Review. Suitable for engineers building with AI agents.
This article introduces `/writing-great-skills`, a meta-skill that serves as a reference framework for authoring and editing predictable AI skills. The core idea is the trade-off between **cognitive load** and **context load**: model-invoked skills cost context load but fire automatically, while user-invoked skills cost zero context load but require you to remember their existence. The article provides tools for managing these loads, including leading words (compact anchors for execution), information hierarchy (progressive disclosure), pruning (single source of truth and no-op test), and failure modes (premature completion, duplication, sediment, sprawl). A must-read for system builders writing consistent, maintainable skills for agents.
A practical 12-step walkthrough for giving Claude agents persistent memory across sessions. Covers four layers: built-in Chat Memory, Project instructions, a lean memory file (CLAUDE.md), and Dreaming – a scheduled background process that consolidates and reorganized memory. Includes setup steps, API calls, and advice on filtering what to remember. Harvey reported ~6x task-completion rate improvement with Dreaming. Ideal for engineers building long-running agents.
This comprehensive survey by Lilian Weng systematically examines the critical role of harness engineering in recursive self-improvement (RSI) for AI systems. A harness is the system layer surrounding a base model that orchestrates execution, context management, tool calling, persistent state, and workflow design. The post synthesizes three design patterns (workflow automation, filesystem as persistent memory, sub-agents and backend jobs) and dives into frontier works: context engineering (ACE, MCE), meta-optimization (Meta-Harness), workflow automation search (ADAS, AFlow), self-improving harnesses (STOP, Self-Harness), and evolutionary search (AlphaEvolve, Darwin Gödel Machine). It concludes with open challenges: weak evaluators, memory management, diversity collapse, reward hacking. Essential reading for AI engineers and agent researchers.
This article presents a 14-step roadmap for building an Agent harness with Claude, from a single agent to a self-improving system. The author argues that the harness — comprising model, tools, permissions, and initial context — is the foundation for any loop, and a weak harness leads to slop. It covers concrete practices: file structure (.claude/), CLAUDE.md for standing facts, settings.json for permission pre-approvals, subagents for isolated contexts, skills for reusable procedures, hooks for deterministic enforcement, and memory for cross-session learning. The final steps add loops and dynamic workflows, closing the feedback loop where output → lessons → skills → better output. The article targets engineers who run or plan to run multi-agent code generation systems.
The author shares hands-on experience with Claude Fable for agentic coding, emphasizing that the prompt (map) never fully matches the codebase (territory). He categorizes unknowns into four types (known knowns, known unknowns, unknown knowns, unknown unknowns) and provides practical techniques to systematically discover them: blindspot passes, brainstorming & prototypes, interviews, references, implementation plans, implementation notes, pitches, and quizzes. Ends with a real example of editing the Fable launch video. Suitable for engineers using AI-assisted coding.
The author shares their journey from a failed attempt at orchestrating long-running AI agent tasks to discovering the Superpowers Skill Set, which solves the core pain points. Superpowers decomposes the development workflow into three phases: brainstorming, writing-plans, and executing-plans (with subagent-driven-development). Key design elements include: using separate prompt templates (implementer, spec-reviewer, code-quality-reviewer) to enforce separation of concerns; spinning up a fresh subagent for each task to avoid cascading context pollution; using hard constraints like "Never/HARD-GATE" to prevent agent deviation; and enforcing software engineering best practices such as TDD, DRY, and YAGNI. The author argues that with frontier models like Opus 4.8 and Codex GPT-5.5 now being sufficiently capable, the real bottleneck is harness design—using clear specifications and structured processes to make even cheaper models reliable for long-duration tasks.
Cursor shares how it continuously improves its agent harness, covering context window evolution from static to dynamic fetching, a two-layer evaluation system (offline benchmarks and online A/B tests measuring code keep rate and user satisfaction), tool call error classification and repair pipeline (anomaly detection + automated log analysis with Cloud Agents), per-model customization of tool formats and prompts (e.g., patch vs. string replacement), and mid-chat model switching with specialized instructions. The post concludes with a vision of multi-agent architectures where the harness orchestrates specialized sub-agents.
The article argues that a good vertical agent is a faithful compression of its task distribution, and its context should be organized as L1/L2/L3 cache tiers. Using their Shortcut spreadsheet agent as example, they detail extreme optimizations: reading a range compresses 500 formulas into a single legend line via R1C1 normalization and aliasing; after writing, a structured diff groups, samples, and triages changes, flagging #REF! errors under MUST FIX. L2 provides curated English specs fetched on demand, like the pivot table recipe that bakes in gotchas (suspendLayout/resumeLayout, raw integer 8 for aggregation). L3 is the raw API reference plus a 100-line grep skill that lets the model mine tens of thousands of lines in bounded steps. The prompt budget mirrors the frequency curve, and the hierarchy moves as models improve. Practical, transferable advice for engineers building reliable agents in any domain.
Anthropic shares four lessons from months of internal testing on building human-agent teams. The shift is from a single-player experience (one human, one AI) to a multiplayer model where agents hold their own credentials, persistent memory, and broad access, joining team channels as full members. The key insights: work in public so agents have context, define clear roles and tool access for every member, set an ambitious north star to make agents proactive, and build trust by granting autonomy gradually. Includes practical examples like agent-led bug backlogs and doer-verifier patterns. A must-read for teams embedding AI agents into collaborative workflows.
This official guide from Claude Code maps out seven mechanisms for injecting instructions: CLAUDE.md, rules (with optional path scoping to save tokens), skills (dynamically loaded on invocation), subagents (fully isolated context, ideal for side tasks), hooks (deterministic triggers with low context cost), output styles (highest instruction weight, but replace defaults), and append-system-prompt (additive but has diminishing returns). It details when each loads, its context cost, and typical use cases. Key advice: use hooks for deterministic behavior over CLAUDE.md, skills for multi-step procedures, path-scoped rules for API-specific constraints, and managed settings for non-overridable guardrails. Aimed at engineers customizing Claude Code for production workflows.
The author, having built several popular Skills (PPT, social media cards, logo generator, AI desk card), argues that Agents amplify rather than erase capability gaps. A Skill is defined as a reusable capability unit that bundles expert experience, workflows, taste, and tool calls. Core insights: Skill design is externalizing human taste as constraints (e.g., no pure white/black, text must not cover faces); architecture should be 'short center, thick radius' with SKILL.md holding only high-signal flow; quality must be maintained like code, with gotchas from real failures being the most valuable; the ecosystem should present each Skill as a feature page, not a repository list; distribution relies on GitHub for cross-platform reach and content platforms for community building, creating a flywheel of articles, products, and use cases. A full lifecycle from real need to feedback iteration is proposed. The article is aimed at AI Agent developers, product managers, and content creators, offering concrete cases and actionable design principles.
This article is an official engineering guide from Claude Code that systematically lays out four agentic loop patterns and their use cases. Turn-based loops are for short exploratory tasks; users encode manual verification steps into SKILL.md — e.g., asking Claude to start a dev server, take screenshots, and check the browser console. Goal-based loops, triggered by /goal, define deterministic termination criteria such as 'get the Lighthouse score to 90 or above' and force iteration until the target is met. Time-based loops come in two flavors: /loop for local polling on an interval and /schedule for cloud-triggered routines, ideal for recurring work like PR review or CI fixups. Proactive loops combine /schedule, /goal, dynamic workflows, and auto mode into a pipeline for long-running, well-defined streams of work. The article also covers code quality maintenance and token usage management: encoding conventions, using scripts instead of re-reasoning, routing routine work to cheaper models, and monitoring cost with /usage. Suitable for engineers embedding Claude Code into daily dev workflows.
This article systematically explains why context engineering is the most critical skill for building reliable AI agents. It argues that agent degradation usually stems from poor context window management rather than model limitations. The context window is likened to RAM, and as tool outputs, retrieval results, and conversation history accumulate, attention thins and the “Lost in the Middle” effect kicks in. Four core strategies are presented: Write (persist information outside context), Select (just-in-time retrieval), Compress (proactively reduce tokens), and Isolate (separate contexts for different jobs). The article details four failure modes—poisoning, distraction, confusion, and clash—and offers concrete evidence: Chroma benchmarks show continuous performance decline well before token limits, RAG‑MCP improved tool selection accuracy from 14% to 43% while halving token usage, and KV‑cache hit rates can yield a 10× cost reduction. A real-world workflow that shipped ~35,000 lines of Rust code in 7 hours using frequent intentional compaction is presented. The target audience is engineers building production‑grade agents.
This is a technical roadmap for building reliable autonomous loops, arguing that a loop is fundamentally different from a prompt—a prompt requires manual initiation while a loop drives itself: set a goal once, then the system finds work, executes, checks, fixes, and repeats until completion. The author emphasizes that the ceiling is set not by prompting skills but by engineering a loop that converges toward truth rather than becoming an expensive random walk. The piece provides step-by-step guidance (Step 0 through Step 7) with working code (Bash scripts), explaining the mechanics of stateless iteration (fresh context per turn to combat context rot), building a narrow relevant context with a token budget, designing incorruptible checks (external deterministic oracle + reward-hacking defense gates + adversarial judge on a different model), dual-level state persistence (human-readable STATUS.md + machine-parseable JSON), physical isolation (git worktree, container with --network none), brakes with observability (structured JSONL log, circuit breakers for stuck/repeated failures, liveness heartbeats), and nonlinear cost analysis (why stateless keeps per-iteration cost constant while stateful grows quadratically). This is aimed at production engineers building AI agent pipelines who need practical, verifiable techniques.
This article, inspired by Claude Code creator Boris Cherny, argues that the center of gravity in agent development has shifted from prompt engineering to loop engineering. It unpacks the trivial core loop and identifies four hard problems: knowing when to stop (distinguishing tool-call cessation from task completion), maintaining context hygiene to avoid decay, designing tools that agents can actually use (idempotent writes, error messages for LLMs), and embedding a critic in the loop to prevent self-agreement. The piece underscores that the model is commoditized; the loop—the harness—is where real engineering value lies. A must-read for engineers building autonomous agent systems.
Starting agents is cheap, but closing the loop (review, merge, judgment) must route through a single serial processor: you. The author frames human attention as the GIL for AI agents — you can spawn 20 agents, but your throughput to main is bounded by your serial review rate. Amdahl's Law applies: the non-parallelizable judgment fraction caps any speedup. Strategies include: scaling agent count to review rate, not UI; sorting tasks into async-able vs. judgment-heavy; batching reviews; making agents prove correctness with tests/screenshots. The insight: busy ≠ productive. Unpaid orchestration tax accumulates both technical debt and cognitive debt, silently eroding your mental model of the system.
Key insights from a Google whitepaper on how AI transforms the software lifecycle. The core thesis: an agent is 10% model and 90% harness (instructions, tools, sandboxes, orchestration, observability). Context engineering is the primary cost lever, with a critical distinction between static context (loaded every turn, reliable but expensive) and dynamic context (loaded on demand, cost-efficient but needs careful design). Verification determines whether you're vibe coding or doing agentic engineering: tests for deterministic parts, evals for non-deterministic output and trajectory. Real data: one team moved a coding agent from outside top 30 to top 5 on Terminal Bench 2.0 by changing only the harness with the same model; LangChain added 13.7 points on the same benchmark by changing system prompt, tools, and middleware around a fixed model. Implementation collapses from weeks to hours, while specification and verification become the new bottlenecks. For engineers and tech leads adopting AI agents in production workflows.
ECC is a comprehensive agent harness operating system designed to enhance multiple AI coding assistants including Claude Code, Cursor, Codex, OpenCode, and GitHub Copilot. It's not a standalone AI tool but a collection of 260+ skills, 67+ agents, persistent memory, continuous learning, cost optimization, and security auditing features. By providing unified rules, hooks, and MCP configurations across platforms, it addresses issues of inconsistent agent behavior, context loss, and inadequate security. Ideal for professional developers deeply using AI coding assistants and teams seeking standardized agent engineering practices.
The author shares a practical workflow for coding with AI agents: define a verifiable 'definition of done' (model eval score, QA pass, green tests, performance benchmark), wrap it in a loop for the agent to iterate autonomously, and get notified via Slack when a decision is needed or the task completes. Loops run in the cloud, not on the local machine. The author runs 3-5 long loops concurrently plus shorter tasks. For engineers looking to level up from one-shot agent interactions to long-running autonomous optimization tasks.
Raft CTO Tenny argues that returning raw IDs or full content to an agent doing a search is bad design. The correct approach mirrors web search results: return a highlighted snippet, context preview, and one explicit next action (e.g., 'read surrounding context'). Every token in the agent's context window has a cost, so results must be compact, immediately scannable, and paired with an actionable next step. This is UX design extended—but the user is now an agent reading tokens, not a person looking at a screen.
This article distills 20 foundational concepts in agentic engineering, covering building blocks (Agent loop, Think-Act-Observe, state, patterns), configuration (config files, workflow files, prompt caching, context rot), capability (MCP, live document retrieval, persistent memory), orchestration (subagents, agent loops), guardrails (sandboxing, permissions, hooks, prompt injection defense, pre-commit gates), and observability (tracing, metrics). The author argues that frameworks change but these underlying ideas persist; understanding them makes any new tool familiar. Includes concrete config examples and practical advice (e.g., keep config files under 100 lines, distinguish proxy metrics from outcome metrics).
Loop Engineering proposes a shift from hand-prompting coding agents to designing autonomous loops: a system with five components (scheduled automations for discovery, worktrees for parallel isolation, skills to codify project context, plugins/connectors via MCP, and verifier sub-agents) that lets agents iterate without manual intervention. The post maps these primitives across Codex and Claude Code, noting that memory persisted outside the conversation (via AGENTS.md or Linear) is the critical sixth piece. The core insight is that loop design is harder than prompt engineering—the engineer's role moves from operator to system architect, while verification burden, comprehension debt, and cognitive surrender remain unresolved challenges that the loop itself cannot eliminate.
A step-by-step guide to building a persistent 'second brain' using Claude and Obsidian, based on Andrej Karpathy's LLM Wiki pattern. Obsidian stores all notes as local plain text files, while Claude (via MCP protocol) reads, organizes, and links the entire vault. Key steps: install Claude Desktop (paid plan), install Obsidian with Local REST API plugin, connect via MCP, create a CLAUDE.md profile via interview, structure projects with Inputs/Process/Outputs/Feedback folders, build reusable skills, wire in live data (calendar, email), and set up autopilot scheduling. The author stresses ownership (plain text, vendor-independent) and security ('keys, not prompts'). Aimed at engineers and knowledge workers tired of context loss.
Headroom is a local-first context compression layer built specifically for AI coding agents. It slashes token consumption by 60-95% by compressing tool outputs, logs, files, and RAG results before they reach the LLM, all while maintaining answer accuracy. Usable as a Python/TypeScript library, a transparent proxy, a CLI wrapper for popular agents, or an MCP server, it fits into existing workflows without friction. Internally, it combines JSON structure-aware compression, AST-based code minification, and a custom fine-tuned model, grounded by a novel CCR reversible compression system that guarantees original data is never lost. This tool is ideal for engineers who rely heavily on coding agents and want to cut API costs without altering their current toolchain.
Headroom is a local-first context compression layer for AI agents that slashes token usage from tool outputs, logs, files, and RAG chunks by 60–95% before they reach the LLM, with preserved accuracy. It offers library, proxy, MCP server, and agent wrapper modes, using a content router to select the best compressor for JSON, code, or prose. Reversible compression ensures originals are retrievable on demand. With cross-agent memory and `headroom learn` for mining failed sessions, it is ideal for engineers running coding agents daily and anyone seeking to slash LLM costs without changing their workflow.
Satya Nadella argues that the future of the firm in an AI-driven economy relies on creating a compounding learning loop that integrates human capital and AI 'token capital.' He emphasizes that organizations must build agentic systems that own their institutional knowledge and private RL environments, ensuring they can swap underlying models without losing proprietary expertise. Warning against a future where a few models commoditize all value, he advocates for building a 'frontier ecosystem' that enables broad value distribution across every industry, rather than solely chasing a frontier model. This piece targets executives and senior technologists strategizing AI adoption.
Anthropic’s data team shares how they use Claude to automate 95% of business analytics queries at roughly 95% accuracy. They identify three core failure modes—concept‑entity ambiguity, data staleness, and retrieval failure—and describe a four‑layer agentic stack to address them: data foundations (canonical datasets, rigorous governance), sources of truth (semantic layer, lineage, business knowledge graph), skills (knowledge and procedural skills, which lifted accuracy from ~21% to >95%), and validation (offline evals, adversarial review, online monitoring). The post includes concrete practices such as colocating docs with code, treating metadata as a first‑class product, and an appendix with a skill file skeleton. It is aimed at data engineers and analysts building LLM‑powered self‑service analytics.
A practical guide based on Anthropic engineering posts and experiments detailing how to build a self-improving agent system around Claude Fable 5. It argues most users underutilize the Mythos-class model, treating it like a bigger Sonnet 4.6. The architecture layers primitives (model, sub-agents, worktrees), orchestration (/goal and Outcomes loops, Dynamic Workflows, Routines for cloud execution), memory (state files and compounding Skills), and self-improvement (vision self-checks, eval loops, rule distillation). Key tactics include using an independent verifier sub-agent instead of self-critique, ensuring parallel safety with git worktrees, running multi-day tasks on cloud infrastructure, and following a 5-stage memory progression from failure documentation to general rule consultation. Designed for engineers building compound systems rather than prompting for minutes.
A practical guide by @eng_khairallah1 detailing 25 workflows and techniques to fully leverage Claude Projects. The core thesis is treating Projects as evolving, persistent workspaces rather than transient chat sessions. It provides actionable strategies including a structured instruction template, strategic file organization, the Living Instructions pattern, and advanced concepts like voice calibration files and competitive intelligence hubs. The guide emphasizes a compounding knowledge strategy where each interaction refines Claude's contextual understanding, suitable for power users aiming to transform Claude from a generic tool into a domain-specific specialist.
R. Lance Martin demonstrates two loop patterns for Anthropic's Fable 5: self-correction and cross-session memory. On the Parameter Golf challenge (train a model under 16MB and 10 minutes on 8xH100s), Fable 5 with CMA and a verifier sub-agent improved the pipeline roughly 6x more than Opus 4.7, favoring structural changes over scalar tuning. On a continual learning SQL benchmark, Fable 5 progressed through fail-investigate-verify-distill into general rules, reaching 73% verification coverage, while Opus 4.7 and Sonnet 4.6 stalled at sparse notes or uncertain schemas. The key takeaway: design loops and environment feedback so the model can hillclimb, rather than relying on direct prompting.
The author shares two practical directions for improving agentic workflows with Anthropic's Claude Fable 5 model: self-correction loops and cross-session memory. In a Parameter Golf challenge—train the best model within a 16MB artifact in under 10 minutes on 8×H100 GPUs—Fable 5 improved the training pipeline roughly 6× more than Opus 4.7 when using Claude Managed Agents with Outcomes judged by an independent verifier sub-agent against nine checkable criteria. Fable 5 bet on larger structural changes and pushed through a quantization regression, while Opus 4.7 stuck to tuning scalar hyperparameters. For memory, the author used a SQL-based task from Continual Learning Bench 1.0 with filesystem-backed memory across agent sessions. Sonnet 4.6 only logged failures and guesses; Opus 4.7 built flagged schema references but verified only 17% of questions; Fable 5 reached 73% verification coverage in the best run and distilled learnings into general rules. Engineers interested in agent architecture and model capability boundaries will find the experiments relevant.
This guide clarifies that AI agents are not a category but a spectrum from simple chat to autonomous loops, defined by tools, memory, and a loop. It then provides a no-code, step-by-step tutorial on building a Telegram bot agent with Claude Code, including system prompt templates, systemd deployment, persistent memory, cost tracking, and practical skills. Also addresses the common memory problem and offers concrete fixes. Suitable for engineers who want a practical agent without writing code themselves.
Matt Pocock's personal agent skills for Claude Code and Codex, targeting four common failure modes in AI-assisted development: misalignment, verbosity, broken code, and design entropy. Instead of controlling the process, these small, composable skills embed engineering fundamentals—grilling sessions for alignment, shared ubiquous language for concision, TDD red-green-refactor loops for code quality, and architecture rescue tools. They work with any model and are designed to be hacked and adapted in your own .claude directory.