2026-06-14

Blogs
Python, Plugins, Software Architecture, Pluggy, Api Design

Engineering Reads — 2026-06-14#

The Big Idea#

Designing a plugin architecture is a deceptively simple “shallow API” problem where it is heavily tempting for developers to roll their own custom solutions. However, adopting a battle-tested abstraction like Python’s Pluggy library trades a minor dependency addition for robust, standardized solutions to hidden complexities like package discovery, execution ordering, and result aggregation.

Deep Reads#

Plugins case study: Pluggy · Eli Bendersky The author examines Pluggy, a standalone plugin management library extracted from the rich ecosystem of the pytest project, to evaluate whether taking on a third-party dependency is better than engineering a custom framework. Pluggy relies on a straightforward architecture where the host application defines API contracts via HookspecMarker decorators, and plugins implement these specific hooks using HookimplMarker. While basic plugin registration is relatively trivial to implement from scratch, Pluggy proves its system-level worth by providing seamless setuptools entry point discovery out of the box, alongside robust execution control like default LIFO ordering, signature validation, and strict execution priorities via tryfirst and trylast. The core architectural tradeoff here is the dependency footprint versus the hidden engineering effort of edge cases: because plugin frameworks inherently expose a “shallow API,” engineers frequently fall into the trap of writing bespoke implementations that eventually recreate these exact advanced features. Software engineers building extensible Python tools should read this to understand exactly what capabilities they gain by adopting Pluggy rather than reinventing the wheel.

2026-06-14

Blogs, AI, Tech
Careers, Generative-Ai, Software Engineering, Llms

Simon Willison — 2026-06-14#

Highlight#

Today’s highlight is a thoughtful commentary on the ongoing debate around AI replacing software engineers. Drawing on an essay by Arvind Narayanan and Sayash Kapoor, Simon highlights why the real value of a developer lies in deep systemic understanding rather than just generating lines of code.

Posts#

Why AI hasn’t replaced software engineers, and won’t · Source Simon highlights an essay by Arvind Narayanan and Sayash Kappor that pushes back against the narrative of mass AI-driven layoffs in tech. They point to hard data—like zero New York WARN Act filings checking the newly added “AI” box over a full year—to demonstrate that developers are heavily cushioned from displacement. The authors argue that while AI accelerates the actual typing of code, the true bottlenecks of software engineering are specifying what to build, verifying the delivery, and applying deep context. Simon echoes this from his own workflow, noting that while LLMs help him decide and verify, his ultimate value remains anchored in his “deep human understanding” of both the underlying problems and the agent-built solutions.

2026-06-15

Blogs
Artificial Intelligence, Software Engineering, Observability, Immutable Infrastructure

Engineering Reads — 2026-06-15#

The Big Idea#

In a world where AI has driven the cost of generating code to near-zero, code itself is transitioning from a heavily curated asset to a disposable, regenerable cache. This paradigm shift requires engineers to drastically increase their focus on architectural discipline, observability, and system-level validation rather than manual line-by-line curation.

Deep Reads#

AI demands more engineering discipline. Not less · Charity Majors Charity Majors argues that as AI-driven code generation becomes incredibly cheap and fast, the economics of software production have completely flipped, turning code into a disposable artifact. Drawing a parallel to the industry’s historical shift from bespoke “pet” servers to immutable infrastructure, she suggests that engineers should treat code as a temporary “materialized view of understanding” rather than a precious, immutable asset. Because human brains are inherently poor at the mechanical repetition required for validation, our focus must shift away from acting as a manual quality gate and toward rigorous production observability, behavioral testing, and maintaining system determinism. The hardest parts of software engineering—defining specifications, formalizing user expectations, and ensuring reliable physical systems—remain deeply human problems that demand a return to foundational engineering discipline. Engineers and SREs grappling with the changing nature of software development should read this to reframe their value around architecture, continuous evaluation, and production health rather than mere syntax generation.

2026-06-15

Blogs, AI, Tech
Datasette, Sqlite, Llms, Anthropic, Jailbreaking

