RSS Feeds

Exclusive: Forensic analysis of found images continues as Meghan’s father denies possessing child sexual abuse images

All signs point to Thomas Markle Sr being a “possible sex offender of the grossest kind” although a full forensic investigation will give a “definitive picture”, the Philippine interior minister has told the Guardian.

Authorities in the south-east Asian country are analysing digital images allegedly belonging to the estranged father of the Duchess of Sussex that were said to have been found at his former home in Cebu. Meghan’s half-brother, Thomas Markle Jr, reported to authorities last week that he had apparently discovered a stash of child sexual abuse images.

Exclusive: Forensic analysis of found images continues as Meghan’s father denies possessing child sexual abuse images

All signs point to Thomas Markle Sr being a “possible sex offender of the grossest kind” although a full forensic investigation will give a “definitive picture”, the Philippine interior minister has told the Guardian.

Authorities in the south-east Asian country are analysing digital images allegedly belonging to the estranged father of the Duchess of Sussex that were said to have been found at his former home in Cebu. Meghan’s half-brother, Thomas Markle Jr, reported to authorities last week that he had apparently discovered a stash of child sexual abuse images.

Старые программы конца 90-х на Windows 11 то зависают до нажатия клавиши, то молчат, то не запускаются вовсе. Песочница Windows тут не помогает, VirtualBox с Windows 98 дружит плохо. Рабочим вариантом оказался эмулятор 86Box: за полтора‑два часа он даёт настоящую Windows 98 SE в окне, со звуком, мышью и CD‑приводом. Руками из этого времени — минут 20, остальное ожидание.

Ниже — пошаговый гайд, который я проверил на живой установке 21.10.2026 (Windows 11 Pro, 86Box 6.0 build 9001, Windows 98 SE English 4.10.2222A), со всеми граблями, на которые наступили. В конце — бонус: инструкция для ИИ‑агента, по которой Claude Code или похожий агент проходит всю установку сам.

The other day, I saw a viral tweet saying that people talking about how LLMs are causing slow, bloated, code are going to eat crow once they re-write everything in super-optimized assembly. We're not quite at the point where we want to write everything in assembly, but some variant of what Nolan Lawson said about testing, you can choose how many bugs you want now, which I less eloquently noted here, is becoming more true for performance.

In response to a comment in my last post that the cost of formerly specialized performance work has dropped by many orders of magnitude and performance work that used to require a person or team that had a rare set of skills can be done by anyone who can type a few sentences¹, which means that you can do all sorts of optimizations that used to be too expensive to be worthwhile for all but the largest scale or most lucrative projects, Marc Brooker responded with

Completely agree with your closing point. Dynamic custom software, fitted to a particular workload rather than a class of workloads, seems like a very likely outcome. (Which comes with all kinds of fun risks and opportunities of its own). Kind of reminds me of FFTW. And a ton of weird old demoscene techniques which were all about being super fast and small on a very particular problem (and often very particular hardware). For example, I remember a demo that re-used its code as textures to get great cache locality.

And Michael Malis has noted

There’s been a meme circulating about how AI doesn’t help because “code was never the hard part.” I think that’s true in some domains, but in others, writing the code absolutely was the hard part. JIT compilers are a great example of that. For many pieces of software, a JIT compiler would help a lot with speeding up the code. The rarity of JIT compilers makes me believe that implementing a JIT compiler historically was too difficult for it to be worthwhile. LLMs have lowered the barrier to entry and made it much easier to write a JIT compiler. This is the thesis behind pgrust. Databases historically were the hardest piece of software to build and were limited because of that. Now, with AI, we can be more ambitious about the type of software we build.

Optimizing for a class of workload

Let's try this out with FRE, the regex engine we built in the last post. Recall that it was created by having an agent loop for a month on improving regex engine performance with access to the rebar regex benchmark suite. This resulted in FRE being heavily overfit to rebar until we warned our agent that we had a holdout benchmark, which caused the agent to generalize the optimizations enough that performance was ok-ish on our holdout. There's no particular reason to use a "software factory" regex engine that doesn't beat a well-tested regex engine on holdout benchmarks, but one notable thing about FRE was that the native AOT compiled version did quite well at longer searches. We noted that, it stands to reason that one could run the native code compiler in another thread while ripgrep was running its normal matcher and then cut over to the native code when it finished compiling and generally get better performance. Of course this will generally result in worse performance for short queries as we lose a thread to compilation, but I care a lot more about how long ripgrep takes when it runs for many seconds or minutes than when it runs for a few seconds, so I'm ok with that tradeoff.

In the same way we could build a regex engine in a few minutes of human time, we can also just try this experiment in a few minutes of human time. I typed a few sentences and an agent went and did the work to allow this to happen (which would be a decent chunk of code surgery for a human) and it ran the benchmark on actual ripgrep queries that come from my codex history. For longer queries, we see a 2x-4x performance improvement here for a few very simple queries. But most queries are more complex, and when we run on representative holdout queries, for queries where AOT should be enabled², we get about a 7% speedup. Not an earth shattering result, but also not a bad outcome for spending a few minutes typing to codex (and it's still doing more optimization and will presumably speed things up further).

Build an index?

This is arguably a silly thing to do, since if we're repeatedly searching for text on a computer, the obvious thing to do to speed that up isn't to write a native code compiler for regex matching, it's to create an index. But the point here is just that this kind of technical work, which used to take a fair amount of time and expertise, can just be done trivially now. And if we wanted to build a text index, it just so happens that I worked on BitFunnel, the Bing search index that was specialized for constant/fast text ingestion that won Best Paper Award at SIGIR, so I can think of a few experiments to try if we're going to build a fast local index of our entire machine (the projects I've seen seem to be intended to index your code directories, but what really kills my machine performance is when codex decides to run ripgrep against huge temporary directories with a ton of generated files and then expands to looking at my whole machine when it misses, so I'd want an index of my entire disk and not just of the code for some projects).

If I were working at an AI lab and had access to things like SOTA models running on Cerebras chips or other accelerators that greatly increase tok/s and therefore load/demand for search, I might actually survey the existing indexers to see if they're fast enough or if I'd want to build something custom myself. While the open source version of BitFunnel "only" contains a bytecode interpreter and one JIT, the Bing version contains multiple JIT compilers. A project that did that level of optimization used to be a major undertaking, but "I could do that in a weekend" is now actually true for some of these kinds of projects. With my lowly $200/mo account, I think a somewhat faster ripgrep plus any off-the-shelf index is fine, so maybe this fast-ingesting whole-machine index project can be left as an "exercise for the reader (who works at an AI lab)".

Optimizations are cheap

The drastic reduction in the cost of optimizations has been true going back to November 2025 and maybe even somewhat before then with public models (and I'm sure before that still with what folks at AI labs had access to). For an example from the GPT-5.1 or 5.2 days, with no knowledge of game AIs, I tried building an Azul AI. This ended up being the strongest AI in the world for the game by a pretty large margin. From reading the thesis that describes the 2nd strongest AI, I think my AI is probably a bit better on the "AI" side of things, but the main place it wins is on optimization despite spending what looks like maybe two orders of magnitude less time (estimated by reading the thesis and seeing the process and comparison to my process) and also mostly working on my laptop vs. having a cluster of machines to use (which means much less bandwidth to run experiments with, do parameter tuning, etc.). For example, that other AI is single-threaded and my AI is multi-threaded. Since I have a native code version as well as a heinous shared wasm memory + javascript version, and two different search architectures for two different versions, which "require" completely different multi-threading algorithms (minimax for a very small and fast net and MCTS for a larger net), this would've been a fairly large undertaking if done by hand. And, because I let an LLM pick the multi-threading algorithm based on its own (incorrect) reasoning a couple times before spending 30 minutes reading about multi-threading algorithms for game AIs myself, I ended up re-writing (having codex re-write) the multi-threading algorithm multiple times.

There's a bunch of standard stuff it makes sense to do to debug and verify a multithreading algorithm for something like this, like implementing replay from debug logs that can reproduce bugs despite the algorithm being nondetermistic. Doing that alone would've probably been days to a week of work had I done it by hand, but it's exactly the kind of thing an agent can trivially do in a loop (just have it try to replay logs and insert logging for non-determinism every time you don't get a perfect replay). A lot of the tedium it used to take to get a tricky optimization like this working is gone.

This also applies to a lot of other tricky optimizations. From having written CPU microcode, done CPU verification, worked on optimizing a search engine index, etc., I have a lot of experience looking at optimizations and thinking "hmm, this would increase performance by 2%, but it's going to take N person-days to verify that this tricky optimization works" and making a call to go ahead or not based on whether or not it's worth the time to get the optimization working. Now that this N has dropped by a tremendous factor (variable but, in terms of human time, frequently 1000x / 10000x / 1000000x, probably more like 1000x on dollar cost if you compare token costs at metered rates vs. the Bing engineer who wrote the compilers at JITs that the search index used), the number of these kinds of optimizations it makes sense to do goes way up. The same goes for optimizations that you aren't sure will work out. I used to sometimes look at an optimization that I wasn't sure would speed things up and think "this will take M hours to implement to the point where we have a good enough measurement to guess at the performance impact". Many more of those optimizations make sense to try out now.

Going back to the game AI case, at least for the AI I tried, it seems like you gain about 100 Elo for every doubling in speed (more than in chess, I suspect because draws are very rare). Just adding multithreading alone is enough to wipe the floor with an otherwise comparable AI on a large machine. If you stack in 10-20 more optimizations that seem too annoying for most people to do by hand, the difference in strength is tremendous and it's not really reasonable to try to keep up with a hand-written AI³.

The game AI case is a little more annoying than for most software because a lot of the optimizations you want to do actually change the result and there isn't a cheap, trivial, way to tell if the speed increase + the change in result gives a better or worse actual result in practice. And, as we noted before, current publicly available SOTA models are pretty bad at experimental design, so I had to set up the framework they used to determine if an optimization is good, but once that was in place, it's like any other optimization problem. I guess people working on LLM optimizations also have to deal with this class of problem but most optimization problems are a lot more straightforward.

To pick another example, as part of preparing for performance interviews, Jamie Brandon tried Anthropic's now public performance takehome. After trying it, he had Claude pick up where he left off and it got a much better result. When he looked at what Claude did that he didn't, he said a lot of the optimizations were things that occurred to him but he hadn't gotten to yet, and "[o]thers were just crazy shit that I would never try unless I was working on this for weeks"⁴. He's a reasonable performance engineer and he got an offer for the performance job he wanted, but on a well-defined optimization problem, he doesn't stand a chance against a decent model (I haven't tried the problem myself, but I suspect I also wouldn't stand a chance given remotely comparable time controls).

Workload-specific optimization

Coming back to this part of Marc Brooker's comment:

Dynamic custom software, fitted to a particular workload rather than a class of workloads, seems like a very likely outcome.

This seems pretty inevitable. In another response to my post, Michael Malis of pgrust said something similar:

[discussion of pgrust optimizations] ... I think it's easy enough to create these optimizations that we could look at a customers workload and add them as needed

Without having any kind of framework or setup, right before I started writing this post, I had an agent do workload-specific optimization for my ripgrep queries (not the native code compiler switch, just the optimizations to the general FRE engine based on a set of benchmarks), which took about 2 minutes for me to launch. The optimizations run on a set of queries, and then there's a later holdout set of queries to run against. That's still running, but the initial results seem promising. After one pass of optimization, the workload optimized version is 2% faster than standard ripgrep on the holdout and it's still getting faster. 2% isn't a big deal for my local ripgrep usage, but considering that this took minutes of time and the optimizations done here got started when I started typing this point and are still improving, I'd take a 2% win here (note that this isn't combined with the native code compiler, which would give a larger overall win if combined properly). And recall that this is leveraging the FRE regex engine⁵, which was substantially slower than the Rust regex engine on holdout benchmarks and was stuck with slow improvement on holdouts because with me knowing nothing about regex workloads and SOTA LLMs not being good enough at experimental design to do unguided open-ended self-improving loops, we didn't have a good way to improve performance on our holdouts. But if what I care about is performance on my own workloads, I have plenty of data and am generating more all the time. As Marc Brooker noted above, we do have to be careful about overfitting if there's a regime change that's not in the old data, etc., but we're still in a better situation than we were before.

In the more general case, if you're someone like Marc Brooker at Amazon or Michael Malis working on pgrust, it makes sense to not just do this as a one-off, but to work with customers to pilot a program that uses their data to optimize things for them and then figure out how to scale it out for customers in general. I'm not working at a company where that's the best use of my time⁶, but it's pretty wild that you can see that this is coming for larger companies with more scale, and given that it only takes minutes of my time to run these experiments for my personal workflows, it's pretty reasonable to mess with this kind of thing on personal projects.

Thanks to Jamie Brandon, Michael Malis, andrea (@s__video), Artyom Bologov, and Max Bittker for comments/corrections/discussion.

P.S. As I've noted in the last couple posts, with coding agents, the time it takes to run an experiment and see enough of a result to satisfy my curiosity has gone way down while the time it takes to make a result really rigorous hasn't changed or has gone up, so writing things up the way I used to would mean running very few experiments relative to the bandwidth I have for them. As a result, I've just been running these experiments and sharing the result with a couple of friends. As an experiment, I'm trying to write these up in a very quick and non-rigorous way instead of years of these experiments only being known to a few friends. Like the last post, I set a goal of writing this post and doing all the clean-up in half an hour and didn't time it but am pretty sure I missed that by a bit.

Even doing this, the time it takes to write these up is long enough that I'm falling behind on sharing recent results, but I'm not inclined to switch to LLM-written posts (yet?), and I don't think I can realistically get the time to clean up the data and write a post like this down enough to turn a post around in less than half an hour. Just on the length of this post, typing this up should be something like 20-30 minutes including time to pause and think about what I'm writing, and then when I look at the data sometimes something will look wrong enough that I need to look into it more closely to see if there's an issue that needs to be fixed (this happened multiple times here, and I would expect that, because I didn't spend much more time, there are other data issues that I don't know about).

Anyway, if you have opinions on these quick (and surely more wrong) writeup, let me know what you think (X Bsky Mastodon)!

Appendix: There's no reason for software to be slow anymore

I've been on the record for a long time as strongly disagreeing with the general sentiment that the developers of X are bad and should feel bad for writing slow code because there are a lot of different kinds of programming expertise and not only is it not the case that most programmers don't have performance expertise, it probably doesn't even make sense for them to develop (from the standpoint of what the business cares about, what the employment market looks like, etc.), so of course most projects will have very poor performance compared to what a performance expert can do. I can see why a performance expert would look at the growing gap between how fast a program can be and how fast programs actually are and think that it's ridiculous. I don't disagree that there's an absurdity to it, but if I think about the gap between how good a UI can be and how a good a UI I can make (by hand) is, I don't think that looks any less absurd, but I also don't think it really makes sense for me to spend time learning how to build a great UI, or even a decent UI, for the same reasons it doesn't make sesne for most people to spend time learning how to decent performance work.

For the example above, Jamie Brandon got an offer from Anthropic and you probably can't afford him unless you're OpenAI, but you can afford to use a coding agent that can beat him on a bounded optimization problem. The agent doesn't have the judgement he has and will do worse on an open-ended problem (recall that when we tried building an optimized regex engine and just told it to not overfit, it was more than an order of magnitude worse than the best regex engines on our holdout benchmarks, but also recall that after telling the agent there was a holdout it was doing poorly on, it sped up regex engine performance enough to generally match 2nd tier regex engines in terms of performance, which is still extremely good compared to the general level of performance optimization in most code today), but that's plenty good to achieve reasonable performance on all sorts of problems. This post has generally discussed backend performance issues, but agents don't seem worse at front-end performance if you want to drive down a set of metrics like LCP and CLS. In fact, after inserting the interactive plots I've been using recently into posts, I found that my client-side perf numbers got worse, so I had an LLM spent 1% of my weekly quota optimizing those and the numbers are once again back to being good. This is a very simple site, but people do these kinds of optimizations on fairly complex apps that ship to many millions of users and it also works there, although it does cost a few more tookens.

I still don't think someone is bad and should feel bad if their software has poor performance, but I do think that someone who doesn't know anything about performance and is a reasonable user of LLMs (just in general, not on performance problems in particular) should generally be able to create software that has decent performance. If you just tell an LLM to optimize, it will often do all sorts of incorrect things that are really bad that you have to catch, but that's generally true of using the LLM effectively in the first place, so getting decent performance is no longer a specialized skill.

Appendix: How is codex running ripgrep?

Here's some information about the distribution of riprep queries on my machine. I make no claims that this is at all representative of what's happening anywhere else. The pattern distribution of the length of the pattern that's searched has a lot more long patterns that I would've expected. The p50 is 55 unicode code points (I'll just call these characters for simplicity), which is already longer than things I grep for by hand, and the p90 is 119!

We can also look at the number of alternation arms in regexes, which are once again much more complex than what I do by hand.

Another view is to look at how these are correlated. Do we get more alternation arms in the regexes as the regexes get longer? Yes.

What are these really long regexes, anyway? If we look at them, most of the longest are long alternations over function or tests names, such as the following regex, which appears to be related to FRE development.

  fn (hot_byte_compiler_is_generic_only_and_anonymous_count_uses_auto_count|
  one_pattern_count_spans_uses_the_retained_complete_span_session|
  formal_compact_state_byte_visitors_coexist_with_native_count|
  fixed_boundary_record_visit_matches_line_relative_reference_and_is_atomic|
  unbounded_languages_refuse_finite_extraction_before_allocation|
  formal_single_raw_span_sweep_preflight|
  assert_exact_fixture_uses_formal_large_continuation_sweep|
  url_only_compile_identity_binds_language_and_owner_mode|
  url_only_compile_exact_limits_and_runtime_refusals_close|
  url_only_compile_post_plan_allocation_faults_close|
  url_only_owner_discriminator_is_stable_and_precharged|
  url_only_compile_owner_is_strategy_and_operation_scoped|
  formal_rebar_url_owner_is_compile_only_and_matches_oracle|
  formal_rebar_url_exact_fixture_uses_certified_execution|
  formal_fixed_schema_materialization_matches_both_record_oracles_and_controls|
  formal_single_count_selects_compact_state_byte_complete_bound_visitors|
  authenticated_bound_line_total_lf_free_domain_opportunity_exceeds_five_percent|
  prepared_absolute_onepass_fuses_slots_and_preserves_pre_source_fallback|
  authenticated_word_boundary_russian_compact_lowering_public_canary|
  ordered_nfa_x86_epsilon_edges_bypass_the_assertion_call|
  ordered_nfa_aarch64_epsilon_edges_bypass_the_assertion_call|
  ordered_edge_dispatch_v2_is_target_neutral_deterministic_and_relocation_free|
  ordered_edge_dispatch_v2_copies_canonical_tables_and_cap_falls_back_to_v1|
  ordered_nfa_v3_composes_terminal_range_and_dispatch_without_data_relocations|
  ordered_nfa_x86_terminal_range_emits_authenticated_reverse_scan|
  ordered_nfa_aarch64_terminal_range_emits_authenticated_reverse_scan|
  ordered_nfa_x86_boundary_assertion_cache_is_lazy_and_boundary_scoped|
  ordered_nfa_aarch64_caches_repeated_assertions_once_per_boundary|
  boundary_assertion_cache_requires_dense_exact_kind_reuse|
  boundary_assertion_cache_selection_is_compiler_only_and_deterministic)

But some are funny numerical constructions, such as

:(13[0-9]|14[0-9]|15[0-9]|16[0-9]|17[0-9]|18[0-9]|19[0-9]|20[0-9]|21[0-9]|22[0-9]|23[0-9]|24[0-9]|25[0-9]|26[0-9]|27[0-9]|28[0-9]|29[0-9]|30[0-9]|31[0-9]|32[0-9]|33[0-9]|34[0-9]|35[0-9]|36[0-9]|37[0-9]|38[0-9]|39[0-9]|40[0-9]|41[0-9]|42[0-9]|43[0-9]|44[0-9]|45[0-9]|46[0-9]|47[0-9]|48[0-9]|49[0-9]|50[0-9]|51[0-9]|52[0-9]|53[0-9]|54[0-9]|55[0-9]|56[0-9]|57[0-9]|58[0-9]|59[0-9]|60[0-9]|61[0-9]|62[0-9]|63[0-9]|64[0-9]|65[0-9]|66[0-9]|67[0-9]|68[0-9]|69[0-9]|70[0-9]|71[0-9]|72[0-9]|73[0-9]|74[0-9]|75[0-9]|76[0-9]|77[0-9]|78[0-9]|79[0-9]|80[0-9]|81[0-9]|82[0-9]|83[0-9]|84[0-9]|85[0-9]|86[0-9]|87[0-9]|88[0-9]|89[0-9]|90[0-9]|91[0-9]|92[0-9]|93[0-9]|94[0-9]|95[0-9]|96[0-9]|97[0-9]|98[0-9]|99[0-9])[0-9]:

This is equivalent to :(?:1[3-9]|[2-9][0-9])[0-9]{2}: (which, if run through ripgrep on the original input, has approximately the same performance; the shorter regex is technically a bit faster on the real query data, but only by a very small amount). The entire pipeline for that was

cargo clippy … | rg 'crates/fre-aot-regex/src/module.rs:' | rg NUMBER_REGEX | head -250

which might be an odd thing for a human to do, but agents seem to do this kind of thing all the time.

On another topic, if we look at how long ripgrep queries took, there are quite a few slow queries, e.g., p99 is almost 1 minute! And p999 is almost 10 minutes! And the maximum query over this time period (around a month on one laptop; queries and distributions seem likely to be different on the AWS hosts I run agents on, etc., but I haven't checked) is approaching 2 hours!

In terms of command line options, we see the following. Perhaps unsurprisingly, codex often wants line numbers and, for whatever reason, it very occasionally uses PCRE2 regexes.

I won't add plots or tables for these, but another thing to note is that there's fairly low locality for what patterns are searched for (about 94% of patterns only occurred once), which makes some sense given how long a lot of the queries were. However, there's fairly high locality in what files get searched and a file that got searched is relatively likely to get searched again soon, indicating that (for small enough files), they're likely to be searched in memory.

Also, 99% of queries were regex queries (1% were non-regex string searches) and 99.9% of search queries were ASCII only, but in terms of files searched, approximately 45% were ASCII only and 55% contained Unicode, a higher percentage than I would've guessed for Unicode.

On a draft of the last post, Peter Geoghegan noted

It's also possible for a regex implementation to be faster by supporting fewer features. Some implementations don't support back references, etc.

which is also true here. The workload-specific optimizations done here were fairly superficial because I just gave codex some short instructions and let it do whatever it wanted (which is, in general, not the most effective use of codex), but with a more detailed plan, more focused optimizations supporting the common use cases for my queries could be expected to yield larger gains.

Since early this year, Michael Malis (of pgrust) has been showing me interesting things he's done and saying

[W]e should be more ambitious¹ with the software we build

There is, understandably, a lot of skepticism about projects like pgrust because there are so many low-quality AI-generated projects out there. If I didn't know Malis and didn't look into it, I would just assume that pgrust was another vibe slopped project that's never going to work. But I know Malis well enough to trust his work without looking into it, and if you look into it a bit, you'll see that in testing pgrust, he's testing thoroughly enough that he's even uncovering real bugs in Postgres, such as this numerical bug that can cause valid SP-GiST operations to fail, this format cache bug that can cause incorrect results from JSONPath, this pgcrypto bug that can cause later operations to fail, multiple memory safety bugs in the dictionary loader², this money overflow bug, etc.

This isn't to say that pgrust is bug free³, but it does indicate that there's a substantial amount of testing happening and, even if pgrust itself is never successful, just making the attempt will have improved Postgres in a durable way. The main pitch for pgrust is actually performance, and that's where the really interesting work is happening; if pgrust fails, it's possible that some of the optimizations they've demonstrated will make it into Postgres, Clickhouse, etc., but that's obviously less direct than filing Postgres bugs which get fixed.

That being said, I find it understandable that, every time I see pgrust discussed on a news aggregator, most people dismiss it as vibeslop garbage because almost all of these rewrite projects are slop. If I didn't know Malis, I would make the same assumption, because who has the time to look into all of these projects? Because I know Malis, I didn't bother to look at it; I just trusted him (I only found the above because I wanted to check on pgrust before using it as an example for this post).

As a consumer of software, everywhere you look, there's slow software that the creator is claiming is fast because the creator is touting some slop benchmark, e.g., here's one of multiple examples I saw yesterday, and of course low-quality software that doesn't work is more common than ever.

But, as a builder of software, it doesn't matter that almost all of these projects are vibeslop, that other people are out there shoveling out huge piles of crap and calling it gold. You can build things like pgrust or other projects that would've been too large to really be feasible in the past and, if you do a reasonable job with testing and benchmarking, that stuff can actually be good-enough quality to use.

If I were writing it, I would say "we can be more ambitious with the software we build" and not "we should", but Malis has been casually chatting with me when he's said this, so maybe he would say the same in an actual post; don't read too much into should vs. can here. What's interesting to me is how capabilities have advanced such that we can do a lot more.

Just for example, after hearing that OpenAI was going to use Cerebras for their SOTA models and not just fast-but-low-quality models like 5.3-Codex-Spark, I looked at where time on my computer would go if I was using a SOTA model, but 10x to 100x faster; some things that were already sometimes a bottleneck that would only get worse with a faster model were:

1. Ripgrep
2. Compiling Rust
3. Syscall and filesystem overhead

At the level of a "works for me" project, these are all things that can seriously be improved. I don't have much spare time at the moment but, even so, I built this regex engine that can be tweaked to be faster than other general-purpose regex libraries on any particular workload I care about, this ripgrep fork that uses the native code compiler from the regex engine and is faster for my codex ripgrep workloads (of course a text index is the better solution, but I've already worked on text indexing and this was a "just for fun" project where I wasn't trying to do the optimal thing), and a Rust that sped up builds for my projects (huge improvement for cold builds, moderate for warm, limited by wanting to avoid forking the Rust compiler front-end). For syscalls and filesystem overhead, just switching development from Mac to Linux improved this a lot, and of course this is another thing that can be sped up a lot as well, especially when agents are hammering lots of small filesystem operations (it's not uncommon to see my machine waiting on filesystem ops because the standard OS filesystem interface wasn't designed with modern disk performance in mind). With modern disks, there's no reason to use the *nix filesystem API. In the past, writing a developer toolchain that uses direct I/O instead of normal filessytem operations or building a custom OS or a funny layer that fakes out syscalls would've been an absurd endevaor, but that's totally doable now.

For someone like me who doesn't know anything about regexes, string matching algorithms, compilers, interpreters, etc., this set of projects would've taken a year or more to get to "works for me" quality. Instead, this was a low single-digit number of hours of my time. If I wanted to make any of these things meet a "useful product or open source project" quality bar, that would be a lot more work⁰, but it's still pretty incredible how much this process is sped up.

My read of Malis's meaning when he says “we should be more ambitious with the software we build”, is that it doesn't even occur to people to do these things that are now easy. For weeks, every time I logged into Twitter, I saw someone complain about how Rust compilation is slow and is limiting development velocity (I think this wasn't actually true when I saw the complaints, in that this was before 5.6 Sol and 6 Astra were available on Cerebras, and if you measured where the time actually went, Rust compilation time wasn't actually that much of a bottleneck at the time). Sure, Rust compliation is slow. You can just write a Rust interpreter as well as speed up compilation directly. There are problems like this which I see people complaining about daily that are solvable without a lot of time or effort now. As far as I can tell, these problems are problems because people are implicitly carrying around a pre-agentic cost model. Ten years ago, the kind of person who implemented a new compiler because their compiler was slow was the kind of person who started programming a new 3d game engine when they wanted to make an indie game, i.e., the kind of person who never ships anything. Most productive programmers I know still have an aversion to this kind of thing, even though it is now actually reasonable to implement this kind of thing now⁴.

Another project I previously mentioned was this Azul AI which is superhuman at matched time controls. When I did that (with GPT-5.1/5.2), with zero AI knowledge, it took about 5 hours of my time to get something superhuman, and about 20 hours of my time to become what appeared to be the strongest AI at the time, including being stronger against humans than this AI that was used to cheat on Board Game Arena. Gabriel Cangussu recently built an AI that demolishes my AI, and AFAICT, it took him substantially less time than my AI took me. From talking to him about it, one key difference is that Fable 5.1 and Opus 5.5 have a much better understanding of board game AIs. When I used GPT-5.1/5.2, pretty much every suggestion they had was wrong and I had to do a lot of steering to get things to be remotely reasonable. If I had GPT read a codebase or a paper to implement relevant techniques from the paper, it would fail. If I read the paper myself and named a technique, it would say it did the technique, but it would generally do something that superficially looked like the technique but wasn't the actual technique until I issued some corrections. When the model is that far from being able to do the right thing, if you have no background in the area, it's fairly time consuming to check if the model did the right thing since you have to learn enough about what it's supposed to do to be able to check that it did what was claimed.

When I did that project, I said to friends that I didn't think the state models were in could last. It seemed impossible that they wouldn't get good enough to be able to read a paper and implement the techniques soon, and it seemed like they should also be able to pick out codebases and papers to crib from as well. From my experience messing around a bit with Fable 5 and Cangussu's experience with Fable 5.1 and Opus 5.5, that seems to have happened, which is a huge time saver for someone like me who doesn't know anything about board game AIs (I know a little bit now, but still less than any real AI researcher)⁵.

For any particular domain, like board game AIs, you can say, "who cares? Board game AIs don't matter", but I've found this increase in capability to be true in quite a few different domains. Just for example, I did this toy eval of verification and test techniques with GPT-5.6 Sol implementing zstd on medium and xhigh. I haven't had time to write it up, but when I published that post, I also re-did the evals with GPT-6 Astra. 6 Astra was so good that I had to find different evals because models had advanced too much. For zstd, 6 Astra succeeds at passing all of the registered tests more than 99% of the time across all conditions, even the ones that significantly impair performance, like using TDD (and, BTW, it does it more cheaply as well, taking about $1 to implement zstd). I ended up using the IMAP RFC, which 5.6 Sol couldn't do effectively, and Pandoc, which is a pretty major thing to implement as it needs to be able to read and write many different formats⁶.

BTW, when people have said they used the new model and everything just works, software is solved, etc., I haven't found this to be true at all. It's true that there are a lot more things the newer model can one-shot, where things basically just work, but this just means that I end up working on more ambitious things where models still struggle⁷. I'm more productive and can work faster, but I find that, in terms of what I'm doing, I get farther from "it just works" with each more capable model because the gap between what the model can verify effectively without significant handholding and what the model can implement has been increasing⁸. All of that is a long-winded and less eloquent way of saying: we should be more ambitious with the software we build.

Thanks to Laurence Tratt, Yossi Kreinin, Alex Kolovsky, Max Hawkins, David Turner, and Michael Malis for comments/corrections/discussion.

I haven't even written up this Rust interpreter. If, five years ago, I'd cobbled together a Rust interpreter that got a 50x speedup on cold compiles and 2x on warm/cached builds (with much more being possible if edits to the Rust compiler were in bounds), that would be a super interesting thing that I'd want to write up, but even operating in this mode where I barely edit posts and just blast them out, this isn't interesting enough to write up because it's so easy to do things that would've been considered very interesting not all that long ago.

Appendix: we should be less ambitious with the software we build

Here's a comment from Yossi Kreinin, quoted (with permission, of course):

If you publish this I will publish a response explaining that for most people they should be less ambitious with the software they build with AI or they'll experience abject failure. I think a lot of the problems don't lend themselves that well to "agentic loops" since you don't have clear pass/fail criteria, and even when you do most people have trouble reasoning about giant black boxes which they can impose constraints on but can't understand the innards of [I include myself in this set.] This is a little bit like microservices I guess, where some people both need it and are very good at using it but likely for most people, they need it less and can't use it well at all. I sort of envy the ones who should and actually can be this ambitious about the software they build of course; not saying you shouldn't be more ambitious at all but moderating said ambition is a big part of handling the current situation for most I think

I have a similar thought about "there's no reason for software to be slow" BTW; in many cases, if you use AI to speed up some flow, you will add a bunch of messy code that will be overfit for the use case you tested on and will neither generalize, perf-wise, for all the use cases you should care about, nor will be maintainable upon future changes. If you know what you're doing and you understand how the system should be decomposed into parts and when it makes sense to go all-in on optimizing some part or a combination of them working together and how to properly benchmark it, etc., then things are great, but if for instance you have a manager who thinks there's no reason for software to be slow and he pushes people to use AI to make random parts of the software fast... Run for cover

My feeling is that, overall, the situation here is a bit analogous to the discussion here about why I don't like when people talk about how AI gives a 100x or 1000x productivity increase. There are some things that are sped up by a very large factor, easily over 1000000x. And some things don't currently get sped up at all. If you do exactly what you would've done five years ago, but with AI, the speedup is fairly poor because of Amdahl's law. But, in the general case, you can choose what to speed up and if you're looking for things that are productive to do, this often seems to involve things that were previously too expensive to do.

And, I think that you can often set up systems that have some kind of self-checking property even when most people wouldn't. This discussion of the implementation of Guards of Atlantis 2 is an example of that. It's a poor choice for an AI project because the official rules are a mess of ambiguous and contradictory English text (it's probably the game I've seen humans misplay at the highest rate, and the rules are confusing enough that the designer has often changed their mind about what their own rules mean despite continually maintaining that the rules are perfectly clear and one can play the game by simply reading the rules as written). If you try to produce a working set of rules in a naive way, AI won't really help with this (although it can speed up implementation once you have a clean spec), but for that, I was able to set up some kind of janky set of consistency checks between all of the inconsistent explanations of the game rules, which got fairly close to a correct set of rules (approximately as close as what someone else did with much more human effort and less of a systematic approach), which was enough to compare it to someone else's implementation and get a working set of rules. This setup did cost a lot more in tokens than a more manual approach. But it was "only" a month or two of the $200/mo OpenAI subscription with GPT-5.1/5.2, which is a lower cost than the cost in time of me sitting down and writing a clean spec for the game, i.e., a copy of the rules that is actually consistent and correct.

I feel like a lot of problems are in something like this class of problem, where it's possible to set up some kind of at least partially self-checking setup that a human can spend a small amount of time on. This also feels analogous to the situation about software testing at large, where (before coding agents) I found fuzzing and property-based testing to be highly effective. For most domains, people told me some kind of reason this kind of testing wouldn't work, but when I've tried these techniques with all of the domains people told me these techniques don't work for, they work fine. They're somewhat more work to apply, but they're still applicable and, AFAICT, more efficient and effective than writing traditional unit tests.

Part of the gist of Yossi's comment is that people aren't doing this kind of thing. Considering how many more bugs I see now than I used to, e.g., the last time I opened up the web chat for a big AI lab, I ran into a double-digit number of bugs within one minute, it's hard to say that Yossi is wrong. But, to that point, I still have my original opinion. Just because other people are pumping out vast quantities of barely working slop doesn't mean that you have to do the same thing.

Appendix: a few "random" examples

The examples in the body of the post I gave for things I've done are tooling things I never would've done. There are a lot more things like that as well since it's so easy to build "works for me" quality tooling that's intended solely for me. I do think it's possible to go further than is productive, e.g., Steve Yegge wrote a lot about Gas Town and how productive it was, but when he was building his next agentic framework, he noted that he never used Gas Town to successfully build anything other than Gas Town and here's someone playing his game that's been created with his next gen framework (the commenter's references to $1B are because Yegge says his game is in the running for being the first solo-run billion dollar company), people were into Ralph Loops for a while even though, when I tried comparing them, they seemed worse than just doing the naive thing I was doing at the time, normal loops with context where you sometimes clear context as appropriate instead of doing it by default at the completely arbitrary point of when a single turn is completed, etc., so I've tried to stick to things where the impact is pretty direct. Besides the obvious reason this has been effective, the dramatic change in model and harness capability over time means that what tooling it makes sense to build changes very quickly, so spending a lot of time working on any particular tool that will be suboptimal at best and quite possibly obsolete in three months doesn't really make sense.

And, for a lot of my personal tools, my assumption is that an AI lab will obsolete anything I make in short order. For a very silly example of this, I have a tool that was useful since the release of GPT-5.6 Sol that restarts codex when it finds a memory leak. Presumably, OpenAI will fix this at some point and this tool will become worthless. For a slightly less silly example, take the Rust interpreter I had some agent build. For token-budget reasons, a lot of things that ought to be done for a very high-performance interpreter haven't been done.

For example, the interpreter doesn't modify the actual Rust front-end compiler to make it easy to take updates; performance would be much better if I just made changes to the Rust front-end, but I don't have the token budget to maintain a compatible fork of the Rust compiler, but this shouldn't be a problem for OpenAI. OpenAI committed $10B+ on getting access to Cerebras while also preventing Anthropic from having access.

Funnily enough, for coding, on many tasks, if you actually use one of their SOTA models and compare it to what you get from Anthropic, the actual speedup isn't all that large because of time spent on things like compiling Rust. Given that they were willing to commit $10B+ on this, it stands to reason that they'll eventually do a better job at speeding up the relevant tools than anyone could feasibly do outside an AI lab, so there's not much point in spending too much effort on this (this could arguably be untrue if non-coding tasks are expected to completely dominate future OpenAI revenue in the short term, but even then, given what they pay for tokens vs. what I pay, it still seems like it would make sense for them to speed a lot of these things up given that I could do it outside of a lab; perhaps there's some kind of argument like, if you have access to their usage data, there are so many more important bottlenecks that this one doesn't make sense to prioritize, but it still seems like it should make sense for them at some point even if it doesn't fall into the top 100 bottlenecks for Cerebras-enabled coding agents).

Another kind of thing that one might not call ambitious, but that speaks to the kind of thing that's possible, are games that I've made. There are games I've thought about and wanted to make that I don't think are generally enjoyable enough that they make sense for a real audience, but that I've wanted to play. For example, ever since reading David Gerrold's Star Wolf books in the 90s, I've wanted to play a game that implements combat as described in the books, which is a sort of like submarine combat. At least among realistic war games, this genre is extremely niche because almost everybody finds naval combat boring, and submarine combat is a particularly boring subgenre of naval combat games, so this doesn't really make sense as a money-making game, but it's so easy to implement games that I had an agent implement the game so I could play it for an hour or two. I never would've spent 10-20 hours implementing a game so that I could play it for an hour or two, but I'd spend 5 minutes. I've also previously mentioned implementing a game with the same rules as Scout and Guards of Atlantis 2 and other board games. I was never going to take the time to implement these games by hand just so I have a way to play with my friends on the occasions where we can't get together in-person, but I'm happy to have an LLM bash these things out. And, of course, for people who want to make games with a wider audience, there's a game renaissance going on right now due to coding agents. It's amazing how many interesting and creative games are being made now that having programming skills and the time to put them to use is no longer a bottleneck for making games.

Data analysis is another thing where the productivity multiplier can be very high and I can do all sorts of things I never would've done. As I've mentioned in a number of my last posts, I have way too many of these projects to really be able to write them up, even when attempting to write very quickly and bash out posts in half an hour apiece.

