Our toolchain assumes one human writer, AI agents break that illusion

Christopher Meiklejohn One Writer Our tools assume one writer, and assume that writer is a human. Nothing computes what a change reads and writes at runtime, so the only known fix is brute force priced for organizations. 27 Jul 2026 In this blog post, I discuss three days in July 2026 when a single agent session ran away from me, and what those three days revealed about the concurrency assumptions buried in our development tooling. Six weeks ago I wrote The Test Suite Was the Incident my test suite had grown a pile of shared data nobody owned, every pull request paid to rebuild it, and the resulting failures had nothing to do with the changes under review. That cost me about $180 in one night. I got a worse one. It lasted three days, and in one twenty-four-hour stretch of it I burned through an entire Codex 20x

max plan. This post is not really about that, though. It is about a property of our tooling that the three days made impossible to ignore. Nearly every layer of this assumes one writer, and assumes that writer is a human. Git hands you a conflict and waits. Code review assumes somebody reads. A migration sequence assumes somebody is assigning the order. Each of those protocols terminates in a person. That is fine while there is exactly one, and while they are, in fact, a person. The agent runtime turns out to be on that list too, which I did not expect. It spawned eighty-four workers into a single checkout without being able to say what any one of them would read or write, and that is the same question git can’t answer about a diff. That assumption was invisible for forty years because nothing ever bound it at my scale. Agents break both halves at once: there are many of them, and not one of them is the person the protocol was waiting for. Git is the partial exception, and I will come to why the exception does not help. Nothing in the stack detects the violation when it happens. It gets caught later, somewhere else, attributed to the wrong change, and paid for at full price. Some context for readers arriving fresh. Zabriskie is a social app for live-music fans, and it’s also a deliberate experiment: I’m building a real, deployed, actually-used application almost entirely with AI agents (agents that wrote the features, agents that wrote the tests guarding those features, and agents that now open most of the pull requests), in order to find out what that’s like and, more usefully, where it breaks. I’ve written almost none of the code. That framing matters, because several things below look like obvious mistakes and are. I let agents design a migration scheme with only another agent reviewing it, I stopped reading most diffs, and I let sixty-four pull requests go up in a single day, all of which a careful engineer would tell you not to do and would be right about. But the point of running an experiment at the extreme is to find the walls. That week I found several at once. A migration, throughout, is a versioned SQL file that changes the database schema. CI is the automated checking that runs on every proposed change: build the app, spin up a fresh database, run the tests. Here is the shape of the three days. Treat these numbers as texture, not as evidence, for a reason I will get to. | | 24 Jul | 25 Jul | 26 Jul | | --- | --- | --- | --- | | pull requests opened | 19 | 64 | 28 | | pull requests merged | 20 | 50 | 30 | | incidents logged | 0 | 6 | 301 | Days in that table are UTC; clock times in the narrative below are Eastern (where I was). The burst ran past midnight UTC: 301 incidents on the 26th plus 60 more before 1 AM on the 27th, so 361 for the burst. Every incident count below is scoped to that window, and 253 rows is the total before 24 July. I offer that comparison as a sense of scale and not as a baseline, for the following reason. Those incidents exist because a standing instruction tells agents to log their own mistakes, and ten minutes into the worst night I tightened that instruction. The log therefore measures reported failures. Look at the daily series and it gets worse: there are days that week with ten and twenty merged pull requests and zero logged incidents, which at any real failure rate means nobody was logging rather than nothing broke. In short, I can’t give you a trustworthy baseline. What follows rests on

