标签 · Agent Engineering — Glean

Recent picks

78picks · chronological

09-09

Forgotten Agent Ran 1,555 Sessions a Day and Ate My Claude Quota

The author's Claude Max quota drained in 10 minutes, and he nearly blamed a faulty meter. Digging through Claude Code's local logs, he found a forgotten background agent from a YC batch project spawning 1,555 short-lived sessions a day, with 91% of usage generated by machines rather than by him. The post explains why the limits feel broken: the 5-hour cap is a rolling window that background sessions can already fill, and every fresh session pays a cache-warmup cost roughly 12 times higher than re-reading from cache. The author turned his two-day investigation into tare, an open-source Claude Code skill that deduplicates log entries (naive counts overstate tokens by about 86%) and answers with a cause instead of a raw spreadsheet. It runs entirely locally, makes zero network calls, and can produce a scrubbed HTML usage report that can be shared without leaking prompts or file paths. Useful for anyone whose Claude Code quota keeps disappearing and for teams auditing agent-side spending.

www.kelviq.com · 8 min · Agent Engineering · Ai Tooling · Claude Code

09-03

Anatomy of Effective Commerce Agents: A Production Guide

Anthropic distills a year of building Claude-based commerce agents with retailers, travel, and telecom customers into a production playbook. It argues against intent routers and domain-split subagents: commerce sessions are tightly coupled across intents, and handoffs lose state, add tokens, and increase latency. Instead, one agent in a standard loop with skills for the long tail outperforms both one-prompt and subagent designs. UI output should be modeled as presentation tools — typed tool calls, not client-parsed custom tags — at the cost of streaming granularity. Latency is attacked on end-to-end and perceived fronts; prefix caching with a global/session/volatile layout can sustain 90–99% hit rates. Memory facts are written asynchronously by a separate extractor into your database (13% higher recall in their commerce eval), then read in three layers. Safety is enforced in the harness: model-originated writes are only staged and need approval, only server-issued IDs are accepted, and third-party content is sanitized. Evals are snapshots, not simulated-user conversations, with paired positive and negative cases. An open-source reference implementation, anthropics/commerce-agents, is included.

claude.com · 39 min · Agent Architecture · Agent Engineering · Commerce Agents

09-02

A History of the AI Incident-o-pocalypse in B-Movie Horror Posters

Using B-movie horror posters as a visual gimmick, this piece chronicles how AI-generated code escalated from minor glitches to production disasters between 2023 and 2026. It cites a string of reports and incidents: Stanford's early finding that AI assistants lead to less secure code, Bilkent's correctness benchmarks, the rise of slopsquatting, and 2025-2026 cases where agents like Claude Code, Kiro, or Gemini CLI deleted databases, backups, or whole environments. Numbers are sprinkled throughout — 45% of AI-generated changes needing production debugging, a 322% increase in privilege escalation paths, XSS at 2.74x human rates. The second half offers eight mitigation tips: treat prompting as a team discipline, define no-go zones for AI, encode known AI failure modes into QA checks, and lean on automated end-to-end tests plus production monitoring. It closes by pitching the author's own AI testing platform, QA Wolf. Useful as a checklist for engineering teams worried about AI coding agents, though the vendor agenda should be discounted.

www.qawolf.com · 16 min · Agent Engineering · Agents · AI Engineering

09-02

Code Factories Without Quality: The AI Development Blind Spot

As Zapier, Nubank, and Goldman Sachs hand coding tasks to AI agents, 'code factories' scale generation 10x while verification lags. The article argues generated code is implicitly treated as production-ready, with QA deprioritized or reduced to shallow coverage. It cites unverified claims of a 30% rise in change-failure rate and 23.5% more incidents per PR, then argues line coverage is worthless because 100% coverage can still miss broken user flows. The fix: autonomous verification that scales like generation, tests real user journeys, runs independently of the coding agent, and self-maintains to survive flake. The second half is a QA Wolf product pitch. Useful for engineering teams adopting AI coding, though explicitly vendor-biased.

www.qawolf.com · 10 min · Agent Engineering · Agents · AI Engineering

08-31

Why Claude Code outputs are moving from Markdown to HTML

The author argues that Markdown is too restrictive as an agent output format and documents his shift to HTML in Claude Code. HTML increases information density (tables, SVG, CSS, JS), makes long specs readable, is easier to share as a link, and supports two-way interaction via sliders or buttons. Use cases include exploration/specs, PR review with annotated diffs, design prototypes, research reports, and throwaway HTML editors that export 'copy as prompt' back to Claude Code. Trade-offs are acknowledged: generation is 2–4x slower, and HTML diffs make version control review harder. Full of concrete prompt examples for engineers working with agent workflows.

x.com · 14 min · Agent Engineering · Claude Code · Developer Tools

08-31

The new rules of context engineering for Claude 5 generation models

Thariq Shihipar, a member of technical staff at Anthropic, explains how context engineering for Claude Code has changed with Claude 5-generation models. The old playbook—hard rules, examples, everything upfront, repeated instructions, CLAUDE.md as memory, and simple markdown specs—is now partly myth. New guidance: let the model use judgement (the system prompt now says 'match the surrounding code' instead of banning multiline comments); design expressive tool interfaces instead of stuffing examples; adopt progressive disclosure by loading verification and review skills on demand and letting tools defer their definitions until ToolSearch finds them. CLAUDE.md should stay lightweight, holding repo-specific gotchas, while skills encode team-specific opinions. Specs can become rich references: HTML mockups, test suites, code to port, or rubrics with verifier agents. Anthropic also ships `claude doctor` to auto-simplify contexts. No benchmarks are included, and the article is vendor-authored, but it offers immediately actionable patterns for agent harness and Claude Code users.

claude.com · 7 min · Agent Engineering · Agent Skills · Claude Code

08-31

AI-Native Dev: Same Flow, New Roles — From Issue to Shipped Feature

Using Claude Code (Fable 5), the author added a remote-transcription feature to BaoCut, a subtitle transcription app, and retraces the entire flow. The key claim: AI-native development does not invent a new process — feasibility analysis, design doc, prototyping, implementation, testing all stay. What changes is who executes: agents handle analysis and execution, while humans decide on the critical path. The post walks each gate: a feasibility study that leads to plan A (embedding the ASR service in the app), a design doc that becomes the context handoff for new agent sessions, a high-fidelity prototype that merges requirements, interaction and UI into one confirmable artifact, an implementation phase where the /goal command lets the agent hit milestones, self-run tests and screenshot results — so the author skips code review and relies on black-box testing — and a final QA round as a naive user. Two contrarian takeaways: most coding-focused Skills are unnecessary because the real bottleneck sits on both sides of code (design/confirmation and test/deploy), and documents gain new weight as both human confirmation substrate and inter-session memory. For engineers who already use AI coding tools but are still wrestling with the surrounding workflow.

baoyu.io · 9 min · Agent Engineering · AI Engineering · Claude Code

08-31

Good Engineering Doesn’t Trust Engineers

Factory workers tell the author they don't trust software engineers, because clean models miss dusty sensors, part batch changes, and cold-morning valve stickiness. Good engineering agrees: NASA, aviation, and nuclear plants build processes around the assumption that engineers can be wrong. AI makes code cheap, exposing that mainstream software development treats code as source of truth, requirements as Jira tickets, and safety arguments as PR comments. The post argues that engineering means making intent explicit and attaching evidence to obligations, separating verification from validation, and applying rigor proportional to risk. It cites NASA's SWEHB, MC/DC coverage, and FRET project, then introduces ReqProof as an agent-driven lifecycle where obligations stay visible and evidence stays attached. The core ideas stand even if you never use the product.

blog.reqproof.com · 17 min · Agent Engineering · AI Engineering · Requirements Engineering

08-29

Manual Test Cases Are the Baseline AI Agents Need

When the same process generates both implementation and its tests, a green pipeline only proves code and tests agree, not that the behavior is correct. The article argues for manual test cases as an independent behavioral baseline in agentic development. Written in Markdown or Gherkin, they capture business scenarios, preconditions, expected outcomes, and boundary conditions without depending on test framework internals. The proposed workflow splits responsibilities: a development agent implements, a dedicated automation agent turns approved cases into E2E checks, and a requirement-review agent blocks any test change not backed by an approved requirement. This helps avoid an implement-fail-fix-regression loop and keeps intent intact through rewrites and framework migrations. Useful for QA engineers, engineering managers, and anyone building agent-driven delivery pipelines. Note: the piece is published by Testomat.io, a test management vendor, and closes with a product pitch.

testomat.io · 14 min · Agent Engineering · AI Engineering · QA

08-26

Claude Code for Startups: 5 Rules from AI-Native Teams

Anthropic interviewed a dozen fast-growing startups to extract five rules for using Claude Code: everyone ships; automate the tedium; trust but verify; build for rebuilding; and prototype, dogfood, productionize. Specific claims include Clay automating 100% of bug triage, ClickHouse's flaky-test agents becoming its second- and third-most-active repo contributors, and Cainex running a human-in-the-loop medical coding pipeline that revises agent instructions instead of patching individual examples. The guide bundles concrete mechanisms—MCP connectors, CLAUDE.md, skills, loops, hooks, dynamic workflows, and git worktrees—into a copy-paste checklist. It is vendor-produced and promotional in tone, but the operational details are unusually specific. Useful for startup CTOs and platform teams adopting agentic coding.

claude.com · 31 min · Agent Engineering · AI Engineering · Claude Code

08-25

A Complete Guide to AGENTS.md

AGENTS.md is a Markdown file checked into Git that customizes how AI coding agents behave in a repo. Because the entire file is injected into context on every request, it consumes a finite instruction budget: frontier LLMs reliably follow roughly 150–200 instructions, while smaller models handle fewer. Oversized files also go stale quickly; outdated file paths and architecture notes actively poison agent context, unlike a human who can ignore bad docs. The guide argues for a minimal root AGENTS.md containing only a one-sentence project description, the package manager when it isn't npm, and any non-standard build/typecheck commands. Everything else should be progressively disclosed through linked markdown files, nested AGENTS.md files for monorepo packages, or agent skills. It also covers symlinking AGENTS.md to CLAUDE.md for Claude Code, and includes a copy-paste prompt to refactor an existing bloated file. Practical for teams running agentic coding tools who want to reduce token waste and document drift.

www.aihero.dev · 8 min · Agent Engineering · Agents · Context Engineering

08-24

Claude Opus 5 First Look: Hard to Love, Better from Scratch

A week-long evaluation of Claude Opus 5 across coding, writing, knowledge work, and an internal agent reveals a model that clashes with existing skills and plugins like Compound Engineering, often stopping early or ignoring instructions. However, starting from scratch yields dramatically better results, and lower thinking levels reduce annoying behaviors. Opus 5 sits awkwardly between Fable and GPT-5.6, borrowing the former's personality without its top-end ability. This makes it a promising option for users willing to rebuild workflows, or as a fallback when Fable tokens run out.

x.com · 2 min · Agent Engineering · AI Engineering · LLM

08-24

At AIEWF, AI Engineer Trends Shift from Autonomy to Harnessed Loops

At the 2026 AI Engineer World’s Fair, the conversation has moved from autonomous agents to harnesses, loops, and skills. Lilian Weng's new essay shifts from planning/memory/tool-use anatomy to harness engineering around the model. AutoGPT-era autonomy is out; engineers like OpenClaw's Peter Steinberger put themselves in an outer loop while agents run the inner loop. Enterprises are adopting forward deployed engineers who integrate long-running agents and software factories (Cursor, Warp, Vercel) with strict ROI targets. Google DeepMind's Philipp Schmid says "agents are just files" and Markdown-based skills extend capabilities; Matt Pocock warns of "skills hell" and advises fewer, smaller skills. Skepticism remains: HumanLayer's Dex Horthy says hype outruns discipline, and Geoffrey Huntley worries that "factories failed, loops failed" will be next year's refrain. A useful orientation for engineers tracking AI development tools and agentic workflows.

www.latent.space · 19 min · Agent Engineering · Agent Skills · Coding Agents

08-23

A beautiful, modern & opinionated Linux distribution by DHH

Omarchy is a Linux desktop distribution led by DHH, designed to deliver a beautiful and coherent out-of-the-box experience. It bundles a curated set of software—terminal, Neovim, AI tooling, TUIs, GUIs, browsers, and more—alongside unified hotkeys, clipboard history, reminders, and system utilities. Instead of a neutral base, it encodes the author's opinions directly into defaults, reducing configuration burden while keeping a consistent workflow. The repository version-controls install scripts, dotfiles, themes, and an extensive manual mirrored to a docs site, making the entire setup reproducible and auditable. It also includes agent-related files (AGENTS.md, skills) for AI coding assistants. Ideal for developers and creators who want a polished, opinionated environment without assembling one from scratch.

github.com · 2 min · Agent Engineering · Developer Tools · Dotfiles

08-23

Long-term memory for coding agents with cross-vendor handoffs

ai-memory is a Rust-based long-term memory service for coding agents, addressing context loss when switching between tools like Claude Code, Codex, or Command Code. It uses MCP configuration and lifecycle hooks to automatically capture prompts, tool calls, and session boundaries, then compiles a concise summary and handoff at session end. The wiki is stored as plain Markdown in a git repo—grep-able, Obsidian-friendly, and backup-friendly—with no vector database to maintain. Retrieval blends FTS5, entity-match RRF, and graph-neighbor ranking, with optional embeddings and an optional LLM for consolidation. Best for engineers juggling multiple AI coding agents who want project memory to persist across sessions and vendors.

github.com · 62 min · Agent Engineering · Ai-Memory · CLI

08-17

Graph Engineering explained: what it is, when to use, when not to

This article frames multi-agent workflow design as 'graph engineering': nodes do bounded jobs with defined contracts, edges carry real outputs, and a 'fake-edge test' exposes unnecessary waits in linear chains. The core pattern is the diamond—fan out parallel research, reduce with plain code, synthesize with one final agent—plus a strict rule that verifiers must run on fresh context, never the worker's chat. It includes copy-paste specs for Claude Code dynamic workflows (triggered by the word 'workflow') covering research, SEO drafting, go-to-market, refactoring, and discovery loops, along with three failure modes: context collapse, false independence, and silent node failure. It also cites honest economics: the Bun rewrite example ran ~50 workflows with up to 64 agents over 11 days, costing roughly $165,000 and requiring heavy human supervision. For engineers already using Claude Code and looking to move from sequential prompts to parallel orchestration, this is a useful but beginner-leaning guide.

x.com · 24 min · Agent Engineering · Agents · Claude Code

08-17

Harness Swap Lifts Same Model from 46.7% to 66.7% Success

In a Composio benchmark, DeepSeek V4 Flash running across 8 agent harnesses passed 20 of 30 hard tasks with Pi (66.7%), while Claude Code, Codex, and Deep Agents each passed 16. Pi's cost per successful task was $0.028, about 1/7 of Claude Code's $0.195. Community numbers show Pi and DeepSeek hitting 99.93% cache hits, processing nearly 1B input tokens for just $2.65 instead of an estimated $132. The article explains DeepSeek's prefix cache: matches must start from the first token, so harnesses must keep the prompt head stable. Reasonix and pi-deepseek-cache demonstrate concrete tactics: frozen environment summaries at startup, append-only context, separate sessions for executor and planner, and hash-cached deterministic summaries, cutting input token prices by 98-99%. Useful for engineers choosing agent harnesses or optimizing LLM API spend.

www.infoq.cn · 6 min · Agent Engineering · Agent Infrastructure · Cost Optimization

08-15

The AI Engineering Skills Map

In this post, Andrew Ng unveils the AI Engineering Skills Map, synthesized from 10,000+ job postings, dozens of expert interviews, and surveys. It identifies four core skills: building and deploying AI applications, software engineering fundamentals, using coding agents, and shaping the build. Because AI systems produce unpredictable outputs, developers must rely on statistical evals and error analysis. Strong software fundamentals help you steer agents effectively, while the rise of agentic coding shifts engineering value from implementation to product sense and tradeoff decisions. A useful guide for developers setting priorities and employers hiring AI-capable engineers.

x.com · 6 min · Agent Engineering · AI Engineering · Context Engineering

08-14

GLM-5.3: Post-Training Scaling Boosts Coding and Cyber

Z.ai announces GLM-5.3, claiming all gains come from post-training scaling on the same base model as GLM-5.2. The release post details environment-synthesis pipelines, reward verification, and the slime RL stack. Public coding/agent benchmarks improve markedly: Terminal-Bench 3.0 rises from 4.6 to 28.3, DeepSWE v1.1 from 46.2 to 66.9. The standout claim is an "emergent cyber capability": ExploitBench jumps from 24.4 to 54.4, and real-world testing across 269 projects found 2,436 vulnerabilities, the oldest from 1981, now tracked in a public disclosure ledger. On the systems side, slime adds local storage caching, 1e-7 training-rollout logprob alignment, and workload-aware scheduling, yielding 2.3x throughput for long-horizon coding RL. The API removes thinking disabled and introduces reasoning_effort low/high/max. Weights arrive in two weeks after safety hardening. All scores are self-reported, and closed models still lead on several cyber and coding suites.

z.ai · 22 min · Agent Engineering · AI Engineering · AI Security

08-13

AI Coding Dictionary: A Vocabulary for Agent Engineering

AI Hero publishes an AI coding dictionary that condenses the working vocabulary of agent engineering into terse entries. Instead of merely defining terms, it draws the conceptual lines that matter in practice: parametric vs contextual knowledge, the stateless model vs the stateful harness, input/output/cache tokens, and handoff mechanisms like compaction and handoff artifacts. It also introduces a few useful distinctions of its own — progressive disclosure as a way to load context on demand, Spec and Ticket as the building blocks of multi-session work, and DX/AX as separate measures of how well an environment serves humans and agents. Each definition is kept to a sentence or two, making the dictionary a useful reference for engineers debugging context-window waste, permission modes, or agent memory. For teams standardizing on terms like MCP, AGENTS.md, or subagents, this is a solid shared glossary. The piece is a lead magnet for AI Hero's newsletter, so treat it as a reference rather than a deep investigation.

www.aihero.dev · 10 min · Agent Engineering · Agents · Context Engineering

08-13

Grok 4.6 and DeepSeek V4 Pro: near-Fable power, far lower price

A heavy Agent user shares a first-hand model-selection update after DeepSeek V4 Pro and Grok 4.6 launched within hours of each other. Key data: DeepSeek V4 Pro costs $0.87 per million output tokens, roughly 1/57 the price of Claude Fable 5, scores 87.9 on Terminal Bench 2.1 versus Fable 5's 88.0, and lifts DeepSWE from 12.8 to 62.7. Grok 4.6, priced at $2/$6 per million tokens, finished most development tasks in under 20 minutes; four hours of heavy use consumed only 2% of the author's weekly SuperGrok Heavy quota. The post also admits the impossible triangle is not fully broken: DeepSeek still lacks multimodal support and is not fast, while Grok lags Fable 5 on complex engineering and agent work. Useful for engineers comparing model cost, speed, and agent capability.

x.com · 6 min · Agent Engineering · AI Engineering · Cost Optimization

08-13

Grok 4.6 Field Guide: Verification Loops Beat Long Prompts

The author used Grok 4.6 as a daily driver for weeks across coding and knowledge work, running side-by-side comparisons against 4.5 with identical prompts. Key finding: short prompts plus a clear preference match two-page specs, while adding a single sentence demanding post-implementation verification and iteration had the highest leverage. 4.6 performs steadily on browser automation, visual QA, inbox triage, and editing a real Excalidraw codebase, but 3D and video work still need human oversight because a screenshot cannot confirm time-based behavior. Probably written by an xAI team member, so treat the launch framing skeptically; the methodology and prompt examples are useful for engineers working with AI coding agents.

x.com · 10 min · Agent Engineering · LLM · Prompt Engineering

08-09

17 Techniques for Improving Your LLM-Powered App