When I've talked to people about their one-off tooling, there's a lot of fun stuff people have done. For example, here's something Peter Geoghegan mentioned a month or two back:

I had Fable implement a custom Neovim Lua function that formats code according to my very specific preferences. This is both something I don't want to maintain myself and inherently a Rube Goldberg device. Theoretically I could accomplish the same outcome in a principled way by patching clang-format, but my requirements are so exact that I think that approach would never be satisfactory.

We use a tool call pgindent, which is our fork of bsd_indent. You can approximate the same formatting rules using clang-format, but that isn't good enough. If I commit something that isn't perfectly formatted/indented according to pgindent, I get a CI failure that I'm expected to fix quickly -- something I'd really prefer to avoid ...

Practically speaking, getting slick, clang-format-style formatting that avoids nag emails about misindented code requires a total architectural mess (I also don't want to spend the time developing a principled approach, but that's really a separate issue). The function allows me to effortlessly format a given block of code from Neovim, similar to the clang-format LSP integration. I'm being unreasonably fussy here, of course, but I find that LLMs allow me to be this exacting about tooling.

The function performs multiple passes: an initial formatting pass using clang-format/clangd, and a separate formatting pass using pgindent. I need it to do both because clang-format handles some cases correctly that pgindent misses. This is brittle because I only want to format the code within a range of lines selected via block visual mode (I don't want to run clang-format on code not added by my patch). This conflicts with pgindent's design; it can only format whole C files.

Figuring out which relevant subset of the temp whole file buffer needs to be copied back into my working buffer is nontrivial. The initial line range I selected doesn't directly map to the affected C AST elements. So the function uses tree-sitter to intelligently delineate the exact subset of the temp indented C code that needs to be copied back. The rules need to be fuzzy in exactly the right way for cases where my selection straddles the same block of code. There are a bunch of edge cases.

Another complicating factor is that pgindent relies on a typedef file generated with objdump to identify types; without that file, the formatting looks wonky. The formatting function dynamically generates any extra typedefs from clangd, for that one file, so I don't have to worry about a stale typedef file (I might have created a new struct seconds before running the formatting tool, I don't want to run objdump on the whole postgres binary each time, that'd blow up latency).

This appears to work perfectly. The latency is totally acceptable. I have only a vague understanding of how all this works, though. I don't even know Lua. This will probably continue to work, even as further changes are made to our fork of bsd_indent that somewhat alter how code is formatted, which happens from time to time.

I'm skeptical of the saaspocalypse. But I do think that LLMs are writing a lot of useful software that would have been insanely uneconomical to write any other way. There's an interesting small subset of software that'd be impossibly tedious for any human to maintain, relative to the value that it creates.

I also caught with Malis while writing this and found out about all sorts of fun stuff he's been doing. It's enough that writing it all up in detail could be its own post, but one fun thing is that, the last time I taked to him about pgrust verification, he mentioned using Kani to verify some parts of the code. He's since switched to Lean and has been using Lean to verify things that are too complex to do in Kani. This would be another topic for another post, but I wonder why people have generally settled on Lean for LLM-driven proofs (as opposed to, say, ACL2). I wonder how Lean would look in an updated version of this theorem prover comparison, or if someone were to run a theorem prover eval that's analogous to this language eval.

Of course, you can think of plenty of examples out of AI labs, such as a mid-sized team Anthropic building an internal replacement for GitHub as well as some other tooling in five months

A team of seven people built both Scion and Antique (our code review tool, which we could easily write a whole other blog post about), not to mention half a dozen related systems, and fully migrated to them in five months.

I think these kinds of examples are interesting and they point to where the industry will be in the not-so-far future, but what you can do with unlimited tokens, while relying on other infrastructure and tooling built with unlimited tokens doesn't tell you much about what you can accomplish today without unlimited funds. Projects like pgrust as well as projects that people I know do in their spare time (of which I've probably mentioned something like 1%—there are just a lot of these, like David Turner creating an ad skipper for podcasts that's "works for me" quality that works better than anything he could find, the spare-time projects Dennis Snell mentioned here, etc.) are more representative of what you can do today.

Трактор John Deere, уехавший в Аргентину, обязан предупредить фермера, что совать руки в этот вал не стоит. Тот же трактор в Индии должен сказать то же самое на хинди или тамильском, во Франции — на французском. И для каждой страны печатается своя наклейка, а переводчик всякий раз рискует перепутать «затянуть» с «отпустить». Генри Дрейфус, проектировавший эти тракторы, предложил нарисовать одну картинку для всех. Со временем экономия на наклейках разрослась до картотеки в двадцать тысяч знаков, «Справочника символов» 1972 года и мечты о языке, который понимают без переводчика от Аргентины до Финляндии.

Человечество выучило из этого словаря десяток ходовых слов вроде стрелки, кнопки питания и человечка на двери туалета и на этом успокоилось. Полвека спустя словарь снова понадобился, и теперь листать его будет машина. ИИ научился собирать интерфейс под каждый запрос, и пользователь всякий раз видит экран, которого минуту назад не существовало. Мы разберем, что прижилось из словаря Дрейфуса, где он поторопился и почему его старая картотека подозрительно напоминает техническое задание для генеративных интерфейсов.

Andrew Woosnam took millions from his recruitment firms before creditors, including HMRC, were left out of pocket

• Companies revived in ‘phoenix’ deals more likely to fail, study finds
  

For three decades, the recruitment industry treated Andrew Woosnam well.

Having learned his trade during the 1990s, he graduated to create his own firm at the turn of the millennium – which allowed him to bank millions of pounds in salary, dividends and loans and to buy assets including a grand house in Berkshire once owned by the comedians Dawn French and Lenny Henry.

Exclusive: research for the Guardian shows ‘pre-pack’ deals with former management also pay far less to creditors

• The boss whose twice-bust business appears to be back

Insolvent businesses reacquired by their previous management in “pre-pack” administrations are much more likely to fail again and tend to repay far less to creditors, research for the Guardian suggests.

The study is the latest to raise questions about the practice of “phoenixism” – accounting’s controversial art of liquidating companies to allow directors to return with a new entity, free of debts.

Teesside town has come out worst in children’s commissioner’s report, but residents say such rankings are demoralising and counterproductive

“It’s disappointing, it’s just another kicking,” said a youth worker after the town in which they work was labelled as the hardest place in which to be a child in England.

“It suggests our children are living unhappy lives,” said a teacher, who described her pupils as joyful.

The comedian unashamedly loves the Spice Girls’ Wannabe and cries to Boyz II Men, but which novelty song changed her life?

The first song I fell in love with
My mother would sing and dance and cook and clean in the kitchen, as many 80s moms did, to divas like Madonna and Paula Abdul. Material Girl made me think: “This is who I want to be.”

The first single I bought
I bought three records at the same time – Jagged Little Pill by Alanis Morissette, a Sheryl Crow single and Waterfalls by TLC – from Sam the Record Man in Sarnia, Ontario, with money I’d saved up from doing chores around the house. My uncle was always trying to influence me with Canadian music, and he wasn’t wrong for doing so.

In a sign of the potentially dire midterm political environment, Republicans have spent millions of dollars playing defense in Arkansas, one of the most conservative states in the country.

(Image credit: Stephen Fowler/NPR)

As they look to win the Senate, Democrats are hoping that independent candidates in Nebraska and Montana can help them topple Republicans in a part of the country where their own brand is hurting.

(Image credit: Austin Johnson)

The U.S. has no national law for paid parental leave. But in states that do, more dads are using the benefit, sometimes more than moms. The change comes as Americans say having kids is unaffordable.

(Image credit: Dania Maxwell for NPR)

Моя точка доступа TP-Link EAP770 v1 портачит загрузки по Wi-Fi, а производитель прекратил обслуживание этой модели ещё до того, как я вообще достал её из коробки. Решение проблемы — прописать два нуля в sysfs. Вот только фирменная командная оболочка TP-Link не даёт этого сделать, и мне пришлось писать эксплойт для своего же @#$%&! устройства.

Хотел просто набрать грибов на выходных, а в итоге натравил машинное обучение на тайгу и сжег 15 часов облачных серверов, уперся в трехметровые заборы непростых объектов и собрали карту боровиковых мест всей Ленобласти. Очередная история о том, как пет-проект зашел слишком далеко.

Помогает ли способ оценки шумных измерений принимать полезные изменения кода при одинаковых ролях, задачах и лимитах?

Разбираю фильтр Калмана на простой учебной модели: как он соединяет прогноз и отзыв критика, чем отличается от регулятора и что происходит при коррелированных ошибках, выбросах и задержках.

Затем проверяю четыре правила принятия правок в реальном цикле «автор — критик». Пилот завершён: 720 ответов модели, из них 144 для калибровки и 576 для оценки на шести задачах оптимизации Python-кода.

В симуляции фильтр улучшил оценку состояния и уменьшил величину правок. В реальном пилоте все четыре режима достигли критерия успеха, а дополнительного преимущества Калмана обнаружить не удалось.

К статье приложены ноутбук, исходники, результаты, графики и описание ограничений, а также готовый пакет для собственного эксперимента с агентами через OpenAI API — с инструкцией, калибровкой, паузой и возобновлением.

Предлагаю всем желающим заняться исследованием, на каких реальных задачах рой ИИ-агентов, использующий фильтр Калмана, лучше или хуже обычного роя ИИ-агентов.

Лет семь назад я собирал домашнюю автоматику примерно на 20 тысяч рублей: датчики влажности, CO₂, движения, розетки, реле. С ESP и Tuya простые команды по локальной сети получались, а вот таймеры и согласование нескольких устройств иногда жили своей жизнью. Хотелось меньше возиться с бытом, а не поменять класс проблем.

С тех пор Home Assistant, Zigbee2MQTT, ESPHome и локальный голос стали куда привычнее. Когда я принёс в IT‑чат первую статью о независимом умном доме, мне об этом напомнили. Дошло до торжественного: «Дамы и господа, мы придумали SprutHub». И ведь справедливо.

Для тех, кто не собирал умный дом: датчик сообщает о событии, шлюз или интеграция передаёт его системе вроде Home Assistant, та запускает сценарий. Иногда в эту цепочку вклинивается облако производителя. И вот тут начинаются приключения.

В октябре 2026-го после повреждения инфраструктуры «Яндекса» перебои затронули «Алису» и часть умного дома. Не значит, что у всех застряли шторы. Но почему команда мотору в соседней комнате вообще должна лететь через чужой сервер? Belkin отключила облачную поддержку части Wemo: устройства, заранее настроенные с HomeKit, могли продолжить работать, а вот новая настройка стала проблемой. Для контраста: во время сбоя Netatmo ручное управление и запись данных сохранились. Хотелось бы знать заранее, какой сценарий ждёт купленную железку.

Но даже полностью локальный дом иногда ломается. Просто теперь дежурный сисадмин — его хозяин. В одном чате человек рассказал, как автоматизация HA попыталась включить осушитель Midea 3407 раз за два часа. Помог перезапуск интеграции. У другого реле исчезло из базы Zigbee2MQTT, но продолжало отправлять сообщения. Пришлось поработать Шерлоком Холмсом. А одна рекомендация ИИ по перезапуску Chromium, по оценке владельца, закончилась 1,86 ТБ записи на SSD за выходные. И после этого мне хотелось бы слышать не только «исправлено», но и «проверил, что больше не ломается».

Среди 377 результатов, о которых OpenAI объявила 6 октября 2026 года, один особенно выделялся. Компания заявила, что ей удалось доказать «квазигипотезу Римана», более слабую версию гипотезы Римана, которую можно назвать важнейшей нерешённой проблемой математики. Новое доказательство, по словам Джареда Дьюкера Лихтмана из Стэнфордского университета, стало «самым значительным на сегодняшний день достижением ИИ в математике, причём с большим отрывом».

Гипотеза Римана остаётся нерешённой уже более 160 лет. Её доказательство позволило бы математикам лучше понять природу простых чисел, одного из важнейших строительных блоков математики. И это только для начала.

Даже последствия более ограниченного результата, касающегося квазигипотезы Римана, «ошеломляют», заявил Максим Радзивилл из Нью‑Йоркского университета. «В некотором смысле подавляющее большинство следствий гипотезы Римана уже вытекает из квазигипотезы Римана».

Более того, вопреки давним ожиданиям математиков, для доказательства не потребовалось вводить никаких новых понятий. Вместо этого удалось обнаружить скрытые связи между уже известными. «Это доказательство представляет собой неожиданное объединение хорошо известных идей», — сказал Александр Данн из Технологического института Джорджии.

Доказательство частично опирается на методы, разработанные Радзивиллом и Данном. Вместе с другими специалистами по теории чисел они пытаются разобраться в доказательстве и понять, что оно может означать. Теперь они начинают получать ответы.

Сегодня мы, Homo Sapiens Sapiens успешно держим лидерство эволюционной гонки. Конкуренты остались в истории. Ближайшие генетические «братья», шимпанзе и карликовые шимпанзе. Но если они самые близкие наши генетические родственники, то почему их интеллект так отстает от нашего? И какую роль в этом играет ретровирусная инфекция?

Я занимаюсь разработкой встраиваемых систем уже несколько лет и не раз сталкивался с проблемой, когда было необходимо написать UART драйвер или систему для работы с каким-либо внешним модулем, используя текстовый протокол, будь то протокол AT-команд или что-то подобное. Чаще всего это модули GNSS, модуль GSM, ESP или т.п. Набор управляющих команд для таких модулей бесконечно огромен, и каждая из них часто требует отдельной обработки. Итогом получается нужно писать свой обработчик и парсер под каждую команду, через колбэки или некую машину состояний их последовательно вызывать и пытаться как-то организовать цепочку выполнения, а про обработку ошибок я вообще молчу.

Да, существуют библиотеки и готовые решения в рамках какой-либо операционной системы или набора SDK под конкретный чип. Но что делать, когда на столе лежит микроконтроллер с 20кб свободной RAM, где тебе надо не только команды эти обрабатывать, но еще и весь остальной функционал устройства реализовывать? Нужно что-то универсальное, независимое от платформы.....

У меня очень давно в «идеях» лежала запись о том, что нужно создать браузер, который предназначен исключительно для чтения. Каждый раз я вспоминал о ней, когда натыкался на очередной сайт, где контент сложно прочитать из-за отвратительной вёрстки или обилия рекламы. И вот время настало: недельный лимит токенов не был израсходован, и мы с товарищем Клодом напряглись и создали браузер для чтения Brevier. Тот факт, что я уже много лет занимаюсь фронтенд-разработкой, дал свои плоды — я решил сделать браузер без JavaScript и без CSS.

Пролог

Когда-то интернет был тихой ламповой библиотекой. Каждая страница была свитком-папирусом. Вы брали нужный свиток, разворачивали и читали. Учёные мужи бережно писали эти свитки, любопытные читали, и никто не был обязан брать печенье для входа в библиотеку.

Худые стороны у этой библиотеки тоже имелись. Свитки было сложно читать: они были написаны разными почерками, разного качества чернилами и совершенно непредсказуемых цветов. Деды помнят, что даже видели свитки, написанные ярко-зелёными чернилами на фиолетовом папирусе. В любом случае, текст присутствовал, и если желание было, то его можно было прочесть.

Затем появились драконы.

Я долго думал как назвать статью, но выбрал именно такое название, модное, а может уже и сильно надоевшее с приставкой AI. Уже понятно, что речь пойдет про нейронки, но при чем тут Морзе? Сейчас расскажу!

Ни для кого не секрет, что азбука Морзе используется буквально везде где требуется передать данные на большие расстояния через бури и штормы, через шум грозы, через ... в общем хоть ложкой по батарее. Морзянка, спасала жизни, помогала найти затерянные суда и самолеты. Даже сейчас, для капитана судна, или пилота самолета знание азбуки Морзе это требование, которое продиктовано безопасностью в крайней ситуации.

Но что если взять и натренировать свою сеть, для распознавания 16 каналов Морзе с наихудшего радиоэфира, да еще и так что бы это работало на любом айфоне с микрофона?

Я руковожу разработкой, а дома отец большой семьи. Последние месяцы эти две жизни сошлись в одном инструменте, и это оказалось неожиданно удобно.

В YouGile у меня хранятся задачи по разным проектам, и к ним по MCP подключены разные агенты: аналитик и агенты из команды разработки. Они берут задачи прямо из досок и отчитываются там же.

Дети - они как маленькие агенты и их тоже нужно фокусировать

• Updates as the Kangaroos and Fiji Bati meet at Suncorp Stadium

• Any thoughts? Get in touch with an email

Tonight’s referee is NRL veteran Gerard Sutton.

A quick reminder about the 2026 men’s Rugby League World Cup format.

The 2026 men’s RLWC features ten teams. Eight of these qualified via their performances at the last world cup, back in 2022. That is: Australia, New Zealand, England, Samoa, Tonga, Fiji, PNG, and Lebanon. The first seven countries in that list also happen to be the top seven on the IRL rankings; Lebanon are a lowly 23rd.

The remaining qualifiers, France and Cook Islands, won regional playoffs. Cook Islands are ranked eighth in the world, by the way, France recently held that position but have slipped to 11th. In other words, the cream of the crop will be on display.

The tournament will be played under NRL rules, including six players on the interchange bench with up to four to be used.

The ten teams have been distributed into three pools.

Pool A contains Australia, New Zealand, Fiji, and Cook Islands. The top two from this group qualify for the semi-finals.

The teams in Pool B (England, Samoa, Lebanon) play the teams in Pool C (Tonga, PNG, France) with the top two on a combined group table qualifying for the semi-finals.

The winner of Pool A takes on the runner-up from Pool B&C in Sydney.

The winner of Pool B&C takes on the runner-up from Pool A in Newcastle.

The world cup final is in Brisbane on 15 November.

The group phase will take place over three weekends.

The fourth weekend will feature the semi-finals, with the final wrapping up proceedings the following Sunday.

10 locations will host matches. Eight of these are in Australia: Sydney (Allianz Arena), Sydney (Commbank Arena), Brisbane, Newcastle, Gold Coast, Townsville, Wollongong, and Perth; while Port Moresby will host two Papua New Guinea matches, and Christchurch will stage one New Zealand fixture.

Reality TV show returns to focus on childbirth, diversity and the sharing of stories in a social media age

When One Born Every Minute first aired in 2010, viewers loved its fly-on-the-wall take on life in a maternity unit, from midwives idly chatting about unusual pregnancy cravings to parents squabbling over whether to call their child Zeus.

Almost two decades later, as the show is rebooted for a generation who spend their lives on social media, much has changed. Parents now share far more about their struggles with miscarriages, infertility and mental health; audiences have to be lured away from watching reels on their phones with more rigorous storytelling.

The torture of the inbox is made insufferably worse by the dated cliches at the beginning and end. Enough!

If email were a person, it would be an adult dressed in a teenager’s clothes, desperately trying to stay relevant. Despite being 55 years old and having been surpassed by numerous developments in communication technologies, its functionality remains largely the same as when it was first widely adopted. Unfortunately, so does the etiquette surrounding it.

Whereas other forms of communication have long since dispensed with unnecessary textual tassels, email communication styles still lean closer to telegram than a text. Since I last checked, almost no one relishes receiving a new email – unless it’s informing you of a significant cash windfall that means you can, in fact, now quit your job and stop using it altogether. Yet, for some reason, many people start their responses with “Thank you for your email!” I would put this forward as one of the least convincing sentences in the English language.

Tom Gill is a freelance journalist and consultant from London, based in Melbourne

Home side broke the game open with some unique corner routines, but a goalkeeping error ruined the plan

There was an odd interlude at Stamford Bridge with 76 minutes gone and the score still 0-0, one of those moments where suddenly your brain seems to be on inside out, like trying to walk the wrong way down an escalator.

Tottenham had a corner on the left-hand side, in a game that had felt to that point like an extended practice session, a refinement of systems, the football equivalent of watching two middle-aged men methodically emptying the dishwasher, adding salt, descaling the hoses, tutting over knives incorrectly slotted, cups in the wrong row.

Matthews’ family ‘very excited’ as London Palladium hosts event 70 years after first award at Blackpool town hall

When football’s dignitaries assemble on Monday at the London Palladium for the Ballon d’Or ceremony it will be a far cry from the first awards 70 years ago. That was held in the slightly less glamorous surroundings of Blackpool town hall, where Stanley Matthews was presented with the prize by Gabriel Hanot, the visionary editor of L’Équipe who came up with the idea of crowning the world’s best player every year.

A specially commissioned china plate was also handed over by the town’s mayor before the 41-year-old Matthews, who was famously teetotal, gave a short speech. “He might have had a double carrot juice that day,” says his son, Stanley Matthews Jr, who will attend this year’s awards with his sister, Jean, and her two daughters. “There was no ceremony. ‘Here’s your Ballon d’Or, well done’, sort of thing. But obviously it’s grown over the years, and now it’s a huge event. We’re very excited.”

⚽️ News before the 2pm GMT Premier League fixtures
⚽️ How they stand | Fixtures | Mail John

Aintree Racecourse has confirmed today’s race meeting has been cancelled due to high winds. Will that mean Liverpool v Brighton is called off?

The Met Office has issued a yellow weather warning for wind in Liverpool and Merseyside due to Storm Boelo, which remains active through today until 9:00 PM on Sunday, October 25, 2026

Incumbent president lost in first round to senator and son of convicted ex-president

Brazilians are going to the polls on Sunday in a highly unpredictable runoff in which the leftist president, Luiz Inácio Lula da Silva, is attempting an unprecedented comeback against the far-right senator Flávio Bolsonaro, who won the first-round vote.

Bolsonaro’s surprise victory despite not leading most polls made him the favourite three weeks ago, but since then Lula’s campaign has gained ground, and the two go into the contest virtually tied.

Incumbent president lost in first round to senator and son of convicted ex-president

Brazilians are going to the polls on Sunday in a highly unpredictable runoff in which the leftist president, Luiz Inácio Lula da Silva, is attempting an unprecedented comeback against the far-right senator Flávio Bolsonaro, who won the first-round vote.

Bolsonaro’s surprise victory despite not leading most polls made him the favourite three weeks ago, but since then Lula’s campaign has gained ground, and the two go into the contest virtually tied.

Путь к файлу тот же, текст обновился, но процесс с открытым дескриптором продолжает читать старую версию. На небольшом Linux-стенде сравнил cp, sed -i и замену через временный файл: права доступа, inode и поведение читателя.

Сегодня супер-юбилей для всей ИТ-отрасли: 25 октября 2026 г. исполняется 25 лет старту продаж Windows XP. В продажу англоязычная версия поступила в этот день в 2001 году, а еще 24 августа сборка 2600 ушла в производство (версия RTM, Release to Market). Microsoft вместе с Intel и другими производителями ПК потратила на продвижение Windows XP не менее миллиарда долларов. Первоначальный англоязычный слоган “Prepare to Fly” после событий 11 сентября заменили на “Yes You Can”. Кстати, на коробках с Windows XP этого слогана не было, только в маркетинговой кампании.

15 октября вышла Ubuntu 26.10 Stonking Stingray. В новом выпуске много чего интересного: разработчики обновили рабочий стол GNOME, ядро Linux, проапдейтили или добавили системные утилиты и средства защиты. Появились нескучные обои интересные настройки экранов и окон, обновился App Center, а в систему добавили предварительную версию голосового ввода Myna. 

Вместе с выпуском Canonical представила планы развития Ubuntu до следующей LTS-версии — 28.04. Сначала разберем обновления нынешнего выпуска, а затем посмотрим, что разработчики готовят на будущее.

В этом дайджесте Metal без магии и лечение телевизоров, Suspend на пальцах и Warcraft II на «Авроре», ИИ для расшифровки языка растений, крупнейшее изменение Xcode за 30 лет, как устроен IDL, отказ от «ненастоящих» градиентов и многое другое. Заходите!

Exclusive: Wastewater analysis in England suggests people took roughly 2.5bn lines of drug in one year

• Ageing users and record deaths – the data behind Britain’s £9.8bn-a-year cocaine habit

• Pubs, festivals and workplaces: how cocaine has become an everyday habit

British police are recording a growing number of crimes linked to cocaine, including assaults, domestic abuse and dangerous driving, as figures show consumption has surged across England.

A Guardian investigation has found police forces across Britain recorded a 10% rise in crime rates associated with the class A drug since 2019, while the Home Office estimates cocaine usage at sites across England has risen by 26% since 2021.