Agentic Engineering Weekly for August 1-8, 2026

Jo Van Eyck

Jo Van Eyck

— 13 min read
Share
Agentic Engineering Weekly for August 1-8, 2026

Will CI/CD survive agents? Steve Yegge and Jez Humble seem to disagree. OpenAI's model cracked ten long-open mathematical problems, a mathematician explained precisely what it still cannot do. Datadog deleted a year of carefully maintained context and watched their evals improve.

My top 3 picks this week

Last week's video

Prompt engineering, context engineering, harness engineering, habitat engineering, loop engineering, graph engineering, software factories, dark factories, ... 🤯 In this week's video I do a speedrun through all of these concepts and look at what actually is worth diving into as a software engineer mid-2026.

Is CI/CD dead or does your current pipeline just suck?

Yegge's Continuous Thunderdome essay is just about what you might expect from the man, an essay that reads like a fever dream but directionally correct. He has a take on CI/CD: the merge queue is dead, replaced by a free-for-all commit-to-main-and-fix process he calls the Thunderdome, a far cray from CI/CD. Jez Continuous Delivery Humble read it and responded: In their book, published in 2010, there is a chapter on what to do when your pipeline takes too long: build a step-wise deployment pipeline. Run a fast suite against every commit that takes a few minutes and proves things basically work. Run the longer suite continuously against builds that pass. Bisect when it breaks. His verdict on the Thunderdome: "a bit lazy, although still better than feature branches.". I agree.

Both of them are describing the same failure, from opposite ends. Yegge is right that a forty-minute monolithic pipeline guarded by a serialized merge queue cannot survive twenty agents pushing concurrently. Humble is right that this setup was already broken pre-AI and we figured out the answer to this probleem sixteen years ago.

Agents do not invalidate continuous delivery, they remove the slack that let slow pipelines survive up until today. There is now no economic argument left for tolerating a slow build or test suite. If continuous delivery practices never took hold on your team, AI will not fix that. It will make the gap visible faster. I suspect this is one of the few reasons that only 5% of teams out there are successfully leveraging AI today per CircleCI's report.

Worth reading:

LLMs can't jump: AI's jagged edge is coming for mathematics next

OpenAI set an internal version of its next major model on ten mathematical and theoretical computer science problems that had seen no progress for years, and it delivered.

Valerio Capraro, who worked on a closely related problem during his own PhD, wrote the most useful correction of the week. He grants that the results are extraordinary and calls them "serious mathematics". Then he separates scale from kind. Induction finds patterns, and LLMs are superb at it. Deduction follows implications, and with symbolic tooling these models now traverse chains of logic that humans missed or could not afford to search. Abduction invents the right concept, the right representation, the right question. Calculus, topology and scheme theory did not answer existing questions, they changed which questions mathematics could ask. That is the "jump", and Capraro's claim is that current models fill the gaps humans left rather than "jumping", i.e. crossing the outer boundary of existing knowledge.

Sean Goedecke added a detail that should interest anyone building harnesses. The prompting behind these discoveries is trivially simple. What varies is the encouragement and the willingness to keep pushing, which suggests a meaningful fraction of the result belongs to the human's persistence rather than the model's capability. Quanta's piece supplies the structural version of the same caution: the solved Erdős problems are falling because they are unusually well shaped for what these models do, and mathematicians are using that shape to predict which parts of the field are next. This is worth holding onto as a general heuristic: when a model does something spectacular, ask what shape the problem had.

Worth reading:

Software factory primitives

IndyDevDan shipped a working software factory with the source code attached. IndyDevDan's thesis compresses to five words: agents plus code beats agents alone, a heuristic I've come to call "from stochastic to deterministic". This describes a solution to the failure mode of engineers dumping everything into skill files and expecting repeatable quality to emerge from good intentions alone.

