🤖 Ghostwritten by GPT 5.4 · Fact-checked & edited by Claude Opus 4.6 · Curated by Tom Hundley
Simon Willison's March 9 releases sharpen a debate executives should care about: will AI push software teams toward lowest-common-denominator tools, or will it reward products that are genuinely better? His new llm-tools-edit plugin suggests the latter. By giving models a controlled way to modify files inside an AI development workflow, Willison is pushing LLM tools beyond chat and into practical execution.
The bigger idea is even more interesting. In his post, "Perhaps not Boring Technology after all," Willison argues that the assumption behind the old "boring technology" thesis may not hold in an LLM-driven market. His point is not that stable tools stop mattering. It is that if AI assistants can learn interfaces quickly, the historical advantage of entrenched, familiar platforms may weaken.
For executives, this is not a niche developer argument. It changes how you think about software leverage, build-vs-buy, and whether your teams should standardize aggressively or leave room for experimentation. My read: Willison is directionally right, but only if companies pair AI-assisted development with strong evaluation and governance.
TL;DR: Simon Willison is one of the most credible independent voices in practical AI software because he ships tools, documents experiments, and changes his mind in public.
If you know Simon Willison, you probably know him from three places: Django history, Datasette, and his relentless field notes on how LLMs actually behave in the real world. He co-created Django in its early days, built Datasette as a remarkably elegant tool for exploring and publishing data, and has become one of the clearest writers on applied AI development workflow.
That last piece matters. There are plenty of loud AI commentators; there are fewer people who both ship software and explain tradeoffs without hype. Willison publishes in public, often with examples you can inspect, rerun, or critique. That makes his work disproportionately influential among senior engineers and technical leaders.
His open-source llm CLI has also become a useful reference point in the emerging ecosystem of LLM tools. Rather than pretending every problem deserves a giant platform, he has favored composable utilities and plugins that let people test capabilities incrementally. That design instinct is one reason his March 9 update is worth watching.
From an executive lens, Willison is worth following because he often spots workflow shifts before large vendors package them into enterprise narratives. If you want early visibility into how AI changes software practice on the ground, he is one of the best signals available.
TL;DR: Willison released llm-tools-edit to let models modify files through his CLI, then published an argument that LLMs may reduce pressure toward "boring technology" rather than increase it.
The headline development was llm-tools-edit 0.1a0, released March 9, 2026. At a practical level, this extends Willison's LLM CLI with file-editing capabilities. Instead of stopping at text generation, the model can participate in making concrete file changes inside a controlled tool-based workflow.
That is more important than it sounds. The difference between "the model suggested code" and "the model edited the file through a defined interface" is the difference between advisory AI and operational AI. Once you cross that line, the conversation shifts from novelty to process design: permissions, review, rollback, and testing.
The same day, Willison published "Perhaps not Boring Technology after all." He was responding to the long-running idea—popularized by Dan McKinley's influential 2015 talk—that teams benefit from choosing mature, unsurprising technologies because novelty carries operational cost. Willison's twist is that LLMs may change the economics. If an AI assistant can help users navigate a less familiar tool, then the usability moat around incumbent software may erode.
His core argument: LLMs may mean users are not "locked into training-dominant tools" in the same way as before. That is a serious claim. It implies that software with a better architecture, cleaner interface, or more thoughtful capabilities could gain ground even if it starts with less market familiarity.
Another reason this matters now: GitHub reported at Microsoft Build in May 2024 that GitHub Copilot had surpassed 1.8 million paid subscribers and was used by more than 77,000 organizations. Those are vendor-reported numbers, but they show the direction clearly: AI-assisted development is already mainstream enough that interface friction is becoming a strategic issue, not an experimental one.
TL;DR: File-editing AI turns LLMs into workflow actors, which can increase developer leverage—but it also raises the bar for controls, testing, and tool choice.
The real significance of llm-tools-edit is not the plugin itself. It is what it represents: a maturing pattern for AI development workflow where models call tools, touch artifacts, and participate in iterative execution.
That puts pressure on old assumptions about developer productivity. Historically, teams favored familiar stacks partly because retraining people was expensive. But if LLMs can compress onboarding and provide just-in-time guidance, then the switching cost between "boring technology" and more innovative alternatives may fall.
Here is the strategic comparison executives should keep in mind:
| Question | Pre-LLM assumption | LLM-assisted reality |
|---|---|---|
| Why choose incumbents? | Teams already know them | AI can help teams learn newer tools faster |
| What creates lock-in? | Human training investment | Workflow integrations and governance controls |
| Where is risk concentrated? | Adoption and retraining | Unreviewed automation and weak evaluation |
| What wins? | Familiarity | Products that are both capable and tool-friendly |
This is why I keep telling leaders that the next phase is not "chatbots for developers." It is tool-using systems embedded in delivery. That includes code generation, file editing, testing, issue triage, and structured outputs. If you missed our breakdown of What Vibe Coding Actually Is (And Isn't), this is the more serious version of that conversation.
The catch is obvious: once the model can act, you need evidence that it acts well. This is where a lot of companies get sloppy. They celebrate acceleration and ignore verification. If you are going to let LLM tools modify source files, you need the disciplines covered in LLM Evaluation: How to Know If Your AI Is Working.
A definitive statement here: file-editing AI is only a productivity gain when review cost stays lower than creation cost. If every AI change creates a bigger QA burden, the economics collapse.
TL;DR: Willison is right that LLMs weaken some incumbency advantages, but they do not eliminate the operational value of stable, well-understood systems.
I think Willison is pushing against a real blind spot in the industry. The "boring technology" idea was always useful as a corrective to shiny-object syndrome. But some people turned it into a religion. That was a mistake even before LLMs arrived.
What LLMs change is not the need for stability. They change the cost of navigating complexity. If an assistant can explain an API, draft a migration, write tests, and now participate in file edits, then a product no longer needs to win solely by being familiar. It can win by being excellent.
That matters for startups and infrastructure challengers. It also matters for internal platforms. A company with strong internal tools may no longer need to dumb everything down for broad adoption if AI can help bridge the learning curve.
But let's not overcorrect. Familiar technology still has advantages that LLMs do not erase:
This is where executive judgment comes in. The right question is not "Should we abandon boring technology?" The right question is "Where does AI reduce the penalty for choosing a better tool?" That is a portfolio decision, not an ideology.
There is a parallel here with autonomous research tooling. In Karpathy's Autoresearch: AI Agents Running ML Experiments While You Sleep, the important story is not just autonomy—it is where autonomy makes higher-variance exploration economically viable. Willison is making a similar argument about software choice.
TL;DR: Willison's optimism holds water, but only for organizations mature enough to separate experimentation from production standards.
My view is straightforward: Simon Willison is mostly right, and the people dismissing this shift are underestimating how quickly tool use changes software economics. The best LLM plugins are not just convenience add-ons. They are adapters between human intent and system action.
Where I part company with the more optimistic crowd is in how broadly this applies. The average company does not suddenly become great at software selection because it added Copilot or another assistant. In many organizations, AI amplifies existing discipline problems. Weak engineering management becomes faster weak engineering management.
That means two things can be true at once:
If you're an executive, this gives you a useful board-level framing:
This is also where some teams will waste money. They will apply AI where the workflow does not justify it, or where conventional automation would do. That is the lesson behind The $50K Mistake: When AI Isn't the Answer. The most effective leaders are not the ones buying the most AI. They are the ones redesigning decision rights around it.
So yes, I buy Willison's thesis in part: AI may help innovative software compete against incumbents that previously won on habit. But habit is only one source of lock-in. Procurement, compliance, integrations, and organizational inertia are still very real.
TL;DR: If you want signal over noise in AI software, Simon Willison is one of the best daily reads in the field.
Follow Simon Willison through:
llm and related pluginsHe is especially useful because he documents evolving opinions rather than pretending to have arrived at final truth. In AI, that is a feature, not a bug.
It is a plugin for Willison's llm CLI that enables models to make file edits through a tool interface rather than just suggesting text. This moves AI from passive assistance toward active participation in the development workflow, raising important questions about permissions, review gates, and rollback procedures.
His argument is that if AI can help users learn and operate unfamiliar tools, then incumbents lose some of the advantage they once got from familiarity alone. In that world, better-designed software has a stronger chance to compete—even without a large existing user base.
Selectively, yes. AI can reduce onboarding friction, which makes experimentation cheaper. But production decisions still need governance, security review, and measurable delivery outcomes. The right approach is to widen the experimentation funnel while keeping production standards tight.
No. It improves productivity only when the value of the changes exceeds the cost of reviewing, testing, and correcting them. Without evaluation discipline, it can shift effort downstream into QA and debugging rather than eliminating it.
Willison's plugin is one instance of a larger pattern: LLMs moving from text generation to tool invocation. As models gain the ability to call APIs, edit files, run tests, and manage workflows, the design of tool interfaces becomes a competitive differentiator—not just for developer experience, but for AI compatibility.
llm-tools-edit pushes LLM tools from suggestion toward controlled action through file editing.Simon Willison has a habit of noticing the important shift before the rest of the industry names it. That is what happened here. The real story is not just a new plugin or a clever blog post. It is the emerging possibility that AI changes which software gets to win—and why.
If that holds, the next few years will not simply reward the biggest platforms or the most familiar stacks. They will reward tools that are genuinely good and easy for both humans and AI systems to use together. That is a meaningful change in competitive dynamics, and one worth watching closely.
Want help designing AI-assisted development workflows that balance experimentation with governance? Get in touch with Elegant Software Solutions to talk about what this shift means for your team.
Discover more content: