This edition covers news from March 21 to March 23.
The Rust community starts debating where AI should fit
Source: https://nikomatsakis.github.io/rust-project-perspectives-on-ai/feb27-summary.html
The Rust project has finally started discussing AI in public, in a way that feels serious rather than performative. Niko Matsakis published a long summary of community comments and made it explicit that this is not an official Rust position. It is a map of the arguments: people who find real value in AI tools, people who remain skeptical, and quite a few who sit awkwardly in the middle.
What stands out is that the document refuses the lazy split between believers and deniers. A lot of the comments point to the same practical reality: results depend heavily on how the tools are used. Context matters. Tooling matters. Prompting matters. The environment matters. That helps explain why one engineer can say AI is already indispensable while another says it is mostly noise.
The harder part is governance. Some contributors worry that open source projects will be buried under plausible but low-quality AI contributions. Others worry that refusing the tools entirely will leave the ecosystem behind. Once a community like Rust starts treating AI as a question of maintenance cost, project culture, and contribution policy, it stops being a side topic.
My read is that the most important thing here is not the conclusion. It is the method. Rust is doing the useful thing: dragging the disagreement into the open and breaking it down into concrete trade-offs. A lot of projects are facing the same pressure already. Most just have not said it out loud yet.
Using Git to control coding agents is becoming table stakes
Source: https://simonwillison.net/guides/agentic-engineering-patterns/using-git-with-coding-agents/
Simon Willison added a new guide to his agentic engineering series, and it gets straight to the point: Git should not just be treated as storage for code. It should be treated as the control surface for coding agents. The piece walks through practical prompts and workflows, like asking an agent to review recent commits, commit frequently, integrate changes from main, recover lost work through reflog, or use git bisect to pinpoint when a bug was introduced.
The point is not to make people memorize more Git commands. It is to reframe Git as a safety system. If agents already understand version control well, then humans should use branches, commits, stashes, and merges as guardrails instead of afterthoughts.
This matters because the next productivity gap will not come only from model quality. It will come from workflow quality. Teams that adapt Git, tests, and review to agent-heavy development are likely to move faster than teams still treating AI output like a lucky autocomplete streak.
One developer turned Claude into a mobile QA teammate
Christopher Meiklejohn published a strong field report on something small teams care about a lot: mobile QA that never quite gets automated. He runs Zabriskie largely by himself and needs the app to work across web, iOS, and Android. The mobile side had no automated checks, so he wired Claude into the workflow to drive the app, take screenshots, inspect them for visual issues, and file bug reports automatically.
The details are the good part. On Android, he used adb reverse to solve local connectivity and then took advantage of the Chrome DevTools Protocol exposed by Android WebView. That let him control the app programmatically in a way that feels much closer to web automation. He says Android took about 90 minutes to get working. iOS took more than six hours, which says plenty about the current state of tooling.
What makes this notable is that it is not a flashy demo. It is already a scheduled workflow that sweeps 25 screens every morning and files bugs before anyone starts the day. In this setup, the agent is not replacing a programmer. It is filling a role that solo builders and small teams usually leave understaffed for months.
Bram Cohen wants to rethink version control from first principles
Source: https://bramcohen.com/p/manyana
Bram Cohen has released Manyana, an early experiment in version control built around CRDT ideas. The ambition is bigger than making Git a little nicer. He is trying to change the way merges behave. In his model, merges do not fail in the traditional sense. Conflicts still exist, but they become information for review rather than hard blockers that derail the workflow.
His examples make the pitch easier to grasp. Instead of showing two ugly conflict blobs, Manyana tries to show what each side actually did. One branch deleted a function. Another inserted code into it. That is a more useful explanation than Git’s usual text collision. He also argues that rebase should not require faking history in order to keep things tidy.
This is still far from a drop-in replacement for Git. But it is poking at the right pain. In an agent-heavy world, code churn goes up, branches multiply, and merge pressure gets worse. A lot of the version-control ergonomics people used to tolerate may stop being tolerable once agents scale the volume of change.
Feed an LLM 1,000 comments and it can profile a person disturbingly well
Source: https://simonwillison.net/2026/Mar/21/profiling-hacker-news-users/
Simon Willison shared a deliberately unsettling experiment: take a Hacker News user’s latest 1,000 comments, feed them to a model, and ask for a profile. The raw material is easy to get through the Algolia Hacker News API. Simon even built a lightweight browser tool to make collecting the data easier. His conclusion is simple: the results are startlingly good.
The model can infer a lot more than broad interests. It can sketch professional identity, recurring themes, debate style, technical obsessions, and pieces of personal context. The bigger point is not that the model is clever. It is that public fragments, once aggregated, are already enough to produce something close to an automated character study.
What makes the post land is its restraint. Simon is not trying to sell doom. He is pointing at a capability that already exists and feels invasive even when used on public text. That gap matters. Plenty of people know they post in public. Fewer have internalized what happens when those fragments become machine-readable, searchable, and compressible into a profile on demand.