20 Nov 2026
Planet Python
Graham Dumpleton: Muru: tracing in the toolbar
The last post was about the development toolbar Muru adds to each HTML page under muructl run, with the record Muru keeps of each request. That record can say a lot about how a request was served, how long it waited for a worker, how long the application took, what it logged and what went wrong. What it can't say is what the application did with its time, because Muru only sees the application from the outside.
For that, Muru uses wrapture, the package I wrote for monkey patching, testing and tracing, which I covered in a series of posts earlier this year. With tracing turned on, wrapture's instrumentation records the calls the application makes while it serves a request, such as its database queries and calls to other services, and the toolbar gains panels showing them.
Turning tracing on
The shop from the last post is a Flask application which uses sqlite3 for its database, and urllib.request to call its stock service. Tracing needs wrapture and its instrumentation packages added to the project:
$ uv add wrapture wrapture-instrumentation
then tracing = true, and a wrapture configuration saying what to instrument, which can go in the same pyproject.toml:
[tool.muru]
entrypoint = "shop:app"
tracing = true
[tool.muru.run]
toolbar = true
[[tool.wrapture.instrument]]
name = "flask"
[[tool.wrapture.instrument]]
name = "sqlite3"
statement = true
[[tool.wrapture.instrument]]
name = "urllib.request"
The flask instrumentation records each request with the view that handled it, sqlite3 records each query, with statement = true so the SQL itself is kept, and urllib.request records calls made with it. The configuration can also be in a wrapture.toml file beside pyproject.toml, or a file named by WRAPTURE_CONFIG, which is where wrapture itself would look for it. I have also put toolbar = true in the [tool.muru.run] table this time, so the toolbar is on without needing --toolbar each time.
When the run starts, the host says where the configuration came from and what it instruments:
muru.host[36012]: tracing on: wrapture configuration from [tool.wrapture] in ./pyproject.toml, instrumenting flask, sqlite3, urllib.request
Not everyone working on a project may want tracing on, since it adds work to every request. tracing = true in the muru.local.toml beside the project turns it on for my own runs only, with the configuration still coming from the project. Tracing needs Python 3.12 or later, and if wrapture is missing, or its configuration can't be found or applied, the run logs a one-line warning saying why and serves the application untraced, rather than failing to start.
What the front page does
With tracing on, the front page's badge now shows two hints, and the toolbar opens on them:

The toolbar also has new tabs, Trace, SQL and Outbound. The Trace panel is the request's tree of operations, on the same clock as the Timing panel from the last post:

The view ran one query for the books, and then for each book, a query for its author and a call to the stock service. This is the code which did that:
@app.route("/")
def books():
rows = database().execute("SELECT id, title, author_id FROM book ORDER BY id").fetchall()
books = []
for book_id, title, author_id in rows:
query = "SELECT name FROM author WHERE id = ?"
(author,) = database().execute(query, (author_id,)).fetchone()
stock = in_stock(book_id)
if stock == 0:
log.warning("%s is out of stock", title)
books.append({"id": book_id, "line": f"{title} by {author}, {stock} in stock"})
return render_template_string(PAGE, title="Books", books=books)
def in_stock(book_id):
with urllib.request.urlopen(f"{request.host_url}stock/{book_id}") as response:
return int(response.read())
Nothing about it looks wrong when reading it, and with eight books, the whole page took under ten milliseconds. It is a different story with a thousand books, a database on another machine, and a stock service on the other side of a network.
Queries and calls, grouped
The Trace panel shows the pattern when there are only a few books, but with hundreds it would be a very long list. The SQL panel groups the request's queries by statement, with how many times each ran and their total time, and then lists each query in order:

Statements which differ only in the values written into them group together, so the author query shows up as one statement run eight times. This is the N+1 pattern, one query for the list and then one more for each row of it, and it is one of the most common performance problems in web applications which use a database. It is also easy to write without noticing, since an ORM will happily generate it from code that looks perfectly reasonable.
The Outbound panel does the same for calls to other services, grouped by method, host and path:

A path segment which names a row rather than the endpoint, such as a number, a UUID or a long hexadecimal string, is grouped as {id}, so the eight calls to /stock/1 through /stock/8 are one endpoint called eight times. Calls made with requests, httpx, urllib3, aiohttp and http.client are recorded the same way, given the instrumentation for them, as are gRPC calls.
The fix for both is to ask for everything at once. A join gets the authors with the books, and the stock service can answer for several books in one call:
@app.route("/")
def books():
query = (
"SELECT book.id, book.title, author.name FROM book"
" JOIN author ON author.id = book.author_id ORDER BY book.id"
)
rows = database().execute(query).fetchall()
stock = in_stock([book_id for book_id, _, _ in rows])
books = []
for book_id, title, author in rows:
if stock[book_id] == 0:
log.warning("%s is out of stock", title)
books.append({"id": book_id, "line": f"{title} by {author}, {stock[book_id]} in stock"})
return render_template_string(PAGE, title="Books", books=books)
def in_stock(book_ids):
ids = ",".join(str(book_id) for book_id in book_ids)
with urllib.request.urlopen(f"{request.host_url}stock?ids={ids}") as response:
return {int(book_id): count for book_id, count in json.load(response).items()}
Saving the file was enough for the run to start a new release with the change:
muru: reloading, /Users/graham/shop/shop.py changed
muru: switched to release r2
and the front page's record now has one query and one call:
$ muructl debug request 01M7PBFZP78AN9K8YRZ0DC3AMY
...
SQL
By statement
SELECT book.id, book.title, author.name FROM book JOIN author ON author.id = book.author_id ORDER BY book.id 1 0.098
Each query
0.419 0.098 SELECT book.id, book.title, author.name FROM book JOIN author ON author.id = book.author_id ORDER BY book.id
Outbound
By endpoint
GET 127.0.0.1:8080 /stock 1 0.991
Each call
0.604 0.991 GET http://127.0.0.1:8080/stock 200
The two hints went with them. Hints are where I would start with any page, since they apply the same thresholds to every request without me having to remember what to look for. A statement run five or more times in one request, or an endpoint called five or more times, is flagged, as is a single query or call taking a quarter or more of the request's time and at least 10 milliseconds.
The failing page again
The author page from the last post still divides by zero for an author with no books. With tracing on, its Trace panel shows where the exception went:

The view, author, is marked as failed, since the exception escaped it. The request is marked as well, because Flask's instrumentation notes the exception Flask's error handling caught against the request. The Exceptions panel lists both, the one Flask handled being marked as such:
GET /authors/4 ZeroDivisionError: division by zero (handled)
author ZeroDivisionError: division by zero
The bars also show something the Errors panel didn't. The view itself was done in about a third of a millisecond, out of a request which took about three. Most of the rest went on Flask handling the exception, which includes formatting and logging the traceback.
Applications without framework instrumentation
The shop gets its request spans from the flask instrumentation, and there is the same for Django and other frameworks. An application without such instrumentation, such as a plain WSGI or ASGI callable, can have Muru wrap its entry point in wrapture's request middleware instead:
[tool.muru]
entrypoint = "api:application"
tracing = true
tracing_middleware = true
The same key in a mount's table wraps just that mount, for an application which mixes WSGI and ASGI. It shouldn't be used where a framework's instrumentation already records requests, since the middleware would then record them instead, and the framework's own request settings would no longer apply.
Tracing and the workers
How tracing is set up follows from how Muru starts an application, as covered in the import once, fork many post. The host process applies the wrapture configuration before it imports the application, so the instrumentation's patches are in place for the application's own imports. What the configuration sends events to, its sinks, are only started in each worker after it is forked, so the host holds no threads or open files of wrapture's when it forks.
The toolbar's panels don't need a sink at all, since Muru collects what wrapture records for each request itself. Any sinks the configuration does declare still work as they would without Muru. Adding wrapture's printer sink, for example, prints each request's tree in the run's output, from the worker which served it:
muru.worker[0]: GET /authors/1 (shop.wsgi_app)
muru.worker[0]: author(author_id=1)
muru.worker[0]: sqlite3:connect('<str>')
muru.worker[0]: sqlite3:connect -> '<Connection>' [220us]
muru.worker[0]: sqlite3:Connection.execute(sql='<36 chars>', parameters='<1 values>')
muru.worker[0]: sqlite3:Connection.execute -> '<Cursor>' [136us]
muru.worker[0]: sqlite3:Connection.execute(sql='<42 chars>', parameters='<1 values>')
muru.worker[0]: sqlite3:Connection.execute -> '<Cursor>' [26us]
muru.worker[0]: flask:render_template_string(source='<!doctype html>\n<html>\n<head><title></title></h...', context='<context>')
muru.worker[0]: flask:render_template_string -> '<191 chars>' [1.3ms]
muru.worker[0]: author -> '<str 191 chars>' [2.0ms]
muru.worker[0]: shop:close(exc=None)
muru.worker[0]: shop:close -> None [27us]
muru.worker[0]: shop.wsgi_app -> '200 OK' [4.4ms, body 6us over 1 chunk]
Each worker writes its own output, so a sink writing to a file needs {pid} in its path to give each worker a file of its own.
The same is true under muructl serve and the Muru daemon, except there is no toolbar there, so tracing costs only what the configuration's own sinks do. In production that would normally mean exporting to an OpenTelemetry collector, as covered in the OpenTelemetry export in wrapture post.
What's next
Between them, the toolbar and tracing answer most of what I want to know about a request while I'm working on an application. How long it waited and why, what it logged and what failed, and what the application did with its time, all without adding anything to the application beyond a dependency and a few lines of configuration.
The toolbar's Timing panel has one more row, for modules a request loads for the first time in its worker, and that is where the next post, when lazy imports help, picks up. Lazy imports are popular for making command line tools start faster, but in a web server which imports an application once and forks its workers, deferring an import is a trade, and Muru has the measurements to make it.
20 Nov 2026 9:39pm GMT
Mariatta: Gidgethub Is in Maintenance-Only Mode
If you use gidgethub, here's some news you may have missed: as of v6.0.0, released on September 25, 2026, the project is in maintenance-only mode.
What that means in practice:
- Bug reports are welcome. We'll make a best-effort attempt at fixing them.
- Feature requests are not accepted, and will be closed.
- Pull requests from external contributors are not accepted. Only maintainers can open them.
It still works, it still gets bug fixes, and v6.0.0 was a big release. It just isn't growing anymore.
20 Nov 2026 5:00pm GMT
Django community aggregator: Community blog posts
Issue 364: 2027 DSF Board Nominations
News
2026 Malcolm Tredinnick Memorial Prize awarded to Raffaella Suardini
We are pleased to announce that the 2026 Malcolm Tredinnick Memorial Prize has been awarded to Raffaella Suardini!
2027 DSF Board Nominations
Five of the seven board seats are open, four two-year terms plus a one-year seat finishing out Jacob Kaplan-Moss's. You do not need to be a DSF member or to have served before. Nominations close December 2.
Wagtail CMS News
Join us for the Wagtail Space community day
Friday closes out Wagtail Space as an unconference: you bring the topics, the organizers sort out the rooms. Roadmap Q&A, first contributions, UX, AI, packaging, and security are already on the list.
Agent-friendly user docs for Wagtail
Four new documentation formats for AI agents, based on weeks of testing.
Djangonaut Space News
Djangonaut Space Log 3: JS one-liners && backend
Wasif Shahzad shares the latest steps in his journey, exploring JavaScript improvements and backend changes while working on his first PR for Django Debug Toolbar.
Djangonaut Log 4: Avoiding asteroids
"I tend to be the type of person who gets very excited about things I'm passionate about and Djangonaut Space - as you may have noticed through my blog posts - is definitely one of those." - Juha-Matti Santala
Updates to Django
Today, "Updates to Django" is presented by Raffaella from Djangonaut Space! 🚀
Last week we had 17 pull requests merged into Django by 13 different contributors - including 8 first-time contributors! Congratulations to Zishan Kadri, Akshat Gupta, Matthew Newton 🚀, Goodluck Igbokwe 🚀, charlesroelli, Awath Javar Abdat, Kryštof Kopečný and Alisson Silveira for having their first commits merged into Django - welcome on board!
New in Django 6.2:
- Passing table names as command-line arguments to
createcachetableis deprecated. Configure cache tables in theCACHESsetting instead. - The HTML and plain text technical 500 debug pages now display the nested exceptions in
BaseExceptionGroupinstances.
New in Django 6.1:
- Fixed a bug in Django 6.1 where the
models.E050system check did not detect mixedon_deletevariants for models with aGenericRelation(#37471).
Django Fellow Reports
Django Fellow Report - Jacob
Three security PRs of his own, plus review and triage on others. Django's release wheels now build reproducibly, thanks to Charles Roelli, and Jacob paired with Tobias and Colin on moving djangoproject.com to a new OS.
Django Fellow Report - Sarah
A security week, with eight issues in flight. The fellows want as many closed as they can before the end-of-year break. She also accepted a fix for makemessages dropping context from multiline translation tags.
Python Software Foundation
PEP 8108: 2027 Term Steering Council election
Seth Larson's PEP sets the schedule for the Steering Council term covering Python 3.16. Core team members nominate candidates, themselves included, from November 16 to 30, then vote December 2 to 16, with five seats decided by Bloc STAR voting.
Stricter checks for uploaded sdists
PyPI now rejects V7-style tar archives and wheels whose ZIP comments could pass for control structures, closing off parser differentials. Almost nothing is affected, since build backends already emit pax tars. If you pack by hand, pass --format=pax.
Sponsored
Reach 4,300+ Engaged Django Developers
Sponsor this newsletter to reach an active community of Python and Django developers.
Articles
Django race conditions and unique constraints
A UniqueConstraint protects your data and hands the user a 500. Tim Schilling validates the constraint in the form first, then catches IntegrityError inside transaction.atomic() so the savepoint survives, and writes a racing form to prove the test works.
Billing LLM tokens through Stripe from a Django backend
Papan Sarkar billed a meter event inline with the model call and double-billed a retry. The fix: a UsageEvent outbox row in the same transaction, drained with select_for_update(skip_locked=True). Good on the limits that bite, including Stripe's 24-hour window for corrections.
How to find and fix N+1 queries in Django
A thorough look at this common issue, how to spot it, inspect, and fix.
Your Django tests use the wrong media storage
From Marc Gibbons at Lincoln Loop, tldr is fake S3 not your code when testing media storage. An elegant writeup with accompanying gist to explore.
How CPython processes Python source code
Velda Kiara follows a file, a -c string, and a readline() callable into the same struct tok_state, where one underflow function pointer is all that still tells them apart. Ends at the PEG parser pulling tokens one at a time, with the compile step promised next.
Events
IndyPy: Django & FastAPI: What's Next?
Tuesday, November 24 at 7pm ET, hybrid from E-gineering in Indianapolis or over Zoom. Tim Schilling covers what's new in contributing to Django, and Calvin Hendryx-Parker argues batteries-included against speed in the Django/FastAPI debate. Register on Meetup for the in-person seat or the Zoom link.
PyCon US 2027 Call for Proposals
Talks, tutorials, posters, and charlas all close December 19, with the Future of AI and Python Security tracks returning. First-time speakers can get matched with a mentor to shape a proposal, but that sign-up closes November 27.
Podcasts
The Real Python Podcast #319: Mentoring Developers Beyond the Code With Tim Schilling
Tim Schilling, Django Steering Council member and Djangonaut Space administrator, talks with Christopher Bailey about turning his Better Simple blog toward one-on-one mentoring, what a mentee has to bring, and how LLMs changed the questions developers ask.
Django Chat #210: Code Is Not the Bottleneck - Johannes Maron
Johannes Maron is a prolific Django contributor, package maintainer, and startup founder. We discuss FOSS Fridays, the growing importance of code review in the age of AI, and what actually makes software engineering valuable.
Videos
Mentoring Developers Beyond the Code With Tim Schilling
The same conversation on video, running an hour and eight minutes, including segments on Djangonaut Space and on Django Commons filling the gap left by Jazzband.
Django Job Board
Three senior roles this week: Python engineering at Manychat in Barcelona with relocation support, backend Python at Proxify, and a founding forward deployed engineer at Alloy.
Senior Python Engineer (Barcelona-based / Relocation support to Barcelona) at Manychat
Senior Backend Developer (Python) at Proxify AB
Founding Forward Deployed Engineer at Alloy
Projects
aws/aws-emulator
AWS runs the AWS APIs on your laptop. A Rust server on 127.0.0.1:9297 that the AWS CLI and the SDKs talk to with no account and no bill, so tests hit it instead of us-east-1. Per-service fidelity scores ship with each release.
oliverandrich/django-pg-sse
Server-sent events over Postgres LISTEN/NOTIFY. No Redis, no broker, no Channels. Events land in a table and go out after the transaction commits, so a reconnecting client replays what it missed. Built for htmx 4's hx-sse.
Apakottur/unref
A dead code finder built on Ruff's parser, so the options and output read like Ruff and the config lives in pyproject.toml. It sweeps all of CPython in under a second, and ships rules for pytest, Pydantic, and SQLAlchemy to keep the false positives down.
Sponsor Django News
Reach 4,300+ Django developers every Friday. See sponsorship details and rates.
20 Nov 2026 5:00pm GMT
Planet Python
Django Weblog: DSF member of the month - Johannes Maron
For November 2026, we welcome Johannes Maron as our DSF member of the month! ⭐

Johannes has long been part of the Django community. He is a frequent contributor including project such as django-hijack which has more than 1.7K stars! He is part of the Django Review and Triage team. He is a DSF member since September 2025.
You can learn more about Johannes by visiting Johannes' website and his GitHub Profile.
Let's spend some time getting to know Johannes better!
Can you tell us a little about yourself? (hobbies, education, etc)
Johannes Maron, or joe, born Johannes Hoppe in the GDR. Raised in West Germany only to return to his home state for uni. Studied software engineering at the Hasso-Plattner institute, dropped out and lived the start-up life. I still live in Potsdam and have the most amazing pug, son and wife (in alphabetical order).
I have an idea but where your nickname "codingjoe" comes from?
I am joe, and I code. Honestly, I was young, and I am just happy it's not naughtyb0i420 and thus never changed it.
How did you start using Django?
I started using Django for my very first company, I believe it was version 1.3? I have used it for every company I build ever since, and would always do it again.
What other framework do you know and if there is anything you would like to have in Django if you had magical powers?
Who said I don't have magic powers? The magic of contributing, we all have it and I made good use of it over the years. But my biggest dream would probably be a browser working group to overcome Django's JavaScript hesitance.
What projects are you working on now?
relay, a communication as a service provider. Think Sentry but for email, SMS, or VoIP. Or like AWS, but instead of shooting Katy Perry into space I hope to funnel the proceeds back into the community that it's build upon. Diamond sponsor or die is what I am aiming for. Until I get there, I am offering all services for free to non-profits or community projects.
Which Django libraries are your favorite (core or 3rd party)?
I can't live without dj_database_url and it's siblings like django-environ. 12-factor, always.
What are the top three things in Django that you like?
People, people, and people. You know who you are! <3
You have recently joined the Triage and Review team, congratulations! I know you are hosting now regular online events on reviewing PRs in Discord, could you tell us a bit more about this initiative?
Like all the best things in life, I just stumbled into it. I wanted to be more active and my PR queue was empty. I went on Discord asked, and people sent me more than I could review that day. I promised review them the following week and the wheel started turning. Fast-forward to some discussion on DjangoOnTheMed which gave me the confidence to make this a recurring thing. A small nudge from Tim (Schilling) to set up a Discord event and thus the FOSS Fridays were born.
What makes a good PR from a reviewer's perspective? What's the most common mistake you see?
It's less about the PR itself, but how it came to be. I maintain a lot of community projects where unsolicited feature PRs are all too common. It starts discussion at the wrong end and it requires a lot of mindful communication to convince authors to go back to the drawing board to reject a proposal. Also, "aura farming", patches to large project for the resume, is something I am not too fond of. Mainly because I know that once the PRs is merged, the maintenance burden will fall on me.
AI is more and more present in the tech world, especially in code contributions and reviews. How do you feel about that as a reviewer of Django?
I think besides the slop, there is one thing often overlooked. AI has decimated the entry level job market, so you have thousands of graduates turning to open-source to grind for XP. While I can genuinely emphasize, I think we need to steer that raw energy towards something better than generating even more code. Hence, FOSS Fridays. Gain XP and create value through review, not code. Given that AI does most of the corporate code writing these days, I believe that the best skill to acquire.
I know you are maintaining a lot of projects related to Django, thank you for your work. What made you create some projects in the first place, like django-health-check or django-hijack, for example?
The funny thing is, I created none of the once you mentioned. I started as a contributor and apparently did a good job at it. So the projects get transferred to me. My process is almost always the same, I build a company, need feature and if I find a package that is unmaintained, I offer my assistance. Only if the technology doesn't exist, I write my own package.
How do you manage to maintain so many projects at the same time?
My solution is twofold. If a project was taken over, I rewrite it from scratch. I am always aiming for an architecture, that can be easily extended via inheritance and avoid adding any settings. Once that is done, I resolve almost all issues with suggestions on how to implement those features within the users own project while constantly trying to improve the documentation. Most of my projects have zero open issues and PRs. The art of a "productive no" is something I could probably fill an entire bookshelf with.
You currently sponsor a lot of projects and people via GitHub (Django, Python, Homebrew and others). What's your view on funding open source, and what would you tell companies that depend on it?
I think you need to separate two things. I use personal donations to show appreciation. They won't pay the bills, but the show maintainers that I care. You just need to decide if you need another streaming to pay for another billionaire's mega-yacht or if those 20 bucks are better spend on your first sponsorships.
Now, corporate sponsorships are a different beast. I believe they are fundamentally broken. For-profits are there to generate profit for their owners. But, they need employees to generate those profits even with all the AI in the world. The one thing you should always ask during an interview, is: "Does the company sponsor any open source projects?" Preferably late in the interview process. It costs nothing to ask, but the pressure will compound. ... Or you do it like my start your own company and do it differently 🤷
How do you envision the future of Django from your perspective?
I can't wait for Django version 2100. While I might not be around for that, I sure hope it'll happen. As for the DSF, I'd hope that it would eventually be able to build or acquire assets and accumulate wealth to be sponsorship independent. I know it sounds far-fetched, but it doesn't mean we shouldn't strive for a Django Software Fund.
After so many times in the Django community, what makes you stay?
I saved the stranges story for last. A long, long time ago, I was kindly offered a refund for my DjangoCon ticket, because of a tweet violating the CoC. Luckily I somehow managed dial down my ego for a minute and apologized like a grown up. The whole encounter changed how I perceived the subsequent conference and our industry as a whole and my role in it. Sometimes we learn more from our mistakes more than from our successes. The Django community has taught and challenged me so much over the years. All those experiences are now inseparable of who I am today. And even if I left, I hope to think I would carry those things with me always.
Is there anything else you'd like to say?
Thank you <3 and go Django 2100!
20 Nov 2026 1:00pm GMT
19 Nov 2026
Django community aggregator: Community blog posts
Code Is Not the Bottleneck - Johannes Maron
🔗 Links
- Johannes Maron's Website
- GitHub - codingjoe
- PyPI - codingjoe
- Johannes Maron on LinkedIn
- FOSS Fridays on Django Discord
- Official Django Skills for LLMs (Django Forum)
📚 Books
- The Practice of Programming by Brian W. Kernighan and Rob Pike
- Build a Large Language Model (From Scratch) by Sebastian Raschka
- The Mythical Man-Month by Frederick P. Brooks Jr.
📦 Projects
🤝 Sponsor
Thanks again to Laravel Cloud for sponsoring this episode. The team behind Laravel's managed hosting platform has something big in the works, and we'll share more here on the show in the coming weeks.
🎥 YouTube
19 Nov 2026 11:25pm GMT
18 Nov 2026
Django community aggregator: Community blog posts
Weeknotes (2026 week 47)
Weeknotes (2026 week 47)
I haven't done any blogging in the last 4 weeks. Instead, I've been writing a lot of code and have let the agent write even more code. I have finally managed to implement some tools I would have liked to implement a long time ago.
Working with LLM agents
The relationship with LLM agents doesn't get any easier, I have to admit. That said, the quality argument against LLMs seems less and less plausible to me. Some people (especially on Mastodon) will say that's because I'm losing view of what's actually important. As I see it, human-written code was never perfect either (maybe apart from the Apollo Guidance Computer). I can actually do good and solve more problems for real users with more than acceptable code quality now and that seems like a net benefit to me.
Governance - a Django app for Holacracy
As some people may know, we are using Holacracy as our organizational model at Feinheit. Holacracy One, the company behind Holacracy, also offers a SaaS solution for managing the structure consisting of circles, roles, policies etc. The tool is unfortunately quite buggy and slow, and hasn't improved in recent years - to the contrary.
I have reimplemented the parts we actually use using Django, Bootstrap and htmx while profiting from years and years of product engineering going into the Workbench agency software.
It won't surprise anyone that after the first rush of getting a half-functioning, half-assed prototype out of the agent it was a lot of work to actually make the tool somewhat consistent, usable and correct. The bar to replace the tool we've been using before wasn't that high, so I was able to cross that in a few days of concentrated work.
I think that this project wouldn't have been doable without the deep knowledge of the organizational model (the domain knowledge) and the product engineering and UX background.
An experimental API and CLI for feincms3
The feincms3-api and feincms3-api-cli allow interacting with a feincms3-managed site. The API allows reading and writing pages and other objects with their regions and plugins, django-json-schema-editor data and django-cabinet files. It's meant for scripts, importers and agents, next to the Django admin, not instead of it. The CLI (f3api) makes the API available from the command line. Writes can be tried as a dry run first, and changes show up in the admin's history like any other edit.
Permissions, editable fields etc. are all handled by the Django admin. Since feincms3 and django-content-editor lean heavily on Django's administration interface this was an easy decision to make. Plugins can be arbitrary models and we don't have an obvious way to discover them, or even know what their structure is apart from introspection or manual work. The constraints of working in an agency are such that I cannot spend a lot of time on each individual project; I really need reusable tools which can be applied to many websites and projects at once. It can be acceptable for the result to not be perfect or a little awkward as long as it is simple and understandable.
Releases
feincms3 and django-content-editor
The rendering engine from feincms3 has been ported to django-content-editor and lives there now. Nested sections stay in feincms3 as a backwards compatible implementation, the new implementation in django-content-editor is much nicer because it doesn't require section closing plugins. Instead, all plugins have a depth field and form a tree structure that way; a new level is opened by a plugin which is marked as a container. Many such container plugins can coexist.
Also, the new releases fully build on the importmap DEP API, and include many bugfixes which will not be mentioned in detail here.
feincms3-sites has also received a small update and a few bugfixes.
django-cabinet
The media library now supports moving files with drag'n'drop and has a collapsible folder tree on the left for quicker navigation.
django-json-schema-editor
The proxy models created by JSONPluginBase.proxy() are automatically injected into the Python module now; this allows Django's model autoimporter in ./manage.py shell to discover those models, which avoids many, many warnings.
django-prose-editor
I am always tracking Tiptap and ProseMirror closely. The editor now has a deeper integration with django-cabinet - inserted files keep their ID around. Apart from that, mostly minor changes.
django-js-asset
I have released django-js-asset 5.0 implementing the ImportMap specification which I'm still hoping to bring to Django core.
form-designer
Bugfixes, French, Catalan and Spanish translations, and a small security fix (don't inadvertently add formulas to generated XLSX files, the fix is in xlsxdocument below).
django-authlib
Hardened the Microsoft Entra ID adapter. Fixed a few bugs and improved docs.
django-imagefield
I did finally release a new stable release of django-imagefield containing the still experimental vips backend.
django-translated-fields
TranslatedField now handles model fields with broken^Wcustomized deconstruct methods properly. For example, feincms3's ChoicesCharField hides the choices from Django's migrations, so changing choices doesn't create pointless migrations (they wouldn't produce any SQL anyway). However, the previous implementation required that fields are reconstructible from the return value of deconstruct, which means that such fields could not be used with TranslatedField. Now they can.
django-tree-queries
Fixed an edge case crash, allowed customizing the node moving machinery to reject targets and slightly modernized the code.
feincms3-cookiecontrol
The cookie banner now supports Google's advanced consent mode out of the box, if you opt in to it as the one implementing it (not as a visitor to the website!). I think supporting that mode is good, because while the mode itself is very questionable, having a simple and straightforward implementation for it is better than having to choose one of the really, really complex and user-hostile consent management platforms.
feincms3-forms
The proxy models created by the forms builder are now injected into their module. Same problem as above, in django-json-schema-editor.
Other releases
- I still seem to be maintaining django-mptt, even though it has been marked as unmaintained for years. Fixed some tree corruption bugs and regressions.
- xlsxdocument doesn't insert formulas anymore except if they are tagged using a new
Formulaobject. form-designer uses it for its XLSX export. - speckenv now supports configuring Django's
MAILERSsetting from the environment as well. The format is the same as the one used bydjango_email_urlanddj-email-url. Also includes more fixes for configuration cases I hadn't encountered before. - towel and towel-foundation, two packages from back in the day when I was a stronger believer in the DRY principle. Note that I have been moving away from that for years. I'd rather have some repetition than more indirection these days.
- html-sanitizer now knows how to preserve whitespace within
<pre>tags. - The venerable FeinCMS and feincms-elephantblog are in maintenance mode, but have received updates and releases.
- Fixed a minor bug affecting django-admin-ordering models which handled comparisons with unrelated objects incorrectly.
- Updated the django-sitemaps README and published a new release, just because.
- django-ckeditor now uses the new django-js-asset API.
- django-email-hosts now supports
MAILERS.
18 Nov 2026 6:00pm GMT
05 Nov 2026
Planet Twisted
Glyph Lefkowitz: Why You Should Care About The Political Project of Twisted
Twisted was originally the network component of a text-based role-playing game engine. In the late 90s when it was first developed, the idea of a video game being able to send you actual emails and instant messages1 seemed pretty neat, rather than the valence that it would have today (nightmare). We never ended up making an actual game, so we eventually removed the "game engine" piece, and just kept the protocol implementations of the email and the AOL Instant Messenger, and the DNS and eventually SSH and so on. The residual pieces of that project have not seen maintenance for a decade.
So it's not really a way to make a text-based game any more.
Then, Twisted was the premier longest-lived and best-maintained event-driven I/O library for Python. If you wanted to make high-performance servers, it was the best and most obvious way to do it. Even if it still acquits itself relatively well in this regard, its claim to fame, and to indispensability, has been somewhat obviated by the inclusion of asyncio in the standard library. Even if it has some stuff to recommend it - better-than-average testing facilities, for example - you can get better-documented and better-integrated low-level asynchronous networking tools without even installing any packages.
So it's not really the premier choice for an event-loop these days.
Twisted does still contain an SSH server and client, an email server and client, a DNS server and client, a web server and client (now including websockets). But you can cobble these together by installing a variety of packages from other sources.
So... it's a bunch of protocols? And I guess it doesn't use AI? But... why would anyone care about that? Why contribute to such a thing?
What is Twisted doing, and who is it doing it for? What is the political project of Twisted, nigh on 30 years into its existence?
Most of all, why should you care about it, or want to contribute?
If you're asking what you could use Twisted for today, it's an excellent choice if you're implementing a new network service and you need more than one protocol. If you need to do HTTP, DNS, packet capture, and a custom SSH server, it would be very hard to arrange a collage of other Python packages to manage this. It's still much better at deterministic testing than most of the standard library. It's a bit easier to hook into a GUI.
But that's not what Twisted is doing.
What I want Twisted to do for the world is still an unfinished project. It's honestly kind of bad at doing what I want it to, but it could be great. The overarching goal of having and maintaining all this stuff is to, as much as possible, demystify networked software operation and let you build Internet facing systems at a human scale.
It's all in a memory-safe language with good error handling, so you can avoid the scariest security pitfalls. It's all integrated into a single paradigm with built-in tools for testing. It's designed to scale down to be runnable on the average laptop, and not require large elaborate server farms or distributed clusters to run. Via the twist command line utility, it provides a Swiss army knife of simple tools that you can use out of the box.
In a world where all of our compute is in massive distant opaque datacenters, where a tiny cartel of gigantic tech companies control nearly the whole supply chain, one of the few things that you still can have agency over is your own server on the Internet.
It's still possible to get a domain name for a few bucks a year, a free-tier or very low-cost VPS, then stick a glue record in and run your own DNS. From that point forward, you can run your own email, your own web server, your own terminal server. But doing this requires deep expertise, and that expertise requirement is massively inflated by the operational concerns that go with running twenty different pieces of software from twenty different projects, probably in twenty different languages, with completely inconsistent aesthetics.
The reason that Twisted is event-driven is because as much as it can be a pain to wrap your head around async/await (or worse yet, Deferred directly), it is much easier for a single person to understand the concurrency requirements of an async I/O multiplexed system than to understand what is going on with an application that requires multiple thread pools. It is possible to understand concurrent code that manages parallel tasks in that idiom. The reason that Twisted integrates so many different protocol implementations and attempts2 to unify them with a common authentication layer is to reduce the overhead required to manage a comprehensive suite of network services.
Even the not-using-AI thing is not an aside due to some accidental personal preference about tools - it's a core part of building an engine that you can personally understand if you dive into it, that's built with a consistent style and layered in a way that you can take apart if you need to. It's not built with AI because we're not building for AI, we're building for people and the entire point is that people are supposed to be able to understand it.
We used to have a tag line, which is somewhat less emphasized these days because its meaning is not immediately clear without this background, but was once quite prominently featured on the home page: "Twisted: Building the Engine of Your Internet". That's what I want to bring to you: an engine for you to build your Internet, that is small enough that you can make it personal, that doesn't require massive investment in management tooling just to get started.
Now, for various reasons, I no longer use twisted.names to host my own DNS (although I did for many years!), and we never wrote enough of a twisted.mail suite for it to be usable for email hosting on its own. But, if you're reading this article, it was probably delivered to you directly via Twisted's own twisted.web HTTP server, using twisted.protocols.tls to configure our own OpenSSL TLS termination. I have run with extremely high reliability for years and next to zero management overhead, in a single simple docker container. Which I then administer and upload files to via Twisted's own twisted.conch SSH server.
If that seems like an appealing project and you'd like to volunteer to help out, drop me a line and maybe I can point you at some tasks to get started. Twisted falls far short of this aspiration despite 30 years of work, and we could use all the help we can get.
Acknowledgments
Thank you to my patrons who are supporting my writing on this blog. If you like what you've read here and you'd like to read more of it, or you'd like to support my various open-source endeavors, you can support my work as a sponsor!
05 Nov 2026 10:51pm GMT
09 Oct 2026
Planet Twisted
Glyph Lefkowitz: Programming Isn’t Special
Creative Work
Writers went on strike to get protections against "AI". Thousands of artists have signed open letters in protest of "AI". There are so many copyright lawsuits from creative industry groups against AI that there's a whole dedicated website for it. Popular YouTubers absolutely hate it. If they're also musicians, they REALLY hate it. Across all creative industries, there is a concerted push to reject this technology.
Yet, almost unique among creative fields, many experienced programmers remain convinced that it's fine to use "AI" for programming. We do seem to hate it, and what it's doing to our industry. It's making us all miserable, but we are using it anyway.
A lot of the justification of this resignation seems to be to be because programming is not Art. If the tool can get the job done, and the job is just functional, then why does it matter?
It does matter, though. It matters because we shouldn't be using AI to produce Art, and programming is Art.
Art can be Mundane
Some people will say that programs cannot be art because programs are functional, rather than being expressive. Programs are mundane whereas art is transcendent.
This is based on a distorted understanding of what Art actually is.
In John Berger's "Ways of Seeing", he names this type of distortion "mystification". His example of this process is both amusing and illustrative. I encourage you to read it in its entirety.
In summary, though: Berger critiques the florid prose of an art historian describing a commissioned group portrait, including phrases like "subtle modulations of the deep, glowing blacks" and "harmonious fusion". The portrait is described as sublime, in nearly ecstatic terms.
Berger reveals that the reality of this portrait is that a poor old painter needed some work, and some officials probably thought it might be nice to have an official portrait. So they paid some money to the poor old man, and he painted it, and then they had a painting. It's a well-executed portrait of a group of people. Beautiful, even. But it was work commissioned for a fairly mundane purpose and it suited that purpose just fine. It was not, and is not, a divine relic.
Culturally, we are prone to mystifying painting, and sculpture, and film, and music. We imbue them with "subtle modulations". We ignore their functional aspects - we desire decoration, amusement, and distraction - and focus on their emotional impact.
Don't get me wrong: I love me some good aesthetic philosophy. I think it's great to really examine our reactions to artwork and to try and gain a deeper understanding of our culture and our selves through media analysis. If anything we really need to do more of it.
This does not mean that the creation of such works is mystical or that it should be venerated beyond any other sort of labor.
Not least of which other types of labor that are adjacent to, but not as culturally venerated, as fine art. We tend to mystify the work of a novelist, but to denigrate the work of a journalist. In reality, the functional prose of the journalist is no less important and deserves no less respect.
Although they might be far below the ethereal realm that novelists inhabit in our collective imagination, even journalists receive more respect and thus more mystification than lowly copywriters. Yet, there is no transcendental distinction between "novelist" and "copywriter"; the many of the skills are the same, and the distinction is merely an accident of commerce and opportunity.
In fact, many famous writers have famously inhabited both roles. This is not an accident! Working with words professionally, even (perhaps especially) mundane words, is excellent practice for working with words in a more purely artistic context, because even mundane creativity is still artistic.
Code can be Beautiful
One thousand Internet years ago, when I was in my late teens, I would describe myself as a "code poet". I was relentlessly mocked for this as what the Youth would today call "being cringe", and at the time was referred to as "pretentious".
I succumbed to the peer pressure, removed it from my email signature and my bio. While I still believed strongly in the parallels, I accepted that - socially, at least - comparing code to poetry, or indeed to Art, was a silly thing to do.
However, I never abandoned the idea, in my heart.
The thing that I am most well-known for, the invention of Deferred, was specifically an aesthetic reaction to the tedium of passing callback and errback parameters to every single remote procedure call in an RPC client/server application. Those two callbacks got the job done just fine. But they were ugly, and annoying to work with.
Deferred is an intentional poem about asynchronous task execution, with a deliberate eye to the aesthetics of the problem and the experience of using it. It was influential because of its focus on aesthetics.
I do not want to overstate the beauty or profundity of this minor contribution, or indeed its durability. That a poem exists does not mean it is a great poem, merely that it is a poem.
Our aesthetic culture around programs is more like folk epic poetry than fine art, so the influence of this contribution is less about its specific enduring power than it is about its influence on what came next; from MochiKit.Async to JQuery Deferred to JavaScript Promises and eventually to async/await; a long chain of different artisans each adding something of their own until the original has all but dissolved. (And I wasn't the "original" here, either, as I drew heavily from the E language's Promises, among other things.)
In order to make code into a deliberate artistic expression, one must have spent quite a bit of time contemplating the problem domain. Without having experienced the tedium of manually passing a thousand callback parameters, I would have had neither the skill, nor indeed the motivation, to bother creating such a thing.
Now, most code does not have to be like this. Most code does not get to be like this. Most code is functional, workday code. Most code could not make a lady weep. It's just copy-writing, if you will.
As I explained previously, most writing couldn't do that either. Most writing is just copy-writing, too. Most visual art is advertising. Most live music performance is background music in bars that will go largely ignored.
However, code that is intentionally aesthetically designed tends to be important, both socially and technologically.
We do have some tradition of self-mystification in software. As Abelson memorably put it, "Programs must be written for people to read, and only incidentally for machines to execute.", so we have long had some conception of programs as highly expressive, even if we can't always agree on what they're expressing or to whom. We will occasionally wax poetical about the philosophical implications of a particular piece of software. This is not unique to a single piece of software, either; more than one community has indulged in similar philosophizing.
The expressive and aesthetic qualities of software are not limited to reading source code or interacting with other programmers via APIs, either. For example, every year, Federico Viticci does a review of Apple's new operating system, which is (among other things) an aesthetic critique. Such a project would not be possible if the software did not have an aesthetic impact on its users.
Not to mention that every video game review is also a software review.
A Brief Aside about Software Literacy
It does make me a bit sad that we don't have much of a critical reading tradition in the software community. Literate Programming is often praised, but rarely practiced.
Moreover, it makes me sad that users have a pretty jumbled idea of what goes into making software, that programming literacy is pretty low, and that modern programming practices often deliberately produce a bad mental model of what the software is doing so it's even harder for the user to understand. The aesthetic experience of software is often wildly detached from its internal state.
While all of these problems predate AI by years or indeed decades, that's no reason to enthusiastically make them worse.
Defend The Mundane
If we use AI to erase all the copy-writing, all the graphic design, all the boring mundane art, and yes, all the boring custom WordPress theme development, then we will be removing all the practical opportunities for the vast amounts of practice and contemplation required for people to elevate their craft to eventually achieve great things. Education is great, but the majority of true skill development happens on the job and always has.
This doesn't mean that we can't use abstractions, or automation, to make our work easier. Programming is the art of abstraction, of understanding how to compose smaller ideas into bigger ones, of how to understand the automation of a larger system by understanding the rules that automate smaller ones and understanding how to combine them.
When we use "AI" to eliminate that understanding rather than raise it up to a higher level, to entirely destroy that creative decision-making process, we do a disservice both to ourselves as programmers and to our users. We would be doing a disservice to our users and our downstream fellow developers in the same way that a visual artist would be doing a disservice to their viewers or a musician would be doing a disservice to their listeners if they served them auto-generated filler instead of their own creative output.
Slop is slop, no matter the medium.
Each mundane project has some tiny chance - let's say, something like 0.1% - of achieving greatness. If we do a single project with AI, then sure, whatever, there's almost no chance that that project was going to be the one hit to create that career-defining moment for an engineer working on it. If we make a habit of doing all projects that way, though, we take the total likelihood of those moments of greatness from "definitely sometimes" to "never".
The precisely appropriate ways in which to resist AI encroachment on all software development lie well beyond the margins of this one short post. How much you can resist and which specific uses you should resist are up to you. But it is worth resisting in software just as much as it would be worth resisting in any creative medium.
Programming isn't special. It's just Art, and Art is the most human - and thus, the most universal - thing that there is.
Acknowledgments
Thank you to my patrons who are supporting my writing on this blog. If you like what you've read here and you'd like to read more of it, or you'd like to support my various open-source endeavors, you can support my work as a sponsor!
09 Oct 2026 7:00am GMT
28 Sep 2026
Planet Twisted
Glyph Lefkowitz: What Would A Serious AI Product Look Like?
One of the issues that I have with the current generation of "AI" products is that they do not appear to take their own premises seriously. I look at a plethora of obsequious chatbots claiming to be serious tools for problem solving, and I think, this is not what a problem-solving tool would look like.
Even before we get to the tremendous ethical problems with the frontier labs, it is this impression of their composition as a product that makes me feel, constantly, whenever I am interacting with them, that they are less a software product than that they are a grift, a scam designed to make me feel like I am interacting with a product that has capabilities that it simply does not, to try to lull me into a false sense of security that I can trust it.
The frontier labs are of course the worst offenders, but every criticism here applies just as much to Ollama, which (if anything, due to the obviously poorer quality of the available models themselves) needs these features even more than the frontier labs do.
Here, I will set down a few features that might convince me that an LLM-based product, particularly one focused on research or software development, was actually serious about helping me do useful things with it.
Make "Checking For Mistakes" A First-Class Feature
This is the biggest issue, and the major reason that I was inspired to write this post.
It is a truth universally acknowledged, that AIs cannot reliably provide information.
I could cite a ton of news articles and studies about this fact, but there is no need. Every single chatbot admits this, up front, in a fine-print disclaimer as a core part of their user interface. Gemini says "AI can make mistakes, so double-check responses", Claude says "Claude is AI and can make mistakes. Please double-check responses.1" ChatGPT says "ChatGPT can make mistakes. Check important info.".
Every time I see that last one, I wonder how I'm supposed to know what "info" is supposed to be "important".
All of these warnings are all small, gray text, painfully obviously included as legalese to push responsibility back onto the user rather than to help with anything. This is a core limitation of all these products. Checking their output is a part of the workflow for using them that:
- you absolutely cannot skip or skimp on without creating risks to yourself and whoever you are conveying its output to, and,
- it is very easy to skip or skimp on and you are encouraged at every turn to do so, because "just trust the output" is one of the quickest ways to save time.
A chatbot product that took this weakness seriously, as an actual consideration for using it, would put a checkbox next to every claim in its output. It would be a 2-column worksheet, where you've got the LLM output in the first column, and next to it, human notes in the second column, explaining what work went into checking this claim, and a big checkbox that you would only check off after you believe you'd checked its claims thoroughly enough.
Coding assistants would need to have some version of this as well. Right now, this is pushed off into code review, which means it is a dark pattern which subtly encourages the "author"2 to offload this work to their code reviewer without ever looking. Once again, "it's probably fine, I don't need to check" is the quickest way to save time and churn out those PRs faster.
It might even be useful for coding harnesses to have some affordance for checking code before it even runs tests. As the vendors themselves have admitted, it's not just expensive to burn tokens on your "AI", you also end up burning far more compute on the AI. Being able to check your diffs before sending them over to uselessly exhaust your testing compute cluster would be useful.
If your product tells me that it makes mistakes and I must be the one to check for the mistakes, but then gives me zero tools to check for mistakes, I cannot take it seriously.
More Citations to Check, And More Details
Most chatbots prefer to give an answer, rather than a citation. In my own personal use, I find that when asked to provide a list of citations with clearly marked sources for each one, they will appear to "get bored" halfway through the list and simply stop including citations at some point.
When the bots include citations at all, present them as inline annotations that say nothing but the domain name of the search result, in a font so small that it's barely legible, and an equally indecipherable icon that is fewer than 16 pixels on a side.
This is backwards.
Now, I am aware that these citations do come from somewhere, and in an attempt to reduce hallucinations, all of the major providers support some form of "grounding"3, and that those little barely-readable citation links are referencing actual structures in the RAG pipeline and not just potentially-hallucinated tokens, but I'm not talking about the underlying machinery in the model, I'm talking about the presentation to the user.
Plus, regardless of whether a snippet of text came from a RAG query, we know that LLMs can never provide an authoritative result; it's a fundamental limitation of the technology. They can still garble the results of RAG as much as they can misrepresent any other training data. This means that it must never present its results as authoritative.
If you ask an AI to do research queries, every result should be presented as a list of citations. Moreover, the presentation should display each citation as a large object of in its own right, with clearly identified metadata, including not just the site where it was found but its publication date and, if possible, the name of the author. The literal, unmodified quotation (not from RAG, not a summary: a quotation extracted with a regular program and not an LLM) should be front-and-center, larger than any AI-generated text.
If the AI product wants to editorialize or summarize (which should not always be necessary!), the AI-generated text should be presented as small text underneath the citation that has been found, de-emphasized as much as the disclaimer is right now, at the very least until the user has verified that the summary is accurate. Perhaps, for a research project, a "did you read the citation" checkbox might even be helpful.
If your product openly tells me that it will scramble, misrepresent, or omit its citations in its summaries, and I must read the original human-authored citations to be sure, but then gives me no tools to track my reading of those citations or even any way to find them, I cannot take it seriously.
No First-Person Output, No Apologies
There is no reason for a software development or research tool to use first-person language to describe itself. They should not do so. In fact they should not be allowed to do so.
There is also no reason that they should ever apologize. It is a waste of everyone's time; it's a waste for the chatbot to generate the apology, it's a waste for the user to read the apology, and it's a waste for the user to respond to the apology. Yet they unfailingly do this upon every correction.
The vendors of these tools know that they are routinely causing mental-health crises. In response, they have added non-functional "guard rails" that can still, in 2026, easily be bypassed.4
A product seriously interested in helping with productivity would correct this glaringly obvious flaw, focus on the task at hand, and stop emitting useless verbiage.
In the previous two sections, I tried to focus on ways in which the harness would be constructed differently even if the LLM technology is fundamentally impossible to improve; in this case, I have to assume that the labs have some control over the model itself. But unless they are truly incapable of influencing their output (and all their "benchmarks" and "capabilities" seem to indicate that they can control it very tightly) they ought to be building models that are much less verbose.
More Non-Natural-Language User Interfaces
Although natural language could hypothetically be a powerful interface for interacting with a computer system, the practical upshot of LLM natural language interfaces is that these interfaces are imprecise and repetitive, full of superstitions masquerading as "best practices". The inputs are a mess and the resulting outputs are a mess.
The general way of addressing this unstructured mess is to allow the chatbot to directly take action in response to the user's input; in other words to supply it with "tools" via an MCP server. But again, this is backwards. If we cannot even express our intent clearly in the first place, why are we trusting this system to take potentially destructive and harmful actions on our behalf?
Instead, I would expect a product that was seriously invested in helping me accomplish specific tasks, to have user interfaces specific to those tasks. Is it supposed to be able to be a security scanner that can discover OWASP top 10 bugs in a codebase? Have a button for that. Build that functionality into your harness, train it directly into the model, use smaller models that can satisfy that functionality more effectively than throwing it at the planet-sized brain of Fable or whatever.
I'm aware that there are small software startups that do something like this, but they are bolted on to the side of the main model providers' APIs, not integrated into the core of the product and not using their own models and AI systems to achieve consistent and repeatable results.
Strong Data Provenance Indicators
Chatbots produce data tables pulled from websites, from APIs, from MCP tools or from summarizing and scrambling the user's input. In order to provide the illusion of a seamless interface, this data is presented in-line regardless of where it comes from. But some of these outputs are produced mechanically via regular old API calls, for example, from the result of calling a tool or querying a website, but presented uniformly.
But there is a huge difference between an authoritative data source being inlined as part of a chatbot conversation, being treated as input by the chatbot, and some ad-hoc hallucinated data being treated as output of the chatbot.
If a product is trying to help me make accurate, empirically-grounded, data-driven decisions, the source of the data is critical.
Integrated into the "check for mistakes" and "verify citations" workflow I described above, there's a necessary "verify data programmatically" pass as well; to have tools that will treat portions of the output as a regular spreadsheet, allowing regular-old computer arithmetic to verify things and showing where such arithmetic was used, and how.
Better User Control of Reproducibility
Anyone familiar with the technical specifics of LLMs will know that they have a variable called "temperature" which controls the degree of randomness that the LLM uses to produce its outputs. But most users don't know this, because it isn't exposed as part of the user interface by default.
This leads to a subjective impression that you asked ChatGPT, and you got ChatGPT's authoritative answer.
You can't just set the temperature to zero and still get useful results - I am aware that it does more than just scramble the output at random, and there are perhaps good reasons that simply exposing just a temperature setting would not be that useful to users. But if we followed some more of my earlier recommendations for making more structured UI elements to solve specific problems rather than having long back-and-forth chats where each refinement depends on the previous response, perhaps those elements could also re-play the process so that users can see how reliable the bot is at a particular task and develop a sense of how the stochastic nature of the process actually affects it.
Similarly, if a user is trying to solve the same problem repeatedly with a chatbot, and the chatbot product has numerous computational tools that don't really have anything to do with the LLM, such as deterministic data-processing tools, then having a way to freeze the non-deterministic parts of the transcript but re-populate a particular data frame with updated information and fork / continue the conversation from there would be a way to avoid introducing pointless additional randomness when you already know what tool you're trying to use.
The fact that every conversation is presented as this flat chat prompt that doesn't let me interact with any of the widgets that were previously produced except through more chatting, really makes me feel like the whole product is just doing predatory social-media style "increase time on site" optimization, just trying to lure me into further repetitive and unreliable chats, rather than letting me get in, solve my problem, and get out.
Context Visibility
Managing the LLM context is the ongoing challenge facing organizations that are trying to use "agentic" workflows. Filling up the context with too much information causes well-known problems. In response, advanced LLM users attempting to solve larger problems must break up very long prompts into "skills", give access to lengthy information via "tools", and delegating sub-problems to "sub-agents" rather than simply extending a single prompt indefinitely.
All of these strategies have flaws, because even on the largest models, compared to the breadth and depth of knowledge-work problems, LLM contexts are quite small.
And yet, none of these products will show the context to the user by default. There are third-party addons that can show you a simple progress bar but for addressing the premier engineering difficulty with this technology, that is below the bare minimum.
This lack of visibility means that almost all of the tools for extending the context are flying blind. Rather than responding meaningfully to a full context, everyone just kind of guesses how much state they need by guessing and trying over and over again with progressively more elaborate skill and sub-agent layouts. Even managing context compaction ends up being an advanced API-driven workflow5.
A serious product that was trying to help the user understand would not only show "available context" but explain the impact of context compactions, make it easier to see harness-generated prompts, and so on. This would be a first-class feature, combined with the aforementioned reproducibility / replay tools, would allow users to do real experiments to develop an understanding about how to make good use of the context window.
A Sandbox That Actually Works
I've been focused on the chatbot interface here because it is the most immediately egregious upon looking at the UI. But the "agentic loop" tools used for coding are equally dangerous, if not more so. Coding tools keep destroying everyone's data, over the course of years.
These catastrophic incidents that become front-page news are relatively rare compared to the amount of coding-agent use out there. But they also aren't the only kind of sandbox violation. Coding models will so routinely edit test code instead of the system under test that there are "pro tips" articles all over the web giving you the flawed advice to simply ask the agent not to cheat. News write-ups of the catastrophic incidents themselves will also offer glib and wrong advice, like "use a docker container". That might prevent it from literally deleting your operating system, but it won't prevent it from destroying all the local work you have in your codebase (it needs access to a checkout, after all!)
There is a flurry of activity in the infosec space where people are rushing to plug the gaps left by these coding harnesses. Everyone's got their own version of an MCP approval gateway where you can optionally place a proxy between your agent and your production infrastructure.
In the best case, though, all these mitigations and proxies and prompts simply turn the user into an auto-approval automaton, hitting Y, Y, Y, Y over and over again, until you finally are driven mad and hit "yes to all", turn on full-auto mode and submit yourself to the void. With nothing between your personal vigilance and disaster, there are no workflows left beyond decrementing your own vigilance until there's nothing left and then hoping the disaster never arrives.
The fact that some mitigations exist that can be deployed by extra-cautious users does not change the fact that "agentic coding" is an unsafe-by-default technology deployed without concern or guidance. Every frontier lab has tied a spring-loaded shotgun to a dog; the fact that dog owners can publish thoughtful blog posts explaining how you can teach your dog the basics of gun safety or how you can have your dogs play in a bullet-proof room does not mitigate the fact that the product should not have been allowed in the first place, nor should it continue to exist without VERY strong security controls.
I might believe that a frontier lab were seriously interested in providing developers with a useful tool if they shipped something that had safety built-in.
That means tools in the harness, detached from any LLM, independent of the prompt, that could:
- sandbox all filesystem operations and strictly limit ANY deletions outside of specified scopes, regardless of operating system,
- enforce snapshotting of the entire repo on every operation for easy rollbacks and minimal lost work,
- remove the disaster of "auto mode" (not to mention nonsense like
--dangerously-skip-permissions) entirely, and - carefully consider a structure for presenting plans to the user where, rather than provoking immediate alert fatigue by asking for checks on every action, make structured plans which can be submitted to the user as a group of actions and reviewed and approved as a batch.
In the same way that I suggested above that research-based tasks should have a way of re-issuing prompts to determine how reproducible a result is, or whether other sources might be found, agent-based tasks should have a way of being executed against mock services for popular APIs, so that the verification can match both on the front-end (review the plan for making the API calls before they're executed) and the back end (review the API calls that were issued to the mock service and verify that they matched).
Instead, the frontier labs provide us products that are disasters out of the box, give us "best practices" to build massive and elaborate, as well as incomplete and error-prone, security perimeters of our own design. Then they blame "operator error" when it inevitably goes wrong. I cannot believe that these design choices are intended to help us be productive.
Bonus: Human Processes
Organizations deploying AI also frequently come across as unserious, for similar reasons. In 2023, naive exuberance could perhaps be forgiven. But today, as we near the close of 2026, there are several well-known problems, that have been extremely well-covered in the press. None of these things should be surprising, but most orgs deploying these tools are still just letting them rip and hoping it all works out.
Organizations deploying these tools would need at least three kinds of major modifications to their internal processes, if they wanted to be serious about using them safely:
1. Shift Rotations to Prevent Vigilance Decrement
There have been several high-profile incidents where software developers' gradual acquiescence to accepting LLM output have lead to serious economic consequences for the companies deploying them, perhaps best typified by Amazon's "millions of lost orders" due to a gradual decay of their engineering processes from LLM use.
These outages, and other AI-related failures, are due to the difficulty of maintaining focus on the same problems. In other words, as I described above, vigilance decrement is a constant problem, because AI outputs are most often correct, but continue to be incorrect in surprising and non-intuitive ways. As I have previously written, you cannot trust yourself to catch every bug with code review, and LLM output.
Aviation, for example, has very strict rules around rest requirements. There is also a specific rule that "No certificate holder may operate an aircraft without a second in command if that aircraft has a passenger seating configuration, excluding any pilot seat, of ten seats or more.". Other safety-critical professions have similar rules.
And yet, even in the age of the supposed "AI revolution", most software teams are still assigning every engineer a full feature load, not planning for any rest, and telling people to review code whenever they happen to have some "free time".
Maintenance of vigilance has to be your top priority. Regular, scheduled, inviolable rest periods where people do work without AI assistance, and are not exposed to any AI output for review or otherwise, would be crucial in order to stay mentally sharp enough.
The tools themselves should have this sort of thing built in. The mistake-review process described above should have a periodic spot-check mode where a second reviewer periodically reviews a chatbot log, doing their own independent verification of claims, to see if they spot the same errors. This could provide a feedback loop to determine how much rest is necessary to maintain continuous attention and actually spot hallucinations.
2. Skill Practice To Prevent Skill Loss
It is also well-known that AI use leads to AI reliance, and AI reliance leads to skill loss.
I like to use the analogy to dockworkers at a seaport6 adopting automation.
If you employ dockworkers to load and unload ships all day long, they are going to be getting tons of exercise. They will be able to lift heavy objects on demand, whenever. They might have plenty of health problems and injuries from this type of work, but "lack of exercise" will not be a problem.
With the development of standardized container ships and mechanized cranes, you are going to be changing their job description substantially: now they mostly spend all day sitting in a small cubicle moving a control lever back and forth, not lifting heavy stuff. They will get worse at lifting heavy objects.
In this analogy however, the cranes are not all that reliable. We know they break, and they drop their payloads sometimes, and the stuff needs to be manually moved. But this only happens a few times a week, at most. If you need whoever is driving the crane to be able to jump out at any moment and still move stuff around manually, then you need to make an affordance for that. You need to give them time to go to the gym and do some lifting for practice, or every crane failure is going to be a major emergency.
An organization doing an AI transformation would also need a massive increase to learning & development budget, both in terms of resources and in terms of schedule. If your people are going to lose skills because they've lost regular practice in the incidental course of doing their duties, then they are going to need deliberate, intentional, non-incidental practice of those skills to keep them sharp.
But rather than trying to accommodate new workflows and give time for people to adjust, most AI mandates are simply dropped on workers like a ton of bricks, with no time to adapt and no affordance for maintaining their skills. Operate the crane and stay fit and healthy and ready to switch back to manual lifting at any time and then get back in the crane cockpit right afterwards. Don't mess up.
Then an accident happens and everyone is surprised, as if this process weren't practically designed to produce a terrible result.
3. Mental Health Resources to Deal with Mental Health Risks
AI psychosis often begins with practical problem-solving, and beyond that, it can start specifically at work. Not to mention the more pedestrian condition of "AI brain fry".
If you are mandating your employees to use a hazardous tool that may seriously and directly damage their mental health, you need trainings and resources. You need in-house therapists and you need to be making sure to check in with people actively to make sure that this is not happening.
Again, the tool itself ought to have some way of dealing with this. An occasional "take a break" popup is easily dismissed; they need a user-visible AI personal dosimeter so you can see your cumulative usage over time.
I don't even know if "usage over time" is a sufficient metric to gauge risk. Maybe if your work chatbot start to talk about resonance too much, unless you literally work as an acoustic engineer, that should be flagged for someone.
We are, again, years into dealing with these tools, and we know these risks exist. Yet no serious mitigations are provided. Not even any way of measuring the risk exposure.
And More
There are also many other risks associated with the technology. There are intellectual property risks with the foundation models, due to recklessness with their training data. There are existential financial risks associated with the infrastructure build-out. The extent to which most "open" models are simply derivatives of frontier models is an open question.
What I Think
If any one of these things were regularly overlooked by AI vendors or users, that would be a totally normal product oversight. Room for improvement for the next version, but nothing catastrophic.
Shipping without any of them doesn't seem like lean product management, it seems like a careless attitude towards risk and a product design philosophy oriented entirely towards short-term demos, with no regard for how to realize actual productivity gains.
Furthermore, being available for years without anything like these features, despite hundreds of incidents demonstrating the risks, with hundreds of billions of dollars of funding, makes it seem to me like if they were to add all the features that would make their product actually safe and hypothetically useful, these features would reveal that it is actually not an improvement to productivity.
In the year since I first wrote about measuring the cost/benefit ratio of AI, I have heard from numerous people who have shown this to management to try to illustrate why their AI initiatives - like almost all AI initiatives - were either failing or burning out their engineers.
I've also heard from lots of people that have told me that it's obviously useful and they don't need to measure so carefully, because they are getting lots of work done that they couldn't have otherwise.7
I have yet to hear from a single person who has said "yeah, we measured according to your methodology8, and it turns out that our AI work is going great and that our ratio is 0.75".
Obviously, I cannot say for sure why this is; absence of evidence is not evidence of absence. But at this point I think the null hypothesis is that AI tools provide, in aggregate, zero value. They make mistakes too often, and the externalities they produce are so bad and so difficult to control that even before we get to the places where they are just physically poisoning people, even the negative effects on their direct users end up cancelling out whatever benefit to they provide to their organizations.
If I were wrong, then including tools to measure an AI's effectiveness at the tasks their users are actually trying to accomplish, rather than meaningless benchmarks, would show big productivity gains. The frontier labs would be champing at the bit to add such features, and crowing about their fantastic results.
I think the labs know that if they did that, it would present a grim picture to their users. Such tools would let their users see that it's making mistakes much more often than they realized, that they're spending much more time with it than they want to be, and that it's just generally not fit for purpose.
If they prove me wrong by adding in all of these safety mechanisms, and in the process, they make all of their AI technology less harmful, I'll be thrilled to be debunked.
Acknowledgments
Thank you to my patrons who are supporting my writing on this blog. If you like what you've read here and you'd like to read more of it, or you'd like to support my various open-source endeavors, you can support my work as a sponsor!
-
It is also interesting that for the next section, sometimes it seems that Claude's disclaimer is "Please double-check cited sources." instead. ↩
-
... by which I mean the "prompter", since authorship is not what's happening here. ↩
-
Claude has the "citations API", Google has various different kinds of "grounding" against its own APIs, and I guess Microsoft can check OpenAI's homework if you want. ↩
-
Given the relatively slow speed of the justice system and the mainstream press around the world, we probably will not hear about whether people are managing to incidentally break through these guard rails to self harm right now, but there are no shortage of stories still being reported right now where people were still doing just that, such as in this story where the effect of the much vaunted "guard rails" in 2025 was that if you wanted it to write you a suicide note, it would refuse twice but acquiesce on the third try. I don't see any reason to believe this fundamental issue has been addressed in the meanwhile, since it had been happening for years at that point. ↩
-
In this tutorial we can also see an incredibly rosy scenario presented, where a long-running workflow effortlessly compresses all of the necessary information into the new context, even if it uses a lower-fidelity model to do so, rather than the tangled and gnarly problem of problems which really are too big to fit in the context, which is to say, "most real-world problems". This presents the context limit instead as a minor speedbump to be worked around rather than the fundamental flaw in LLM tooling. ↩
-
A heavily fictionalized seaport. This is not how actual dockworkers work. This is a simplistic metaphor about incidental benefits of instrumental tasks, it is not supposed to delve deeply into the mechanics of maritime shipping. In particular I know that cranes are more reliable than this and this is not actually how you would respond to a crane malfunction anyway. Feel free to share fun facts about maritime shipping if that is your special interest but please do not @ me to correct this metaphor. ↩
-
To my knowledge, none of their publicly-traded employers have posted a measurable improvement to efficiency outside the margin of error. ↩
-
Or any similar methodology. I don't need people to adopt the exact practice that I proposed there. ↩
28 Sep 2026 4:27am GMT