mechanism and on a few dated, checkable events, not on 361. The Session Late Saturday night the queue jammed. Sixty-four pull requests had gone up that day, ` was red, and nineteen open pull requests were stuck behind a suite that could not tell me which of them was broken. At 12:31 AM I opened a session with Codex and complained that CI was wasting too much money. Codex read that and hired a workforce. Over seventeen hours that session made 81 spawn calls, producing 74 direct children; those children spawned 10 more, for 84 threads. Then 358 calls waiting on them, 96 listing them, 85 sending follow-up work, and 13 interrupting them, which comes to six hundred and thirty-three tool calls of pure management overhead (spawn, wait, list, follow up, interrupt) against 54 messages from me over the same seventeen hours. All 84 ran in the same checked-out copy of the repository. Trivial parallelization, at scale, with a coordinator that only managed agents, on a toolchain built for one writer. The rest of this post is about why that combination is so much worse than it sounds. I asked afterward why it had spawned anything, since I never requested it. A language model asked why it did something produces plausible narrative, not introspection, and I apply that same skepticism to the self-reported incidents above. So the quotes below are not evidence, and I’m not offering them as any. I had already reached the same conclusion from the tool-call counts before I asked. I print them because they state that conclusion more plainly than I did, and because there is something worth looking at in a system that can describe the failure this precisely and could not avoid it. I chose to spawn multiple agents even though you did not ask me to. The environment permitted proactive delegation, but that was permission, not a requirement. I treated the availability of agents as a reason to use them instead of first asking whether they would reduce time, cost, or risk. It then diagnosed why the task was a bad candidate: A PR queue is largely serial because every merge changes ` , which changes the integration state of every remaining PR. The work needed one authoritative coordinator moving through the queue in order. Parallel agents could not independently merge overlapping PRs without continuously invalidating one another’s assumptions. On what those 358 waits were doing: The agents’ outputs created additional coordination work for me. I had to read their findings, compare conflicting recommendations, inspect supporting evidence, and decide how to combine them. The agents therefore generated work for the coordinator instead of reliably removing work from the critical path. A system with no notion of its own concurrency was handed a concurrency primitive and used it, reasonably, on a task the substrate could not support. What that substrate is, and why nothing in it objected, is the rest of this post. One number deserves care. I do not know how many of those 84 threads wrote to the checkout instead of reading it; from Codex’s own account many were investigating. A reader is harmless and a writer is not, and nothing in the toolchain drew the distinction or could. That’s the same missing primitive one level up: not even the agent runtime knew which of its children were writers. The Substrate Start with the layer that did anticipate this, because it is the one people reach for. Branches are optimistic concurrency control; worktrees go further, giving each writer a