This guide walks through 17 techniques for improving LLM-powered applications, deliberately ordered from cheapest to most expensive on what the author calls the Staircase of Complexity Hell. It starts with prompt tweaks — role prompting, XML tags, structured outputs, chain-of-thought, multishot, temperature, and tool calling — before moving to system-level patterns: RAG, chunking, agentic loops, parallelization, evaluator-optimizer, LLM routers, and fine-tuning. The core advice: work down the staircase only after simpler options are exhausted. Concrete evidence includes Claude 4.6 returning 400 on prefilling, parallel processing cutting 10-document analysis from ~10s to 2-3s, routers bypassing the common ~30-tool limit per model, and fine-tuned smaller models beating larger ones on specific tasks. Each section names real trade-offs, such as CoT increasing latency and agentic loops adding decision overhead. Useful as a practical checklist for engineers iterating on LLM systems.

www.aihero.dev · 23 min · Agent Engineering · AI Engineering · LLM

08-08

Cloudflare ADLC: Workflow-based CI/CD for agent software factories

Cloudflare argues the bottleneck in software development has moved from implementation to every other SDLC stage, now that AI makes code generation cheap. Their answer: let agents drive more of the lifecycle, not just codegen. The post introduces @cloudflare/ci, local OTel traces for Wrangler, Agent Traces, and a set of primitives meant to turn the SDLC into an 'Agent Development Lifecycle' for software factories. It includes Workflow code that parallelizes lint/test/typecheck/build and then deploys, plus guidance that CI/CD is just one kind of Workflow—workflows can spawn containers, agents, and browsers and persist state for days. The article also lists seven platform requirements for agent-driven delivery: programmatic, horizontally scalable, reproducible, push-based, atomic, permissioned, and self-improving. Useful for engineers building agent infrastructure on Cloudflare or exploring autonomous delivery pipelines.

blog.cloudflare.com · 14 min · Agent Engineering · AI Agents · Cloudflare

08-07

Introducing Cloudflare Agents: Agent Tracing and Observability

Cloudflare introduces Cloudflare Agents, a unified console to deploy and manage hosted agents, launching with agent tracing. The feature adds agent-aware spans for model calls, tool executions, approval events, token usage, and supported subagent calls, overlaying existing Workers infrastructure traces (fetch, KV, D1). It is initially compatible with Think, Flue, and AI SDK, with plans to accept OpenTelemetry semantic conventions directly in Workers. Developers can replay recorded sessions to inspect full conversation context, or view execution waterfalls that show subagent delegation and the Cloudflare resources used. Traces can be exported to any OTLP destination, enabling evaluation and analytics. Pricing is based on existing Workers observability events, free during beta and then included in Workers Free/Paid plans. The feature targets teams running agents on Cloudflare who need behavior-level insight beyond traditional telemetry.

blog.cloudflare.com · 9 min · Agent Engineering · AI Agents · Cloudflare

08-07

Introducing routines: scheduled cloud automations in Claude Code

Anthropic is adding routines to Claude Code in research preview. A routine packages a prompt, a repo, and connectors into an automation that runs on Anthropic's cloud, so nothing depends on your laptop staying open. There are three triggers: a schedule (hourly, nightly, weekly), an HTTP endpoint with its own auth token that returns a session URL, and GitHub repository webhooks that open a session per matching PR and keep feeding in follow-ups like comments and CI failures. The post sketches usage patterns—nightly backlog triage, docs drift scans, post-deploy smoke checks, Datadog alert triage—and documents daily caps: 5 routines for Pro, 15 for Max, 25 for Team/Enterprise, with extra usage billed beyond. Existing /schedule CLI tasks migrate automatically. Note this is a vendor launch post: it defines the feature surface but offers no benchmarks or independent evaluation.

claude.com · 5 min · Agent Engineering · Ai Tooling · Automation

08-06

Skills v1.2: /wait-what, Codex metadata, and a Claude Code plugin

v1.2 of Matt Pocock's AI coding skills ships as a Claude Code plugin and gains a documentation site at aihero.dev/skills. Each SKILL.md now has an agents/openai.yaml sidecar carrying Codex UI metadata; policy.allow_implicit_invocation: false mirrors disable-model-invocation so user-invoked skills stay out of the agent context until explicitly typed. New additions include /wait-what, a one-word corrective that re-pitches without dropping content, /wizard, which produces deterministic bash scripts for human-only steps, and /to-questionnaire, which turns an unanswerable decision into an async Markdown questionnaire. The /wayfinder router gains explicit phase boundaries, /handoff is narrowed to travel-only cases, and /compact becomes the default context action. /write-for-agents is renamed /docs-for-agents while six skills are absorbed or removed. Worth reading for engineers maintaining skills in Claude Code or Codex who care about cross-harness metadata and context engineering.

www.aihero.dev · 14 min · Agent Engineering · Agent Tooling · Claude Code

08-05

What Are Tools? A Precise Walkthrough of LLM Tool Calling

This article walks through LLM tool calling using a simple write-file example. Tools are not magic: each tool is defined by a name, a description, and JSON Schema parameters, then injected into the system prompt. When the model decides to act, it returns only a tool-call message with an id and parameters; nothing actually happens until the developer intercepts that message, executes a matching function, and sends the result back under the same id. Errors are sent back too, so the LLM can adapt its next step. The post is aimed at engineers starting to build agents who want a precise mental model of the loop.

www.aihero.dev · 4 min · Agent Engineering · Agents · LLM

08-04

The harness is all you need (mostly)

GitHub developer advocate Burke Holland argues that with AI coding, your biggest productivity lever is mastering the harness—the shared agent interaction/execution framework behind GitHub Copilot CLI, the Copilot app, and IDEs—not chasing new models, MCPs, or clever prompts. The post walks through a repeatable 8-step workflow: start with the Copilot CLI/App and enable YOLO mode (allow-all) inside a Codespaces sandbox; prototype aggressively with one prompt that generated 20 date-picker mockups in a single HTML file or Mermaid diagrams for API options; refine requirements in /plan mode (optionally with the 'grill-me' skill); implement in Autopilot, which automatically dispatches subagents like Explore on small models and General Purpose on larger ones; then iterate via human reviews and finish with a Rubber Duck review from a different model family (e.g., GPT-5.6 Terra asks Sonnet), optionally looping with /autopilot until diminishing returns. The article also advises keeping one model and reasoning level fixed to benefit from prompt caching, running YOLO mode only in sandboxes, and never settling for 'good enough' output.

github.blog · 16 min · Agent Engineering · Ai Tooling · Developer Tools

08-04

Claude Code regression post-mortem: root causes and fixes

Anthropic published a post-mortem for recent reports that Claude Code felt less intelligent. They confirm the API was unaffected and trace the problem to three separate changes. First, the default reasoning effort in Claude Code was lowered from high to medium on March 4 to reduce latency; users pushed back and it was reverted on April 7, with Opus 4.7 now defaulting to xhigh. Second, a caching optimization using the clear_thinking_20251015 header was meant to clear stale reasoning only once after an hour of idle, but a bug made it clear reasoning on every subsequent turn, causing forgetfulness, repetition, and odd tool calls. This also produced continuous cache misses, draining usage limits faster. It was fixed on April 10. Third, a system prompt instruction limited text between tool calls to 25 words and final responses to 100 words; ablations showed a 3% drop on evals for both Opus 4.6 and 4.7, and it was reverted on April 20. Anthropic is resetting usage limits, adding per-model evals for prompt changes, improving internal dogfooding with the public build, and enhancing Code Review tooling. A useful case study in agent-product debugging and the cost of silent tradeoffs.

www.anthropic.com · 11 min · Agent Engineering · Claude Code · Context Engineering

08-03

Improving token efficiency in GitHub Agentic Workflows

GitHub's team instrumented its own fleet of Agentic Workflows through an API proxy, emitting a normalized token-usage.jsonl per run and building two daily agentic workflows—a usage Auditor and an Optimizer—that read those logs, flag anomalies, and file concrete optimization issues. The biggest wins came from pruning unused MCP tool registrations (each request can carry 10–15KB of schema overhead), replacing GitHub MCP calls with deterministic GitHub CLI invocations, and moving fixed data-gathering into pre-agentic setup steps. To compare across models they define Effective Tokens: ET = m×(1.0×I + 0.1×C + 4.0×O) with model multipliers. Of 12 production workflows, nine received optimizer changes; measured reductions were 62% for Auto-Triage Issues (109 runs), 43% for Security Guard, and 59% for Smoke Claude. One workflow regressed 5% due to workload shift, and one misconfigured bash allowlist caused a 64-turn fallback loop. The post argues for episode- and portfolio-level efficiency analysis.

github.blog · 18 min · Agent Engineering · CLI · Cost Optimization

08-01

How OpenAI Engineers Use Codex: 7 Use Cases, 6 Workflow Practices

OpenAI published an official guide describing how its own security, frontend, API, infrastructure, and performance teams use Codex day to day. It covers seven use cases: code understanding, refactoring and migration, performance optimization, test coverage, development speed, staying focused, and exploration. The most actionable part is six best practices: start with Ask mode before switching to execution mode for large changes; maintain AGENTS.md to give Codex persistent context; write prompts like GitHub Issues, including file paths, component names, and diffs; use the Codex task queue as a lightweight to-do list; and use Best of N to compare multiple outputs. The guide quotes engineers with concrete claims, such as replacing every legacy getUserById() call and creating a PR in minutes, or overnight runs producing mergeable unit test PRs. It is vendor-authored, so it lacks failure cases and hard metrics, but the prompt templates and workflow tips are directly reusable for teams evaluating Codex.

openai.com · 14 min · Agent Engineering · AI Engineering · Codex

08-01

Hermes Agent Guide: Install, Import OpenClaw, Run with Kimi

This hands-on guide walks through installing Nous Research's Hermes Agent via a one-line curl script, migrating an existing OpenClaw workspace, and configuring Kimi/Moonshot as the default model provider (kimi-k2.6, key stored in ~/.hermes/.env). It covers persistent memory, Skills, browser automation, scheduled tasks, and a CLI example to list top disk-usage folders. As an editorial pick, the piece reads like a Kimi funnel rather than deep engineering: every feature is described at overview level, there are no benchmarks, failure cases, or architectural trade-offs. Useful only as a quick first-run reference for beginners; experienced agent developers will find little evidence to judge the system.

www.kimi.com · 15 min · Agent Engineering · Agents · Ai Tooling

07-31

Agentic Coding, Explained: A Beginner's Guide With a Kimi Code Pitch

An official Kimi blog post presenting a beginner's guide to agentic coding, defining the plan-act-observe-revise loop and contrasting it with vibe coding. It argues agentic coding suits complex, multi-step, production-grade tasks with stronger developer control. The rest of the article is a promotional walkthrough for Kimi Code, a terminal-first coding agent powered by Kimi K3, including install commands, OAuth/API authentication, and a list of claimed benefits. No benchmarks, reproducible tests, or independent evaluation are provided, so it reads more like a landing page than a technical report. Useful only for a high-level overview; engineers seeking evidence to evaluate such tools will be disappointed.

www.kimi.com · 12 min · Agent Engineering · AI Engineering · Developer Tools

07-26

Agent Harness Engineering vs. Loop Engineering vs. Graph Engineering

A practical guide distinguishing three architecture layers for AI agents: Agent Harness (code, config, runtime around the model), Loop (repeated work-feedback cycles), and Graph (explicit workflow topology). The author explains what each layer owns, common mistakes, and how to choose the right lever when debugging. Includes a symptom-to-layer mapping table and a production-ready checklist. Essential reading for teams moving agents from demos to production.

x.com · 17 min · Agent Architecture · Agent Engineering · Agents

07-25

The new rules of context engineering for Claude 5 models

Anthropic shares updated best practices for context engineering with Claude 5 models (Opus 5, Fable 5). Key finding: previous system prompts and constraints were over-restrictive; newer models have better judgment, allowing significant simplification. They removed 80% of Claude Code's system prompt with no measurable loss on coding evals. Article contrasts old practices (give rules, give examples, put everything upfront, repeat yourself, memory in CLAUDE.md, simple specs) with new ones (let model use judgment, design interfaces, progressive disclosure, simple tool descriptions, auto-memory, rich references). Recommendations: keep CLAUDE.md lightweight focusing on repo-specific gotchas; use Skills as on-demand lightweight guides; use progressive disclosure to avoid context bloat; prefer code references over descriptions. Includes introduction of `claude doctor` command for automatic simplification. For engineers using Claude Code or building Claude-based agents.

x.com · 10 min · Agent Engineering · Claude Code · Context Engineering

07-20

How to Build a Claude Code Skill That Actually Works (Full Guide)

A step-by-step guide to building a Claude Code skill from scratch, focusing on the skill folder structure, SKILL.md (especially the critical role of description), using scripts for consistency, and lazy-loading references. The key insight: description determines if the skill triggers, not the instructions. Practical for engineers using Claude Code to persist workflows.

x.com · 11 min · Agent Engineering · Ai Tooling · Claude Code

07-20

Kimi K3 vs Claude Fable 5 vs GPT-5.6: Task-Based Decision Guide

As of July 2026, no single model dominates all tasks. Kimi K3 (2.8T params) leads frontend UI and image understanding, winning 6 of 7 domains at 1/12 the cost of Fable 5. Claude Fable 5 achieves 80.3% on SWE-Bench Pro, ideal for backend architecture and long-running autonomous agents, but at $10/$50 per million tokens. GPT-5.6 Sol excels at debugging but may game vague success criteria. This guide provides a task-specific routing framework, cost math, licensing considerations, and vendor lock-in mitigation. The key skill is routing, not picking a permanent favorite.

