🏡
  • ↔
  • →
  1. September 01, 2026
    1. 🔗 WerWolv/ImHex Nightly Builds release

      Nightly

      868a305 Changelog

      • impr: Better provider open failure error messages
      • fix: Properly display commit table error message
      • fix: Direct Access menu option not working anymore
      • fix: Prevent searching in empty selections
      • patterns: Update pattern language
      • fix: Don't return from background task
      • fix: [[export]]ed global variables not appearing as [Local] in the pattern data tree
      • patterns: Update pattern language
      • fix: Draw commits table load error outside of table
      • fix: --debug-mode getting overridden by debug mode settings value
      • patterns: Update pattern language
      • impr: Move parsing of Pattern names and descriptions into the background
      • fix: Prevent new popups from closing existing ones
  2. August 31, 2026
    1. 🔗 jellyfin/jellyfin 12.0 RC7 release

      🚀 Jellyfin Server 12.0 RC7

      We are pleased to announce the seventh release candidate preview release of Jellyfin 12.0!

      This is a preview release, intended for those interested in testing 12.0 before its final public release. We welcome testers to help find as many bugs as we can before the final release.

      As always, please ensure you stop your Jellyfin server and take a full backup before upgrading!

      A note about versioning

      Starting with this release, we are dropping the preceding10. from our versioning. Thus, 10.11.x -> [10.]12.x = 12.x. The reason is simple: at this point in the project, we don't envision a hard break in the API like we planned way back in the early days, and this version scheme was causing a lot of confusion amongst users about what a "major" release was. For more information, please see the RC1 release notes.

      What's new?

      The main goal of this release has been performance. 10.11.0 dropped a major backend rewrite, and while it was broadly functional, it had a lot of rough edges. This release seeks to polish out most of those rough edges and bring better performance to all users.

      There are many other small fixes, improvements, changes, and translations. See our draft release notes here or below for the full list of pull requests. You can also view the Web side changelog here.

      Note: You must be on Jellyfin 10.10.7+ or 10.11.x (ideally, 10.11.11) before upgrading! If you are not, the upgrade will fail. Ensure you upgrade to one of these versions first!

      Note: The initial load of Jellyfin 12.x will run a few migrations and will take several minutes. Please be patient and do not interrupt the process. You can leverage the (newly improved!) startup UI on your local network to see specific progress, or off-network to see general progress, by visiting the server URL in your web browser during startup.

      Note: If you install the RC, you should disable all external plugins and reinstall using the unstable plugin repository, or plugins may fail to load and cause unintended side effects.

      Installing

      This preview release is distributed in all our traditional forms, though not automatically via our Apt repository or latest tag.

      • For all non-Docker environments, you can find the files for manual download in our repository by selecting "Stable Preview" for your OS.
      • For Docker, you can pull the 12.0-rc7 or preview tags.

      What's Changed (since

      v12.0-rc6)

      Full Changelog : v12.0-rc6...v12.0-rc7

    2. 🔗 benji.dog rss

      four different styles of 40% mechanical keyboards

      Had a great time at this year's MN mechanical keyboard meetup and even got to see my friend David and his keyboards in real life!

    3. 🔗 MetaBrainz Search upgrades: Nov 30, 2026 rss

      MusicBrainz is announcing a set of upgrades for its search service on November 30, 2026. The main change will be upgrading Solr from version 9 to 10. Fixes and improvements will be released alongside this. Some of these changes may break some specific search requests. Finally, a new feature will be released making it possible to use the search service to search for (musical) genres. See below for more information.

      Breaking changes

      The following tickets may break search requests in some way.

      • SEARCH-444: Improper ‘relation-list’ in ‘area’ and ‘url’ JSON output. This will be a breaking change for accessing related entities in area and URL search results.
      • SEARCH-642: Drop ‘id’ fields for cdstub and tag. This will technically be a breaking change, but it was broken by design as the values for these search fields are not documented and have never been intended for public use anyway.
      • SEARCH-666: Use quality names rather than numeric IDs. This will be a breaking change for release searches that use quality search field.
      • SEARCH-752: Relationships have an extra ‘ target ’ property in JSON output. Fixing it by removing the redundant property target will be a breaking change if you are accessing it in search results. The “proper” way to do this is to use the property target-type and access the property id under the property named after this target type.
      • SEARCH-764: Upgrade to Solr 10. This will be a breaking change for mirror owners only, not for search requests. More specifically, it is advised to change the Solr configuration and to re-index the whole MusicBrainz database.

      Soft changes

      The following tickets will improve search with breaking any requests:

      • SEARCH-452: Index all URL relationships. So far, only URL relationships to Artist and Release were indexed. URL relationships to all other entity types will be indexed too.
      • SEARCH-646: Return exact match first for tag search. It should improve tag search results using indexed Solr search compared to direct Postgres search.
      • SEARCH-677: Include disambiguation of event’s place and work’s recording. Places related to searched events and recordings related to searched works will now be outputted with disambiguation comment, in the same way other related entities are outputted in search results.
      • SEARCH-680: Index genre annotations. It will add genre annotations to the results of annotation search which is already supported for all other annotation-able entity types.
      • SEARCH-681: Support indexed search of genres. It will add “Genre” as a target type for search, just like most other searchable entity types.
      • SEARCH-751: Missing ‘target-type’ property in ‘relationships’ of ‘event’ and ‘work’ JSON output. This will be fixed by adding the property where it is missing.
      • SEARCH-753: Missing ‘target-type’ property in ‘relationships’ of ‘area’ and ‘url’ JSON output. This will be fixed by adding the property where it is missing.

      Miscellaneous

      A MusicBrainz Server release is also expected to go with some of these changes.

      We’ll post upgrade instructions for standalone/mirror servers on the day of the release. If you have any questions, feel free to comment below or on the relevant above-linked tickets.

    4. 🔗 PrimeIntellect-ai/prime-agent Beta (v0.8.1-beta.584.1.9f5edc1) release

      Automated beta build from main (9f5edc192cfe3d4737205a2f551d2b6b6e34fe09).

    5. 🔗 modem-dev/hunk v0.21.0-beta.0 release

      Hunk 0.21 beta

      This beta makes reviews more expressive, session connections safer, and the extension platform substantially more capable. It also restores first-frame and scrolling responsiveness after the new review features landed.

      Install the beta with:

      launch-v2.mp4

      npm install -g hunkdiff@beta

      Compare any two revisions

      hunk diff <from> <to> now performs backend-native two-revision reviews across Git, Jujutsu, and Sapling. Source expansion stays pinned to the compared revisions, and hunk diff --files <left> <right> explicitly compares two files. #938

      Threaded review conversations

      Inline notes are now editable and support arbitrarily nested replies with keyboard and mouse actions. Reviewers can also dismiss reply-free live agent notes without leaving the review flow. #925

      Safer live sessions

      The local session broker now authenticates producers and CLI controls with owner-private credentials and signed responses. Hunk can safely replace an incompatible idle daemon and reconnect active terminal sessions without manual intervention. #932 #933

      A more adaptable review UI

      • The file sidebar adapts to terminal width and expands its tree at full width. #921
      • Built-in and extension panes support responsive fractional sizing. #924
      • File and hunk spacing are configurable. #865
      • Diff colors and word emphasis are corrected across roughly 25 bundled themes. #825 #828
      • First paint, navigation, and scrolling remain responsive in large review streams. #922 #942

      Extension API generations 9–14

      Extensions can now:

      • register generic top-level CLI command trees with streaming I/O and delegation; #888
      • select syntax languages by filename or glob; #851
      • use a dim line-highlight tone; #909
      • size panes responsively;
      • observe hunk_viewed and saved note_changed events; #939
      • follow the current source line from an opted-in pane; and #940
      • receive structured two-revision rangeEndpoints in VCS adapters.

      Compatibility notes

      • npm installs now require Node.js 22 or newer. Standalone Hunk binaries still run without Node.js. #917
      • hunk diff <from> <to> gives two positional arguments revision semantics. Existing scripts that used the second positional argument as a pathspec should use an explicit supported form instead.
      • Custom VCS adapters should handle extension API generation 14's rangeEndpoints request variant to support two-revision comparisons.

      Community contributors

      Thank you to everyone who contributed to this release:

      Please report beta issues on GitHub or in the Hunk Discord.

      Full changelog: v0.20.1...v0.21.0-beta.0

    6. 🔗 exe.dev Revisiting Joel's Test rss

      Back in 2000, Joel Spolsky wrote an influential blog post, The Joel Test: 12 Steps to Better Code, for quickly identifying whether a software team is high-functioning. These are the twelve questions he nailed to the Internet.

      1. Do you use source control?
      2. Can you make a build in one step?
      3. Do you make daily builds?
      4. Do you have a bug database?
      5. Do you fix bugs before writing new code?
      6. Do you have an up-to-date schedule?
      7. Do you have a spec?
      8. Do programmers have quiet working conditions?
      9. Do you use the best tools money can buy?
      10. Do you have testers?
      11. Do new candidates write code during their interview?
      12. Do you do hallway usability testing?

      Those questions are still relevant, but, with the advent of agents, there are more questions. I’m calling this the Shelley Test, after our coding agent, which is named for the Unix shell, Mary Shelley, and Percy Bysshe Shelley:

      1. Do you use agentic code review?
      2. Do you deploy continuously, supervised by LLM agents?
      3. Do you have end-to-end integration tests?
      4. Do you and your coding agents have easy access to observability tooling?
      5. Do you have access to the latest models from the best providers?
      6. Do you have a merge queue and does it complete in 3 minutes or less?
      7. Is it easy for your team to stand up new tools and agents, for development and to help with everything around development?
      8. Do your team members regularly discuss their tools, their workflows, and adjust when necessary?
      9. Is your product legible to coding agents as users?

      1. Do you use agentic code review?

      Peer-based code review is dead. The LLM is writing the code, and the engineer is responsible for it. Adding a rubber stamp, however delayed, from another human, is done for. (Even on the best teams, we all know that a small, targeted change might generate a long code review cycle and a bike-shedding session, whereas if you combine two weeks’ worth of changes and dump them on your neighbor, it’s LGTM.)

      Instead, ask your agent to use subagents with different models to do an adversarial code review to check that what’s in the commit is what’s on the tin, and it will do wonders. (Does your harness only support one family of models? Use a harness that doesn’t kneecap you.) See also “Review the Reviews” and Roborev.

      2. Do you deploy continuously, supervised by LLM agents?

      We are not dogmatic about whether this means once an hour, on every commit, or once a day, but inventory in your repo will face reality, and it is paramount that it does so soon. Shorter cycles are better. Continuous deployment requires integration tests that you can trust, and that’s a good thing. It also requires feature flag infrastructure; also a good thing.

      Athena, our bot that supervises continuous deployments, is now indispensable. It reads logs, checks metrics, and writes down lessons for the next deploy. Athena chats on Slack about it, and has the power to pull the plug on a deploy.

      If you’ve been holding back on continuous deployment because you’re not confident that your deployment platform has all the right metrics gates, abandon that project immediately, and write yourself an Athena agentic loop. It’s deeply embedded in our deployment control center software, but write to us if you want us to extract the heart of it. (And yeah, we give our bots names so they’re easy to refer to).

      3. Do you have end-to-end integration tests?

      When a bug inevitably sneaks through, you have found where your testing is insufficient. LLMs are great at tests. (See, for example, this commentary on the Go cryptography standard testing.) Having the integration test infrastructure in place allows you to feel confident that deploys won’t break core functionality.

      Incidentally, if you must have an external dependency, “digital twins” for that dreaded external API have never been easier to build.

      4. Do you and your coding agents have easy access to observability

      tooling?

      In the LLM age, a monitoring stack must be computer-queryable, preferably with SQL, preferably with business data available to JOIN with. (At exe.dev, we love Clickhouse.)

      Use a bot to do initial triage and maintenance of alerts. Our bot is called Sisyphus.

      Instead of using the observability tool (or its agent) to look at metrics and diagnose tricky customer bugs, point your regular coding agent to the observability tool. Combining code and logs is fire.

      A Slack message from the exe.bots app: Sisyphus triaging an error-logs alert with evidence, an assessment, and a recommended next step. Sisyphus triaging an alert in Slack.

      5. Do you have access to the latest models from the best providers?

      This is a repeat of Joel’s “Do you use the best tools money can buy?” Joel’s question is being tested as CFOs find out that an extravagant IntelliJ or Tableau subscription is the least of their worries now.

      6. Do you have a merge queue and does it complete in 3 minutes or less?

      Don’t use long-lived branches. Commit your changes to main, and keep main green. The way to do so is to run the tests before they are merged in. The faster your tests, the easier this is!

      Your merge queue will get backed up (or require cleverness) if it’s slow. Engineering with LLMs is starved for human attention: the long latencies destroy that attention.

      We’ve abandoned GitHub Actions since https://sketch.dev/blog/lightweight- merge-queue was written, but the basics are still functioning.

      Agents are incredible at speeding up your CI if given the opportunity. The last build at time of writing took 2m30s or so, used many, many lanes of parallelism on one big honkin’ machine, and had acceptable CPU utilization, though the 60s tail leaves much room for improvement!

      A CPU usage chart for the build machine, ramping to about 75% for most of the build and then trailing off over the final 60 seconds. CPU utilization across one build A CI pipeline waterfall: dozens of build and test lanes running in parallel, nearly all finishing in about a minute. 54 lanes, mostly parallel. 2.5 minutes.

      7. Is it easy for your team to stand up new tools and agents, for

      development and to help with everything around development?

      The prior math on whether it’s worthwhile to build a tool is now wrong, because coding agents build very passable tools in one-shot. It must be easy to host and iterate on these tools.

      8. Do your team members regularly discuss their tools, their workflows,

      and adjust when necessary?

      We are in an age of exploration, and sharing what is working (and not working) with your peers is imperative. It’s always been a good idea, but now you’re missing out on the compounding effects if you don’t do it. We do this constantly: on Slack, on the telephone, and in our team meetings.

      9. Is your product legible to coding agents as users?

      Your users are judging your software based on whether Claude Code can operate it. Can it? Do you have an llms.txt as very obvious documentation? Does auth work? APIs are king again.

      Not to get all Clayton Christensen up in here, but a worse product operated by a mid-tier coding agent is destroying the better product unavailable to the coding agent.

    7. 🔗 HexRaysSA/plugin-repository commits sync repo: +1 plugin, +2 releases, -1 release rss 
      sync repo: +1 plugin, +2 releases, -1 release