Simon Willison — 2026-06-15#

Highlight#

The most exciting update today is the release of datasette-agent 0.3a0, which introduces natural language database modification right from the terminal. By combining the new execute_write_sql tool with an --unsafe auto-approval mode, Simon has made it possible to chat directly with a SQLite database and modify its schema and records on the fly.

Posts#

datasette-agent 0.3a0 · Source Simon just shipped a major update to his experimental datasette-agent project, adding an execute_write_sql tool that can prompt for user approval before writing to a database. He also enhanced the CLI chat terminal with options like --yes, --root, and --unsafe to streamline or bypass these permission checks entirely. Using the --unsafe flag alongside a model like gpt-5.5, developers can now converse directly with a specific database to execute structural changes, such as creating tables or inserting records via natural language.

2026-06-16

Blogs
Software Engineering, Large Language Models, Decentralization, Agentic Ai

Engineering Reads — 2026-06-16#

The Big Idea#

As Large Language Models achieve undeniable product-market fit in software engineering, the industry is transitioning from speculative hype to a phase where rigorous engineering discipline—like strict context management, robust architectural design, and domain-driven design—is the only way to prevent rapid code generation from destroying system reliability and institutional trust.

Deep Reads#

Fragments: June 16 · Martin Fowler This piece aggregates critical industry reflections on the integration of AI into software engineering, highlighting that both enthusiastic claims of discontinuous capability leaps and skeptical warnings of degrading system trust are entirely correct. To manage this tension at the developer level, Chelsea Troy suggests maintaining healthy LLM context windows by strictly separating conversation “registers”—categorizing prompts into exploring, brainstorming, deciding, and implementing. At the organizational level, Charity Majors argues that bridging the gap between rapid AI code generation and reliable production requires treating AI integration as a rigorous engineering problem, emphasizing the need to adapt review processes and ground technical authority in practical engagement rather than speculation. Concurrently, Mike Masnick warns that without deliberate decentralization and low barriers to exit, the emerging AI ecosystem risks falling into the same trap of centralized lock-in and “enshittification” that defined Web 2.0. Any engineer attempting to balance the speed of AI-assisted development with the long-term maintainability of their systems should read this.

2026-06-16

Blogs, AI, Tech
Jailbreaking, Claude-Code, Local-Llms, Datasette

Simon Willison — 2026-06-16#

Highlight#

The meatiest topic today is Simon’s sharp criticism of the export controls placed on Claude Fable 5. He connects the dots between a press report and security expert Katie Moussouris to point out the absurdity of penalizing an AI model for successfully fixing security vulnerabilities, which is a core feature of cyberdefense.

Posts#

The Fable 5 Export Controls Harm US Cyber Defense Simon strongly criticizes the US export controls placed on Claude Fable 5, citing security expert Katie Moussouris. The so-called “jailbreak” that triggered the ban was merely researchers asking the model to “fix this code” after it had refused a prompt to “review the code for security issues”. Simon argues that banning models for executing the “find, fix, and test loop” fundamentally misunderstands how AI assists in defensive security, effectively penalizing a model for fixing bugs.

2026-06-17

Blogs
Software Engineering, Llm Architecture, Mental Health, Music Theory

Engineering Reads — 2026-06-17#

The Big Idea#

The abstraction layer of modern software is moving aggressively up the stack, shifting the engineer’s primary job from writing syntax to conducting high-leverage systems. Whether designing hybrid LLM architectures or auditing personal mental models, the limiting factor for shipping robust work is no longer keyboard speed, but human judgment.

Deep Reads#

Conducting Between Roller Coasters · Kenneth Reitz · Source The abstraction layer of software development has shifted so far up the stack that coding now resembles “conducting” rather than typing. By combining a mobile device with Claude Code, the author designed, tested, and shipped massive architectural updates to PyTheory entirely while waiting in lines at an amusement park. This leverage is entirely dependent on the engineer’s domain expertise; because the machine hallucinated detunes and tempos, the human’s “ear” remained the absolute bottleneck. Systems programmers curious about how LLMs fundamentally alter the feedback loops of maintaining complex open-source libraries should read this essay.

2026-06-17

Blogs, AI, Tech
Datasette, Large Language Models, Open-Source, Web Components, Ai-Assisted Programming

Simon Willison — 2026-06-17#

Highlight#

The deep dive into Z.ai’s GLM-5.2 model is today’s most significant read, offering a hands-on look at a new 753B parameter open-weights giant that is currently topping intelligence and coding benchmarks. It captures the rapid evolution of massive models and provides practical prompt testing on their UI-generation capabilities.

Posts#

GLM-5.2 is probably the most powerful text-only open weights LLM · Source Chinese AI lab Z.ai has released GLM-5.2, a massive 753B parameter open-weights model with a 1 million token context window. Simon notes it is currently leading the Artificial Analysis Intelligence Index and ranking second on the Code Arena WebDev leaderboard, which is deeply impressive for a text-only model lacking image inputs. He tested it via OpenRouter with his standard SVG generation prompts, finding it produced a flawless, self-contained animated pelican on a bicycle. However, it disappointingly failed to animate an opossum on an e-scooter, marking a regression from its predecessor, GLM-5.1.

2026-06-18

Blogs
Webassembly, Compilers, Reproducible Builds, Large Language Models, Sparse Attention

Engineering Reads — 2026-06-18#

The Big Idea#

The friction between idealized abstractions and hardware realities constantly forces engineers to compromise. Whether you are battling the hidden, non-deterministic state of C++ build toolchains or applying sparse attention to make massive LLM context windows economically viable, the lowest layers of the stack inevitably leak into your application design.

Deep Reads#

I hate compilers · xeiaso.net To maintain a single source of truth for proof-of-work checks without locking out users who have disabled WebAssembly, the author decided to compile their WASM logic to a JavaScript fallback using wasm2js. However, bundling this tool exposed the brutal reality of reproducible builds: while compilers are theoretically deterministic functions, they are practically overflowing with implicit state. The post dissects how Clang secretly shells out to $PATH dependencies like wasm-opt, which can unexpectedly break builds if the host’s version lacks WebAssembly Exception support. Even more insidiously, Clang’s exception-handling code generation leaks raw memory pointer values into the output byte order, forcing the author to disable Address Space Layout Randomization (ASLR) and maintain separate architectural checksums. Any systems engineer relying on cross-platform C++ compilation or reproducible builds should read this for a sobering reminder of how brittle our build infrastructures actually are.

2026-06-18

Blogs, AI, Tech
Datasette, Sandboxing, Javascript, Content-Security-Policy, Ai-Assisted Programming

Simon Willison — 2026-06-18#

Highlight#

Simon has launched datasette-apps, a major new concept allowing developers and LLMs to build self-contained, sandboxed HTML+JS applications that run directly against a persistent Datasette backend. It brilliantly merges his ongoing experiments with “vibe-coded” single-file HTML tools, Claude Artifacts, and secure iframe sandboxing into a core feature of the Datasette ecosystem.

Posts#

Datasette Apps: Host custom HTML applications inside Datasette This post dives deep into the “why” and “how” behind the newly released datasette-apps plugin. The plugin allows tightly constrained iframe sandboxes to run JavaScript that executes read-only SQL queries or allow-listed stored write queries against a Datasette instance. Simon outlines the clever security architecture required to run untrusted code safely on an authenticated domain containing private data, relying on an <iframe sandbox="allow-scripts"> tag combined with an immutable, injected Content-Security-Policy (CSP) header. He also details porting his API communication from postMessage() to MessageChannel(), a defense-in-depth upgrade suggested by GPT-5.5. The plugin seamlessly integrates AI workflows by providing a copyable prompt—complete with database schemas—that users can drop into ChatGPT or Claude to instantly generate a working app. Additionally, Simon shares a fascinating security anecdote: before access was restricted, he used Claude Fable 5 to evaluate the product, and the model discovered a severe data exfiltration vulnerability related to CSP allow-listing, which he promptly patched by locking down domain-allow permissions to trusted staff.