physically separate checkout so that two agents can hold two versions of the tree at once. That works. However, git’s isolation stops at the edge of the source tree. A worktree gives an agent its own files. It doesn’t give it its own database, port range, mock server, or position in the migration sequence. Everything below the filesystem is shared and singular. That assumption was invisible to me because it never bound me. It has bound large organizations for a very long time, however, and over the last two decades they built the response to it: merge queues, hermetic builds, database-per-test, trunk-based development, automated culprit-finding, and whole infrastructure teams whose only job is to keep the thing moving. So what is new here isn’t the concurrency. It’s that a solo developer now operates in the regime that used to require an infrastructure organization, with none of the infrastructure and no headcount to build it. Agents removed the cap on my arrival rate. They didn’t hand me Google’s build system. The organizational fix is worth naming, because it isn’t subtle. Large companies make every developer’s environment a faithful copy of the one that builds and ships the product, either by moving development onto cloud machines provisioned from the same definition as CI, or by reproducing that environment in miniature on the laptop: a container per service, a database per test, a toolchain pinned to a lockfile. Somebody owns that, full time. The cost of getting it wrong is paid once, by a platform team, instead of every day by everyone else. I don’t have a platform team, and neither does anyone else building alone with agents. An independent developer can now reach a working prototype absurdly fast, faster than at any point in my career, and then hit the wall this whole post is describing: one environment, artifacts that assume one writer, and no organization to absorb the difference. Getting off the ground is close to solved. Staying up is not, and I don’t have a good answer for it. That’s the same argument I made a few months ago about civil engineering coming at it from the other side. When construction gets cheap, design is what fails, and the design here is the substrate: what runs where, what is isolated from what, and what has to be serialized. An agent isn’t going to do that for you, and it won’t show up in the prototype. Partial isolation is then its own trap. A worktree gives you the feeling of a private workspace (clean tree, own branch, no file collisions), and it reads as properly parallel right up until two private workspaces write the same database row. Nothing errors. Nothing warns. The contention surfaces later, somewhere else, as a red X on an unrelated pull request. Worse, the isolation below git is advisory, and agents have to choose it. Mine routinely don’t. One incident reads “PR 1868 isolated E2E attempt fell back to shared ports”: the agent tried to isolate its test environment, isolation failed, and nothing stopped the run. Worse still, a worktree is cut from a commit and stays there, so it’s isolated in the past and decays with every merge. When I changed one of the agent gates in July (they’re tracked scripts in the repository, not .git/hooks ` , so every worktree carries its own copy pinned to the commit it was cut from) the fix merged at 1:48 AM, and four hours later 73 of 74 worktrees were still running the old one. A stale worktree can’t detect its own staleness, so it goes green about a world that

no longer exists, and the error is deferred to the only actor holding current ` , which is CI. Convergence and Invariant Preservation One framing before the specifics, because it unifies them. Every merge mechanism here is built to terminate, and none of them is built to preserve invariants. Git is honest about the cases it cannot decide: on a textual conflict it halts and asks you. The trouble is the far more common case, where it doesn’t halt, produces a merge confidently, and the invariant it never knew about is now false. That distinction is the oldest lesson in the replicated-data literature, and it has a canonical counterexample. Take a replicated map where each field merges independently under its own perfectly reasonable rule. One field holds a person’s name; another holds the length of that name. Two replicas concurrently write different names. Each field converges exactly as specified, and the result is a record whose ` came from one replica and whose ` came from the other, with the invariant tying them now false. Nothing merged incorrectly. The composition of correct local merges is simply not a correct global merge. Closing that gap is the point of work like Balegas and colleagues’ Indigo which enforces application invariants over eventually consistent stores, and which I have written about before Some of what follows has that shape. The first case does not, and I will not dress it up. The Sealed Prefix This project has 1,388 migrations, and rebuilding a test database from all of them on each of eight parallel test machines is as slow as it sounds. So, in response to my complaining for weeks that CI was too expensive, an agent froze a database snapshot into the repository for CI to restore, applying only what came after. It’s a good optimization: it saves 13 to 18 minutes of machine time per run. It merged at 5:01 AM Eastern on the third day. Fifty-four minutes later the first pull request failed, because its migration no longer sorted after the newly frozen prefix. Then another. By late morning a single incident covers four at once: “Four queued PRs carried migrations older than the sealed CI baseline suffix.” The diagnosis here is ordinary, and a critic will say so. Other agents had already opened pull requests that appended migrations; one agent then sealed a new prefix underneath them; those two streams of work conflicted; and nothing anywhere in the system noticed until CI rejected the queued pull requests several hours later. That’s parallel work colliding and finding out late, not a subtle invariant bug. Caching a prefix of an ordered log made the collision loud and retroactive, but it did not invent the collision. So the loop closes: I complained CI was expensive, an agent made CI cheaper, and the mechanism became a new source of CI failures against the whole queue. Merge Functions and Runtime State Git detects conflicts over lines of text; my conflicts live in shared runtime state. From that week: “Song-call E2E suites deleted each other’s shared pending call.” Two test files, no overlapping lines, both green alone, and the row one of them depends on is the row the other deletes. The collision is in the database at runtime, not in the diff. Those two files are the ` and the ` . They share no lines, each merges cleanly, each is individually green, and the invariant binding them is false the moment they land together. No improvement to git’s merge algorithm catches that, because the property is not a property of any

file: it is a property of the composition, and git has no representation of the composition to check. Verification Under Composition Which gives the sharpest version of the problem: green(A on base) and green(B on base) does not imply green(merge of A and B). The test suite is the only thing in my pipeline that checks the invariant at all, since git checks text and timestamps check ordering. So the tests are my invariant checker. I do run them on the composition. Pull requests rebase onto current ` and merge in sequence, each one retested before it lands, and ` itself is checked after land. That catches the break. It just catches it late, and only by paying the serial tax: rebase, retest, merge, next. That tax is exactly the queue-wide cost the sealed prefix made visible on the morning when one seal invalidated everything queued behind it. Serialization is the honest answer, and I already pay it. Speculative merge queues try to buy the same guarantee back with parallelism: build the candidate futures, main+A ` , main+A+B ` , main+A+B+C ` , test them concurrently, and discard a failure from the middle. OpenStack’s Zuul has gated that way since 2012; GitHub’s merge queue ships a version; and bors which lands Rust, does the cheaper batch-and-bisect variant. It works, and it works by brute force, which I will come back to. Shared Environments One port range, one development database, one mock server. I do have a script assigning each worktree its own ports by hashing the directory name (the right idea), and it hashes into 99 slots. With dozens of worktrees on disk the birthday math makes a collision effectively certain, and two agents get handed the same port whenever the colliding pair happens to be running at once. Undivided Work Trivial parallelism doesn’t work on a problem that was never split into non-conflicting units. The agents were pointed at one jammed queue and found their own boundaries, which were mostly the same boundaries. What looked like a coordinator was a process manager: spawn, wait, list, follow up, six hundred and thirty-three tool calls of overhead, all of it without any deep context about which pieces of work actually interacted. A coordinator that only manages agents can’t divide work it does not understand, so the children rediscover the same failures, edit the same new scripts, and invalidate one another’s assumptions. Codex said as much afterward: the agents generated work for the coordinator instead of removing work from the critical path. Classified by root cause, 245 of the 361 entries collapse into ten systemic problems, 73 are one-off product bugs, and 43 I could not classify. Here are the ten, because a taxonomy whose majority is invisible isn’t a taxonomy: | systemic root cause | incidents | | --- | --- | | tooling the session was writing that same day | 87 | | no per-agent workspace isolation | 33 | | errors skipped, swallowed, or reported as success | 32 | | affected-spec selection far too broad | 20 | | migration order versus the sealed baseline | 16 | | tests leaning on shared fixture state | 16 | | recovery work that would not converge | 12 | | CI cost structure | 12 | | evidence produced against a base that moved | 10 | | verification run without its dependencies | 7 | I would defend the shape of that table rather than the ratio: workers under a shallow coordinator rediscover the same things, often enough to dominate a log. Look down the column and the majority is exactly that failure. The top row

alone (tooling the session was writing that same day, 87 incidents) is agents redoing and colliding on the same work, because nothing holding the session had enough context to keep them off each other’s toes. Add isolation failures and swallowed errors and the top three account for 152. Those are not ordinary defects that concurrency merely made frequent. They are the artifact of coordination without context: a parent counting agents instead of understanding the work, so that the children rediscover and rewrite the same things, file the same findings, and hand the parent the job of reconciling them. The seal and the port hash still have boring mechanical fixes, and recovery-that-would-not-converge and CI cost structure are process problems. The rediscovery is neither. The one that is irreducible in a different sense is the sixth row: tests leaning on shared fixture state, or green(A) and green(B) failing to imply green(A+B) in ordinary clothes. It accounts for sixteen of the 361, tied with the seal for the smallest systemic bucket, and I want to put that number in front of you instead of letting you find it by subtraction. Sixteen out of 361 is four percent. So that substrate problem is the rarest thing that happened that week. It is also the only one where catching it means building the composition and running the entire suite against it, which I do, serially, late, and which is precisely the expensive thing. It is therefore the only one on the list where I can’t tell you what an affordable fix would even look like. The common problem looks much simpler: parallelism without a division of the work, supervised by something that was counting agents instead of unde

60 Minute Creator 发布：基于节点的AI内容工作流，支持自有API密钥

近日，一款名为“60 Minute Creator”的创新工具正式上线，提供基于节点的AI内容工作流系统。用户可使用自己的API密钥，通过可视化节点编辑器构建可重复使用的创作流程。该工具强调“一次构建，随时运行”，旨在帮助内容创作者快速搭建自动化管线，灵活组合文本生成、图像处理等AI服务，从而提升内容生产效率。此举降低了AI应用的技术门槛，尤其适合需要高频输出内容的创作者和中小企业。目前，该工具已开放使用，但具体功能细节尚待进一步披露。 #AI工具 #内容创作 #工作流 #节点化 #API #自动化 #创作者经济

AMD 发布 CDNA5 架构，基于 RDNA 全面革新

在 AMD Advancing AI 2026 大会上，AMD 正式揭晓了新一代数据中心 GPU 架构 CDNA5。AMD 图形架构企业院士、数据中心 GPU 首席架构师 Alan Smith 在访谈中详解了架构变革。他指出，此前 CDNA 系列基于 2012 年的 GCN 架构，而 CDNA5 彻底转向 RDNA 体系，旨在通过引入现代缓存系统、执行引擎及工作调度机制，大幅提升能效。这一转变也将使 AMD 的 RDNA（消费级）与 CDNA（数据中心）路线图更加统一，便于未来在 AI 渲染、神经网络升频及数据中心 AI 负载间实现协同优化。针对 HPC 与 AI 的不同需求，AMD 计划利用小芯片架构分别优化高精度计算版，从而在双精度浮点支持与专用 AI 核心间取得平衡。CDNA5 将率先搭载于 MI455 和 Helios 产品中，进一步强化 AMD 在 AI 计算领域的竞争力。 #AMD #CDNA5 #RDNA #GPU #AI #HPC #数据中心 #架构创新

AI盲测胜出：65%读者偏爱AI改写胜于卡尔

学术写作中的“逻辑情节进展”被视为高级技能，对创作者功底要求极高。人工智能是否具备这种能力？《纽约时报》近期组织盲测，选取天文学家卡尔·萨根的原著段落与Claude Opus 4.5 AI的改写版本作为对比。结果显示，65%的读者更倾向于AI的改写文段，认为其在表达上更具吸引力和流畅性。文章指出，AI虽不负责原创构思，但在传达和重组已有思想方面表现出色，其逻辑进展与行文风格甚至超越原著作者。这一结果挑战了对人类写作不可替代性的传统认知，也引发了对AI文本创作潜力的新一轮讨论。 #AI #写作 #盲测 #卡尔萨根 #Claude #人工智能 #逻辑情节 #纽约时报 #人机对比 #文本生成

Relve 发布 Q2 AI SaaS 趋势报告

据 Relve 发布的 2026 年 Q2 AI SaaS 季度报告，该季度共追踪 182 个 AI 进展，但只有 29 个被视为对 SaaS 公司运营有直接影响的“信号”，其余 84% 为噪音。报告指出，AI 模型正变得廉价且可互换，越来越多直接嵌入已有工具；会议工具正在演化为公司操作系统。尽管 AI 采用率已达 88%，但价值高度集中于少数组织，瓶颈在于工作流、治理与人员而非技术本身。信号率方面，Spotify 最高（83.3%），微软（60%），而 OpenAI、SpaceX 等信号率为 0%。报告建议企业关注真正改变构建、人员与预算的核心变化，而非媒体热点。 #AI #SaaS #趋势报告 #信号 #噪音 #采用率 #模型 #企业软件 #科技报告

Nexmy：一款100%离线的Android金融追踪应用，集成本地AI

Nexmy 是一款专为 Android 平台设计的个人财务管理应用，主打100%离线运行与本地AI功能。用户无需注册账户即可开始使用，所有数据仅存储在设备上，备份由用户自行管理。该应用整合了收入、支出、账户余额、预算目标和还款期限等核心功能，提供直观的总览界面，帮助用户快速掌握每月财务状况。此外，Nexmy 还结合了分析与规划工具，使消费洞察与预算设定无缝衔接。开发者强调，应用注重简洁高效，减少不必要的操作步骤，从首次使用起即保持清晰可读。它适合希望快速理解资金动向、降低隐私顾虑的用户，通过简单设置即可获得全景式的财务概览。 #Nexmy #Android #金融科技 #离线应用 #个人财务 #本地AI #隐私保护 #预算管理 #开源精神

AI立场罗盘发布

随着人工智能的争论日益激烈，许多个体观点被宏大叙事淹没。一个名为“AI立场罗盘”的互动地图项目正式上线，允许任何人添加自己对AI的立场和评论。该地图以横轴表示对AI的赞同度，纵轴表示对其能力的信心，旨在捕捉“支持/反对”二元标签之外的细微差异。用户还可以按年龄、行业、地域筛选，观察不同群体的观点分布。项目发起人Keith Herrmann表示，希望能为公众提供展示AI态度多样性的平台，但强调其并非正式科学调查。 #AI #公众舆论 #互动地图 #观点多样性 #科技 #AI治理 #态度罗盘

美国科技界呼吁开发更开放AI模型

近日，科技界人士在支持开放大语言模型的基础上，进一步呼吁美国政府大力投资开放权重、开源代码以及开放语料库的AI模型，以在中美科技竞争中保持领先。此前，黄仁勋等业界领袖联名致信特朗普政府，反对可能禁止开源软件的保护主义举措，所有大型及小型科技公司CEO均签署了该信函。支持者认为，构建优秀模型需要人才、算力和数据，而开放生态将大幅提升效率。中国公司DeepSeek、Moonshot等已证明可以用较低成本训练模型，美国也应通过产业联盟共享算力资源。开放研究、代码和数据集将加速机器学习创新，并实现更高效的系统。这一倡议旨在打破封闭实验室的垄断，推动整个行业进步。 #AI #开放模型 #开源 #开放权重 #开放语料库 #中美科技 #大模型 #科技竞争

Kimi 恐慌是“开放”AI的斯普特尼克时刻

彭博社刊发评论文章指出，中国人工智能产品Kimi引发的行业恐慌，对“开放”人工智能领域而言如同斯普特尼克时刻。文章分析称，Kimi在长文本处理等技术指标上的突然领先，打破了原有预期，使得倡导开放与协作的AI研究者感到紧迫。这一事件可能促使全球政策制定者更重视技术竞赛，并推动对AI安全及开放边界的重新界定。文章还探讨了Kimi现象对中美AI关系的影响，强调了国际合作的重要性，认为开源社区需调整策略以应对新挑战。 #Kimi #开放AI #斯普特尼克时刻 #彭博社 #AI竞争 #技术突破 #人工智能