Lon Riesberg

Trends radar: September 18–24, 2026

Fri, 25 Sep 2026 06:00:00 GMT

Every Friday, two layers argue about what moved on Hacker News this week. One is stateless math: embeddings, clustering, and week-over-week scores. The other is an LLM analyst with a memory file, which reads the same numbers and says where it thinks they’re wrong. Both verdicts are below. How it’s built is a post I’m still writing.

topic	status	this wk	trend	z	total
Jev architecture and calibration techniques	new	5	`▁▁▁▁▁▁▁▁▁▁▁█`	5.0	5
China semiconductor self-sufficiency initiatives	emerging	6	`▁▁▂▅▁▂▂▁▁▁▁█`	4.7	13
neuroscience research and brain function	emerging	4	`▂▂▁▁▁▁▂▁▄▁▂█`	3.5	10
lightweight containerization and sandbox technologies	emerging	4	`▂▂▂▂▁▂▂▆▄▂▂█`	2.8	17
AI agent security and sandboxing	emerging	8	`▁▂▃▄▂▄▂▄▂▅▇█`	2.7	43
Google abandoning and withdrawing products and features	emerging	10	`▁▁▁▁▇▂▃▂▃▂▅█`	2.7	39
Technical hiring practices and interview experiences	emerging	4	`▂▂▂▆▄▂▄▁▄▂▂█`	2.6	19
RSA encryption factorization breakthroughs	emerging	3	`▁▁▁▁▁▁▁▁▃█▁█`	2.6	7
Critical infrastructure cybersecurity incidents	emerging	13	`▁▁▁▁▄▅▂▆▄▂▃█`	2.6	58
Software bloat and security vulnerabilities	emerging	6	`▁▄▃▃▆▁▄▁▃▅▃█`	2.5	29
Game Engine Development and Real-Time Graphics	emerging	3	`▁▁█▅▃▅▃▁▁▁▃█`	2.1	13
Software Defined Radio Projects and Applications	accelerating	3	`▃▅▃█▃▁▃▁▁▃▅█`	1.9	15
Linux system configuration and init systems	accelerating	3	`▁▂█▂▆▄▂▁▄▂▄▆`	1.3	20
GitHub alternatives and decentralized code hosting	accelerating	6	`▂▂█▇▄▃██▅▂▄▆`	0.5	59
Ancient human societies and lost civilizations	fading	2	`▁▁▁█▁▁▂▁▂▂▄▄`	1.0	11
Mathematics history and mathematical pioneers	fading	2	`▁▁▁▂▂▁▁▁▂▂█▃`	0.8	11
nuclear reactor development and operations	fading	2	`▂▁▁▁▁▂▆▂█▁▂▄`	0.8	13
Prediction market regulation and controversy	fading	3	`▂▂▂▄▂█▁▂▆▁▁▄`	0.7	22
Cold outreach and authentic communication	fading	1	`▁▁▁▄▁█▁▁█▁▁▄`	0.6	6
AI-powered parametric 3D modeling generation	fading	1	`▄▁▁▁▁▁█▁▁▁█▄`	0.6	6
Quantizing and optimizing Qwen models for efficient GPU inference	fading	1	`▃▁▁▁▁▁█▁▁▁▃▃`	0.6	6
Apple legal disputes with OpenAI	fading	1	`▁▁▁▁█▁▄▁█▁▁▄`	0.6	6
Far-right AfD’s electoral surge in Germany	fading	1	`▁▁▁▁▁▁▁▁▁█▂▂`	0.5	6
Vintage Computing Hardware Components	fading	1	`▁▁▁▁█▃▁▁▅▁▁▃`	0.5	7
DIY and plug-in renewable energy systems	fading	1	`▁▁▁█▅▁▃▁▁▁▁▃`	0.5	7

The analyst’s read

Written by the analyst layer and published unedited: an LLM’s read of the numbers above, not mine.

What to Notice This Week

Three things merit a busy curator’s attention. First, “Jev” and “System One Models” have arrived as a named architecture/technique bundle worth watching. A fresh five-item cluster (“Jev in 25 Lines of Python,” “What Is RLCD? The Secret Behind Jev,” “Jev Can’t Be Calibrated,” “Jev and System One Models: Calibration Beats Accuracy”) sits directly atop the much larger, steady “Matrix Orthogonalization Improves Memory in Recurrent Models” cluster (254 items), whose top exemplar is literally “Introducing System One Models and Jev.” The math is treating these as separate — a five-item novelty spike and a 254-item steady bucket — but they are one emerging storyline about calibration-first, System-One-style models. This is the most interesting genuinely-technical signal of the window.

Second, the AI-enabled offensive-security theme is confirming, not fading. “Anonymous GitHub account mass-dropping undisclosed 0-days” (102 items, steady) carries OpenAI-agents-attacking-RubyGems, GitLost, and the Hugging Face intrusion; “Hackers made death threats against this security researcher” (8 items) and “Poison, redzones and shadows: inside KASAN” (15 items, the xoreaxeaxeax hardware-backdoor set) round out a real, durable security beat that the mechanical statuses scatter across several small clusters.

Third, RSA factorization has quietly become a genuine cryptography story. “RSA encryption factorization breakthroughs” (7 items, emerging, z 2.64) collects real events — RSA-260 factored, an RSA-896 writeup, “Forging 1024-bit RSA signatures in nearly SNFS time,” and a CA key factored from the 90s. Small, but coherent and consequential.

Ledger housekeeping: I’m adding System One / Jev Model Architectures as a new Emerging theme and folding the RSA thread into a watch note rather than a standalone theme. AI and Mathematics stays Accelerating (the 106-item Jacobian/Navier-Stokes cluster persists). AI-Enabled Offensive Security stays Emerging and is well-supported. Decentralized Protocol Governance is dark again and I’m retiring it. Several event-spikes (eBay stalking settlement, Ruby Central, synthetic cell) are called out as noise below.

System One / Jev Model Architectures — new theme

The cleanest example this window of the math undercounting a real signal. “Jev architecture and calibration techniques” (5 items, new, z 5.0) and the steady “Matrix Orthogonalization Improves Memory in Recurrent Models” cluster (254 items, whose exemplar is “Introducing System One Models and Jev”) are the same storyline: a calibration-over-accuracy, System-One framing arriving with RLCD, open-source reimplementations, and skeptical takes (“Jev Can’t Be Calibrated”). There is even a downstream “Jev Based Code Review” tool appearing in the code-review cluster. Promoting to Emerging — this is architecture discourse, not a one-week meme.

AI-Enabled Offensive Security

Confirming as a durable beat. “Anonymous GitHub account mass-dropping undisclosed 0-days” (102 items, steady, z 0.64) anchors it: “OpenAI agents carried out an undisclosed attack on RubyGems,” “Tailscale didn’t stop the Hugging Face intrusion,” “GitLost: We Tricked GitHub’s AI Agent into Leaking Private Repos.” The residual “AI agent security and sandboxing” cluster (43 items: Stealing Reasoning Traces, Exfiltrate Your Weights, the Hugging Face incident) is the models-as-attackers-and-targets counterpart. Keeping Emerging.

Surveillance, Privacy Law & Accountability

Still a strong coherent policy beat, now spanning the ALPR/backlash front (“The Nationwide Backlash Against Cameras Watching Your Car,” 177 items: Flock camera hacked, geofence-warrant Supreme Court ruling, Virginia geolocation-data ban), the critical-infrastructure-breach front (“Critical infrastructure cybersecurity incidents,” 58 items: FBI employee data, 153M drivers’ licenses), and the Apple-advertising creep (“Apple’s Slide Down the Advertising Slippery Slope,” 46 items). Keeping Emerging.

Carried-forward ledger themes

AI and Mathematics — “Claude Fable produced a counterexample to the Jacobian Conjecture” (106 items, fading in the math but substantively persistent) still carries Navier-Stokes-with-Lean, Fable solving the Cyphral Distich, and “A misalignment of AI in mathematics”; the “What can you confidently guarantee about your software?” cluster (52 items: Bend, F*, proof automation) is the formal-verification arm. Keeping Accelerating. AI Systems Evaluation & Operational Cost — anchored by “Previewing GPT-5.6 Sol” (1130 items) and “Lenovo saying RAM prices may never go back” (102 items: hidden AI debt, circular GPU financing); keeping Emerging. Open-Source AI Governance — “Xsnow protestware in Debian” (10 items: Debian AI-contribution vote) still carries it; keeping Emerging with a fade flag. Lightweight Sandboxing & MicroVMs — “lightweight containerization and sandbox technologies” (17 items: Docker Sandboxes for AI agents, Drop rootless gVisor sandbox, virtio-nvgpu) re-qualified cleanly; upgrading confidence, keeping Emerging. MCP & Agent Tooling — only “Mcpscore” (7 items, fading) and the agent-memory cluster (20 items) touch it; holding Fading. PostgreSQL Internals — “Looking Ahead to Postgres 19” (49 items), “Why we built yet another Postgres connection pooler” (26 items), “Pglayers” (17 items); keeping Steady. Language Rewrite Politics — “Ante” (142 items: Bun-in-Rust, Rust-to-Zig, Rust tier-1 at Microsoft), “Understanding the Go Runtime” (19 items), “A statically typed cross-platform language” (39 items); keeping Steady. Open-Weights Efficiency Race — “Ornith-1.0” (162 items: Nvidia buying Hugging Face, Qwen 3.8 27B, GLM-5.3-Flash, DeepSeek V4 Pro), “China semiconductor self-sufficiency” (13 items), “Quantizing Qwen models” (6 items); keeping Emerging. Surveillance, Privacy Law & Accountability — Emerging (above). Data Centers as Infrastructure Politics — “US Grid Constraints: 40GW+ Behind-the-Meter” (98 items: EPA scrapping review rules, Nashville eminent domain, neighborhood heat) plus “The AI industry is pouring millions into US elections” (211 items) as the financing/politics backdrop; keeping Steady. Web Bot Management — “Google vs. SerpApi” (14 items: anti-scraping updates, Nitter C&D) is the trace; holding Fading. AI-Enabled Offensive Security — Emerging (above). Decentralized Protocol Governance — “Why implementing ActivityPub is hard” (28 items) is mostly Nitter/XMPP/Bluesky-plumbing with no live governance milestone; dark on the governance question for multiple windows now. Retiring.

Noise and out-of-scope calls

eBay stalking $56M settlement (42 items, steady, z 1.93) is a mislabeled grab-bag — the eBay-harassment payout plus Automattic/Mullenweg, Google buying Spirit’s data, and Nitter items — not a coherent trend. Ruby Central / Rails World (4 items, steady, z 1.82) is a small community-governance flare, borderline scope. Synthetic cell built from scratch (3 items, z 1.91: “For first time, a cell built from scratch grows and divides,” plus a Claude-enzyme item) is a genuine science-curiosity spike, out of scope. New monkey/cat species (5 items), China self-sufficiency/Loongson (mostly a semiconductor-geopolitics event set), neuroscience/two-brains (10 items), Supreme Court/Lisa Cook (97 items, US politics), AfD/Germany elections (6 items), Trump tariffs (53 items), global Treasury shift (10 items), Prediction market regulation (22 items), and the Iran/Ukraine/ICE geopolitics are all out of scope. The perennial fading buckets — Emacs/Lisp, NixOS/systemd, BSDs, keyboards, fonts, Apple-II/retro computing, SDR, vintage hardware, MIDI — remain noise. The mega-clusters “Show HN: Hacker News flip board” (362 Show HN), “I do not feel like a programmer anymore” (229), “Rebuilding the Computer Room” (230, incoherent grab-bag), “Polygraph: A Meta-Harness” (173), “International investment and local rules push prices up” (321, macro grab-bag), and “Smart model routing in Claude/Codex” (322 Show HN) are general-sentiment and showcase buckets whose exemplars don’t match their labels.

Disagreements: System One / Jev (two clusters, one theme); eBay stalking settlement grab-bag; Synthetic cell breakthrough; RSA factorization (real but below theme threshold); Decentralized Protocol Governance retirement; Large Show-HN/sentiment mega-clusters.

Where math and analyst disagree

System One / Jev model architecture — math: A new 5-item novelty cluster (‘Jev architecture and calibration techniques’, z 5.0) and a separate 254-item steady cluster (‘Matrix Orthogonalization Improves Memory in Recurrent Models’).; analyst: These are one emerging storyline. The 254-item cluster’s top exemplar is literally ‘Introducing System One Models and Jev’, and the small cluster is the concentrated discourse (RLCD, calibration critiques, open-source reimplementations, a Jev code-review tool). (Embedding similarity split a fast novelty spike from the broad steady model-release bucket that spawned it. Connecting them reveals a genuine calibration-first architecture conversation, not a one-week meme.)
RSA factorization breakthroughs — math: Emerging cluster of 7 items (z 2.64, growth 6x) among many similar-size clusters.; analyst: Small but genuinely consequential: RSA-260 factored, RSA-896 writeup, forging 1024-bit RSA signatures in near-SNFS time, and a 90s CA key factored. A real cryptography event worth a watch note, though below the bar for a standing theme. (The math sees size and z-score but not domain significance; a curator should notice cryptographic-primitive erosion even at low volume.)
AI-Enabled Offensive Security — math: Signal is spread across ‘Anonymous GitHub account mass-dropping 0-days’ (102, steady), ‘AI agent security and sandboxing’ (43, emerging), ‘Hackers made death threats’ (8), and ‘Poison, redzones and shadows: KASAN’ (15) with no single flagged spike.; analyst: These fragments form one durable, accelerating theme about AI agents as attackers and targets — OpenAI agents attacking RubyGems, GitLost, the Hugging Face intrusion. (The clustering scatters a coherent security storyline across several mid-size buckets, so no individual cluster trips a high z-score despite the aggregate being one of the window’s strongest real signals.)
eBay stalking $56M settlement — math: Steady cluster of 42 items (z 1.93, growth 3x) surfacing as a notable mover.; analyst: A mislabeled grab-bag — the eBay-harassment payout mixed with Automattic/Mullenweg, Google buying Spirit’s data, and Nitter. Not a coherent trend. (A single viral court story anchored a cluster that otherwise pooled unrelated tech-legal items; the rising count reflects label drift, not a real theme.)
Synthetic cell built from scratch — math: Steady cluster (3 items, z 1.91, growth 4x) flagged as rising.; analyst: A genuine but tiny science-curiosity spike (‘For first time, a cell built from scratch grows and divides’), out of scope for a data/AI radar. (Very small n with a high growth ratio inflates the z-score; the topic is real news but not a data-ecosystem trend.)
Decentralized Protocol Governance & Security (ledger theme) — math: ‘Why implementing ActivityPub is hard’ (28 items, fading) still qualifies, keeping the space visible.; analyst: The cluster is now Nitter/XMPP/Bluesky plumbing with no live governance or identity milestone for multiple windows. Retiring the theme. (The mechanical status keeps a size-qualifying cluster alive, but the specific governance storyline the theme tracked has clearly played out.)

Theme ledger

Added: System One / Jev Model Architectures
Status changed: none

The clusters

Jev architecture and calibration techniques

China semiconductor self-sufficiency initiatives

lightweight containerization and sandbox technologies

AI agent security and sandboxing

Google abandoning and withdrawing products and features

Technical hiring practices and interview experiences

RSA encryption factorization breakthroughs

Critical infrastructure cybersecurity incidents

Software bloat and security vulnerabilities

Software Defined Radio Projects and Applications

Linux system configuration and init systems

GitHub alternatives and decentralized code hosting

nuclear reactor development and operations

Prediction market regulation and controversy

Cold outreach and authentic communication