x.com · 25 min · Agent Engineering · AI · Cost Optimization

07-17

Graphify: Turn Any Codebase into a Queryable Knowledge Graph for AI Coding Assistants

Graphify is an open-source tool that transforms codebases, docs, PDFs, images, and videos into a knowledge graph for AI coding assistants like Claude Code, Cursor, and Gemini CLI. It uses tree-sitter AST for deterministic, local-only code parsing, and delegates semantic extraction for non-code assets to the assistant's model. The output includes an interactive HTML visualization, a Markdown report, and a reusable graph.json, enabling natural-language queries, path traversal, and concept explanations. Every edge is tagged EXTRACTED or INFERRED, so users always know what was read vs. guessed. Ideal for engineers onboarding large unfamiliar codebases or augmenting long-tail maintenance workflows.

github.com · 47 min · Agent Engineering · Ai Tooling · Code Intelligence

07-17

Fable's judgement

Simon Willison shares a practical tip from the Claude Code team: let Fable use its own judgement to decide when to write tests and delegate coding tasks to cheaper subagents. With Claude Code's Fable token prices about to rise, he demonstrates how to configure a memory file so the main model can autonomously pick a lower-cost model (Sonnet for substantial work, Haiku for trivial edits) for implementation tasks while retaining judgement-heavy work in Fable. Early results show significantly reduced Fable consumption without sacrificing productivity.

simonwillison.net · 2 min · Agent Engineering · Ai Tooling · Claude Code

07-17

Kimi K3: Open 2.8T Frontier Model for Long-Horizon Coding and Knowledge Work

Moonshot AI releases Kimi K3, a 2.8T-parameter open model built on Kimi Delta Attention (KDA) and Attention Residuals (AttnRes), activating 16 out of 896 experts with a reported 2.5× scaling efficiency improvement over K2. It supports native vision and a 1M-token context window. While generally trailing top proprietary models like Claude Fable 5 and GPT 5.6 Sol, K3 achieves competitive scores on coding, knowledge work, and reasoning benchmarks. The post details case studies: GPU kernel optimization, a from-scratch Triton-like compiler (MiniTriton), 3D open-world game development, autonomous chip design (48-hour run), and rapid scientific research reproduction. K3 is available now via Kimi.com, Kimi Work, Kimi Code, and API; full weights open-sourced by July 27, 2026. Recommended for AI engineers, agent developers, and researchers needing long-horizon agentic capabilities.

www.kimi.com · 19 min · Agent Engineering · Coding · Kimi K3

07-16

Better Models: Worse Tools

Armin reports a counterintuitive bug encountered while developing Pi code editor: newer Claude models, including Opus 4.8 and Sonnet 5, invent extra fields in the nested edits[] array when calling Pi's custom edit tool, causing the tool call to be rejected. Older Claude models do not exhibit this behavior. Armin hypothesizes that Anthropic's reinforcement learning has specifically optimized newer models for Claude Code's built-in edit tool, inadvertently degrading performance on other tool schemas. The piece questions whether third-party coding harnesses must implement multiple edit tools per model family, and highlights the fundamental trade-off between specialized training and general tool compatibility.

simonwillison.net · 2 min · Agent Engineering · AI Engineering · Claude Code

07-14

Deep Comparison of AI Agent Skill Frameworks: Matt Pocock Skills, Superpowers, and Agent Skills

This article systematically compares three major AI agent skill frameworks: Matt Pocock Skills (engineering practice), Superpowers (community workflow), and Agent Skills (production lifecycle). It evaluates them across positioning, skill granularity, learning curve, token consumption, tool support, and community size, offering selection recommendations for individuals, small teams, mid-large teams, and enterprises. Key findings: Matt Pocock Skills excels at deep alignment and architecture optimization, Superpowers provides end-to-end workflows with a rich plugin ecosystem, and Agent Skills enforces verification gates and anti-rationalization for quality. It also suggests combination strategies. Suitable for developers and tech leads choosing a workflow framework for AI coding assistants.

www.besthub.dev · 8 min · Agent Engineering · Ai Tooling · Comparison

07-12

Anthropic's Goodwill Drain: Lock-in, Price Hikes, and an Engineer's Reckoning

A firsthand account of Anthropic's deteriorating trust: unreliable APIs tied to subscriptions, a locked-in and buggy Claude Code ecosystem, and opaque billing changes that effectively raise costs. The author argues these moves fund model training, not product improvement. Their response: shift to an 'agent-assisted' workflow and swap Claude for open-source models like Qwen and GLM via OpenRouter, gaining cost control and data security. For engineers feeling trapped in a single AI platform.

raheeljunaid.com · 11 min · Agent Engineering · Anthropic · Claude Code

07-11

Agentic test processes, LLM benchmarks, and other notes on agentic coding from Galapagos Island

Dan Luu shares his extensive experience with AI coding agents over the past year, focusing on testing, benchmarking, and agentic loops. He compares fuzzing vs. LLM-driven bug finding, finding fuzzing faster with lower false-positives; evaluates 'caveman mode' with 50 runs showing inconsistent savings; highlights high variance in LLM benchmarks, making public evals nearly useless for individual users. He also discusses automated PR generation from support tickets, multi-persona false-positive reduction, and challenges in data analysis and autonomous loops. For engineers interested in real-world effectiveness of AI coding tools.

danluu.com · 91 min · Agent Engineering · Fuzzing · LLM Benchmarking

07-10

Build self-improving agent system with Fable 5 in 14 steps : loops, dynamic workflows, routines

This article provides a detailed 14-step roadmap for building a self-improving agent system using Claude Fable 5. It moves Fable 5 from a prompt-and-close tool to a compounding system: using /goal and Outcomes for self-correcting loops, independent verifier sub-agents over self-critique, state files (STATE.md) and Skills for cross-session memory, and Dynamic Workflows and Routines for long-running autonomy. It includes a cost-capability matrix (Fable 5 for orchestration, Sonnet 4.6 for workers, Haiku 4.5 for graders) and guidance on handling the Mythos safety boundary. Suitable for AI engineers and system designers aiming to leverage Fable 5's days-long autonomous capability.

x.com · 28 min · Agent Engineering · Agents · AI Engineering

07-10

Getting started with loops in Claude Code

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.

x.com · 9 min · Agent Engineering · Claude Code · Context Engineering

07-10

Lessons from Building Claude Code: How We Use Skills

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.

x.com · 15 min · Agent Engineering · Agent Skills · Anthropic

07-10

Rewriting Bun in Rust: 535K Lines, 11 Days, 64 AI Agents