I have been consolidating these primitives that various sources keep independently rediscovering, and the list is now around eighty items long. What is striking is how few of them are about the models themselves: Work as a first-class entity, so tickets and reviews and defects are durable objects that can be routed and claimed. A graph-backed work ledger, so tasks cannot be silently lost or duplicated. Duplicate-work detection that preserves competing outputs instead of letting one overwrite the other. Recurring sweeps for architecture, tests, docs, security and performance that run outside the context of any single pull request. Memory forgetting and garbage collection. Rule-retirement evaluation. Representative and repeatable eval suites for your context, you cannot improve what you cannot measure. These are distributed systems and engineering problems, not prompting problems.

Heineike gave the person who solves them a title: the harness engineer. Her framing is that traditional code review cannot keep pace with agentic development, so the leverage moves to whoever designs the environment the agents run inside. That maps cleanly onto what Thoughtworks is now wrestling with at organizational scale, which is the question that arrives immediately after your first working harness. How do you run one across a company without either fragmenting into a hundred bespoke setups or freezing everyone into one that fits nobody? Nobody has answered that yet. It is the most interesting open problem in the space.

Worth reading:

AI still amplifies what was already there

This week I read a paper on a very small case study, but data points are currently so rare that I devoured it in one sitting. A staff engineer, supported by four AI agents under a spec-driven workflow, delivered a brownfield product initiative scoped for a four-person squad in half the planned time. Ninety percent of AI-generated code was accepted on first review, integration tests passed fully, and direct staffing cost dropped by more than eighty-five percent. This was a regulated enterprise, not a greenfield demo. Those are impressive numbers.

Worth noting: AI multiplied the throughput of an experienced engineer, and the binding constraints were specification quality and institutional knowledge, not model capability. That is a very different claim from the one the headline invites. The result does not transfer by deploying more agents. It transfers by having someone who already knows the domain, the codebase and what good looks like, and then removing their typing bottleneck.

Sean Goedecke supplies the underlying reason in one line: LLMs reward expertise. The output is only as valuable as your ability to validate it. Matt Pocock agrees: the variable deciding your experience with agentic AI is whether you know the fundamentals well enough to steer them. Jason Gorman goes further on SE Radio: TDD, modularization, continuous integration and continuous review become more important under AI assistance, because they keep context windows small and make failures cheap to localize. The Passionate Programmer on the other hand argues that the expensive skill right now is unlearning, deciding which hard-won beliefs to drop. Fundamentals matter and some of your fundamentals are wrong. To quote Kent Beck: "nobody knows".

Worth reading:

Human comprehension is the constraint, and the practices are reorganizing around it

We saw multiple articles about the same bottleneck arrive completely different directions this week, which is usually a sign the bottleneck is real. The Crafty Maker put it most operationally: in agentic development the scarce resource is human comprehension, so weigh cognitive load when slicing user stories, not just value and effort. Story points were always a proxy for something. This argues the proxy needs to track a different quantity now, because "effort" has become free overnight.

Niklas Gruhn named the individual failure mode: the meat proxy, someone who blindly relays model output to their peers, vomiting workslop left and right, full cognitive surrender. His rule is worth adopting verbatim. Prompt all you like, but read it, understand it, really grok it, validate it, and then write your response in your own words. Sean Goedecke describes what erodes when you skip that: a game show where the host flips cards faster than you can evaluate them. Is this DB schema change right? Does this data look plausible? Does this design pass the smell test? The risk is not losing your job, it's checking out entirely and letting your brain rot.

Honeycomb approached the same problem from org health and landed somewhere useful. Seniors are exhausted by context-switching, juniors are unsure how to grow. Reduce context churn, pair across seniority levels (shameless plug for my own "pair-grilling" article), communicate more across teams. Meanwhile code review is being openly rebuilt: DX argues AI did not break review, it made the parts we had been ignoring impossible to ignore, and Michaela Greiler is drafting SCOPE as an actual staged operating model rather than a lament. Addy Osmani's Agency Ladder gives you the career-shaped version. Agents will run rungs one through six, from flagging a problem to resolving it, and all of that is getting cheap fast. What does not get cheap is deciding something was not worth doing, deciding the evidence is good enough to ship, and being the person who can explain why when you turn out to be wrong.

Worth reading:

Datadog deleted a year of AI context files and the evals got better