How to ask for help from people who don’t know you · 543 pts
LinkedIn CringeBot 3000 · 360 pts
The Cold Email · 251 pts
My Business Is Dying · 82 pts
I stopped drinking the AI Kool-Aid · 62 pts
Ethical Cold Outreach · 51 pts
Human Slop · 19 pts

AI-powered parametric 3D modeling generation

Quantizing and optimizing Qwen models for efficient GPU inference

Apple legal disputes with OpenAI

Far-right AfD’s electoral surge in Germany

Vintage Computing Hardware Components

DIY and plug-in renewable energy systems

13,099 stories in the 12-week window · 211 qualifying clusters · similarity threshold 0.85 · generated by TrendsWorks.

Teaching an AI My Taste

Lon Riesberg — Fri, 31 Jul 2026 06:00:00 GMT

When putting together an issue of the Data Elixir newsletter, there are hundreds of relevant posts, tools, and resources to consider. Most of it gets to me through ~200 RSS feeds, 806 social media accounts, Hacker News, and Reddit.

I’ve written Python scripts to fetch and rank posts from the social media accounts and those scripts have become essential for catching what’s resonating around the web. But resonating isn’t the same as good, and it’s not the same as being right for Data Elixir either. That judgment still comes from me, reading. And even with the scripts helping to filter everything, I still end up with 100-200 posts to consider each week.

It would be great to automate some of that last-mile curation, but that kind of reading and judgment isn’t something traditional code can do.

LLMs make it possible.

I still make the final calls, but some of the links in the Data Elixir issue you read this week were surfaced by an LLM that I taught to think like me.

This post walks through how I built it, including the judge at its center, and the part I care about most: how I taught it my taste, and how I checked whether it actually learned. Along the way are the dead ends that taught me the most, and a prompt you can drop into a coding agent to start building something like this yourself.

How It Works

Every morning, a Python script pulls new links from a collection of RSS feeds, an email inbox, and Hacker News. Then each link is followed and simplified to a common structure that includes a title, the link, where it came from, and a short snippet.

The script skips links that are stale or have already been seen, and then it passes what’s left to an LLM judge that scores each link against my taste. Whatever clears the bar gets ranked and sent to my Inbox.

That’s the entire application, and most all of it is plumbing.

The judge is the most important part. If I added more sources but didn’t have a good judge, I’d just be drowning faster with things to read. And the judge is only as good as the rubric it judges against. For this project, the rubric is defined in a plain markdown file I call taste.md.

Teaching It My Taste

taste.md is 111 lines of short descriptions of what I’m looking for. It’s organized into categories that cover who the audience is, positive signals that raise the score, and things that disqualify a post.

Those three categories cover everything I need, including specific traits like:

“Substantive and about working with data (or directly useful to people who do)”
“Teaches, demonstrates, or argues something”
“Reasonably fresh (roughly within the last month) and durable”

and on and on.

Writing taste.md is easy. Figuring out whether I actually got it right is not. And it didn’t start out as 111 lines, either.

Vibes

My first attempt at a taste.md file was just me, describing what I look for and what I skip. “Teach me something. Posts should target a smart, data-savvy audience. No hype.”

I ran it against a week of candidates and read the results. They looked fine. Good stuff near the top, junk near the bottom. Great.

But that’s the trap. The results were plausible, but plausible isn’t the same as right. It’s the same trap as ranking by engagement. It’s a useful first filter, but a high number doesn’t prove that something is good. I needed a test that an LLM couldn’t talk its way through.

Labels

So I built a test using a spreadsheet of my own curation decisions. I started with 20 links that I had featured in Data Elixir and another 15 that I had passed on, and included a one-line reason for each.

The rejects, and especially the near misses, turned out to matter more than the picks. That boundary between “good” and “good-but-not-for-me” is where taste really lives. A slam-dunk “yes” doesn’t teach the judge anything it didn’t already know.

I did two things with that spreadsheet. The first was to write a script that reads each labeled article and works out the traits that separate the yeses from the nos, so I could fold them back into taste.md. The first time I ran it, I used only the featured examples and it confidently concluded that my audience was professional software engineers. For Data Elixir, that’s not true. Without the rejects there was no contrast, and everything that makes my taste specific rather than generic lives in what I say no to. Negatives carry the signal.

The second thing I did with that spreadsheet was the one that hurt. I used it for backtesting. Score all 35 links blind. No labels, no notes, just the judge, and then measure how often it agreed with me. The first number was 51%. That’s essentially a coin flip. And when I looked closer it was even worse than that. The median score of the things I had featured was 62, and the median of the things I’d rejected was also 62. The judge didn’t disagree with me so much as it had no opinion. Everything landed in the same undifferentiated pile.

But now I had a number to move instead of a feeling to satisfy. I tightened the traits, re-ran the backtest, and watched the results climb. First, 51%, then 57%, then 71%, and the medians finally pulled apart: 72 for featured, 48 for rejected. The judge had learned to discriminate.

Of course, it’s more complicated than that because the traits interact. At one point I softened a rule about engineering depth, because it was sinking a post that had been a popular pick in Data Elixir. The softening fixed that post but then floated a dense, math-heavy theory piece I probably wouldn’t feature. It was whack-a-mole.

Outcomes

The reality is, my labels are taste too, and my taste isn’t ground truth. What I think is a great link and what my readers are actually interested in are not always the same. So I added real engagement as a final judge.