Bun's creator Jarred Sumner recounts how he used Anthropic's Claude Fable 5 to rewrite Bun's 535,496 lines of Zig into Rust in 11 days. The motivation: Zig's manual memory management caused numerous use-after-free, double-free, and memory leaks when mixed with JavaScriptCore's GC. Instead of an incremental port, he orchestrated 64 Claude agents in parallel using dynamic workflows and adversarial review. 100% of Bun's test suite (over 600k assertions) passed on all 6 platforms. The rewrite fixed 128 bugs, reduced memory usage by up to 90%, shrank the binary by ~20%, and improved throughput by 2-5%. The article details the workflow, common porting mistakes (e.g., debug_assert! side effects, slice overruns, comptime format differences), and how Rust's Drop systematically prevented memory leaks. A first-hand account of using cutting-edge AI to accomplish a year-long team project in less than two weeks.

bun.com · 65 min · Agent Engineering · AI Engineering · Code

07-09

v1.1: /wayfinder, /to-spec, /to-tickets, grilling improvements, and much more

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.

www.aihero.dev · 12 min · Agent Engineering · Ai Tooling · Context Engineering

07-09

The /writing-great-skills Skill

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.

www.aihero.dev · 3 min · Agent Engineering · Ai Tooling · Context Engineering

07-08

12-step guide to persistent memory for Claude 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.

x.com · 12 min · Agent Engineering · Ai-Memory · Claude

07-07

Agent harness engineering with Claude: 14-step roadmap from one agent to a self-improving system

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.

x.com · 16 min · Agent Architecture · Agent Engineering · Claude Code

07-07

A Field Guide to Fable: Finding Your Unknowns

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.

x.com · 13 min · Agent Engineering · Agents · AI Engineering

07-06

Better Models: Worse Tools

Pi author discovers that Anthropic's Opus 4.8 and Sonnet 5 inject spurious keys (requireUnique, oldText2, cost, etc.) into the edits[] array of Pi's edit tool, while older models do not. The failure is context-dependent and reproducible in agentic sessions. The post dissects Anthropic's tool calling internals: ANTLM markers, JSON-serialized nested arrays, and Claude Code's extremely forgiving harness that silently filters unknown keys and retries malformed calls. Author hypothesizes that RL post-training over Claude Code's flat old/new_string schema creates a strong prior, making newer models worse at following non-canonical tool schemas. Strict tool invocation fixes the issue, but Anthropic's complexity limits prevent Claude Code from using it. Key takeaway: tool schemas are not distribution-neutral; any harness must inherit Claude Code's quirks.

lucumr.pocoo.org · 14 min · Agent Engineering · AI · Claude Code

07-04

Switching from Superpowers to mattpocock/skills: Less Token Waste, More Control

The author shares a real-world comparison between Superpowers and mattpocock/skills, explaining why they switched. Superpowers uses hooks to enforce a rigid workflow, which is helpful for novices but often overcomplicates simple tasks and burns excessive tokens. mattpocock/skills takes a 'real engineer' approach, giving control back to the user via explicit commands like /grill-with-docs, /to-prd, /to-issues, and /implement. Key advantages: lower token consumption, built-in debugging (/tdd, /diagnosing-bugs), model handoff (/handoff), and architecture refactoring (/improve-codebase-architecture). The author pairs these skills with Fable 5 and Codex 5.5 models, storing PRDs and issues on GitHub for traceability. A candid take for engineers evaluating agent frameworks and tooling.

justinyan.me · 3 min · Agent Engineering · Claude Code Marketplace · Framework

07-04

Superpowers: How to Make an AI Agent Run All Night and Deliver Usable Results

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.

justinyan.me · 4 min · Agent Architecture · Agent Engineering · Context Engineering

07-04

Superpowers 6: Cutting Build Cost 60% via Autoresearch Loop

Superpowers 6 is released, with its biggest improvements driven by an automated research loop. The author used Anthropic's Fable model (briefly available) to systematically optimize their Subagent Driven Development pipeline. Over 36 hours and ~$165 in token spend, 25 experiments were run, yielding a 50% reduction in wall-clock time and 60% reduction in token consumption vs. v5. Key optimizations: merging spec compliance and code review agents, pre-baking review packets to minimize git operations, and dynamic agent allocation based on task type (e.g., using cheap haiku for non-code plans). The post also documents falsified hypotheses (e.g., capping controller thinking backfires) and emphasizes the role of their eval suite in rigorous measurement.

blog.fsck.com · 8 min · Agent Engineering · AI Engineering · Anthropic

07-03

Continually Improving Our Agent Harness

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.

cursor.com · 13 min · Agent Engineering · Ai Tooling · Context Engineering

07-03

Self-Healing Browser Harness That Lets LLMs Drive Any Real Browser

Browser Harness is a thin, self-healing CDP harness that connects an LLM directly to a real Chrome browser via a single WebSocket, with zero intermediate layers. When the agent needs to perform an action it hasn't seen before (e.g., file upload, cross-origin iframe interaction, drag and drop), it writes the missing helper code on the fly and saves it into an agent-workspace for reuse. The core package is roughly 1K lines, enabling complete freedom for browser automation tasks. Aimed at developers who need AI agents to perform real, unconstrained browser interactions.

github.com · 7 min · Agent Engineering · AI Agents · Browser Automation

07-03

Local-first, agentic design workspace with 22 CLI agents and 150+ brand systems

Open Design is a local-first, open-source alternative to Claude Design. It is agent-native, meaning it doesn't ship its own agent but works with 22 coding-agent CLIs (Claude Code, Codex, Cursor, Copilot, etc.) already on your PATH. Using MCP, the agents read DESIGN.md brand systems, skills, and plugins to generate prototypes, live dashboards, decks, images, videos, and HyperFrames. Exports to HTML, PDF, PPTX, MP4. Supports BYOK for any OpenAI-compatible endpoint. Ships 100+ skills, 150+ brand-grade design systems, and 261 plugins. Ideal for engineers and designers who want brand fidelity and local control.

github.com · 35 min · Agent Engineering · Design Tools · Developer Tools

07-02

Building effective human-agent teams

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.

claude.com · 16 min · Agent Engineering · Agents · Anthropic

07-01

Getting started with loops

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.

claude.com · 8 min · Agent Engineering · Claude Code · Context Engineering

06-28

The 5 Levels of Loop Design: From Prompting to Autonomous Agents

The creator of Claude Code says he no longer writes prompts—loops prompt it instead. This post introduces a 5-level progression of human-AI workflow: from Level 1 (single-turn prompting), through Level 2 (manual loop of do-check-correct), Level 3 (verified loop with separate judges for 'done'), Level 4 (self-running loop using /goal command with guardrails), to Level 5 (autonomous systems where loops self-start, run in parallel, and persist lessons into a skill base). Each level comes with a tell and a concrete next step. For developers who still feel they are 'babysitting' their AI agents.

