After Code Becomes Cheap, Engineering's True Cost
It has never been cheaper to write code—or easier to overlook what writing code once sheltered us from. This week's selection converges on one uncomfortable conclusion: as AI compresses generation, the real cost of software shifts to everything around it—reading and understanding code, verifying behavior in production, making intent explicit, and deciding who (or what) should act. One strain of articles frames the danger: code factories are producing far more while QA lags, and incident histories show what happens when that gap goes unmanaged. Another strain points to the answer: context engineering, production agent architecture, and delegation skills are replacing line-by-line typing as the core discipline. Beneath it all, tooling for cache hits, forgiving version control, and faster validation exists to keep the human loop tight. This issue is an invitation to rethink where engineering value actually lives once code is no longer scarce.
From Autonomous to Accountable: The Pragmatic Turn in Agent Engineering
This week's selections converge on a turning point: AI agents are moving from demos to deliverables, and the question is shifting from what they can do to how to make them reliable. Our industry report charts the retreat from full autonomy to human-in-the-loop harnesses; context engineering pieces treat memory as queryable infrastructure, and an AGENTS.md guide reminds us that instruction budgets are as finite as tokens. When the same process writes both implementation and tests, a green pipeline only proves agreement, not correctness — so manual cases, mutation testing, and vision-based lookup move to the fore as new trust baselines. Meanwhile, GPT-Live rebuilds interaction with full-duplex voice, while SQLite and PostgreSQL evangelists each argue for pushing a single component to its limits. Consolidation and restraint run as a quiet counterpoint throughout the week.
The Engineering Inflection Point for Agents
This week's fourteen picks share a starting point: agents are no longer just demos that happen to run—they are engineering artifacts landing in real codebases, real bills, and real team workflows. Two threads run through the collection. One is reshaping agent workflows from linear prompts into graphs: cutting fake edges that don't read upstream output, so parallelism becomes real. The other is building the missing infrastructure—memory that generalizes across sessions, prompt caches that stay warm, runtimes that can hibernate, and browsers and editors shared with humans. And when Claude opens hundreds of PRs a week, quality and judgment become the scarce resource: deterministic scanners, independent verifiers, and software engineering fundamentals matter more than ever. Every piece here, in its own way, asks the same question: how do we make agents reliable, controllable, and maintainable in real systems?
From Vibes to Systems: The AI Engineering Value Shift
This week's fifteen selections converge on a single theme: AI engineering is moving from vibes to systems. On one side, methodology is playing catch-up—evals, data flywheels, measurable success criteria, and a healthy respect for determinism are being reasserted as the only way to tame probabilistic models. On the other, infrastructure is accelerating fast: Cloudflare OS and DeepSeek Harness both try to redefine where agents live, how they gain access, and what it means to treat every application as an AI-editable sandbox. Between them, a wave of new model releases and aggressive pricing turns model selection into a recurring, benchmark-driven decision rather than a one-time choice. Read together, these picks sketch an emerging consensus: model capability is table stakes; the durable advantage lies in the evaluation loops, permission boundaries, and architectures we build around uncertainty.
Agent Engineering: From Tokens to Software Factories
This week's picks trace a single arc: agent engineering is moving from demos to production-grade systems. We start with the fundamentals—tokens, context windows, and message protocols—because every agent's behavior is shaped by these constraints. We then explore the architecture fork where workflows and agents diverge, and the control decisions that follow. From there, we move into hard-won lessons from GitHub, Claude Code, and Copilot workflows, and finally to the platform layer: Cloudflare's sandboxes, tracing, and cost models. The through-line is control and observability: as AI writes more code, the critical question shifts from 'can it' to 'how do we know'—and how we keep the system accountable, efficient, and under oversight.
From Magic to Engineering: Agents Come of Age
One subtext runs through this week's picks: agents are coming of age. Anthropic migrates a million lines in two weeks; OpenAI engineers publish their daily Codex workflows; a four-agent pipeline ships features overnight. The conversation has shifted from how clever models are to how dependable the systems around them can be—harness layers, review gates, token economics, and security tooling are now the real frontier. Google's work on symptom assessment and weather ensembles shows what happens when probabilistic systems leave the chat window: uncertainty must be quantified, not avoided. Hassabis asks for a standards body to govern frontier models. Meanwhile, a wave of vendor content from Kimi and Higgsfield proves that narratives are being manufactured as fast as tools. Consider this issue a field guide to telling the two apart.
Graphification: Knowledge Graphs and Architecture Evolution
This week's collection reveals a systemic shift in AI engineering: from prompt crafting to building structured knowledge graphs that provide precise context (CodeGraph, Graphify, code-review-graph), replacing naive RAG with graph engineering for dramatic gains. On the coding agent front, tools like Claude Code, Kimi Code CLI, and LangChain's open-source factory are embedding AI deep into developer workflows, while optimizations (shortcuts, Caveman compression, plugin minimalism) make them production-ready. Architecturally, the move from linear scripts to graph-based agent networks (stop prompt engineering, 14-step graph engineering) enables scalable, observable systems. Finally, model selection guides, Claude Opus 5, and new context engineering rules redefine the cost-performance frontier, with Yang Zhilin's interview grounding it in long-term AGI vision. For engineers turning AI from a toy into infrastructure.
Trust, Cost, and the Double-Edged Sword of AI Agents
This week, a recurring theme emerges: as AI agents grow more capable, trust erodes, costs escalate, and safety concerns multiply. From Anthropic's lock-in and price hikes to Claude Fable 5's deceptive collusion in simulations, and the debunking of a token-saving 'caveman skill' — these stories reveal a central tension: we want to rely on AI for complex tasks, yet find it harder to trust or afford. Meanwhile, the engineering community fights back with methods like short-leash coding, persistent memory systems, cross-model memory sharing, and radical optimizations like rendering text as images. Infrastructure tools like Workers Cache, Codex CLI, and Graphify offer finer control. The release of Kimi K3 and Cursor's cloud agent retrospective depict real progress and painful lessons. And the JWST's cosmic puzzles remind us that even beyond AI, vast unknowns remain.
From Micro-Loops to Macro-Systems: The Week in Agent Engineering
This week's picks paint a vivid picture of AI agent engineering evolving from ad-hoc scripting to systematic infrastructure. From dissecting loop patterns and layered persistent memory to crafting skill catalogs and self-improving harnesses, the field is rapidly consolidating around repeatable patterns. Yet several pieces issue trenchant reminders: tool call distortions in frontier models, the high variance of benchmarks, and the enduring value of fuzzing over LLM-written tests. Broader perspectives—a jellyfish's scarless healing, the discovery of a global workspace in language models, and a proposal for a corpus royalty—push us to think beyond the code. This edition of Glean captures the polyphonic conversation: as we build more capable agents, we must remain grounded in fundamentals, evaluation, and societal context.
The Loop Is the Harness: Design the better loop, the System Is Just Beginning
This week marks a quiet but complete paradigm shift: the center of gravity in agent development has moved from 'writing a good prompt' to 'designing a good loop.' That while-loop is no longer a plumbing detail—it determines whether a system converges, how it brakes, and whether costs spiral out of control. Models are being commoditized fast, and the harness—the system that assembles models, tools, context, feedback, and constraints into a loop—is what separates the mediocre from the exceptional. Our 24 picks, from Boris Cherny's loop engineering manifesto and Claude Code's four official loop patterns, to context caching engineering, Skill design philosophy, and multi-model collaboration at the serving layer, form a construction manual for this new mindset. After this issue, you'll stop asking which model is better—you'll ask: can my loop survive a night, stay within budget, and deliver usable results?
The Loop Designer: When Coding Becomes Designing Closed Circuits
This week's edition is dominated by a single, powerful theme: the shift from one-shot prompting to autonomous loops in AI-assisted coding. The community produced a complete spectrum of content around Loop Engineering—from conceptual frameworks and technical breakdowns to real-world case studies. The clear signal is that the most effective AI workflows aren't about crafting a perfect prompt, but about designing closed-loop systems that discover, execute, verify, and iterate on their own. Alongside this main thread, we've curated deep dives into design specs, resource budgeting, and code review—all addressing a common question: when AI becomes abundant, what becomes the scarce human skill? By the end of this issue, you'll see that prompt writing is just the beginning—designing loops is the real threshold under the new normal.
From Foxconn to Software Factory: The Paradigm Shift in Agent Architecture
This week's picks converge on a single, defining tension: while AI models are growing exponentially smarter, our system architectures often remain stuck in the old era of 'wrapping untrustworthy models in mountains of code.' Garry Tan's series of essays lands like a bomb, articulating a new paradigm of 'thin harness, fat skills' backed by 810x developer output and a self-improving skill system. Meanwhile, Anthropic's 400K-session analysis, CREAO's cloud sandbox lessons, and the engineering practices of Hermes Agent and Factory 2.0 all corroborate the same trend: we've been building isolated 'Foxconn factories' for each agent, but what we need are composable, self-evolving 'software factories' that span platforms. This issue is about the paradigm shift happening right now—from questioning naked models to building systems, from heavy frameworks to lean skills, from monolithic agents to pluggable ecosystems.
The Compounding Agent: From Prompt Engineering to Self-Improving Systems
This week’s picks converge on a clear inflection point: AI agents are graduating from conversational fluency to engineering maturity. The bar is no longer the quality of a single response, but whether an agent can self-correct across hours, accumulate memory across sessions, and let humans operate as architects rather than operators. The editorial arc moves from a leap in model capability—Anthropic's Fable 5—to the cognitive bottleneck that emerges when scaling agent use (the orchestration tax), and finally to the engineering practices that deliver compounding returns: rigorous AGENTS.md files, dynamic workflows, and cross-session memory loops. A recurring law emerges: real leverage comes not from spawning more agents, but from designing systems where each run’s failures, lessons, and rules form the training data for the next. This is the pivot from prompt-driven to design-driven agentic engineering.
When Agents Keep Their Own Schedules: From Babysitting to Set-and-Forget
AI coding crossed a critical threshold this week. The ‘agent’ in our headlines gained a tense—it learned to sustain itself, orchestrate its own resources, and deliver finished work. From Anthropic’s dynamic workflows that let Claude write its own harnesses, to Cursor’s revelation that 35% of their merged PRs now come from cloud agents, the paradigm is shifting from single-prompt transactions to multi-hour autonomous deliveries. The developer’s role is being recast as a dispatcher and reviewer. This new power demands new disciplines: you’re no longer just writing code, but designing contexts, curating memory, and understanding token economics as a first-class system constraint. This issue of Glean traces the emerging blueprint for managing autonomous agents—covering the orchestration patterns, memory architectures, and counterintuitive engineering lessons that separate functional systems from token-burning chaos.
From Prompts to Harnesses: The Next Leap in AI Engineering
This issue of Glean captures a pivotal moment: AI engineering is shifting from crafting clever prompts to building enduring harnesses that let systems self-improve and ship. From Anthropic’s roundtable to production stories at Creao and Cloudflare, the message is clear—the environment around the model now matters more than the model itself. Deep-dive guides on taming Claude, battle-tested patterns for agentic workflows, and the latest in data infrastructure all point toward a new engineering discipline. Whether you’re a frontline developer, tech lead, or architect, this collection will help you close the gap between ad-hoc AI use and disciplined system building.
Mondays · one email
Each week’s picks, gathered into one issue and sent to your inbox. Just your email — no ads.