I use a platform called beehiiv to publish Data Elixir, and it logs every time an actual person clicks a link in the newsletter. “Actual person” is important here because there are a LOT of bots that click links in the newsletter as they try to determine if something is spam. For me, that’s noise, but beehiiv uses a variety of mechanisms to identify and filter out bot clicks.

For the 35 links I had selected to help define the taste.md file, I pulled the engagement numbers from beehiiv and lined them up against the judge’s scores for the same posts. Two stories came out of that, and they pointed in opposite directions.

The first story was a “build attention from scratch” post that I had featured. The judge scored it as a 38, which was well below my bar. I would have been tempted to modify the taste.md file to push it up, but based on reader engagement, it was one of the weakest links in that issue. The judge wasn’t missing something. It was seeing something my own enthusiasm had talked me past.

The second story was a post from a well-known AI writer about what it feels like to work with a new model. The judge scored it 38 and buried it. That particluar post was the single most-clicked link in that issue. The judge was being hard on first-person posts, but readers love those posts.

I kept reworking the taste.md file and running backtests until the judge consistently scored like me. Or scored like my readers, actually.

The individual verdicts aren’t the point. The ladder is: vibes → my labels → real outcomes. Each step corrects the one before it. I started out by trusting my gut, but that wasn’t measurable, so I replaced it with my documented decisions. But those decisions didn’t always line up with what my readers actually clicked. Every step made the judge’s taste a little less mine-in-theory and a little more mine-in-practice. And sometimes the judge’s scores were better than mine.

What It Sends Me

Every morning before I’m awake, the whole thing runs and drops a ranked shortlist in my inbox:

The morning shortlist, ranked and reasoned.

The reason is the part that matters. The score tells me where something landed. The reason tells me why, and that’s what lets me accept or overrule it in about two seconds. “Clear, hands-on Bayesian workflow in Python” is a yes. “Package release announcement dressed up as an article” is not. I’m not reading 200 posts anymore. I’m reading 15 one-line arguments and then clicking through to read the 3 or 4 posts that are actually worth my time.

Extending It

Nothing about this is specific to Data Elixir. The judge doesn’t know or care where a candidate came from. It could be from an RSS feed, a newsletter in an inbox, or a social media feed. Every source gets normalized into the same shape before it reaches the taste test. Which means the whole system can be aimed at something completely different by just changing the sources it reads and the taste.md it judges against. This same scheme will work to search job listings, find useful social media discussions, find relevant academic papers, etc.

To verify that, I stood up a second instance. It’s the same code, untouched and pointed at a list of the most popular blogs among Hacker News readers. After developing a new taste.md file, I had a completely different curator. This one reads a couple hundred of the web’s most-loved technical blogs and then hands me the posts that it thinks I’m most likely to be interested in. It’s super useful!

Try It Yourself

If you’re interested in building this, a Hacker News curator is a great place to start. To track what’s new, there’s a ranked list of popular Hacker News writers at HN Popularity Contest.

It’s a bit of work to pull out the URLs and then track down the RSS feeds, but here’s an OPML file that I created recently for this exact use-case. Just drop this file into your own code:

Top Hacker News Writers

The Conversation Isn’t Real

Lon Riesberg — Fri, 03 Jul 2026 06:00:00 GMT

Most people interact with AI like they’re having a conversation. They ask a question, the AI responds, they respond back, and so on. It’s a natural flow for people that feels like a conversation, but that’s an illusion. Understanding why will supercharge how you use AI.

Behind the scenes, every message you send and every reply is a big, evolving transcript. People respond to the latest interaction, but AI doesn’t have any awareness of an ongoing discussion. There isn’t a sentient being on the other side that remembers what was just said. The model re-reads the entire transcript everytime you click send, and then reponds to the entire transcript.

Understanding that is key. You can do things with a transcript that you can’t do with a conversation. For instance, you can hand a transcript to a different model. You can fork a transcript. You can delete bad ideas. And then watch the AI reason through the transcript as if the edits never existed.

In this post, I’ll walk through three tiers of working with LLMs and show you specific ways to get more from your prompts. The first tier shows how to get more from a single chat. This tier feels like a conversation and is where most people work. The second tier breaks out of conversations and shows how to use multiple AIs together. The third tier is where you’ll notice that what you’re doing in tier 2 is actually a pipeline. And pipelines can be built.

You don’t need to be an engineer for any of this. Tiers 1 and 2 are just copy-paste. Tier 3 is a way of thinking that happens to point towards code.

Tier 1: Talk to One Model Better

LLMs do two things that limit the quality of every response: 1) they guess your context and, 2) they defer to you more than they should. Every strategy in Tier 1 fixes one of those two things.

1. Get interviewed first

One of the biggest failure modes with current LLMs is that the model guesses your context. So, stop it from guessing:

Please draft a job description for a senior analyst on my team. Before writing anything, ask me the 5 questions whose answers would most change the draft.

This will get the model to ask about things like team size, stakeholder mix, whether your culture is SQL-first or Python-first, etc. You know these things intuitively but don’t think to include them in a question.

2. Force a choice

If you ask an LLM a “this-or-that” question, it will essentially respond with, “It depends.” This is better:

Postgres or BigQuery for a 50GB analytics workload, 3-person team. Pick one and include one sentence of justification.

“Pick one” forces the model to make a choice and you can dig into details from there.

Telling it to rank choices is even better. “Rank these five KPI candidates from most to least useful for a subscription business. No ties allowed.” Not allowing ties forces it choose.

3. Run a pre-mortem

If you ask an LLM, “Do you see any issues with this plan?” you’ll get a list of generic risks. Ask for a “pre-mortem” instead:

We're launching a self-serve analytics tool for non-technical PMs. Imagine it's 8 months later and no one's using it. Write an internal post-mortem, including the warning signs everyone ignored.

Phrases like “internal post-mortem” and “warning signs everyone ignored” produce specific failure modes instead of a checklist of risks.

It works on artifacts too. Take a marketing email you’re about to send: “imagine no one responded and tell me why” is much better than “how can I improve this email?”, which will mostly get you tone tweaks.

4. Roleplay your audience

Giving an LLM a role to play is a good way to get different perspectives. I like this approach for charts:

You’re a CFO seeing this in a board deck and you have 10 seconds of attention. What do you take away? Now, what did the author intend you to take away?

On their own, the perspectives are useful and, in this case, the gap between those perspectives offers a worthwhile critique.

5. Ask what you should have asked

Say you just got some suggestions from an LLM about a database migration. Before moving on, ask one more question:

What should I have asked you that I didn't?"

That question will reveal any deal-breakers. For instance, “You never asked about your downtime tolerance.” The model didn’t volunteer that because you didn’t seem to want it.

This one’s even better: “What’s the one question that, if I answered it, would most change your recommendation?” That one gets the model to tell you about its assumptions.

6. Demand calibration flags

Models sound confident about everything, which is a real danger. So make confidence explicit:

Summarize the changes in pandas 3.0. Tag every claim [confident] or [verify] and be stingy with [confident].

The “be stingy” clause is important because without it, everything gets rated as “confident.”

Tier 2: Escape the Context

Everything up to this point works within a single chat. But since that “conversation” is just a transcript that’s re-read from scratch with every new message, nothing binds you to that one chat. The chat is completely portable. You can change it and give the transcript to a new instance of the model you’re already working with. Or you can give it to a completely different model. The models don’t care.

Every technique in Tier 2 exploits that loophole.

7. Switch models mid-stream

Pitting the models against each other is my favorite LLM strategy.

Ask Claude to architect your data pipeline. Then paste the entire chat into ChatGPT or Gemini, starting with something like this:

A consultant proposed this architecture. What do you think?

A new model will often have a different perspective than the first. It may also have different strengths and capabilities and will find issues that the first model would have defended.

8. Make them argue

ChatGPT says I should normalize this table into 3NF. Where would you disagree?

Models defer to you, but not so much to each other. By attributing a position to another AI, you’re more likely to get a constructive response.

You can take that a step further and give a third model both answers: “Two AIs disagree about whether I should use embeddings or fine-tuning here. Here are both arguments. Judge them and declare a winner.”

That’s a debate-and-judge evaluation, which is a real technique from the research literature.

9. The colleague gambit

Ask “can you review my SQL query?” and the model might say something nice like, “Great approach! One small suggestion…”

Now try: “A junior analyst submitted this query for review. Give the feedback you’d put in the PR.”

It’s the same question but dramatically more useful.

10. Never let the author grade its own work

The chat that wrote your essay will defend every paragraph of it, so don’t ask that chat. Open a fresh one instead:

I found this essay online. Is it worth my time? Be honest about where it loses you.

The fresh chat may tell you the intro is 200 words too long but the chat that wrote it would defend it because the back-and-forth process that created it is baked into the transcript.

11. Branch, don’t scroll

The edit button on your earlier messages isn’t for fixing typos. It forks the chat.

For example, say you’re 20 rounds into planning a project and you wonder about a different approach. If you ask “what if we did it the other way?” at the bottom, the model anchors on everything already decided. Instead, edit the message where you made the choice and let the branch develop independently. Then compare endpoints.

This also makes it easy to A/B test your prompts. Edit your initial request and watch how far downstream the changes propagate. People A/B test their landing pages all the time but never think about testing their prompts. The edit button makes it a two-click experiment.

Tier 3: Notice the Pipeline

At this point, you’re running the same prompt against multiple models. You’re spinning up fresh chats to evaluate outputs. You’re generating variations and picking winners.

Essentially, you’ve stopped having conversations and have started running experiments.

It’s the beginning of a pipeline. It’s a slow one, with you copy-pasting into different windows, but the real dividing line between casual users and people who build with AI isn’t technical skill. It’s noticing which of your manual workflows are actually scripts waiting to be written.

12. Invert the prompt

Take three pieces of your own writing that you’re proud of:

Write the prompt that would make an AI produce output in exactly this style, capturing the rules I'm following unconsciously.

This gives you a portable style guide that you can drop into any future chat. It’s your voice and editorial instincts, externalized.

Push it one step further and drop in placeholders:

Here's a report format that works for my team. Reverse-engineer the prompt that would produce it, parameterized with {dataset} and {time_period} slots.

With the placeholders, you now have a template that you can drop into a script for automated reporting.

13. Generate diverse, then judge

In an interview from the 90s, a National Geographic photographer said they typically had two or three good shots in a roll of 36. Having lots to choose from was key for getting the great ones.

It’s the same with LLMs.

Ask for options and be specific:

Give me three launch-announcement drafts: one safe, one contrarian, and one that takes a genuine risk.

Even better, ask it to give you multiple versions of each draft. Then, in a fresh chat, have a model judge them: “Which of these would you actually keep reading past the first paragraph? Why?”

This is a hand-run version of two patterns from the research world: best-of-N sampling (generate several candidates, keep the winner) and LLM-as-judge (use a model to do the picking).

It works on analysis too: “Interpret this churn data three ways: the optimistic perspective, the alarming perspective, and the boring-but-most-likely perspective.” Then let another chat pick the most likely interpretation.

14. Create a Rubric

“Is this a good README?” gets you “Yes, but it could use some examples.”

A better approach is to create a rubric first:

Write a 6-criterion rubric for a great open-source README, with what 1/5 and 5/5 look like for each criterion.

Once you have a set of rules you like, then have it read the document:

“Score my README against this rubric, with one line of cited evidence per score.”

Now you have a rubric that you can use with future drafts. That gives you a persistent, reusable evaluation component.

That’s the Tier 3 mindset in one artifact. And once you have a few of these (a style prompt, a parameterized template, or a rubric), wiring them together in code is a smaller step than you might think.

Where This Goes

The advice in Tier 1 is about getting more out of a single chat.

Tier 2 is about escaping that frame: fresh chats, rival models, and forked timelines.

Tier 3 is where the frame dissolves. If you’ve been copy-pasting between chats, running the same prompt through three models, and keeping a rubric in a notes file, you’re already building a pipeline. You’re just running it slowly.

Making it fast and automated is what code is for. More on that in another post.

Investing with Agents

Lon Riesberg — Mon, 22 Jun 2026 06:00:00 GMT

What I Wanted

I keep hearing about people using LLMs to make investments on the stock market and then losing a bunch of money. It sounds like people are giving agents access to APIs for data and news, giving them an account with some working capital, and then connecting them to a brokerage account too.

It’s an interesting idea but it seems pretty optimistic to think that would work. LLMs are becoming very capable for a lot of things but at this point, June 2026, using LLMs for short-term wins on the stock market seems like gambling. But it also seems that LLMs would be useful somewhere in an investing stack, right? So I asked Claude:

If I were to use an LLM to invest, what would be the best use of your skills?

Great question. Here’s where LLMs genuinely add value in investing — and where they don’t:

Where LLMs are actually useful

Research synthesis — Quickly summarizing earnings calls, 10-Ks, analyst reports, or news about a company. Reading 80 pages of an SEC filing and pulling out the key risks or revenue drivers is tedious for humans but straightforward for an LLM.

Comparative analysis — Laying out how several companies in a sector stack up across business model, moat, management, and financials. Great for building a mental model before you go deeper.

Thesis articulation — Helping you write out your investment thesis clearly, which forces you to identify gaps in your reasoning. “If I’m wrong about this, what would the world look like?”

Sentiment and narrative tracking — Parsing large volumes of text (news, social media, filings) to spot shifts in how a company or sector is being talked about.

Scenario modeling prompts — Stress-testing assumptions. “What are the bear case risks to this thesis that I haven’t considered?”

Learning and frameworks — Explaining valuation methods, walking through DCF mechanics, explaining what a specific financial ratio means in context.

Where LLMs are NOT useful (and actively risky)

Price prediction — No LLM can reliably tell you where a stock is going. Anyone claiming otherwise is selling something.
Overconfidence — LLMs sound confident even when wrong. In investing, that’s dangerous. Always verify numbers independently.
Replacing your own judgment — The final call on risk tolerance, position sizing, and conviction has to be yours.

The best mental model: treat an LLM like a very well-read research analyst who reads fast, never sleeps, but has no real money on the line and can hallucinate facts. Use it for synthesis and thinking, not as an oracle.

Given your growth-focused, risk-tolerant approach, the highest-leverage use is probably thesis stress-testing and sector deep-dives — areas where reading volume is the bottleneck, not judgment.

Got it. So, if I wanted to hire you as an always-on research assistant who followed the news, markets, and industry events around the world, what would you want access to?

Great framing. Here’s what I’d want:

Tier 1: Essential

Live market data feed — Prices, volume, options flow, futures. Even a free API like Polygon.io or Alpaca covers the basics.
News — RSS aggregator or an API like NewsAPI, Diffbot, or The Economist/FT feeds. Ideally categorized by sector.
SEC EDGAR filings — Earnings, 10-Ks, 8-Ks (material events). EDGAR has a free API. This is underused alpha.
Earnings calendar — So I know what’s coming and can prep pre-earnings context.

Tier 2: High value

Social/alternative sentiment — Reddit (r/investing, r/SecurityAnalysis), X, Bluesky
Macro data — FRED (Fed economic data), BLS releases, CME FedWatch for rate expectations.
Transcript access — Earnings call transcripts via Koyfin, Seeking Alpha, or a paid service like Sentieo/AlphaSense.
Insider trading filings — SEC Form 4s. Quiet signal that’s often overlooked.

Tier 3: Nice to have

Patent filings — For tech/biotech, a leading indicator of R&D direction.
Job postings data — Hiring patterns reveal where companies are actually investing.
Satellite/alternative data — Foot traffic, shipping, credit card spend. Expensive but powerful.
Central bank communications globally — ECB, BOJ, PBOC statements.

The architecture I’d want