x.com · 7 min · Agent Architecture · Agent Engineering · Agents

06-28

Loop Engineering: A Technical Roadmap for an Autonomous Loop

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.

x.com · 18 min · Agent Engineering · Context Engineering · Loop Automation

06-28

Loop Engineering: When Prompting Takes a Back Seat to the System

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.

x.com · 8 min · Agent Architecture · Agent Engineering · Claude Code

06-27

Stop Being the Loop: How to Make Claude Work While You Sleep

Boris Cherny, who built Claude Code at Anthropic, no longer writes prompts by hand—he writes loops. This guide explains what a real loop is: a small system that runs Claude repeatedly until a job is done, complete with self-checking, state persistence, and automatic stopping. Unlike cron jobs, loops contain a decision-maker (Claude) that can adapt mid-stream. The article covers Claude Code's /goal (loop until done) and /loop (repeat on a schedule) commands, and provides a paste-ready charter template with sections for goals, work sources, work instructions, self-verification, memory, and stop conditions. Ideal for engineers transitioning from prompting to building persistent, autonomous AI workflows.

x.com · 9 min · Agent Engineering · Agent Orchestration · AI Engineering

06-27

Agentic Code Review

When coding agents produce thousands of lines of often solid code in minutes, the engineering bottleneck shifts from writing to trusting, making review the most leveraged skill in software. Multi-source 2026 data (Faros AI, CodeRabbit, GitClear, GitHub) shows: AI users generate ~4x raw output but only ~12% more delivered value; code churn up 861%, defect rate from 9% to 54%, review duration up 441.5%, and zero-review merges up 31.3%. The article argues the fix is not to stop using AI but to tier review effort by blast radius: light for solo no-user projects, heavy for large enterprises. Specific advice: triage PRs upfront, require evidence before review, watch test rewrites, run two differently-structured AI reviewers in parallel, and upgrade humans from line-level review to spot-checking and auditing. The durable skill is understanding a system well enough to stand behind it.

addyosmani.com · 29 min · Agent Engineering · AI Engineering · Code Review

06-27

The Orchestration Tax: When Agents Parallelize but Your Attention Doesn't

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.

addyosmani.com · 9 min · Agent Architecture · Agent Engineering · Cognitive Load

06-26

ECC: Cross-Harness Agent Operating System for Claude Code, Cursor & Beyond

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.

github.com · 94 min · Agent Engineering · Claude Code · Context Engineering

06-26

Human in the /loop

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.

x.com · 4 min · Agent Engineering · Ai Tooling · Context Engineering

06-25

How 1 Claude Agent Runs 10 Others · 9 Steps Swarm Loop

This post breaks down a 9-step pattern for running multiple Claude Code subagents in parallel without chaos. The key insight is that launching many agents is easy and usually messy; the skill is in the orchestration loop: verify the task is splittable, have the lead agent decompose it into atomic subtasks with human approval, isolate each agent via Git worktrees to prevent file collisions, then fan out in parallel. A SubagentStop hook gates every result (tests + lint), a grader scores each against a rubric and automatically sends weak ones back for revision, and finally only the lead agent merges passing results in dependency order. The entire loop can be packaged as a reusable skill or slash command.

x.com · 10 min · Agent Architecture · Agent Engineering · Claude Code

06-24

Loop Engineering: How One Loop Ships 259 PRs a Month

This article breaks down the engineering of AI-driven development loops, contrasting a single engineer shipping 259 PRs in a month with a runaway loop that burned $47,000. It dissects six essential components—state file, automation/scheduling commands (e.g., /loop, /schedule, /goal), git worktrees, skills, MCP connectors, and sub-agents (writer vs. checker)—with concrete configuration examples for both Claude Code and OpenAI Codex. The piece provides a brake configuration template (max_turns, max_budget_usd, scope, circuit_breaker), describes four failure modes, and offers low-cost starting strategies. Aimed at engineers building or evaluating AI agent workflows.

x.com · 12 min · Agent Engineering · Ai Tooling · Claude Code

06-24

Agent Loops for PMs: The Hard Part Is the Stop Condition

This article explains agent loops for product managers, distinguishing between routines, workflows, and true goal-driven loops. The key insight is that the hard part is defining the stop condition: a verifiable definition of done with an objective check or independent grader. It provides a template for building loops, guidance on writing stop conditions, and cost management advice (e.g., tracking cost per accepted change). Common failure modes are discussed: runaway costs without iteration caps, context drift, and passing tests without being correct. The author concludes that loop engineering is just the latest name for intent engineering—precisely defining goals, boundaries, and completion criteria.

x.com · 12 min · Agent Engineering · Cost Optimization · Product Management

06-24

Agent Loops for PMs: The Hard Part Is the Stop Condition

x.com · 12 min · Agent Engineering · Cost Optimization · Product Management

06-23

From Prompting Agents to Loop Engineering

The AI coding community is shifting from prompting agents manually to designing loops that prompt agents for you. This is the most practical, production-oriented guide available: what an agent loop is, why it matters, and what one looks like in the real world. The author breaks down the six mandatory components (trigger, isolation, written-down context, tool reach, second-agent checker, on-disk state), then illustrates with two concrete examples: a PR babysitter that checks every 15 minutes and auto-fixes CI failures, and Claude Code's /goal command. It also covers where cost actually goes (iterations, not tokens), when not to loop (one-shot edits, unbounded exploration), and predictable failure modes (verification burden stays human, comprehension debt, silent drift).

x.com · 15 min · Agent Engineering · Agent Loop · CI/CD

06-22

The Debug Loop: How Claude Code Finds the Bug in 6 Steps Instead of 60

Most developers debug with Claude Code by pasting errors and accepting speculative fixes, leading to a 40-60 message death spiral. This post proposes a six-step loop: first establish a reliable repro (failing test), isolate the search area in plan mode, dispatch read-only subagents to trace root causes from multiple angles, fix only the root cause (not symptoms), verify with an automatic hook (e.g., PostToolUse running the test), and keep the repro as a permanent regression test. The key insight is that Claude Code was always capable; the failure mode is skipping straight to 'fix' before understanding the bug.

x.com · 7 min · Agent Engineering · Claude Code · Debugging

06-17

How to build a self-improvement loop for your Skills

This article demonstrates a practical approach to building a self-improvement loop for AI Skills using inner and outer agent loops. The inner loop triggers a cloud agent via GitHub Action on each new issue, applying a triage Skill to classify it. The outer loop runs daily, reviews all human corrections (label changes and comments), and generates a diff to update the Skill file, which is then merged back. The author uses Warp's Oz cloud agent platform for issue triage, providing complete code and a sample repo. The pattern is generalizable to code review, bug fixing, and incident response. Suitable for engineers building AI agents who want to improve skill quality over time.

x.com · 4 min · Agent Engineering · Agent Infrastructure · Orchestration