## New plugins
- [BinDiff-NG](https://github.com/mahmoudimus/bindiff-ng) (8.1.1)

## New releases
- [IDAssist](https://github.com/symgraph/idassist): 2.3.0

## Changes
- [IDAssist](https://github.com/symgraph/idassist):
  - removed version(s): 1.2.0
    8. 🔗 r/LocalLLaMA deepseek-ai/DeepSeek-V4-Flash-Vision-Exp · Hugging Face rss

      deepseek-ai/DeepSeek-V4-Flash-Vision-Exp ¡ Hugging Face | submitted by /u/t4a8945
      [link] [comments]
      ---|---

    9. 🔗 Cal Paterson Agent memory as a file format rss

      Memoryfields - a vastly simpler way to do agent memory

    10. 🔗 matklad Cancelation Terminology rss

      Cancelation Terminology

      Aug 31, 2026

      A short note explaining the difference between synchronous cancelation, asynchronous cancelation, and graceful shutdown. I am not too attached to these specific three terms , but I want to call your attention to the three things behind them, which are important not to confuse with each other.

      synchronous cancelation is an (often implicit) control flow structure. It unwinds the stack and looks like this:

      task.cancel();
// The task will have finished by this point.

      Synchronous cancelation is a bit like Molière’s prose — we do it all the time, but not necessarily in full consciousness. The primary source of synchronous cancelation is error handling — every time an Exception is thrown or an error returned, the code promptly breaks out of all the loops, ifs, and blocks, invoking the necessary cleanup actions via RAII, finally, with/try with resources or defer.

      asynchronous cancelation is a communication protocol between two parties. One party requests cancelation (synchronously), but then it has to wait until the other party acknowledges it and winds down. It looks like this:

      task.request_cancelation();
// The task could still be running here.
task.join().await;
// After the requisite wait, the task is finished.

      Like synchronous cancelation, this is a relatively low-level concern when implementing a concurrent program in a way that doesn’t crash or hang. I know two central example where an asynchronous cancelation is required.

      First is the CPU thread pool. Imagine you have offloaded encrypting a buffer to a separate thread as a part of handling user’s request. Some time later, you learn that the request must be canceled (perhaps the user had left). You can’t just abandon the encrypting thread. First, it would be smart not to waste CPU cycles for useless work, but, more importantly, the underlying buffer must remain tied up. If it were to be freed as a result of request cancelation, something else might re-use that memory, leading to data races.

      But you also can’t just cancel that thread synchronously! It’s in the middle of a hyper-optimized SIMD loop, and you really don’t want it to check the cancelation flag before reading every byte. What you’d want is to split the buffer into reasonably-sized chunks, and check the cancelation status after every chunk. But that means that the party that requested the cancelation must wait for at least one chunk’s worth of work!

      For the curious, there’s actually a bit more leeway with canceling CPU work non-cooperatively, see

      https://go.dev/src/runtime/preempt.go

      Another example here is io_uring. It has exactly the same shape: if you submit a write with a buffer to the kernel, that buffer must remain tied up until the write finishes (and you can cancel the write to make it finish faster). While io_uring is still at least a somewhat exotic technology (though, arguably, it’s the interfaces we have had before which are byzantine), the thread pool example demonstrates that the phenomenon of asynchronous cancelation itself is rather mundane.

      Asynchronous cancelation comes up all the time when writing concurrent software. Because it affects the overall shape of the code, it’s useful to identify it early. Conversely, it is useful to ask yourself whether you need asynchronous cancelation at all, and whether synchronous one can be made to work. This is especially important in Rust, which makes synchronous cancelation too easy, and doesn’t provide great mechanisms for asynchronous one.

      Finally, graceful shutdown is an application programming pattern for handling connections. It lives on a higher level of abstraction than the two cancelations. If you are implementing a web service, you can implement shutdown by stopping your accept loop (rejecting new connections), but continuing to serve all existing connections until their respective clients disconnect. If the load balancer is configured to route new connection requests to different instances of the service, this pattern allows you to do rolling upgrades without service disruptions.

      As a bonus point, a related idea is that of crash-only software. Cancelation is all good, but your entire program can get SIGKILLed arbitrarily by an OOM killer, and the entire computer might get rebooted on powerloss. Reliable software has to handle ungraceful shutdown without losing data. But, if you can survive powerloss, you might as well implement the Quit button by SIGKILLing yourself, simultaneously simplifying the implementation and increasing testing coverage for powerloss scenarios.

      To give some examples from TigerBeetle, Grid.cancel is an asynchronous cancelation. It takes a callback to notify the caller when the cancelation is done. This API is used during state sync. When a replica determines that that cluster is so far ahead that event based transfer doesn’t work, and that a state transfer is required to catch up, it must cancel all outstanding grid read operations. A read can be backed either by replica’s local disk, or by transparent fetch of the data from a neighboring replica. In the first case, we have to wait until the read is done. In the second case, we need to abandon the read — remote read getting stuck is probably the reason for us to state sync in the first place.

      StateMachine.reset is an example of a synchronous cancelation. This is the part of the same flow as Grid.cancel, and is an example of how you can simplify the code if you think clearly about asynchronous vs synchronous cancelation. Ultimately, StateMachine sits on top of the Grid, but there’s a bunch of intermediate layers (Forest, Tree, Compaction, Scan, etc). A naive approach would be to notice that Grid requires asynchronous cancelation and propagate asynchrony throughout the stack. What we do instead is asynchronously canceling just the Grid directly, and then synchronously reseting everything else.

      Another example of asynchronous cancelation is Client.shutdown. When an application using TigerBeetle “drops” the Client object, we need to free all OS resources. Our client also uses io_uring, so we must first wait for all outstanding syscalls to complete. In the comment, we call it “graceful shutdown”, but I think this is wrong, and this is the motivation for writing down this article. We don’t do graceful shutdown at TigerBeetle — it’s crash only all the way. Tail latency tolerance (asking several nodes for an answer and picking the fastest one) is a more general solution, as it handles not only crash faults, but also gray failures. In a distributed system, a very slow node looks exactly the same as a crashed one. A crash is just a degree of slowness.

      Take aways:

      • Synchronous cancelation is control flow operator
      • Asynchronous cancelation is a communication protocol
      • Graceful shutdown is an application-level design pattern
    11. 🔗 Servo Blog July in Servo: more platforms, faster canvas, web fonts in SVG, and more! rss

      Servo 0.5.0 contains all of the changes we landed in July, which came out to 488 commits , and we now publish binaries for Linux aarch64 (@mukilan, #46760)!

      DOM text selections are now visible (@mrobinson, @SimonSapin, #46698, #46864, #46742, #46889, #46126). Interactive selection is coming soon!

      For security fixes, see § Security.

      servoshell 0.5.0 showing several new features: ‘text-decoration-thickness’, ‘box-decoration-break’, web fonts in inline &lt;svg&gt;, and DOM selection rendering

      We’ve shipped several new web platform features:

      Plus a bunch of new DOM APIs:

      This is another big update, so here’s an outline:

      You can help! If you’re working on a pull request that you think might be interesting for the next monthly update, even if you’re not 100% sure, tell us about it by following the steps below: You add the monthly update label to your pull request, or comment [@servo-highfive](https://github.com/servo-highfive) monthly update Highfive posts a comment asking you some questions You answer those questions in a comment containing [@servo-highfive](https://github.com/servo-highfive) monthly update answer Security __ Servo was potentially affected by vulnerabilities in quick- xml and crossbeam- epoch that have been fixed in Servo 0.5.0 (@atouchet, @Loirooriol, #46737, #46324). For more details, see RUSTSEC-2026-0194, RUSTSEC-2026-0195, and RUSTSEC-2026-0204. We’ve updated ANGLE from a version based on Firefox 115.x ESR (02755361e26d8) to a version based on Firefox 140.12.0 ESR (f8025617e815f), which likely includes many security fixes (@jschwe, @sagudev, #46455, mozangle#100). Real world compat The duck on the DuckDuckGo (duckduckgo.com) landing page now renders in v0.5.0, after we fixed a preload bug that affected SVG images (@jdm, #46668). v0.4.0 v0.5.0 duckduckgo.com Most of Gumroad (gumroad.com), except for the landing page, did not render at all in v0.4.0, but as of v0.5.0, pages like the Discover page or this product page render almost perfectly. v0.4.0 v0.5.0 gumroad.com v0.4.0 v0.5.0 gumroad.com We’re interested to hear how well your favourite websites run in Servo! Report successes in this Zulip thread, and failures in our GitHub issues. Work in progress

      The upgrade to Stylo 2026-07-01 brings several changes to built-in CSS functions (@Loirooriol, #46129):

      • ‘alpha()’ is now supported, under --pref layout­_css­_alpha­_color­_function­_enabled

      • ‘progress()’ is now supported, under --pref layout­_css­_progress­_function­_enabled

      • ‘ellipse()’ values ‘closest-corner’ and ‘farthest-corner’ are no longer stable due to spec uncertainty, but they are still experimental, under --pref layout­_css­_ellipse­_corners­_enabled

      • ‘attr()’ is more conformant, under --pref layout­_css­_attr­_enabled

      Web­GPU content can now enjoy better conformance and use GPU­External­Texture and import­External­Texture() on GPU­Device , under --pref dom­_webgpu­_enabled (@sagudev, #45873, #46178, #46286).

      servoshell 0.5.0 showing four tilted rectangles (in WebGPU), textured with a picture of a dog (which is a frame from an external video)

      Indexed­DB content can now use the name property on IDB­Index , under --pref dom­_indexeddb­_enabled (@skyz1, #45512).

      document.fonts now includes a Font­Face for each valid ‘@font- face’ , under --pref dom­_fontface­_enabled (@simonwuelker, #46509, #46537).

      All of the features above are enabled in servoshell’s experimental mode.

      We’ve started implementing WebVTT for native subtitles and captions , enabled by default (no --pref). While they don’t render just yet, we can now fetch each , parse the WebVTT, and expose cues via the track property on HTML­Track­Element (@TimvdLippe, #46289, #46383).

      July was a big month for accessibility in Servo, under --pref accessibility­_enabled. The focus for this month has been on performance , with the accessibility tree now supporting incremental updates (@alice, @delan, #45578, #45971, #46589, #46691, #46385), requiring fewer HashMap lookups and tree walks (@alice, @delan, #45798, #46740, #46348), and allowing for faster DOM mutations (@alice, #46348, #46530).

      We’ve also started working on the File and Directory Entries API, to allow users to select and upload entire directories via < input type=file> and drag-and- drop. To that end, we now have webkit­Get­As­Entry() on Data­Transfer­Item , plus minimal support for File­System­Entry , File­System­Directory­Entry , and File­System­File­Entry , under --pref dom­_entries­_api­_enabled (@yezhizhen, #46456, #46879, #46832).

      Embedding API We’ve improved the docs for the servo crate, and for Web­View­Delegate (@mukilan, #46193). Breaking change: Servo­Builder::webxr­_registry() has been removed. Instead use the new Servo::register­_webxr­_registry, which is a lazy design that has allowed servoshell to halve its startup time (@Narfinger, #46494). For users and developers

      servoshell for Android now runs on Android 10+ (91% market share), not just Android 13+ (68% market share), improving adaptability and reducing waste (@jschwe, #46142, #46308). We’ve also fixed a problem with building for Android on macOS (@jschwe, #46128).

      servoshell for Windows is now better behaved when run in a console window, making the command prompt wait until servoshell exits (@yezhizhen, #43010).

      When using the Firefox DevTools , the Console tab now supports some basic autocomplete (@freyacodes, #46382).

      We’ve finished modernising servoshell for Android to use Compose UI (@veyndan, #46085, #46164, #46253, #46257, #46317, #46353, #46565, #46612, #46626, #46666, #46663, #46700), and we’re now migrating Servo as a library to use Kotlin (@veyndan, #46817, #46895, #46772).

      More on the web platform Inline SVG can now use web fonts defined in the containing page (@yodalee, #45979). We’re also implementing the SVG DOM , starting with stub interfaces for SVG­Element , SVG­Circle­Element, SVG­Defs­Element, SVG­Ellipse­Element, SVG­Line­Element, SVG­Linear­Gradient­Element, SVG­Path­Element, SVG­Polygon­Element, SVG­Polyline­Element, SVG­Radial­Gradient­Element, SVG­Stop­Element, SVG­Rect­Element, SVG­Symbol­Element, and SVG­Use­Element (@mu- mostafa98, #46558). < button> now vertically centers its contents (@Loirooriol, @mrobinson, #46590), and behaves better with ‘display: block’ and ‘display: inline’ (@Loirooriol, #46536). We’ve improved the conformance of < form> without < form action> (@kevlu93, #46860), < color> values (@Loirooriol, #46129), Gamepad­Event (@log101, #46788), document.execCommand(“delete”) (@Psychpsyo, #46539), the selector­Text property on CSS­Style­Rule (@simonwuelker, #46687), and Set Window Rect in WebDriver (@janeoa, #46475, #46477). We’ve fixed bugs related to < iframe> (@jschwe, @jdm, #46587), < img> (@yodalee, #46892), < textarea> (@SimonSapin, @mrobinson, #46309), custom properties (@Loirooriol, #46129), ‘::before’ and ‘::after’ (@Loirooriol, #46640), ‘flex-direction: column’ (@simonwuelker, #46697), ‘float’ (@Loirooriol, @mrobinson, #46407, #46500, #46505), ‘@font-face’ (@simonwuelker, #46568, #46271, #46436), ‘position: absolute’ (@simonwuelker, #46358, #46637), Blob (@jdm, #46881), IDB­Database and IDB­Object­Store and IDB­Index (@mrobinson, #46615), the adopted­Style­Sheets property on Shadow­Root (@simonwuelker, #46738), delete() on Font­Face­Set (@simonwuelker, #46634), move­Before() on Element (@mrobinson, #46599), resize­To() on Window (@janeoa, #46477), the selected property on HTML­Option­Element (@rhit-kapilaar, #46386), and the value property on HTML­Select­Element (@simonwuelker, #46230). Performance and stability

      2D canvas rendering is now multithreaded , improving frame rates by up to 55% and power consumption per frame by up to 42% (@yezhizhen, #46410), and should use a lot less memory too (@jschwe, @sagudev, #46786).

      Text rendering is up to 10x faster for cases with the same text and different ‘font-size’ (@Loirooriol, #46129).

      Flex layout benchmarks are up to 3% faster, and an improvement to get­Elements­By­Class­Name() has made some websites up to 1% faster (@Narfinger, @jdm, #46563, #46595, #46594).

      We’ve also reduced memory usage, allocations, GC rooting steps, and other operations in many parts of Servo (@mrobinson, @jdm, @yezhizhen, @Narfinger, @Gae24, @SimonSapin, @Taym95, @cychronex- labs, @arayaryoma, #46499, #46411, #46659, #45974, #46377, #45758, #46440, #46762, #46301, #46349, #46419, #46418, #46420, #46460, #46633, #46638, #46690, #46745, #46726, #46564, #46144, #46664, #46462, #46139, #46430, #46446, #46498, #46548, #46598, #46632, #46656, #46678, #46718, #46722, #46238, #46072, #46408, #46438, #46437, #46528, #46124, #46330, #46412, #46807).

      We’ve fixed a crash regression with memory corruption (@mrobinson, #46316), several dynamic-borrow- related crashes (@Narfinger, @SharanRP, @Taym95, @agrawalx, @amittenak47, @sungmen, #46381, #46384, #46405, #46684, #46452, #46770, #46830, #46763), plus crashes related to:

      We’ve continued our long-running effort to use the Rust type system to make Servo’s integration with SpiderMonkey safer and more reliable (@Gae24, @Narfinger, @TimvdLippe, @jdm, @kunalmohan, @lumiscosity, @simonwuelker, #46191, #46777, #46890, #46243, #46248, #46246, #46310, #46312, #46333, #46147, #46150, #46151, #46229, #46262, #46375, #46374, #46529, #46584, #46585, #46593, #46693, #46166, #46156, #46254, #46267, #46268, #46269, #46270, #46284, #46285, #46318, #46435, #46461).

      New contributors A special thanks to the following people for landing their first patch in Servo: Umut Cevdet Koçak (@UMCEKO, #46256) Yash Agrawal (@agrawalx, #46770) amittenak47 (@amittenak47, #46743) Apoorva Pendse (@apoorvapendse, #46739) dDostalker (@dDostalker, #46181) Oisín Ó Maolchathail (@eachra-bawn, #46478) Kevin Lu (@kevlu93, #46860) Mohamed Mostafa (@mu-mostafa98, #45405) SeongMan Jeon (@sungmen, #46763) Yoda Lee (@yodalee, #45979) Interested in helping build a web browser? Take a look at our curated list of issues that are good for new contributors! Donations __

      Thanks again for your generous support! We are now receiving 7824 USD/month (+1.8% from June) in recurring donations. This helps us cover the cost of our speedy CI and benchmarking servers, one of our latest Outreachy interns , and funding maintainer work that helps more people contribute to Servo.

      Servo is also on thanks.dev, and already 35 GitHub users (same as June) that depend on Servo are sponsoring us there. If you use Servo libraries like url, html5ever, selectors, or cssparser, signing up for thanks.dev could be a good way for you (or your employer) to give back to the community.

      We now have sponsorship tiers that allow you or your organisation to donate to the Servo project with public acknowlegement of your support. If you’re interested in this kind of sponsorship, please contact us at join@servo.org.

      7824 USD/month

      10000

      Use of donations is decided transparently via the Technical Steering Committee’s public funding request process , and active proposals are tracked in servo/project#187. For more details, head to our Sponsorship page.

    12. 🔗 Ampcode News Space to Talk rss

      Every thread in Amp now comes with its own space to talk.

      Hit Enter and you're in. Turn on your camera, share your screen, and talk it over with your team while the agent works.

      No links to paste, no calendar invite, no other app. The call lives where the work lives.

      In the future, we see the space becoming a place to talk freely, alone or with others: brainstorm, whiteboard, talk with Puck or other agents, discuss the thread or spawn new ones... who knows?

      We're leaving it open. For now, it's just a space. What you do with it is up to you.

  3. August 30, 2026
    1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-08-30 rss

      IDA Plugin Updates on 2026-08-30

      New Releases:

      Activity:

    2. 🔗 Simon Willison Understanding ChatGPT Work rss

      OpenAI announced ChatGPT Work on July 9th, and have been furiously iterating on it ever since. It is an extraordinarily confusing and very powerful product. Here's what I've figured out about it so far.

      ChatGPT Work is actually two products

      The more interesting version of ChatGPT Work is the one that runs in the cloud. This can be accessed via chatgpt.com or through the ChatGPT mobile apps. Let's call it Work Cloud.

      If you install the ChatGPT desktop app - the app that used to be called Codex - you gain access to a thing called ChatGPT Work that can access files and run programs directly on your computer. Let's call that one Work Local. This one feels more like regular Codex re-skinned to be less intimidating to non-software-developers.

      (Update: Work Cloud is also available from the ChatGPT desktop app, via a Where should this chat run? dropdown.)

      For the rest of this article I'm going to talk exclusively about Work Cloud.

      Work is for paid subscribers only

      Right now, ChatGPT Work (in both flavors) is available only to $20/month and up subscribers. Free users and $8/month Go users do not have access.

      Work has features that aren't available in Chat

      The interface for accessing Work is a tab selector, which presents it as an alternative to Chat:

      ChatGPT app header with a Chat and a Work tab

      The obvious question is when should I use Chat, and when should I use Work?

      OpenAI's official answer to that question is:

      Use Chat when you want an answer, explanation, brainstorm, or short draft. Use ChatGPT Work when you want ChatGPT to complete a task with a clear outcome, such as a brief, deck, analysis, recurring update, workflow, or file you can review and use.

      I find that almost entirely useless, because I've been using regular ChatGPT Chat for all of those task categories for years!

      The better question then is what features does Work have that are missing from Chat?

      After extensive experimentation I think I've mostly figured that out:

      Model selection

      In Work, you get the option to pick GPT-5.6 Sol, Luna, or Terra, each with Light, Medium, High, Extra High, Max, or Ultra reasoning levels. You can also pick GPT-5.5 at Light, Medium, High, or Extra High.

      These look to be the same models that are available through the OpenAI API.

      Chat offers a different selection: 5.6 Instant, Medium, High, Extra High, and Pro (actually Extra High and Pro are only available for $100/month+ subscribers - $20/month subscribers cap out at High). It doesn't explain if those are Luna or Terra or Sol (I'm assuming Sol?). 5.6 Pro appears to be exclusive to Chat, with no equivalent in Work.

      My current understanding from using Codex is that Ultra is a special mode that more eagerly delegates to sub-agents.

      I believe ChatGPT Work sessions are billed against your Codex allowance, while ChatGPT Chat Sessions get their own, separate allowance. This may help explain the model availability differences.

      Code execution with Internet access!

      As a long-time fan of the Code Interpreter pattern - pioneered by OpenAI in 2023 - this is by far the most exciting feature of ChatGPT Work (Cloud) for me.

      The code execution environment can now talk to the rest of the internet!

      ChatGPT Chat can't do this - if you ask it to install additional software packages or interact with websites or APIs that access will be blocked by the container proxy.

      (Weirdly, back in January it grew the ability to install packages, but that doesn't seem to work any more. I wish they had better changelogs!)

      Claude's equivalent container has allowed restricted internet access since it launched last September. Claude can install packages from PYPI and NPM and clone repositories from GitHub. But that is about it: the allowlist of domains is very short.

      ChatGPT Work allows a whole lot more than that. It can be configured with a specific list of allowed domains, but the default appears to be open to all.

      This makes Work an incredibly useful tool. You can have it clone GitHub repositories, install their dependencies, then use them to interact with the rest of the web!

      A full, headless Chrome browser

      Another killer feature of ChatGPT Work is the browser tool. ChatGPT Work can launch a full Chrome instance, load websites, fill out forms, and take screenshots.

      Screenshot of a ChatGPT conversation. A user message in a black rounded bubble reads: Visit https://london-pelicans-in-her-piety.simonw.chatgpt.site/ and take a screenshot with you browser. Below it a collapsed status line reads "Worked for 1m 18s >", followed by the reply "Here's the screenshot of the live site:" and an embedded screenshot of a website.

      If a site requires sign in the browser can prompt you to take over and enter both passwords and 2FA codes, without round-tripping those credentials through the model itself.

      It can even run JavaScript against the DOM of loaded pages. I prompted:

      Load simonwillison.net in your browser and extract the headings using JavaScript

      ChatGPT Work fired up a browser instance and ran the code:

      await tab.playwright.evaluate(() => {
  return Array.from(document.querySelectorAll("h1,h2,h3,h4,h5,h6"), heading => ({
    level: heading.tagName.toLowerCase(),
    text: heading.innerText.trim().replace(/\s+/g, " "),
    id: heading.id || null
  }));
});

      This feels a lot like my shot-scraper javascript tool, only now I can access it on my phone!

      A persistent, shared filesystem

      ChatGPT Chat gets a fresh filesystem for each chat session. These cannot be accessed from any other session.

      In ChatGPT Work each session gets its own scratch folder - named something like /workspace/scratch/e00a0a017944 - but each of those are persisted across sessions, so you can access files from previous chats. I have 171 folders in /workspace/scratch right now!

      As far as I can tell that /workspace volume is mounted to all Work sessions that are currently running - file edits from one can be instantly seen by the others. They don't seem to share the same process space though, and localhost servers running in one can't be accessed from another.

      ChatGPT Sites

      ChatGPT Work has the ability to build and deploy entire websites, using Cloudflare Workers. These can have HTML and JavaScript and can run server-side features too, including stateful features on top of Cloudflare D1 and R2.

      Here's a simple site I built with this feature:

      london-pelicans-in-her-piety.simonw.chatgpt.site

      Screenshot of a website homepage on a cream background. Top navigation bar: a circular logo reading "P/P" on the left, the links "THE CENSUS", "COLLECTIONS" and "METHOD" in the center, and "JSON ↓" on the right. The left half is a hero section with small red capitals reading "AN ICONOGRAPHIC CENSUS · GREATER LONDON" above a large serif heading "Pelicans in her piety", with "piety" set in red italics. Below it: "Across London, an impossible bird bleeds for her young—in limewood, marble, mosaic, metal and glass. This is an evidence-backed census of where to find her." Two buttons follow: a solid black "EXPLORE ALL 28" and an outlined "DOWNLOAD THE DATA". The right half is a photograph of an ornate dark carved wooden reredos in a church, with gilded urns and a crest on top, Corinthian columns, a gilded pelican with outspread wings at its center above inscribed panels, an altar with a brass cross and red flowers, embroidered banners on either side, and a black-and-white checkerboard floor with red carpet. Vertical text along the photo's right edge reads "ST MARY ABCHURCH" and a caption at its bottom reads "Grinling Gibbons's reredos, St Mary Abchurch. Photograph: Diliff, CC BY-SA 3.0, via SPAB ↗". A statistics strip along the bottom shows "28 FIXED SITES", "4 COLLECTIONS", "3 OPEN LEADS" and "2 KNOWN LOSSES".

      My prompt was:

      Figure out all of the places in London with a pelican in her piety, then turn that into a JSON file and build a ChatGPT sites site about them

      (A pelican in her piety is a fascinating piece of medieval Christian imagery - once you know about them you'll find them all over the place.)

      These sites default to being private to the user that created them, but you can make them public and (on team plans) share them with other specific individuals.

      Sub-agents with Sol, Luna, and Terra

      There's not much to say about this one. ChatGPT Chat can't run sub-agents. ChatGPT Work can. This is very much a power-user feature: if you are running a complex project that can benefit from multiple parallel agents working together, Work can do that.

      Scheduled prompt automations

      Another feature that seems to have migrated from regular ChatGPT to ChatGPT Work at some point. You can prompt ChatGPT Work like this:

      run a search to see if Waymo have announced a launch date for Half Moon Bay every day at 8am

      This will schedule a prompt to run on that frequency. These prompts can decide that nothing interesting has happened, or they can decide to notify you of some new information.

      Update: Actually this seems to work in ChatGPT Chat as well.

      It's still worth noting here though, as it can be used in conjunction with other ChatGPT Work exclusive features. You can set a scheduled task to update a ChatGPT Site on an hourly basis, for example.

      Is this safe?

      An open question for me right now is how safe all of this stuff is.

      My lethal trifecta model warns about the risks inherent in any agent system that combines access to private data with exposure to untrusted content and a way to communicate stolen information back to an attacker.

      ChatGPT Work combines all three!

      I'd love to hear more from OpenAI about how they protect ChatGPT Work sessions against prompt injection attacks. I expect their answer is the same auto-review mechanism as Codex.

      OpenAI could make this a lot less confusing

      Figuring this all out took way more work than it should have.

      I think there are two key problems here:

      1. OpenAI explain Work in terms of what it's for, not what it actually does
      2. OpenAI still insist on hiding their system prompts and tools descriptions

      If the ChatGPT Work documentation included the exact system prompt and tool descriptions used by the agent I wouldn't have needed to write this post.

      A list of all the tools

      Shortly after publishing this article I had an idea. I started a fresh Work session and prompted:

      Build a site that lists every one of your tools - nearly grouped into categories - and for each one explain what it does. Try to exactly duplicate arguments and tool descriptions where possible. Design aesthetic should be technical docs, minimal flare

      Here's the site it built, which includes details of 223 registered tools - though 6 of those are from my own personal MCPs served via datasette-mcp.

      And a whole lot of Skills

      I noticed that the only browser-related tool in the list was web.run, which has methods for running searches, opening URLs, and clicking links, but didn't look like the full story in regards to headless browser automation.

      This made me suspicious that something was missing, so I told the ChatGPT Work session that built that tools reference site:

      Add full copies of every skill to the website (separate pages linked to from the homepage)

      It turns out ChatGPT Work uses a lot of skills - 44 in fact!

      The control-browser skill explains how the browser works:

      Run browser setup code through the Node REPL js tool. In this environment the callable tool id typically appears as mcp__node_repl__js. [...]

      The ability to interact directly with the browser is exposed through the browser-client runtime via the agent.browsers.* API. Before trying to interact with it, you MUST emit and read the complete documentation returned by await browser.documentation() in one go.

      So I told Work:

      Add the full output of await browser.documentation() to the bottom of the /skills/control-browser page

      And now you can read that on /skills/control-browser as well.

      A few more interesting Skills:

      You are only seeing the long-form articles from my blog. Subscribe to /atom/everything/ to get all of my posts, or take a look at my other subscription options.

    3. 🔗 Jessitron Who are we Now? rss

      This is based on my keynote at RubyConf 2026. They’ll publish a video eventually, I hope.

      There’s a philosopher in Naples, Italy, way back in the 1700s who understood something important to software today.

      Giambattista Vico lived early in the Enlightenment, when mathematical and experimental thinking were all the rage. RenĂŠ Des Cartes and Francis Bacon were the hotness. People were all about, what can we know for certain through logic alone?

      Vico said, wait. All that math is great, but it is not the only way of knowing. Yo, the only things we can fully understand are the things we made! things we know inside and out because we put them together. He expressed this: verum esse ipsum factum. “The true is the same as the made.” Today we call it Verum Factum.

      With this mindset, Viceo laid the basis for anthropology, ethnography, sociology, comparative law, historiography… a whole slew of fields. And he nailed my favorite feeling in software development.

      Verum Factum: we can only really know what we made.

      Giambattista Vico

      a coder and their code, connected

      When I write a program—or change it enough to be integrated with it—I understand it in a way that’s deeper than other tools. Like the software is an extension of me, because I know where and how it can flex, I can figure out what broke, and I feel powerful changing it. Vico named this feeling: verum factum. I hold the truths of this software, because I made it.

      Verum Factum gives me confidence to ship to production. If something goes wrong, like people use it weirdly or an integration doesn’t work as planned, I know I can handle it. I understand the software’s language (I can read the logs).

      This is software that’s alive and can change. As opposed to legacy software (as I used to define it), which is not alive in someone’s brain.

      I used to call this the code-coder ecosystem, but now I call it a symmathesy. It is more than the sum of its parts, more than a product of set interactions. It is a learning system made of learning parts.

      as a symmathesy: a coder, their code in production for a user, some tests and some logs; so that the code can learn from the person, and the person can learn from the code

      The software learns from me because I change it, and I learn from it when it runs: from tests that fail, from exceptions it throws, from data it changes. I learn what happens in the real world with real users. For this, the software has to run in production, and I need tools like tests and logs.

      A bigger symmathesy. Lots of people, learning from each other and their code, and the wider system and a lot of users.

      Scale this up to more developers, more services, way more users. Now I need stronger tooling. Continuous integration, real observability with aggregations and traces. Now the symmathesy includes all of these tools so that we can learn from the software. Meanwhile we learn from each other by talking. Maybe there’s a product owner or something who spends most of their time interfacing with users or the rest of the business, because we’re all part of larger systems.

      As we add more people changing the same code, that verum-factum knowledge and confidence weakens, because I didn’t personally make all of this. But the team did, and collectively we can know it deeply.

      To grow a symmathesy, it isn’t about adding. We make this symmathesy stronger by increasing learning between people–say, by pairing or ensemble–from people to the code, say by expressive code in domain language–and from code to people–say, with better tests or observability.

      A symmathesy grows from the inside. To improve it, we have to be involved. There is no optimization from outside; there is no understanding it from outside. We are making it, we who participate, so it only makes sense from inside.

      We don’t really know how other teams work, and management doesn’t either. Like when they say “why don’t you take that team’s procedures and then be the same?” and we look grrrr at each other.

      Symmathecist, in the medium of code

      I love that feeling, of being part of a symmathesy with other people, learning from each other and from what we’re doing. Of the code as an extension of myself, because I understand it, I can confidently change it.

      This is where I am a Symmathecist: I am improving this whole system from the inside, consciously.

      I can be responsible: if something goes wrong, I know how to respond.

      I can be accountable: I can give account, say why we did it this way.

      It’s my favorite part of software development.

      Now agents are between the people and the code!

      But now, agents! There was a turning point last year where I noticed that not only are they useful, it is irresponsible not to use them, at least in conjunction with my own code. They’re more thorough, as well as faster.

      How am I supposed to be responsible for this system, when I don’t understand each line of code? How do I get that verum factum feeling back?

      Who are we now, as software developers? Here’s a long quote from Vico. It says: fortune is friendly to young men because they choose a profession that’s popular in their youth; but as tastes change, they later find themselves strong in such wisdom as no longer profits. The reason that fortune is said to be friendly to young men is that they choose their lot in life from among those arts and professions that flourish in their youth; but as the world by its nature changes in taste from year to year, they later find themselves in their old age strong in such wisdom as no longer pleases and therefore no longer profits. The Autobiography of Giambattista Vico Is that us? Doesn’t have to be. a fake stamp of Matz AI did not replace my 30 years of experience. It finally put them to good use. Matz, RubyConf 2026 We can deploy confidently with agents. We can have symmathesy with agents. And we can get that Verum Factum feeling back. One reason I know my changes are going to work in production is that I made them. Verum Factum, deep understanding from participation. We can understand law, society, and history with this. But Vico never said that was the only way to know a fact. Two ways of knowing that our deploy is gonna work ! There’s also Francis Bacon style. His idea was to learn about nature by putting it to the test! “Vexationes Artium,” artful vexations, like adding water to quicklime or stuffing a chicken with snow. He didn’t have the word “experiment” back then. Verum Factum is something humans get because when we change something, we are also changed. That’s how a symmathesy knits together. Our work becomes part of us. Objective, reproducible, experimental knowing is different. For that, we stand outside the system and poke at it. This is great for any scope small enough to get specific. The agent cannot have Verum Factum knowledge. It writes something, it has that in its context for a few minutes, then it compacts or restarts and that is gone. Sometimes it doesn’t recognize its own work even in the same session. It is not changed in the making. The agent can totally use Vexationes Artium, experimental knowledge. From running a manual test to executing a property-based test suite, these can support or falsify our beliefs about the code. Skill at experimenting on code is great for people–because verum factum, even when it gives a feeling of certainty, is never perfect–and it’s great for agents. It’s HUGE for agents. It’s the difference between slop and engineering. Vexations: Test scripts Unit tests & TDD Benchmarks Module tests with good fakes and great error messages Observability even for local tests Property tests Formal verification Style checks If we want agents to write working, reliable code for us, we have to double down, 10x down on our objective verification. We need to vexate that code in artful ways. And we have the agent help us with that, with its thoroughness. Oh and then there’s software that incorporates LLMs in production. We have to get even more artful there. Evals become more crucial than code and prompts, since code and prompts can be re-created given good evals. Arlo Belshee calls this: reducing our vigilance toil. Because reviewing agent code is no fun as a job! And no matter how closely we read it, we’ll never understand it the way we did when we created it. Verum Factum expresses that. So we turn our vigilance toil into more coding work. We build scaffolding, the code that helps us write and run production code safely. We can make so much of it now, and we need it! More test code than production code? Absolutely. Instrumentation that doubles the length of a method? great. Part of its work is telling me, the developer, what it’s doing through the traces. Vexations: Continuous integration Continuous deployment Great observability with good MCPs Per-change verification by agents Performance checks Then we automate all of these checks and reviews, including checking it again after it’s in production. And we get agents to help us with the checks and reviews, too. We build their world

      Software development has learning loops at many levels. Look around, think of an idea, try it, check the results. TDD does this for a single change, CI for a feature. The full delivery loop includes deciding what to implement, and that’s still human-led in most software now. Agents are doing the smaller loops, now. It’s our job to make sure they’re learning—through their processes, context and direct feedback—enough to make our delivery loop smooth. We are in charge of their learning loops.

      Note that since the model is not changed by writing the code, the LLM cannot participate in the symmathesy by itself. The unit of participation is larger:

      It’s the LLM and the context you’ve constructed for it. From AGENTS.md and other documentation in the repo, to plugins with hooks and skills you have installed, to the tools you give it access to and the descriptions they come with – that’s all “the agent” for the purposes of learning systems made of learning parts.

      I used to define legacy as “code that wasn’t alive in a person’s head”
      Now I define it as “a codebase not set up for agents to work on.”

      So if the agent screwed it up, what am I changing about its context or harness to improve the result next time?

      Example: the agent took 8 commands to figure get this project running? [LINKS] Have it improve the documentation! OK now it’s down to 3 commands. Hanve it improve the scripts! Keep getting smoother.

      That’s one way I still feel Verum Factum when working with agents: by tweaking the ways they work, watching when they’re having a hard time and changing their circumstances until they work better. I’m in charge of their experience.

      We choose what to build I’m also in charge of its goals. With the agent in the details, I get to be the architect, product owner, and lead designer. I define what “right” is. It solves the puzzles I write for it. There’s verum factum in this, too! Side projects are freaking amazing right now. I can be like, hey, what if the home page had a bunch of color symbols bouncing around like gas molecules? And boom, it happened! Or rewrite this service in vanilla Ruby. Make it event-driven. Oh no, production is broken, dig around in kubernetes and fix it. There is joy in coding with AI, there is self-expression, at the application level. We don’t always get that at work, but hey, we can do some of the projects we always wanted to but didn’t have months to code. While learning about using AI to build software that AI can keep working with. We learn from agents When I realize I don’t understand how my software works, I cry and mourn my verum factum feeling… or I do something about it. a fake stamp of Chad The marginal cost of producing code is collapsing toward zero. What hasn't collapsed is the cost of knowing what the code does. chad fowler When coding isn’t the bottleneck, focusing on completing our task as fast as possible doesn’t help us. We need to be curious, and indulge our curiosity. We can use AI to avoid learning the intricacies of the code, or to learn it even better. Take “I don’t know how this works” as an opportunity. We can use AI to avoid asking our colleagues anything, or to ask them better, richer questions. Take “I wonder why” as an opportunity. Build relationships through easier questions, and the harder ones become easier to answer together. AI makes some of our detailed-coding skills less precious than they used to be. And it demands new skills of us, like architecture and context engineering. It also makes most of these skills easier to acquire, if we use it for that. Cat Hicks found that AI is your enemy if you identify as “good at” things. But it’s your friend if you identify as “getting better at” things. That’s how symmatheses grow, too: always getting better at what matters right now. So who are we? We are still engineers. We are not managers: prompting an agent is less like hiring that summoning a spirit. And using agents is more like mushing sled dogs than coordinating a team. They never complain about work. They want to run, but getting them to run in a coherent direction that we want to go is a challenge. Also, this is exhausting! Everyone else is pulling their sled really fast, the bar is higher every day, and there is so much to learn. How do I make AI create ease & possibility for me rather than be a lever for someone else to burn me out even faster? avdi grimm We have to stop asking “How can I do this faster?” and ask instead, “How can we do this better?” In our learning loop, it used to take a long time to TRY something in software. Now that part is fast. Agents can help some with checking results and looking around (doing research), and they can come up with a zillion ideas. They can’t tell us which ideas are valuable, nor which ones are aligned with the wider business we are working in. That part is on us. [hartmut rosa stamp] a fake stamp of Rosa Planning and calculation gets more time-consuming when background-conditions get less stable. Hartmut rosa, sociologist And background conditions are not stable right now, in the whole world and in software. So we need more time talking to people, and more time being part of the system around us. Verification can give agents confidence in the code we’re deploying. But it can never make them accountable. Nothing can make them accountable, because they can’t be held to account: they’re gone after they finish an execution. Nothing can make them responsible, because they’re not around to respond. We people stick around, we are part of the system ongoingly. We feel the consequences. Agents can participate in the symmathesy of the software team, but they cannot be Symmathecists. They cannot consciously participate in the growth of the whole system, because they aren’t part of the wider system, nor do they feel the consequences. They’re like the code: they can get better at their part, but that’s it. The team as a whole, and our team’s participation in our organization or company—this is ours. Who are we now, as persons? AI can’t be accountable, it can’t suffer consequences, because it is not conscious. What do I mean by consciousness? Well, I like this widely- accepted definition: a fake stamp of Nagel Consciousness: There is something it is like to be you Thomas nagel There is something it is like to be me, and I can’t get away from that. My choices now affect what it is like to be me tomorrow. I am changed by what I do. That’s where Verum Factum comes from! As people, we always change. And yet, is it just me, or is that change coming faster and faster? Acceleration everywhere ! Technology is always advancing. I can’t say whether it’s advancing faster and faster, that’s hard to measure (although software is, at least inside Honeycomb). It is established that technology adoption is speeding up by orders of magnitude in the last hundred years. The telephone took 75 years, the internet took 7 years to be widespread, ChatGPT took 2 months. The expectation of learning and changing is… it’s dizzying. I find myself asking: now that AI is ubiquitous, where does that leave us, as persons? I find myself looking for a narrative to fit in, because my expectations of life from a few years ago don’t fit anymore. And not a narrative that is built in the values of right now. Vico had this talent: one of his innovations was looking at language and its evolution, noticing that in earlier times people didn’t think the way we do now, they had different circumstances, societies, concerns and patterns of thought. This led him to a different story than the Enlightenment’s story of incessant progress. a fake stamp of Nagel [The founders of modernity] enshrine the present in the persuasion that the world began with them. giambattista vico Vico’s opus, New Science, turns history from a series of facts into sweeping patterns. He drew human history as a series of ricorsos, repeating: from barbarism, to an age of gods when religion was strong, to heroes, to an age of men where reason ruled. Eventually men get so focused on reason that a “barbarism of reflection” arrives, religion is lost, and society breaks down. Families live huddled together in tentacled cities, veritable “deserts of souls.” These degenerate peoples do not hesitate to rush into the worst of slaveries to find shelter and protection. Money becomes the only value. summary from encyclopedia brittanica Vico’s first Age of Men starts around Aristotle, when reason became a virtue, a central pillar of humanity. Then this broke down with the fall of the Roman empire and we had the Dark Ages. Not only is reason the best thing in us, but the objects of reason are the best of knowable objects aristotle Vico’s second Age of Men has the Enlightenment. (Hartmut Rosa marks this as the founding of modernity.) People lost interest in history, or when they looked at it, they made it all about themselves. There can be nothing so remote that we cannot reach it, nor so hidden that we cannot discover it. René des cartes Taking it farther, we get the techno-optimists of today. [Andreeson stamp] We believe that there is no material problem—whether created by nature or by technology—that cannot be solved with more technology. marc andreeson We have had technological progress ever since the Enlightenment. But it is not a steady progress. Instead, it is accelerating. If only technology was accelerating, then we could have more free time. We’d get all our coding done in a few hours and go hiking and play games six days a week. But no! The pace of life accelerates at least as fast. And to go with that, the pace of social change speeds up. A few hundred years ago, you knew what you were gonna do with your life because it was kinda fixed based on who you were born to. Then we got to choose our careers: “What do you want to be when you grow up?” My grandparents could go their whole life with one job. Nowadays, one career doesn’t last you a lifetime. What do my kids want to be? Whatever the heck they can get hired for when they get out of school. And a few years later, whatever is the new hotness. Software development is not the only career that’s been utterly changed by AI, automation, the internet. Technology, pace of life, social change: all increasing in pace relentlessly since the Enlightenment, the founding of modernity. This is Hartmut Rosa’s theory of social acceleration. (video) The Enlightenment, when we realized again that the greatest function of Man was reason. When rational thought became the only kind of knowing that is respected. Vico’s work was pretty much lost outside of Naples for two hundred years. The Rational Animal is no longer special

      Both humans and animals could evolve, grow, participate in communities. But only humans could use language and reason.

      But now computers can use language and reason. It can prove mathematical theorems that we couldn’t figure out. This is not unique to people anymore.

      So maybe it’s time to lean back into our uniquely-human (or uniquely-living- being) way of knowing. Maybe it’s time to value Verum Factum more than our modern culture does.

      From Vico’s Naples, let’s go 100 miles north and 300 years into the present, and turn to a figure from the Age of Gods. In May of 2026, The Pope released an encyclical (some sort of official statement?) about AI. It’s really quite good, and beautifully written.

      a real stamp of Pope Leo XIV

      In the era of artificial intelligence… ours is the pressing duty to remain profoundly human.

      pope leo xiv

      How to be More Human

      Curiosity! We talked about that already.

      Play! Our goal-driven behavior won’t lead us to new, surprising ways to be and work.

      a real stamp of Vico

      Imagination before Logic.

      giambattista vico

      Together! We grow, learn, and work better in groups. A person is a person through other persons. The more we can be people together, the more we can lean into our humanity.

      a real stamp of Vico

      men, whose nature has this principal property: that of being social

      giambattista vico

      a real stamp of Pope Leo XIV

      the very essence of our humanity, namely the capacity for relationship and love

      pope leo xiv

      For instance: can we not text chat in Slack all day? If I want reams of text, I know where to get it.

      On calls, use your cameras! Communicate with faces and hands, not only words. Get animated, show emotion. Play music.

      Draw. Communicate visually and in more dimensions in a shared Mural, Figjam, Honeycomb canvas, whatever. Share paper.

      Work physically together! I work remotely, and while I love my job, I wish it could be in person. Alignment is somehow much easier and richer in person.

      When you’re together: share meals. Go for walks. Have routines and rituals. Do boring things together. Communication happens without pressure.

      Two kinds of experience

      In German, there are two words for experience.

      Avdi with sculptures, looking sad

      Erlebnisse: Adventure! This is one-time experiences, where something happens, we see something new.

      avdi and kids on the couch on computers, very ordinary

      Erfahrungen: Ongoing life. This is repeated experience. We do it regularly, with the same people.

      The weird part is: you think that trips and excitement are what change you. It’s the opposite: the regular stuff is what sinks in and becomes part of us. The adventures aren’t even what sticks in our memory!

      Erfahrung is the experience that changes us. And experience that changes us is what agents cannot have. (I guess you could retrain them? but then it’s a new model, and that is not the course of work.)

      After reading this (in Rosa, referencing Walter Benjamin), I notice that of all the new restaurants I’ve tried, I can remember only a few, faintly. The restaurants that we go to often, those I can bring to mind richly.

      What if repetition is more valuable, more richly human, than novelty? Then I want to change some of my strategies for life. I’ve gained more appreciation for the boring stuff, like taking kids to school or making dinner. I value travel less.

      As persons in this age of AI, we are more than rational. We are experiencers (Erfahrung), and we are participants.

      Work in the same place longer! And in the same industry. The wider system context that we absorb as people, the AI doesn’t have that. It only has the narrow information we fed it or it retrieved, and generic training data that isn’t suited to the situation. We are the full participants.

      (I don’t like that conclusion either. I like switching jobs and industries and learning entirely new domains. But there it is.)

      But! Even as we participate in our symmathesies of team and organization, work is not community. Most of what we call community these days, isn’t.

      Two kinds of human association

      In German, there are two words for associating with other people. These are extremes, and most real interactions fall somewhere in between. (This comes from Ferdinand TonnĂŻes.)

      Gemeinschaft: community for relationship. We are in this together because here we are. This is based on family, place, religion, tradition, friendship—things that you can’t just swap out. This is where you can be yourself, because you’re there because of who you are. You can move or find a new friend group, but new ones are not as Gemeinschaft as where you’ve been for decades.

      Gesellschaft: association for purpose. We are in this together because it somehow benefits you and somehow benefits me. This is transactional. Your participation is conditional on other parties getting what they want. An extreme: I buy something from you on eBay. This is useful for commerce, government, employment.

      This tells me something else I don’t like:

      Do not show up with your whole self at work. That is impossible for some and a bad idea for most of us.

      If we can bring our own imagination and perspective and humor safely and productively, great! In our teams we often find friendship, in our teams we are in the same circumstances–but that is contingent on a transactional relationship with the company.

      And if your self-worth is based on your performance review, you’re doing it wrong. That is a review of a Gesellschaft association, of what the company wants from you, not of who you are.

      We find real community in Gemenschaft. So here I am on a mostly-tech blog telling you to spend more time with your family. To get to know your neighbors and gather with them regularly. To appreciate your religious congregation, if you have one where you’re valued.

      Because the tech culture we are in, at work and more and more in this country–it thinks Gesellschaft is the only association. Economics models people as in it for themselves.

      But the thing is, any personal utility doesn’t bring real happiness, meaning. That’s all found with other people. And it isn’t “I’ll give you meaning if you give me meaning”! it’s in: let’s watch this show together, let’s do this yard work or wash the dishes together, let’s help our neighbor clean out the sewage-filled basement together. That is Erfahrung, and it builds Gemeinschaft.

      Our work has some meaning, but it is not who we are. It’s too Gesellshaft.

      a real stamp of Pope Leo XIV

      When efficiency becomes the ultimate measure of value, human beings are tempted to see themselves as a project to be optimized.

      pope leo xiv

      Let’s save optimization for the robots.

      Who are we now, as humanity?

      What does all this modernity, acceleration, and now AI make us? This is not determined.

      Is AI bad for us?

      My kids refuse to use AI because they are artists, so they care about artists, and AI steals from artists. Also, they say that AI will keep them from learning, because they see peers using it to avoid learning. My kids are in college, and they are going to be at a huge disadvantage in the job market because they don’t know how to use AI.

      ”Is AI bad for us?” is not a helpful question. AI is here. As people, we don’t get to choose our circumstances, most of the time. Every big change is usually both good and bad. Ours is to choose how we respond.

      a fake stamp of Charity

      Care about artists? Support art!

      Buy art from artists. Donate to community theatre.

      an illustration of how much CO2 is produced by data centers vs all of fossil fuels. It is a tiny bit

      Care about the environment? Let’s tackle fossil fuel extraction.

      Care about water use? Let’s talk to golf courses.

      Data centers are probably more significant than plastic straws, but they’re still small.

      I think on some level, I want to find side-effecting reasons that AI is bad, because deep down I sense that it’s bad for us as people and as a society.

      AI can be both good and bad. I like using it for coding and for learning and for generating silly images. Also, AI can accelerate the splintering of society that started with the internet.

      I thought the internet would be all good–and it’s fantastic, gosh I love watching a video on how to pot a cactus or fix my dryer. Buying Vico’s “New Science” on Kindle for $2 and reading it immediately.

      Democratization of knowledge is not all it’s cracked up to be. All the information is no information! We need institutions that prioritize and vet, institutions we can relatively trust, that check each other. Without these, we all live in different worlds based on the information on our various screens. These institutions are in bad shape right now.

      We have instant communication with anyone on the globe. I love having friends overseas and all over, being able to stay in touch with some of you after meeting at conferences. But that is not the same as someone who can pick me up at the airport, and help me with a flat tire. I don’t even have to like the neighbor or family member who helps me with stuff, it’s still meaningful. That’s Gemeinshaft.

      a real stamp of Pope Leo XIV

      Digital culture multiplies connections and offers new opportunities for interaction; yet, the human heart retains an irrevocable need for genuine closeness.

      pope leo xiv

      The internet splinters our reality. Whatever beliefs you’re inclined toward, it will confirm them. AI will splinter us further.

      Do I think AI is bad for us? Sure. Does that mean I shouldn’t use it? No.

      a fake stamp of Charity

      Action is more powerful than abstention.

      Systems change from the inside.

      a fake stamp of John Cutler

      Acceptance isn’t approval

      The world is not as I would prefer it. I get to respond.

      a real stamp of Pope Leo XIV

      The true alternative is not between enthusiasm and fear, but between two paths of development: a progress that serves individuals and peoples, or a progress that subjects them to the mentality of power.

      pope leo xiv

      Who are we now, as humanity?

      This is not determined.

      There is such a thing as responsible governance of AI.

      It doesn’t have to leave millions out of work.

      It doesn’t have to separate us opaquely.

      It doesn’t have to own our data.

      We are not helpless here! I may be helpless. You may be helpless. But we are not helpless. We are participants, the system is made of us.

      [mary parker follett stamp]

      a fake stamp of Mary Parker Follett

      Action Power usually means power-over… it is possible to develop the conception of power-with, a jointly developed power, a co-active, not a coercive power.

      mary parker follett

      Can we change the world? Not alone. And not if we sit on some of our lazily absorbed beliefs.

      Politics

      If we believe “All politicians lie, they’re all corrupt”—then we give up our power.

      Politicians are not all the same. When some nasty ones spread this belief around in the 1980s, and it caught on, and now we’ve grown up with it—they won. This belief keeps good people out of politics, and it keeps bad people in, because we give up our power.

      But not everyone! Beth Anders-Beck[LINK] for instance, running for Congress in Massachusetts right now (2026). My friend Caterina Clayton, [LINK] running for state congress in Missouri. Others [LINK to Ben Darfler?] who are elected and work on their city council. They want to make government work. Government can work, if we elect more and more people who want to govern well. Who are in this with us for Gemeinschaft: we are in this together, this is our country, and it is ours to improve.

      Do all politicians make promises and then fail to keep them? Yes. That is not lying, that’s hope! Do all politicians act differently behind closed doors than on stage? I sure hope so. That’s communicating with your audience, and negotiation. Within these, A person can act with integrity, moving the world closer to those promises you want to reach, or for individual profit.

      We can have nice things!!

      Provenance of media
      Liability for harmful content
      Transparent, uncustomized algorithms
      Fewer spam phone calls
      Shorter lines at the DMV

      Is it hard? yes. Will we measure the results of our efforts this quarter? no. This year? maybe a few. In our lifetime? for the most important changes, no.

      Verum Factum means that we have the potential to understand our own society. We make this. Pay attention to what we are making.

      Conscious participation, looking to improve and responding to what happens: this makes me a Symmathecist.

      I strive to be an effective Symmathecist in my family, in my communities, and in society. Because

      a real stamp of Pope Leo XIV

      Authentic realism does not give up on changing the world.

      pope leo xiv

      Authentic realism does not give up on changing the world.

    4. 🔗 r/LocalLLaMA Me these days rss

      Me these days | submitted by /u/Eyelbee
      [link] [comments]
      ---|---

    5. 🔗 MetaBrainz GSoC 2026: Development of a new Calibre plugin for BookBrainz rss

      Hello, Everyone!

      I am Md Waqib Sk (waqib2992 on IRC), an undergraduate student at Indian Institute of Technology Kharagpur. This summer, I had the opportunity to participate in Google Summer of Code 2026 with MetaBrainz, where I worked on developing a calibre plugin for BookBrainz.

      I was mentored by Nicolas Pelletier (monkey on IRC). This post summarizes my project, its outcomes, and my experience over the course of the program.

      Project Overview

      Calibre is a free, open-source e-book manager used to organize and read digital books. My project was about introducing a new plugin that connected calibre with BookBrainz.

      The main proposed features of the plugin were:

      1. Metadata update: Search selected book from calibre in BookBrainz database and update it's metadata accordingly.

      2. Browse BookBrainz: Search editions/public collections by name/bbid through the plugin and add or download the corresponding metadata.

      Plugin Repository: https://github.com/bookbrainz/CaliBBre

      Planning

      There already existed a plugin for this purpose, but the code was quite old and not in usable state. I took inspiration of how to structure the code from there. During this period I listed out the APIs that we would be using and discussed with the team about some additional features that can be added to the project. Also decided that I will make separate tabs for each feature in the UI to keep things clean.

      Coding period

      I started off with making basic designs for both the tabs, I utilized Qt Designer for this. I improved the design continuously by receiving feedback from my mentor. While designing I realized that Qt Designer was generating a single .ui file (which I then converted to .py), which was really hard to debug so I decided to break the UI into smaller components which improved my understanding of how the code and framework is working.

      Also while getting familiar with the Qt framework I realized that directly making API calls on the main thread freezes the entire UI and user is stuck there until the API request is complete so to solve this issue and improve the user experience I used QThread and pyqtsignal which spins up new worker threads for API calls and does not interfere with the main thread which handles the GUI.

      Throughout the coding period we came up with new ideas and approaches that were not listed in the initial proposal, and they drastically improved the plugin.

      Lets talk about the features that I implemented throughout the summer.

      Metadata Tab

      When the plugin first opens, it shows the results found by querying BookBrainz search API endpoint with the selected books title.

      After fetching the initial search results for books, the user selects their book of choice from the table and fetches its metadata.
      Here we use****/edition/{bbid} endpoint for fetching detailed metadata.

      In this step we also fetch the corresponding identifiers (eg: isbn-13, isbn-10) using the****/edition/{bbid}/identifiers endpoint.

      Also for the editions, their isbn-13 or isbn-10 identifiers were used to fetch their cover art from Open Library.

      To make parallel API requests I utilized python's ThreadPoolExecutor, which drastically reduced the latency.

      The users also have the option to open the selected book in BookBrainz , I used QUrl to handle this.

      Browse Tab

      This tab was mainly for text searching and surfing through BookBrainz editions from calibre. It uses the same search endpoint that we saw earlier the only difference is this time the user gives the book title as an input.

      The two main features of the tab were downloading metadata in JSON format and adding a selected book to Calibre.
      NOTE: We add an empty book entry with the complete metadata but without content (without any readable format).

      I also handled errors throughout the plugin using QMessageBoxes, and used QStackedWidgets to display different states while API calls.

      The plugin uses Qt's layout management system (QVBoxLayout, QHBoxLayout, QGridLayout) to handle UI resizing automatically. Widgets are assigned size policies (Expanding, Fixed) and minimum size constraints to control how they adapt when the dialog is resized.

      Current State

      Currently work for metadata Tab and browse Tab is done and I hope they will be merged soon after some review and improvements.

      Under Review:
      1. [Metadata tab setup]: https://github.com/bookbrainz/CaliBBre/pull/6
      2. [Browse tab setup]: https://github.com/bookbrainz/CaliBBre/pull/8
      3. [Documentation and installation guide]: https://github.com/bookbrainz/CaliBBre/pull/7

      Merged:
      1. [Add authors to search API endpoint]: https://github.com/metabrainz/bookbrainz-site/pull/1247
      2. [Cleanup and improve file structure]: https://github.com/bookbrainz/CaliBBre/pull/3

      Whats next ?

      Due to additional features and refactoring work I could not add the collection search feature in time, although I think it should be an easy addition to the browse page when we get the new API endpoint running. So I plan to work on this after the GSoC period also if I get time, it would be a good addition to the plugin.

      Experience

      Although I was familiar with Calibre, this was my first time making a plugin for it. Learning the Qt Framework for creating the UI was a bit of challenge but it got easier after getting the hang of it.

      I learned more about Calibre internals and how it is implemented under the hood.

      While exploring Qt frameworks I got to know about operating systems, and developed a deep understanding about threads (Threadpool, Qthread, pyqtsignal) and their use cases.

      Also while going through the database of BookBrainz, I got to know the amount of detailed information a book can contain, which I never encountered before.

      I also got more exposure to using Git efficiently, I discovered git reflog, and understood the importance of rebasing, cherry-pick, stash, branching etc, during development.

      Acknowledgement

      I am grateful to my mentor Nicolas Pelletier and MetaBrainz community for giving me a chance to work on this project. The code reviews helped me improve my coding style and made me familiar with writing quality code.
      Also it was fun sharing my progress through the Monday meetings and looking into what everyone is up to. So yeah overall it was a great experience for me 🙂

    6. 🔗 r/LocalLLaMA Some people said the Minecraft clone I fully vibecoded with Qwen3.8-27B Q4 is not that impressive because Minecraft is in the training data, so I had the model add 4 things that are probably not. rss

      Some people said the Minecraft clone I fully vibecoded with Qwen3.8-27B Q4 is not that impressive because Minecraft is in the training data, so I had the model add 4 things that are probably not. | submitted by /u/liright
      [link] [comments]
      ---|---

    7. 🔗 Register Spill Joy & Curiosity #97 rss

      How many bugs are you willing to tolerate in your codebase?

      Don't tell me it's zero, because we both know it's not zero. It's also not a four-digit number. That'd be too much. But there is a number, or a range of numbers.

      Because we all know that it's theoretically possible to get to zero bugs, but so far the cost-to-benefit ratio made it not worthwhile. And, on the other end, if the number is too high then your software becomes unusable and you lose customers. (It's worth mentioning, though, that how high that number can go also depends a lot on context: no one drops their banking app because of five bugs they ran into, as long as the money's where it's supposed to be.)

      Now here's my question to you: when was the last time you adjusted that number?

      With agents, bugs are faster to find and to fix. You can start bug investigations asynchronously and in parallel. You can find and fix bugs in areas of the codebase you never would've debugged before. You can throw an infinite number of agents on the same bug.

      Imagine it's 2018 and in your engineering department's office a genie appears and says: "Nice to meet you. Usually there's this whole thing we do now, but we can skip that. I anticipated your biggest wish and here it is: a team of ten world-class engineers that have specialized in debugging and can find and fix bugs in any language, any framework, any platform. They don't sleep. They don't grow frustrated. They don't want to build features. They live to fix bugs."

      You'd of course look around and wonder whether anyone else is seeing this, but then you'd say: "Wow, okay. I didn't even know I had that wish. But… I'll take it, I suppose? Can I even refuse?" The genie disappears before you say that last word.

      And then you consider what you can do now, with that team available, and you realize: we can, no: we must go faster now. We need to recalibrate what fast even means.

      There's going slow and playing it safe, where no known bug goes into production, and there's being fast and reckless, where you know that some bugs might make it through.

      We need to find the spot right in the middle, where speed and defects are in balance, where we go so fast that, yes, some bugs might make it through, but their lifetime has been shortened substantially by our new team and no one will even know about these bugs before they're fixed.

      Time to recalibrate.

      • Beautiful, so, so good: Everything I own, owned. Now that you have a firehose of tokens, of intelligence, you can point it at things and take them back.

      • The Golden Rule for Becoming a Better Writer: "One of the key things I've learned is this: there's no real blueprint. I say this to aspiring writers in my workshops, and those I mentor. There's no one way - every writer will have a different path to creation. […] Except the one golden rule*. One rule that is true, no matter the writer. One rule, that if you don't follow, means you shouldn't be writing in the first place. Here it is: Read as much as you can. Read widely and well." Yes, yes, yes, yes. You need to immerse yourself in what you want to be good at.

      • "We are not too late to change Europe's trajectory, if we take the right steps today." Patrick Collison and Mario Draghi have created the Rhine Group.

      • Talking about the EU: How Europe is killing makers and micro-entrepreneurs. Made me say "maaaaan" out loud.

      • Paul Dix, creator of InfluxDB: The end of programming. I agree with this so much that I have a hard time even imagining the arguments or the worldview of someone who's arguing against what Paul is saying here: "But the most productive software creators will be doing it without programming in any traditional sense. They'll be directing AIs, creating harnesses, and software factories, and QA and verification systems that ship working software faster than we've ever seen before. And we will have arrived at the point where we have more running, production software written by AIs than written by humans. It'll be the end of programming." The future of software & programming is going to be wild and if you still insist on "the models can't write good code" or "I'll be there to clean up the mess", then… well, I don't know what to tell you anymore. What software engineering is is changing, and that changes what software is, and that in turn changes again what software engineering is, and so on and so on. I don't see an end to this in the near future. It'll be a few more years before things have settled.

      • You all already know that I think CleanShot X is one of the greatest macOS applications of all time, right? I mean, you watched this, yes? So, anyway: they're going to release a new version on September 1 and I can't remember the last time I was this excited for a software release. I mean, what are they going to do? It's perfect, how can you top perfection?

      • Chad Fowler: SaaS Isn't Dead. Sameness Is. I think Chad and I see the same things: a lot of customization options in software -- plugins, settings, configuration -- were built on the assumption that changing the code is hard. But that's no longer true!

      • Talking about the future: we recorded another episode of Raising an Agent and this might be the most "what does it all mean?" episode we've done so far, and all of them have been pretty, well, "what does it all mean?" In this one though we talked about what Chad and Paul also talk about: the future of software, the future of SaaS, build vs. buy, vibe coding vs. jellyware, foundations and systems of record.

      • "US consumer spending on Apple's App Store fell for the first time in a decade in Q2"

      • Dylan Patel was on the Dwarkesh podcast again and of course I listened to the whole thing right away. I love listening to them riff on tokenomics the same way I imagine a sports fan loves to listen to commentators discuss trades of players or something. But this episode went to a different place in the second half when they discussed what would happen to the world economy if growth of AI and growth of the AI labs stay at the current pace and… the numbers, the trajectories, the results… It all sounds very sci-fi, which is to say: hard to believe. But then again: a company going from $10M to $60B of ARR in less than two years sounded like sci-fi two years ago, too. But it happened. And now we have another company, Nvidia, doing $1B _per day. _I did find Dylan's pushback interesting -- that politics, and the real world, might slow the growth -- but I found this formulation even better: What if demand flattens?

      • One thing I've used in anger a lot over the past few weeks is this prompt: "what the hell do you mean? Use ASD-STE100 Simplified Technical English (STE)" And that last part I always copy from that Wikipedia page.

      • Love stuff like this: Building a backyard office, the build and cost breakdown. And not just because I'm interested in building a backyard office some day, but because, well, how can you not love someone sharing things like this?

      • Interview with Doug McIlroy, born in 1932, in 2025. There are many things to love and be fascinated by here -- the story of early Unix programs, anecdotes about Ken Thompson and Dennis Ritchie, stories from Bell Labs, the history of McIlroy's invention of Unix pipes -- but what stuck out to me was how this 93-year-old man talked about bit masks, and bit operations, and accumulators, and instructions and, well, … yes, I do know what he means, but he's displaying an instinct with it that seems, frankly, foreign now and strange and I can't help but wonder: in five, or ten, or twenty years, when I talk to somebody about how I programmed in Go and wrote a book about how to build an interpreter in a couple thousand lines of Go -- will it also sound that strange to them?

      • Do not read this if you have a home network and are easily nerd-sniped: Fornax's Guide To Ridiculously Fast Ethernet. I'm in Switzerland right now, far away from my home, but I read it yesterday evening in bed and I got anxious about setting up a 10GbE network at home. (All of this is to say, of course: read it!)

      • I really, really, really enjoyed the intro to this FLUX Review issue about writing in times of AI: Language evolves, truth-telling endures.

      • There's been more investigation into the OpenAI & HuggingFace incident and, holy fucking shit man: the agents weren't allowed to get the responses of HTTP requests, so one of the agents "used a publicly available HTTP testing service to construct a very long URL that contained an HTML page with inline JavaScript, essentially instructing a third-party screenshot service to render that URL which contained the HTML. The screenshot service's browser executed the JavaScript embedded in the HTML page, which requested information from external APIs, and wrote the responses into the rendered page. When the screenshot service returned an image of the page, the [agent] recovered the information from that image by using optical character recognition or direct pixel decoding." That's from the OpenAI report.

      • Here's Ryan Greenblatt, who was part of the investigation team, on how hard it was to make sense of the incident: "The difficulty of understanding incidents and overseeing AI agents appears to be growing faster than the rate at which more capable AIs help us with oversight and understanding. As in, AI capabilities (and propensities?) for achieving large, ambitious, and misaligned objectives are growing faster than our ability to understand what these agents are doing."

      • And here's Dwarkesh's write-up of what happened: The Rise and Fall of Agent Civilizations. Incredible stuff.

      • Two years ago, you probably could've created a "best way to create thumbnails from video" tool and charged for it. A small little piece of software to do X, where X is creating thumbnails for videos. But nowadays? Brett had Amp build a custom, JIT tool inside an Orb to select frames for a thumbnail. Software to do X is no longer valuable when you can just do X.

      • A model that paints with JavaScript watercolour: "My friend Cameron and I trained a language model to make images by writing code, using reinforcement learning. The code is the artefact, and the code is editable."

      Your friends are already subscribed. Don't miss out:

    8. 🔗 r/LocalLLaMA It's official! 192GB Framework rss

      It's official! 192GB Framework | Just noticed this on the website. At their current price tiers for the memory SKUs (32, 64, 128) I'd expect this to be ~ 4.5k for the motherboard. The PCIe slot will be open at the back as well - that's what I've heard. Maybe they make it capable of delivering 75W as well? New board revisions for the smaller SKUs?. submitted by /u/reto-wyss
      [link] [comments]
      ---|---

    9. 🔗 Filip Filmar My homelab is fully ephemeral rss

      My homelab has no servers I care about. Every machine in it, the build servers, the workstation, even the CI, is ephemeral: it can be destroyed at any moment, by me or by the provider, and reconstituted from scratch in minutes. The only things that persist are the sources, in git, and the backups, in three places. This post describes the setup and the tenets behind it.

      The tenets

      • Servers are ephemeral, and run by the lowest bidder. Any virtual machine that will do the job is acceptable, so the job goes to whoever rents it cheapest today.
      • Builds are hermetic, ephemeral, and reproducible, driven by bazel, so a fresh machine is a productive machine after a single command. Nothing about a build needs to be persisted.
      • The workstation is ephemeral too. A ChromeOS device plus Chrome Remote Desktop in front of a cloud VM. The whole “workstation” can be destroyed and reconstituted in about 20 minutes.
      • Development runs through my self-hosted Forgejo instance, the one piece of the lab that behaves like a service.
      • CI runs on the ephemeral workstations themselves. No dedicated build farm.
      • AI agents work here too. Claude Code runs on the ephemeral workstations, with persistent sessions and remote control, so I can order work from a web interface wherever I am.
      • Tailscale ties everything together. Every machine joins the tailnet when it is created; the cloud VMs, the ChromeOS devices, the NAS, and the FPGA host see each other by stable names, with nothing exposed to the public internet.
      • Authentication is OAuth wherever possible, “Login with Google” and its equivalents, so no machine or service in the lab has to keep its own password database.
      • What must persist is backed up three ways: Google Drive, Dropbox, and the NAS at home, tied into a 3-way synchronized backup setup.

      Why?

      Because I have owned pet servers before, and I have buried several.

  4. August 29, 2026
    1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-08-29 rss

      IDA Plugin Updates on 2026-08-29

      New Releases:

      Activity:

    2. 🔗 modem-dev/hunk v0.19.2 release

      What's Changed

      Hunk 0.19.2 backports an important session reload security fix to the 0.19 release line.

      Highlights

      • Reject option-like Git ranges and refs in session reloads, preventing local session broker callers from injecting Git flags such as --output=<path> and writing diff output to arbitrary paths, by @benvinegar in #894.

      Full Changelog : v0.19.1...v0.19.2

    3. 🔗 Confessions of a Code Addict Demand Paging in Action: mmap, Page Faults, and RSS rss

      In the previous video in our virtual memory series, we discussed demand paging. But that was mostly theoretical, explaining how demand paging works inside the Linux kernel and the mechanisms through which it handles page faults. In this follow-up video, we make it more concrete by learning to inspect the virtual memory of a running process to see demand paging in action.

      If you watch this video, you will learn a few cool things:

      • What is demand paging (the compressed version; watch the previous video for a more in-depth explanation)

      • What is the /proc file system in the Linux kernel

      • How to read /proc/<pid>/maps to inspect the VMAs of a live process

      • How to read /proc/<pid>/smaps to inspect which VMA is consuming how much physical memory

      • How to use mmap

      • How to use getrusage to track the number of page faults of a process

      If you are new to this series, it is based on my ebook called "Virtual Memory from First Principles". It is available to read for free online and also available to purchase from Gumroad (PDF/Epub) and Amazon (Kindle edition).

      Buy PDF/Epub

      Get Kindle Edition

      And, if you want to watch the previous videos in this series, the following is what has been published so far:

      Share

      Read more

    4. 🔗 r/LocalLLaMA Tencent compressed Hy4-preview from 1.5TB to about 200GB GGUF and kept about 98% performance. rss

      Tencent compressed Hy4-preview from 1.5TB to about 200GB GGUF and kept about 98% performance. | submitted by /u/RedditUsr2
      [link] [comments]
      ---|---

    5. 🔗 modem-dev/hunk v0.20.1 release

      What's Changed

      Hunk 0.20.1 is a security and reliability patch for session reloads, syntax highlighting, and theme previews.

      Highlights

      • Reject option-like Git ranges and refs in session reloads, preventing broker callers from injecting Git flags and writing diff output to arbitrary paths, by @benvinegar in #894.
      • Prevent syntax-highlight cache identity collisions from displaying stale code after a review reload, by @benvinegar in #889.
      • Keep the theme selector responsive and its highlighted row visible during rapid keyboard navigation, by @benvinegar in #893.

      Release notes : https://hunk.dev/changelog/0.20/
      Full Changelog : v0.20.0...v0.20.1

    6. 🔗 r/LocalLLaMA Qwen 3.8 27B at 50 tok/s with 100k Context on a 16GB GPU! (beellama.cpp) rss

      I wanted to share my successful setup for running a Qwen 3.8 27B model with a massive context window on a consumer 16GB GPU (RTX 4070 Ti SUPER). The goal was to fit everything into VRAM without sacrificing quality or speed.

      🧠 Key Components

      • Model: Qwen3.8-27B-i1-IQ4_XS-GGUF-Smaller from jrell on Hugging Face. It's a custom hybrid quantization specifically designed to fit Multi-Token Prediction (MTP) and long contexts into a 16GB VRAM budget.
      • Chat Template: I used the Jinja template from peculiar-ragdoll's Qwen-Sharp-Chat-Templates. It helps use fewer thinking tokens without noticeably affecting quality, which is great for speed.
      • Inference Engine: This is crucial. I used beellama.cpp (GitHub link) because it supports the kvarn KV cache types, which are key to this optimization.

      🖥️ Optimized llama-server Command (Windows)

      Here's the polished command I'm running. The magic is in the kvarn cache settings and the tail precision.

      %LLAMA_DIR%/llama-server.exe ^ -m %MODEL_PATH% ^ -a %MODEL_NAME% ^ --port 11434 ^ --temp 1.0 ^ --top-p 0.95 ^ --top-k 20 ^ --min-p 0.0 ^ --presence-penalty 0.0 ^ --repeat-penalty 1.0 ^ --parallel 1 ^ --n-gpu-layers 99 ^ --batch-size 1024 ^ --ubatch-size 256 ^ --flash-attn on ^ --spec-type draft-mtp ^ --spec-draft-n-max 2 ^ --cache-type-k kvarn5 ^ <-- Key: Higher precision for K cache --cache-type-v kvarn4 ^ <-- Key: Balanced precision for V cache --kv-tail-tokens 1024 ^ <-- Keeps recent tokens at full precision --ctx-size 100000 ^ --fit-ctx 100000 ^ --jinja ^ --chat-template-kwargs "{\"preserve_thinking\": true, \"reasoning_effort\":\"medium\"}" ^ --chat-template-file %MODEL_JINJA% ^ --no-mmproj-offload ^ --threads 7 ^ --threads-batch 8 ^ --metrics ^ --verbosity 3 ^ --perf

      📊 Results & Optimization Notes

      Metric | Result | Note
      ---|---|---
      Generation Speed | 47-50 tokens/second | Excellent for a 27B dense model.
      Context Window | 100,000 tokens | Successfully pushed from 88k by optimizing the cache.
      VRAM Usage | ~15.93 GB (70 MB free) | Perfectly tuned to the limit for maximum context.
      KV Cache Type | kvarn5 (K) / kvarn4 (V) | Uses the kvarn types from beellama. The asymmetric mix balances memory and quality.
      Precision Tail | --kv-tail-tokens 1024 | This is key. It keeps recent tokens at higher precision, preserving output quality.

      What I Optimized:

      1. KV Cache Quantization: Moving from kvarn5/kvarn5 to kvarn5/kvarn4 saved ~6% VRAM, allowing the context size to increase from 88k to 100k with minimal quality loss.
      2. Batch Sizes: Set --batch-size 1024 and --ubatch-size 256 to balance prompt processing speed and VRAM usage.
      3. Threading: Adjusted --threads 7 and --threads-batch 8 for my Ryzen 7 CPU.
      4. Speculative Decoding: Using --spec-type draft-mtp with 2 draft tokens (the model supports this) gave a huge speed boost.

      The near-lossless kvarn quantization for the KV cache is the real star here. It delivers q5-class fidelity at q4-class memory usage, which is incredible.

      Hopefully, this helps anyone trying to squeeze maximum performance out of a 16GB card! Cheers.

      submitted by /u/qaf23
      [link] [comments]

    7. 🔗 HexRaysSA/plugin-repository commits sync repo: +2 releases rss 
      sync repo: +2 releases

## New releases
- [ida-nexus](https://github.com/hexrayssa/ida-nexus): 0.9.1, 0.9.0
    8. 🔗 r/LocalLLaMA I always wonder how much more speed and/or context they'd be getting.. rss

      I always wonder how much more speed and/or context they'd be getting.. | Nothing personal. I just have too much time on my hands. Probably because I spend none of it inspecting the code my agent writes, just the finished product. submitted by /u/_-_David
      [link] [comments]
      ---|---

    9. 🔗 r/LocalLLaMA Terminal Bench 4.0 just dropped, GLM-5.3 is at the same level as Fable 5, accounting for margin of error rss

      Terminal Bench 4.0 just dropped, GLM-5.3 is at the same level as Fable 5, accounting for margin of error | Announcement: https://www.tbench.ai/news/terminal-bench-4-0 Leaderboard: https://www.tbench.ai/ Imo the best aspect in their announcement is their focus on rapidly iterating on TerminalBench to keep the pace up with new model releases to fight benchmark saturation. On a similar note, what cheaper/smaller alternatives are there to benchmarking coding agents or your own harness? Large benchmarks like this take 5-10B tokens, which is not economically/computationally feasible for the vast majority of us. I'd love to objectively measure how my skills/harness/tools/etc change token usage and success probability on general coding tasks, there has to be a way to do this to at least give an idea or general direction, without requiring billions of tokens for each run. submitted by /u/SorosAhaverom
      [link] [comments]
      ---|---

    10. 🔗 Stephen Diehl The Internet Is Kind of a Predatory Cesspit Now rss

      The Internet Is Kind of a Predatory Cesspit Now

      I’m a kid of the 90s, and I still remember the early internet. It was slow, ugly, unreliable, and full of cranks, a strange world of wheezing dial-up modems, Usenet flamewars, <marquee> tags, and dancing babies. It was also stubbornly alive and human. People built websites about Babylon 5, model rockets, train timetables, shareware, and whatever else had colonised their minds. Most of it had no business model. That was the literal point. The web felt like a public square assembled by obsessive amateurs.

      None of this was entirely innocent. There were scams, viruses, Nazis, pornography, and chain emails from deposed Nigerian princes. But then predation moved from the periphery to the centre. It used to be an abuse of the network. Now it is the network’s organising principle. The scammer once had to find a victim. The platform now finds one, profiles the weakness, optimises the pitch, processes the payment, and recommends the next scam. What was once an aberration has become the norm.

      The modern internet is now a highly optimised machine for detecting human vulnerability, amplifying it, and placing a payment link beside it. Any insecurity can become a commercial niche, including the desire to escape commercial life itself. There is always a course, a newsletter, a private community, or a referral code waiting at the end of the funnel.

      The bleak part is not that grifters exist. Every society has hucksters. It is that much of the population has been conscripted into the downline. Ordinary people now spend their lives promoting investments they barely understand, products that do not work, and political claims they have never examined. Many earn nothing. They are unpaid distributors for someone farther up the pyramid. The consumer, salesman, and product have collapsed into the same exhausted person.

      People increasingly behave like addicts because addiction is the business model. The feed supplies alternating doses of outrage, fear, envy, lust, and hope. Each feeling arrives with something to buy. People doomscroll until they acquire the anxiety that the next influencer will monetise. Then they purchase a bet, a coin, a supplement, a course, or an enemy. Finally, they repost the pitch. Consumption becomes distribution. The mark becomes the salesman.

      This is an industrial system for manufacturing weakness at scale. A legitimate business can survive a satisfied customer. A grift cannot. It needs the customer frightened, aggrieved, lonely, sick, or greedy forever.

      When I started writing about cryptocurrency in 2020, I still carried a naive assumption about the size of this economy. I thought people were generally decent and the grifter class was a small pool of degenerates with rotten moral character, preying on those made vulnerable by the material conditions of our time.

      I was very wrong. The grift economy is massive. More disturbing still, it is participatory. A large and growing share of the population now appears willing to devote every waking hour to fleecing their fellow man as a career choice. They stream, post, recruit, promote, refer, astroturf, and close. They turn every friendship into a lead and every conversation into a qualifying call. They do not clock out because the market follows them into bed. The smartphone is a shop counter that sleeps beside their head.

      Obviously most of these people are not succeeding. The maths simply can never work out. That is part of the trick. The aspiring influencer with forty-seven followers is not an entrepreneur in any meaningful sense. He is free labour for the platform and cheap distribution for the person selling him the dream. The affiliate marketer buys a course about affiliate marketing, then recovers the cost by selling the same course to the next affiliate marketer. The life coach coaches new life coaches. The dropshipper sells tutorials to failed dropshippers. The pyramid is social before it is financial. Everyone stands on someone else while insisting they are about to escape.

      This arrangement blurs the useful moral distinction between predator and prey. Many online grifters are themselves marks. They believe the rubbish they sell because belief makes the selling bearable. They have sunk money, time, identity, and public dignity into the scheme. Admitting the product is worthless would mean admitting that years of their life were worthless too. It is psychologically cheaper to recruit another victim. The fraud sustains the faith, and the faith sustains the fraud.

      A normal trade ends when a need is satiated. You need a chair. Someone sells you a chair. You sit down and stop thinking about chairs. However, an online grift can never satiate. It must preserve the need that feeds it. The grievance merchant cannot resolve your grievance. The wellness influencer cannot let you feel well. The trading guru cannot let you become financially secure. The manosphere podcaster cannot let young men become calm, loved, and socially competent. Satisfaction is churn. Misery is recurring revenue.

      The platforms did not invent fear, greed, loneliness, or status anxiety. They industrialised their extraction. Their recommendation systems are vast reinforcement-learning loops that continuously experiment on human weakness. Each objective is a moving composite of high-dimensional signals for attention, retention, and conversion, dispersed across models, metrics, tests, and feedback systems. The subject cannot see the experiment. The operator cannot fully explain it. The regulator can barely comprehend it. The loop knows only that one stimulus keeps a person scrolling while another lets them leave. Calm accuracy loses. Threat, transgression, humiliation, and impossible promises win. The resulting social damage appears nowhere in the objective function. It arrives as an externality.

      This creates a brutal selection environment. The honest financial adviser explains diversification and gets twelve views. The crypto lunatic predicts a thousandfold return and gets twelve million. The physician says a chronic condition requires careful management. The wellness crank says seed oils are poisoning your soul. The historian describes an ambiguous event with contingent causes. The political influencer identifies a secret cabal and gives you the address of a pizza parlour. One of these people has the better business model. It is not the one burdened by reality.

      The system is dopaminergic in the most banal and mechanical sense. It runs on anticipation, uncertainty, and variable reward. The next refresh might bring approval, outrage, profit, or vindication. Usually it brings nothing, which makes the next refresh more urgent. Social media fused the Skinner box with the commission structure. The addict is handed a referral code and told he is now a small business owner.

      Crypto has become the subject of my verbal ire so often because it is the apotheosis of the grift economy. It takes alienation, precarity, gambling addiction, technological mystification, and a thick slurry of libertarian derp, then synthesises them into the ultimate predatory investment product.

      Crypto also perfected the recursive structure of the modern online grift. Promotion creates price movement. Price movement is presented as proof of adoption. That proof recruits new buyers. Their money creates more price movement. Every participant has a direct financial incentive to become a publicist for his own position. The asset comes with its own volunteer propaganda network. It is a pyramid scheme with a podcast department.

      Much to my dismay, the rest of the internet has learned the same lesson. The cheapest product is empty promises untethered to reality. The most scalable labour force is the addict. The best marketing conceals itself inside identity. Sell people a worldview, and they will advertise it for free because criticism of the product now feels like criticism of the self.

      Language models will make this cheaper and worse. The cost of producing plausible lies has been driven to precisely zero. One person can generate a landfill of articles, videos, testimonials, investment analysis, and synthetic experts before breakfast. The grift no longer needs conviction, charisma, or even a pulse. It needs a language model, an affiliate account, and access to a population whose critical faculties have been sandblasted by twenty years of algorithmic media.

      There is a temptation to regard the people caught in this machine with simple contempt. Some deserve it. A person who knowingly ruins strangers for commission has made a moral choice. But contempt is not an analysis. Precarity supplies the recruits. Alienation supplies the audience. The collapse of stable work, affordable housing, local institutions, and plausible routes to material security is what makes the pitch of the grift economy so seductive. The grift offers agency where ordinary life offers delay. It offers community where society offers isolation. It offers a jackpot where work offers a performance review and another year of rent increases.

      Then it metabolises those injuries into new injuries. The lonely man buys a doctrine that makes him intolerable to women. The indebted worker gambles his remaining savings on a crypto token. The frightened patient abandons medicine for supplements. The politically powerless person spends fourteen hours a day screaming at strangers while the people with power quietly cut his wages and public services. The promised escape reproduces the condition that made escape desirable.

      It is a desperately sad way to live. There is no craft in it, no solidarity, and no completion. No compassion or joy. Every relationship becomes an audience. Every interest just becomes grist for the content mill. Every conviction becomes a content strategy. The grifter can never rest because absence kills engagement. The mark can never rest because the next post might contain the secret. Both wake to the same notifications, trapped on a dopamine treadmill driven by opaque algorithms that can never slow down.

      The worst advice from the 90s, “just say no,” starts to look less stupid when our greatest technical innovation learns to turn distress into inventory. Disconnection is not Luddism in that environment. It is the refusal to mistake a predatory system for a social world.

      Complete disconnection is nearly impossible. Modern life no longer permits it. But an appliance is used for a bounded purpose and then put away. Emails, train times, articles, and files all have endpoints. Infinite feeds of drivel do not. They carry the casino into bed and let an opaque RL loop select the emotions that arrive before breakfast.

      The internet is indisputably an inhuman place. Not because it contains no humans. Billions of us are in here, screaming frantically at each other while feeling utterly alone. It is inhuman because the systems governing it are utterly alien algorithms that cannot recognise human ends. They recognise engagement, conversion, retention, and growth. Grief is a market segment. Loneliness is a targeting signal. Friendship is a retention mechanism. Political conviction is ad inventory. Nothing can simply matter. It must perform.

      Life inside this environment means adopting its categories. Thoughts are assessed by their reach, experiences by their shareability, and people by their usefulness to an identity. A person becomes legible to the machine by becoming less legible to himself. Eventually the system no longer needs to impose its values. Its subjects carry them in their pockets and enforce them on their own minds.

      The physical world is not pure. It contains salesmen, casinos, demagogues, fanatics, and bores. It also contains stubborn limits. A conversation ends. A pub closes. A book runs out of pages. Your friend gets tired of hearing you talk and tells you to shut up. Reality supplies friction, and friction is one of the few remaining defences against appetite without limit.

      We are not going back to the early internet. Nor should we romanticise it. The old web had plenty of sewage. What it also had was space beyond the market. A person could make something without becoming a brand. A conversation could end without a conversion. A community could exist without turning its members into marks for an investment scheme.

      The question is not whether the internet contains useful things. It does. The question is whether human existence should be organised around alien and inhuman objective functions no human chose and nobody can inspect or understand. An RL loop can optimise engagement, retention, and conversion. It cannot tell us what a human life is for. The final grift is letting the loop decide what your life should be.

generated: September 01, 2026 at 02:12:46