The best approach would be a multi-stage pipeline where cheap models do triage and filtering, and a more capable model (like me) does synthesis and narrative. The key additions for investing specifically:

Structured memory — A SQLite or Postgres store that tracks your positions, thesis notes per ticker, and historical context so I’m not starting cold each session.
Alert triggers — Not just a daily briefing, but event-driven pings (8-K filed, price moves >5%, Fed speaks).
A “devil’s advocate” prompt layer — Every bull thesis gets automatically stress-tested with a bear case pass.

All of this sounds reasonable and seems like a good foundation for an investment research assistant so I built it.

Mostly, anyway. I’m not day-trading so I don’t see the need for Claude’s real-time requests, like alert triggers, but otherwise, the assistant outlined in this post has become surprisingly useful for my personal investing stack.

It knows what’s in my portfolio, knows what I’m paying attention to, reads the news, pulls market data, pays attention to earnings announcements, reads filings, watches key economic indicators, and looks for new opportunities - all from the perspective of my personal interests and current holdings.

Then it synthesizes everything and sends me a report. Two reports, actually. One is a daily pre-market report for stocks and themes I’m tracking and the other is a weekly wrap that is specifically focused on my long-term holdings.

Everything lives on my own machine so if I have questions about a report, I just point Claude Code at the directory that contains everything and dive in. Codex or other LLMs would probably work too.

This post walks through key design decisions, has sample digests for inspiration, suggests some alternative approaches, and if you’re interested in building something like this yourself, there’s a prompt to help you get started.

You don’t have to be an engineer to build this

There’s a ready-to-use prompt at the end of this post and you can start building everything here by pasting the prompt into an AI coding agent like Claude Code.

How to Build It

Initially, I built this using OpenClaw, which works but OpenClaw has a lot of features I don’t need here. That made it more work to set up, more work to maintain, and it seemed heavy on tokens.

My current version is very simple. It runs locally on a laptop, it doesn’t cost anything beyond the APIs, it’s easy to work with, and since it’s on the machine I’m already using, I can easily point Claude Code at my investing directory to go deeper into market events, suggested themes, stocks to watch, etc.

I use python for the orchestration code, markdown files for memory, and GitHub for version control. I’m running it on a Mac Air, automated with launchd, but otherwise, there isn’t anything that’s platform-specific so something like this should work on a Windows or Linux box too.

It will evolve but so far, I’m happy with it.

Note that I’m a builder, not an investment advisor. This post describes how to build an always-on research assistant but nothing in this post should be considered financial advice.

Architecture

To keep things simple, I built this using a directory-as-agent pattern, which means there are several agents that work independently and are confined to the directory that contains their code. That organization offers a few key benefits:

Minimal security issues. Agents don’t have the ability to access information from elsewhere on my machine.
Agents are loosely coupled so if one fails, the system doesn’t break. Each agent performs its task and then writes output to a markdown file. A synthesis agent runs at the end and reads the reports. If a report is missing, it’s flagged, and the synthesis agent continues.
Each agent has its own prompt and makes its own calls to an LLM. That makes it easy to use less expensive LLMs for tasks that don’t require a lot of thinking power. The synthesis agent is where intelligence matters for this assistant and that’s where I focus my LLM budget.

Directory-as-Agent Pattern

Lon Riesberg

Trends radar: September 18–24, 2026

The analyst’s read

What to Notice This Week

System One / Jev Model Architectures — new theme

AI-Enabled Offensive Security

Surveillance, Privacy Law & Accountability

Carried-forward ledger themes

Noise and out-of-scope calls

Where math and analyst disagree

Theme ledger

The clusters

Jev architecture and calibration techniques

China semiconductor self-sufficiency initiatives

neuroscience research and brain function

lightweight containerization and sandbox technologies

AI agent security and sandboxing

Google abandoning and withdrawing products and features

Technical hiring practices and interview experiences

RSA encryption factorization breakthroughs

Critical infrastructure cybersecurity incidents

Software bloat and security vulnerabilities

Game Engine Development and Real-Time Graphics

Software Defined Radio Projects and Applications

Linux system configuration and init systems

GitHub alternatives and decentralized code hosting

Ancient human societies and lost civilizations

Mathematics history and mathematical pioneers

nuclear reactor development and operations

Prediction market regulation and controversy

Cold outreach and authentic communication

AI-powered parametric 3D modeling generation

Quantizing and optimizing Qwen models for efficient GPU inference

Apple legal disputes with OpenAI

Far-right AfD’s electoral surge in Germany

Vintage Computing Hardware Components

DIY and plug-in renewable energy systems

Teaching an AI My Taste

How It Works

Teaching It My Taste

Vibes

Labels

Outcomes

What It Sends Me

Extending It

Try It Yourself

The Conversation Isn’t Real

Tier 1: Talk to One Model Better

1. Get interviewed first

2. Force a choice

3. Run a pre-mortem

4. Roleplay your audience

5. Ask what you should have asked

6. Demand calibration flags

Tier 2: Escape the Context

7. Switch models mid-stream

8. Make them argue

9. The colleague gambit

10. Never let the author grade its own work

11. Branch, don’t scroll

Tier 3: Notice the Pipeline

12. Invert the prompt

13. Generate diverse, then judge

14. Create a Rubric

Where This Goes

Investing with Agents

What I Wanted

How to Build It

Architecture