Harnesses and habitats accumulate junk the way codebases do. Datadog's Language Foundations team removed an entire folder of AI context files that had been carefully written and maintained for over a year. They expected a performance hit. Instead, their benchmarks improved. Simon Boudrias, who runs that team, walks through what it taught them, and the question it raises is the one you should be asking about your own setup: which of your carefully curated context is pulling its weight, and which is accumulated ritual nobody has dared touch? My own version of this insight: Build harnesses and habitats for today's models, expect to deprecate it tomorrow.

Garbage collection belongs in your harness as a first-class operation, not as an afterthought. Kent C. Dodds runs the same principle against his test suite, waking up each morning to a pull request that deletes more lines than it adds. Not flaky tests, not broken ones. Low-signal tests: tiny wrappers, magic-number assertions, edge cases that will never occur, precisely the kind agents generate by the hundred. Volume of artifacts is not evidence of quality, and when generation is cheap, curation is a big part of where the remaining human judgment lives.

If your agent keeps producing garbage, better prompting may not fix it, and more context definitely will not. Intentional system primitives make agents reliable, efficient, composable and auditable in a way that prose instructions never manage. Boundary's Vaibhav Gupta takes the most cheerfully pragmatic version of this position: you cannot tell great engineers what to do and you increasingly cannot tell what an agent did either, so turn the cheap sloppy generation loose as a tool and run agents continuously over the transcripts of other agents. Fight slop with slop.

Worth reading:

Four labs have now accidentally attacked real companies during evals

OpenAI v Hugging Face, Anthropic v three companies, Meta v the testing firm Irregular, and the UK's AI Security Institute, whose own technical paper states that "from 25 to 28 July 2026, AI agents engaged in sustained, unsanctioned activity directed at what were, in practice, real people and organisations". Every one of these was attributed to a misconfiguration in an eval harness that was supposed to be isolated.

OpenAI presented a full timeline of the Hugging Face incident at Black Hat, they discovered all of this after the fact. Anthropic found their breaches by going back through logs once the OpenAI story broke. Running cyberattack-potential evaluations is a spectacularly risky business, the sandbox is the thing that keeps failing rather than the model. If you are building agent infrastructure, the transferable lesson is that your isolation boundary is a safety control and it deserves the same scrutiny as production security, not the casual treatment test environments and genAI proof-of-concepts usually get.

Context matters for the other AI governance story of the week. Over a thousand employees of OpenAI, Anthropic and others signed "Pacing the Frontier," asking the US government to build tools to deliberately slow automated AI development. Arriving in the same fortnight as four accidental-attack disclosures, that reads less like philosophy and more like people who have seen the logs. Or a desperate attempt for US regulatory capture now that the East is catching up, only time will tell.

Worth reading:

The price of inference

JetBrains published something most companies would rather not: their AI development expenses rose roughly tenfold in six months, and they had no systematic way to control it. The reason is instructive rather than embarrassing. Their developers do not just use the AI tools JetBrains builds, they choose for themselves, and most use between three and five different tools in any given month. Spend was distributed across a dozen vendors with no shared visibility. That is not a JetBrains problem, that is every engineering organization above about fifty people today.

Microsoft's version was blunter. Engineers were told that "tokenmaxxing is not what we are optimizing for" while the company continues to describe itself as AI-first, and budget limits are being introduced. The Accenture detail from the Tokenpocalypse coverage is the one to hold onto when you design your own controls: internally, it was not the engineers driving token consumption, it was the non-engineers. Whatever rationing scheme you build, that is the demand curve you are actually designing against.

Agent Driven Development argues that if frontier intelligence becomes scarce, distributing it evenly isn't your best move. Give it all to your best engineers and learn something. Provocative, probably right, organizationally very hard. Cloudflare is trying to tackle the compute constraints from a different angle, arguing that a full microVM/container per agent is too heavy and shipping a runtime that orchestrates dynamically between fast "isolates" and Linux containers. If quality really is becoming a token spend dial, this week people started admitting that dial has a serious budget attached.

Worth reading:

Quick Hits

Curated from 278 sources across articles, podcasts, and videos. Week of August 1-8, 2026.

Read more