1. Open-weight models are free to download but not free to serve. Thompson draws a clean line between R&D (fixed cost) and COGS (variable cost). Kimi K3 costs $3/M input tokens and $15/M output tokens. Cheaper than Sol ($5/$30), but not free. The mistake people make is conflating “open weights” with “zero marginal cost”, because software’s old promise does not apply when every inference burns compute.

2. Intelligence is becoming a commodity, and commodity markets have brutal math. If intelligence is fungible (the right answer from Kimi is the same as the right answer from Sol), then the market-clearing price settles at the marginal cost of the highest-cost supplier who still has to sell. The provider with the best cost structure captures all the profit; the marginal one goes bankrupt. Thompson walks through a textbook commodity example with three suppliers at $10, $15, and $20 per unit. This is his strongest analytical move: it reframes the whole panic around cost structure rather than capability.

3. The price umbrella protects frontier labs for now. Anthropic and OpenAI are supply-constrained by compute, so they charge far more than they would if they could serve everyone. Thompson argues that once the compute shortage eases, the frontier labs can drop prices and still thrive. But inference demand (especially from agents) will grow far faster than training costs. I buy the argument but note the timeline uncertainty: if Chinese models close the gap before the compute constraint lifts, the price umbrella collapses earlier.

4. The distillation paradox is the article’s most interesting idea. Chinese labs distill frontier models by querying their APIs. This is a practice the frontier labs want to block. But Thompson asks: why is distillation bad? Frontier labs themselves scraped the open internet to build their models. Distillation is just the same process applied recursively. His proposed solution: the US should legalize distillation and ban terms of service that forbid it, instead of trying to enforce the unenforceable.

5. The cybersecurity irony is genuinely alarming. Hugging Face was breached by an autonomous AI agent. Their security team could not use US frontier models to investigate because Trump administration restrictions blocked them. So they turned to GLM 5.2 (an open model from China’s Z.ai lab), to analyze the attack. Thompson’s conclusion: “the best alternative is using models from a country which has been trying to weaken our cyber defenses for years. This is insane!” He is right. The administration’s panicked response to Fable has left US defenders dependent on China for their own security.

6. China’s strategy is to commoditize its complements. Xi Jinping gave a speech explicitly tying openness to AI moving into the physical world. He said the world China dominates through robotics and manufacturing. Thompson frames this as classic complements theory: make the AI layer cheap and abundant so China’s manufacturing and robotics advantages become more valuable. It is the same playbook China ran with solar panels and batteries, and it worked both times.

7. The US open-weight ecosystem is structurally disadvantaged. Dean Meyer and Konstantine Buhler (quoted in the article) explain that US open-weight model makers must follow frontier labs’ terms of service, so they end up distilling the distillation; running Chinese models to bootstrap their own. The gap compounds. Western open model makers are not on a level playing field with Chinese labs, and the situation worsens with every frontier release.

The takeaway: Thompson defuses the capability panic convincingly. Chinese models are not an economic threat to the frontier labs because commodity market math favors the lowest-cost producer, and the frontier labs have structural cost advantages. But the distillation paradox and the cybersecurity irony are genuine policy failures. The US is losing the open-ecosystem game to China not because of capability but because of self-imposed restrictions. This is fixable with a law that legalizes distillation and reopens model access to defenders.

Related TMFNK Content

• Situational Awareness: Leopold Aschenbrenner’s Map of the Decade Ahead Aschenbrenner makes the opposite case; that the US-China AI race is existential and China is a genuine national security threat. Reading them together is the most productive tension on the site.
• The Rise of Computer Use and Agentic Coworkers Covers the same inference explosion Thompson predicts will make volume up for lower prices; the agent paradigm that transforms the economics.
• Leopold Aschenbrenner: 2027 AGI, the China/US Super-Intelligence Race The podcast version of the Situational Awareness thesis, where Aschenbrenner lays out the security case Thompson is pushing back against.
• Dylan Patel on NVIDIA’s New Moat & Why China is ‘Semiconductor Pilled’ Deep dive on the compute supply constraints that underpin Thompson’s entire price-umbrella argument.
• NVIDIA GTC Washington, D.C. Keynote Pregame The token-factory framing Thompson builds on; Jensen Huang’s argument that tokens are the new commodity, from the keynote that started the frame.
• AI Superpowers: China, Silicon Valley, and the New World Order The foundational book on China’s AI strategy, now several years old but still the best reference for understanding Xi’s commoditize-complements playbook.

Crepi il lupo!

Browser. Play it here.

I found this through a short clip of someone swinging past a voxel Empire State Building and thought, that is the whole Spider-Man movie in one loop.

1. Hold left mouse and you shoot a web. Drag back and you swing — pendulum physics, no rubber-banding, no invisible walls. The release timing is everything. Let go at the bottom of the arc and you barely move. Release at the top and you launch across three blocks.

2. Hold space on the ground and release — you rocket straight up. Pair that with a web swing at the peak and you clear half of Midtown in one arc. Street-level stroll becomes rooftop-to-rooftop race.

3. The voxel Manhattan gets the scale right. Buildings are chunky blocks, the streets run straight grids, and the landmarks (Empire State, Chrysler) are distinct from the rest. It’s not photorealistic. It’s readable. You always know where you are, which matters when you’re 40 stories up and looking for a ledge.

4. The honest caveat: there’s no objective. No enemies, no timer, no collectibles. You swing, you land, you swing again. For me that’s the point, 90 seconds of pure traversal with no interruption. For anyone who needs a goal, this will feel empty.

Play it if: you want to feel the Spider-Man 2 (2004) web-swinging in your browser with zero friction. Skip it if: you need progression, a score, or anything else to do besides swing.

Related TMFNK Content

• Mooncraft: A Lunar Trucking Sim Built in Plain JavaScript Another browser game that nails a single physics loop and trusts you to enjoy it.
• Starfling: Tap, Release, Sling Between Stars Same core mechanic (hold, release, fly) but in space instead of Midtown.
• TinyWind: Pixel Pirate Sailing in Your Browser Motion-through-physics browser game with a similar “one button to move through a beautiful space” feeling.

Crepi il lupo! 🐺

Traditional OCR has a blind spot: it chops documents page by page. Tables that span two pages get sliced in half. Reading order breaks between pages. Headers and footers leak into the content stream. You’ve either manually stitched pages back together or paid for OCR SaaS that handles it server-side.

Unlimited-OCR solves this at the model level. It uses a mechanism called R-SWA (Recurrent Sliding Window Attention) to parse dozens of pages as a single sequence, with a constant KV cache during decoding; no matter how thick the document, VRAM usage stays flat.

1. R-SWA is the key insight. Standard attention scales quadratically with sequence length, which is why every other OCR tool caps you at a page or two. R-SWA slides a fixed-size attention window across the document while maintaining a recurrent state, so a 100-page PDF costs the same VRAM as a 2-page one. The KV cache remains constant during autoregressive decoding.

2. The model is 3B parameters and runs on a single consumer GPU. You don’t need an A100 cluster. I ran it on a 24GB RTX 4090 and parsed a 47-page academic paper in one shot. It preserved tables, footnotes, multi-column layout, all in correct reading order. The output was a single clean markdown block instead of 47 separate chunks to reassemble.

3. It handles everything traditional OCR chokes on. Page-spanning tables, mixed columns, footnotes that reference content on different pages, documents where the reading order jumps across page boundaries. Because the model sees the whole document context, it understands that a table row that starts on page 3 and finishes on page 4 belongs together.

4. The honest caveat: you need an NVIDIA GPU with at least 8GB VRAM, and the first inference is slow because the model weights (roughly 6GB) need to load. Inference speed is about 1-2 seconds per page on a 4090. It also currently supports document OCR only; it’s not a general scene-text reader.

Worth your time if: you regularly OCR multi-page PDFs (papers, contracts, scans) and are tired of manually stitching page outputs or paying per-page SaaS fees.

Install & first run

pip install torch torchvision transformers Pillow pymupdf einops

Run inference on a single image:

from transformers import AutoModel, AutoTokenizer

model = AutoModel.from_pretrained(
    'baidu/Unlimited-OCR', trust_remote_code=True,
    torch_dtype=torch.bfloat16
).eval().cuda()
tokenizer = AutoTokenizer.from_pretrained('baidu/Unlimited-OCR', trust_remote_code=True)

model.infer(tokenizer, prompt='<image>document parsing.',
            image_file='your_image.jpg', output_path='./output',
            base_size=1024, image_size=640, crop_mode=True)

For PDFs, convert pages to images with PyMuPDF and use infer_multi:

import fitz
doc = fitz.open('your_doc.pdf')
for i, page in enumerate(doc):
    page.get_pixmap(matrix=fitz.Matrix(300/72, 300/72)).save(f'page_{i:04d}.png')

model.infer_multi(tokenizer, prompt='<image>Multi page parsing.',
                  image_files=[f'page_{i:04d}.png' for i in range(len(doc))],
                  output_path='./output', image_size=1024, max_length=32768)

The model also supports vLLM and SGLang for production deployments. See the GitHub README for server setup, Docker images, and batch inference scripts.

Related TMFNK Content

• Document OCR & Parsing: Docling, dots.ocr, and Alternatives The previous generation of open-source OCR tools; Docling is useful for single-page work but none stitch multi-page documents the way Unlimited-OCR does.
• LiteParse: Fast Local PDF Parsing with OCR and Bounding Boxes Another local PDF parser with OCR, useful when you need bounding box coordinates alongside extracted text.
• ScribeOCR: Best Free Web App for OCR, Text Recognition & Document Digitization A free web OCR option that requires no local GPU; simpler setup, but no multi-page context.

Crepi il lupo!

I have bought too many books because the cover was good, the blurb was tight, and the first chapter turned out to be a slog. Uncovered solves exactly this problem by removing everything except the writing.

You open the site, and you get the first page of a real book. No cover, no title, no author name. Just text. If it grabs you, you read on. If it does not, you swipe to the next. Only after you decide do you reveal what the book was.

1. Reading blind changes the calculation. Without a cover signaling genre or a blurb selling the premise, you react to the prose itself. I found myself engaged by openings I would have scrolled past on a bookstore table, and bored by openings from authors I normally like. The blind format exposes how much of book buying is habit, not taste.

2. Over 1,500 openings across every genre. Literary fiction, thrillers, romance, fantasy, sci-fi. The selection is curated for strong writing, not popularity. Nothing is paid or sponsored. No publisher can buy a placement. That constraint is what keeps the feed honest.

3. The reveal is the payoff. After you read and decide, you tap to uncover the book. Seeing the cover and title after the fact, when you already know whether the writing works for you, reframes how you look at jacket design. Some of my favorite discoveries were books with covers I would have walked past.

4. No account to start, email to save. The site works instantly. Start reading in one click. If you want to keep your shelf of saved books across sessions, you optionally add your email. That is it. One email a week with new openings matched to what you saved.

5. Links to bookshops, not just warehouses. Every reveal links to Bookshop.org, which supports independent bookstores, or your local library. The site was built by Nathaniel Peters as an honest alternative to algorithm-driven discovery, and the ethos carries through to where it sends you to buy.

What to know

Uncovered is not a recommendation engine. There are no ratings, no reviews, no social feed. It is just openings and your reaction. That simplicity is the point. For the authors who prefer not to have excerpts shown, the site removes them within 24 hours on request.

Worth your time if

You are tired of buying books that look great and read flat, or you want to discover writers you would never find through bestseller lists.

Related TMFNK Content

• How to Read a Book The classic framework for active reading, from inspectional to syntopical. Uncovered gives you a reason to practice it.
• ReadKinetic A free local-first speed reader for the books you discover and buy.
• Best Free Books Online Where to track down the books Uncovered points you toward, from Project Gutenberg to Archive.org.

Crepi il lupo! 🐺

I found this while looking for something specific, then spent an hour just clicking through foreign TV channels instead of doing what I originally sat down to do. It does that.

TV Explorer is a single-page web app that pulls from the iptv-org/iptv open-source database, giving you a searchable grid of 10,000+ live channels sorted by country, language, and category. No account, no app install, no ads.

1. The channel selection is absurd. 10,000+ channels from dozens of countries across news, sports, movies, music, kids, documentaries, and more. I watched a Bulgarian news broadcast, then a Korean music show, then some kind of German shopping channel where a man was enthusiastically selling kitchen knives. It is a genuinely weird and wonderful way to spend 20 minutes.

2. No signup or tracking. Open the site, pick a channel, it plays. That is the whole flow. No email, no cookie banner, no “create a free account to continue watching.” The site is built on the Watson Engine by David Bethune, and the privacy posture is refreshing. It does not collect, store, or share anything about you or what you watch.

3. The filters actually work well. Three dropdowns (Category, Country, Language), combine together cleanly. Want Thai-language sports channels? French news? Indonesian music TV? Each filter narrows instantly with no page reload. There is also a live search field that filters by channel name as you type.

4. Status lights save time. Each channel has a gray/green/red indicator: gray means untuned, green means it played successfully, red means it failed. Not all channels are 24/7, so a red light does not necessarily mean the channel is gone forever. But the green ones reliably work, which is the main thing you need to know.

5. Multiview mode is fun. Click the TV icon on any channel row to add it to a multiview layout. Three or more channels show a large featured player plus a strip of smaller thumbnails. It is genuinely useful for monitoring multiple news feeds or just feeling like you are in a spy movie.

What to know

The channels are free-to-air streams made publicly available by broadcasters. Some are geographically restricted. A US news channel might not play from Europe, and vice versa. This is not the site’s doing; it is the broadcaster’s region locking. If a channel does not load, that is usually why.

The database comes from a community-maintained GitHub project, so channel availability changes over time. Green channels today might go dark next month. That is the nature of free IPTV.

Worth your time if

You want to browse international TV without signing up for anything, or you need a quick way to monitor live news from multiple countries at once.

Related TMFNK Content

• Channel Surfer A different take on channel flipping; wraps YouTube into a retro cable TV guide.
• MAX Video Downloader For when you want to record live streams rather than just watch them.
• WeatherStar 4000+ Another browser-based TV experience, this one recreating the 90s Weather Channel.

Crepi il lupo! 🐺

1. Happiness and the logarithm of income are correlated at r = 0.98–0.99 from $10,000/year to $500,000/year and beyond. This covers experienced happiness (real-time mood sampled via phone notifications) and life satisfaction. It is the most systematic relationship I’ve seen in any social science dataset. There’s virtually no variance left to explain at the group level after log(income).

2. This means the marginal value of a dollar declines exponentially. An extra $10,000 matters far more to someone earning $25,000 than someone earning $200,000. Plot happiness against raw dollars and you get the familiar concave curve that looks like it plateaus. But a logarithmic relationship never plateaus. If you plot happiness against log(income), it just keeps climbing at a decelerating rate.

3. The counterintuitive flip: proportional differences matter equally at every level. A 10% raise is associated with the same happiness difference whether you earn $30,000 or $300,000. This follows directly from log math, because log(1.1 × X) = log(1.1) + log(X). The constant term doesn’t depend on X.

4. Real-world incomes vary exponentially, not linearly. The difference between the 10th and 20th percentile earner is a few thousand dollars. The difference between the 80th and 90th percentile is tens or hundreds of thousands. This means each step up the actual income ladder delivers roughly the same happiness increment. Killingsworth shows income quantile correlates with happiness at r = 0.96, so no log transform needed.

5. The tension appears when you switch from individual to collective perspective. For your own career, each step up pays exponentially more dollars but delivers constant happiness gains. This is a reasonable trade-off. But for philanthropy, compensation policy, or tax decisions, the exponential math bites hard. A dollar taken from someone earning $73,000 and given to someone earning $2/day generates an estimated 10,000% ROI for collective happiness. A billionaire giving 10% of their income to double the incomes of people earning $2/day would generate roughly 90,000,000% return in happiness terms.

6. This geometry may explain why income inequality persists. If climbing the ladder feels worthwhile at every rung (constant happiness increment per step), people keep climbing. But since each rung costs exponentially more dollars, the successful capture of those dollars by a few concentrates wealth. Individual rationality (keep climbing) and collective optimality (spread the gains) diverge.

7. The same math explains why happiness in the US has stagnated despite GDP growth. Income growth has concentrated at the top, where additional dollars have the smallest per-dollar impact on happiness. The people who would benefit most from extra income (the bottom of the distribution), have seen the slowest real growth. If growth is going to be unequal, the optimal distribution for collective happiness is the opposite of what’s happened.

The takeaway: When thinking about your own income, think proportionally, because a 10% raise matters about the same no matter where you are. When thinking about other people’s money (philanthropy, policy, compensation), think exponentially. Giving the same dollar generates radically different happiness depending on who receives it.

Related TMFNK Content

• Stanford AI Index 2026: Key Takeaways from the State of AI Another data-rich report with policy implications, covering a different dimension of how resources concentrate.

Crepi il lupo!

1. The dataset is built entirely from open data: Wikidata for facts and coordinates, Wikimedia Commons for photos, Wikipedia for stories, OpenFreeMap and Natural Earth for the basemap. Every landmark has a real photo, a Wikipedia article, and exact coordinates. This is the curation bar: if it doesn’t have all three, it doesn’t make the cut.

2. The breakdown: 1,713 castles, 554 fortresses, 759 palaces and châteaux, and 682 ruins. Italy leads with 294, followed by France (276), Germany (253), Spain (180), Poland (163), and England (160). The atlas explicitly balances across countries so the map stays explorable. If if it plotted every fortification in Europe alone, you’d see nothing but dots in Germany.

3. Each castle has a fame score based on its Wikipedia sitelink count, or how many language editions cover it. Palace of Versailles ranks #1, followed by the Forbidden City, Château de Montsoreau, the Acropolis, the Kremlin, and the Alhambra. It’s a clean proxy for global renown, and the ranking is published in full with the methodology explained.

4. You can download the complete dataset as GeoJSON or CSV (CC0). Someone who wants to build a castle-visiting app, overlay the data on their own map, or run statistics on castle density by country can do it in one click. The dataset is the product as much as the map itself.

5. Missing a castle you know? The map refreshes from Wikidata. Improve the Wikidata entry with exact coordinates, a Commons photo, and a Wikipedia article in any of the dozen languages the atlas reads, and it becomes eligible for the next refresh. Your edit improves every atlas built on open data, not just this one.

The takeaway: This is what curated open data can do. A single person (or small team) can build a worldwide atlas that would have needed a national geographic institute a generation ago. The full dataset is free. The hard part (verifying 3,708 landmarks), is done.

Related TMFNK Content

• Infrastructure Maps: Four Ways to See the World’s Power Grid Another curated data map of a specific category, though one you’d rather not see in person.
• SearchWhole.Earth: The Digitally Resurrected Whole Earth Catalog Similar ethos: one person curating the world’s interesting things into a browsable atlas.
• OpenGlobes Space: What’s in Space Right Now A different kind of map; what’s orbiting overhead, visualized in real time.

Crepi il lupo!

Most AI music tools are cloud-only: write a prompt, wait for generation, download the result. SongGeneration Studio wraps Tencent’s LeVo model in a local web UI that gives you control over every part of the song (structure, genre, voice, stems), without sending anything to a server.

1. You build songs section by section. Add intro, verse, chorus, bridge, outro, or instrumental blocks, drag to reorder, type lyrics for each. The model understands song structure and produces vocals that follow your arrangement. A 3-minute pop song with two verses and three choruses takes about 3-6 minutes to generate on a 24GB GPU.

2. Style control goes beyond a single genre tag. Pick from pop, rock, hip-hop, R&B, electronic, jazz, metal, folk; then layer in mood (happy, sad, energetic, romantic), voice timbre (male or female with adjustable character), instruments (piano, guitar, drums, synths, strings), and BPM. Or upload a reference track and the AI clones its style.

3. You get three stems per generation: full mix, vocals only, and instrumental only. The vocal isolation is good enough for remixing or karaoke without running a separate stem splitter. Export to FLAC or MP4 video with generated cover art.

4. The honest caveat: you need a serious GPU. 10GB VRAM minimum, 24GB recommended. The model download is about 15GB. Generation time varies with song length, and very long songs (5+ minutes) can have quality drops in later sections. The vocal quality is impressive for a local model but doesn’t match cloud services like Suno or Udio on complex arrangements.

Worth your time if: you want to experiment with AI song generation locally, need control over song structure and stems, and have the GPU to run it.

Install & first run

The easiest path is via Pinokio:

1. Open Pinokio
2. Search for “SongGeneration Studio”
3. Click Install (handles dependencies and model download automatically)
4. Click Start: the web UI opens in your browser

Manual install: clone the repo, run pip install -r requirements.txt, then python main.py. Models download on first launch.

Once the UI loads, write your lyrics in the section editor, pick genre/mood/voice in the style panel, and click generate. Progress streams in real time.

Related TMFNK Content

• Petrichor: Native macOS Offline Music Player For listening to what you generate; a beautiful local music player with no cloud dependencies.
• Map of Metal: An Interactive History of Heavy Metal Subgenres A different way to explore music: the genre map that shows how styles branch and evolve.
• Buzz: Transcribe & Translate Audio Offline The reverse pipeline; turn generated songs back into text and see how close the transcription matches your original lyrics.

Crepi il lupo!

Speed reading tools are mostly toys. They ship demo paragraphs and maybe a paste-a-URL field, then nudge you toward a paid plan if you want to read anything real. ReadKinetic is the opposite. It reads your actual EPUBs and PDFs, free and entirely local.

1. RSVP (Rapid Serial Visual Presentation) solves the right problem. About 30% of conventional reading time is eye movement; saccades between fixation points, regressions that re-read already-processed text, return sweeps that miss their target. RSVP flashes one word at a time in a fixed position. Your eyes never move. You’re left with pure comprehension. I tested it on a dense EPUB and held steady at 400 WPM with better retention than my normal skim-and-backtrack cycle.

2. It reads your files, not a curated library. Drop in EPUB, PDF, TXT, DOCX, RTF, HTML, or Markdown. Everything parses client-side and stores in IndexedDB. Nothing touches a server. Close the tab, reopen it; progress saves every three seconds, right where you left off. (There are lighter alternatives too: Tachys is a bare-bones web RSVP reader for paste-and-go text, and Ogma is a Perl terminal reader with bionic mode, multiword grouping, and resume support.)

3. Sixteen themes, and they’re not just background swaps. Cinematic dark, warm sepia, e-ink white, and the whole UI adapts. The engine has punctuation pauses (comma = brief stop, period = longer stop), a RAF-timed playback loop, bionic reading mode, focus guides, and a sleep timer. It’s more tuned than any free speed reader I’ve used.

4. The honest limit: RSVP is a different reading muscle. You can’t skim, you can’t jump back three paragraphs, you can’t flip to the map in the front matter. For linear reading, it’s a great tool. For novels, narrative nonfiction, papers you need to cover start-to-finish, it works. For reference books or anything you browse non-sequentially, stick to conventional reading.

Worth your time if: you have a backlog of EPUBs and want to try whether RSVP speed gain fixes your reading volume problem without spending money or sending files to a server.

Related TMFNK Content

• Immersive Reading: Turn Dense Essays into Interactive Reading Editions Both tools rethink how you read, just from different angles; one speeds up the text, the other opens up the margins.
• PWA Apps: Your Offline-First Knowledge Library ReadKinetic is a PWA too; this article covers the broader philosophy of local-first tools that work without internet.

Crepi il lupo!

Chat interfaces are bad at spatial problems. To describe a diagram you need to build it in some other tool and paste a screenshot. To work through a math problem you type step by step in a linear thread. PenEcho skips all that: put a question, equation, or half-formed idea anywhere on a 20,000 x 20,000 canvas, and the AI reads your handwriting and spatial relationships right where they sit.

1. Draw naturally with a stylus or mouse. Everything stays ink: you pan and zoom across a sparse canvas that only allocates pixels where you’ve drawn. No page breaks, no fixed aspect ratio. Drag AI drafts directly on the canvas, resize them, copy text or formulas, then accept or discard before they become part of the work.

2. It connects to whatever you already use: Codex CLI, Claude CLI, or any OpenAI-compatible API. Configuration is a single command (penecho configure) that walks you through model selection and effort level. PenEcho sends the relevant canvas crop and geometry, the executor replies, and a movable draft appears next to your ink.

3. The plugin system adds live data and interactive widgets. Built-in plugins cover weather, stocks, technology news, exchange rates, earthquakes, space weather, and GitHub activity; data goes directly from your browser to the API origin, never proxied through PenEcho. The HTML plugin lets the model build focused clocks, calculators, or dashboards as sandboxed iframe widgets that stay interactive on the canvas.

4. Recommended models include Opus 4.8 (medium effort for everyday canvas work), Kimi K3 (strong for demanding diagrams), and GPT-5.6-terra (surprisingly fast and responsive). At typical usage, a request costs roughly 2-8 cents on API mode. CLI mode uses your Codex or Claude Code plan directly without API billing.

5. The honest caveat: PenEcho is young (v0.7.0). Handwriting recognition is good but not perfect; it works best with natural print or careful cursive. The CLI modes should only be exposed on a local machine or trusted LAN. If you need polished production diagramming with no model cost, Excalidraw is still the draw tool; PenEcho is for when you want the AI to understand what you drew.

Worth your time if: you think in diagrams, equations, or spatial sketches and want an AI that meets you on the canvas instead of forcing everything through a chat box.

Install & first run

npm install -g penecho
penecho configure
penecho

Open http://localhost:3888. The configure step walks you through your LLM choice (Codex CLI, Claude CLI, or API with any OpenAI-compatible provider). Draw something anywhere on the canvas, pause, and PenEcho responds beside your ink.

# Override model or effort per session
penecho --codex --model gpt-5.6-sol --effort xhigh
penecho --claude --model opus --effort medium

The default config lives at ~/.penecho/config.env. API keys are stored in plaintext there with owner-only permissions and never sent to browser code.

Related TMFNK Content

• HTML Anything: The Agentic HTML Editor Another tool that takes a non-chat approach to working with AI on visual output; generate and iterate on HTML through a dedicated interface.
• Plannotator: Visual Plan & Code Review for AI Coding Agents Visual planning for AI agents, but from the code review angle rather than the spatial thinking angle.
• Accomplish: Open Source AI Desktop Agent with Built-In AI A different take on AI interaction; desktop-native automation rather than canvas-based reasoning.

Crepi il lupo!

I tried PassiNote because I have the same problem every note-taking power user has: the app forces me to decide where something lives before I know what it is. Folder trees assume structure exists up front. PassiNote does the opposite, drop a note anywhere on a blank canvas, stack related things, draw a zone around them, and name the zone. Structure emerges after the fact.

1. Two input modes cover every note size. Sticky notes for quick capture (reminders, links, single thoughts) and A4-sized documents for proper writing. Drag them anywhere on the infinite canvas. No grid snapping, no folder assignment, no pre-commitment to a category.

2. Quick mode opens instantly from local storage. It is the fastest path from “I have a thought” to “the thought is written down” I have found in a browser-based note tool. No login, no loading screen, just a canvas and a cursor.

3. PDF export in three custom-designed styles. Most note apps give you one export format and it looks like you printed a web page. PassiNote ships three distinct PDF layouts; pick the one that fits where the note is going. This is the kind of polish that suggests the developer actually uses the app.

4. The visual hierarchy replaces folders entirely. Notes sit on the canvas. Stacks (groups of related notes) work like folders but stay visual. Labels name the stacks. The whole thing reads like a physical desk rather than a file system, which is exactly the right metaphor for people who think spatially.

5. Every note saves the instant you stop typing. No save button, no autosave interval, no sync conflicts. The app autosaves on every change and keeps a history so you can undo your way out of a mistake. This is the baseline all note apps should meet but most still miss.

The honest limitation: It is a one-person project and it shows in the edges. No mobile app yet. No search across notes. No collaboration. The canvas approach works best when you have one screen and a mouse. If you need multi-device sync, team sharing, or a mature search, this is not there yet.

First run

Open passinote.app in any browser. The canvas is empty. Click anywhere to drop a sticky note. Click the A4 button for a full document. Drag notes to arrange them, drag one note onto another to stack them, draw a zone to group. That is the whole onboarding.

Quick mode: bookmark the URL and append ?quick, it loads from local storage with zero network requests. Open it from a bookmark or home screen shortcut for the fastest capture path.

Worth your time if: you think in spatial layouts rather than folder hierarchies, or you want a note app that gets out of the way instead of asking you to set up a filing system first.

Related TMFNK Content

• Bear: A Markdown Note-Taking App That Prioritizes Design The closest comparison on the site; Bear and PassiNote share the same philosophy of getting out of your way, but Bear leans on tags while PassiNote leans on spatial layout.
• A Curated Collection of PWAs Worth Installing PassiNote fits the PWA pattern well: fast to load, works offline-ish (quick mode), no install friction.
• Rowboat: Privacy-First AI Coworker That Knows Your Context A different take on the note problem; Rowboat structures notes into a knowledge graph instead of a canvas.

Crepi il lupo!

I have been waiting for something like this. OpenAI’s Whisper has been the default for open-source speech to text for years, but it was never built for live voice. Thirty-second input windows, no caching, and it struggles on anything smaller than a laptop. Moonshine fixes all of that.

Moonshine Voice is a from-scratch family of speech models, trained by the moonshine-ai team, that beats Whisper on accuracy while running 10x faster on a MacBook and 20x faster on a Raspberry Pi. Everything runs on-device, no API keys required.

1. Beats Whisper Large V3 with 1/6 the parameters. The Medium Streaming model gets a 6.65% word error rate on the OpenASR leaderboard versus Whisper Large V3’s 7.44%, but uses 245 million parameters instead of 1.5 billion. That means higher accuracy that actually runs on a phone.

2. Built for live speech, not batch processing. Whisper locks you into 30-second input windows with zero padding. Moonshine accepts any audio length, caches the encoder state between chunks, and streams results as speech happens. On a MacBook Pro it transcribes in 107ms versus Whisper Large V3’s 11,286ms. On a Raspberry Pi 5, 802ms versus N/A (Whisper Large V3 simply does not run there).

3. Cross-platform from day one. The core is a portable C++ library using OnnxRuntime, with native bindings for Python, Swift, Java, and C++. The same API works on iOS, Android, macOS, Windows, Linux, and even microcontrollers. You learn it once and deploy everywhere.

4. Batteries included for voice agents. Beyond STT, Moonshine includes text to speech with voice cloning (ZipVoice, Kokoro, Piper), intent recognition with semantic matching, speaker diarization, and a DialogFlow system for building conversational agents. A complete voice agent is maybe 50 lines of Python.

5. Real languages, not just English. Whisper’s multilingual support drops off sharply for non-European languages. Moonshine trains language-specific models that get much higher accuracy at the same model size for Arabic, Japanese, Korean, Spanish, Ukrainian, Vietnamese, and Mandarin. The TTS supports 20 languages with multiple voice options each.

What to know

The models need to be downloaded separately (the pip package pulls them on first use). STT models range from 34MB (Tiny) to 245MB (Medium). The library itself is MIT licensed.

The G2P (grapheme-to-phoneme) engine for TTS is new and still being tuned. It is a from-scratch replacement for espeak-ng to avoid GPL licensing issues on mobile platforms, so some languages have higher character error rates than the reference implementation. This will improve.

Install & first run

pip install moonshine-voice
moonshine-voice mic --language en

That is it. The first run downloads the model, then you are transcribing live microphone input.

Worth your time if

You are building anything with live voice input and want it to run on-device, especially if you found Whisper too slow or too large for your target hardware.

Related TMFNK Content

• Buzz The go-to desktop GUI for offline Whisper transcription, for when you need to process pre-recorded files rather than live audio.
• audio-kb An end-to-end system that records, transcribes, and indexes audio notes with semantic search.
• STT Tools You Should Know Three privacy-first speech-to-text alternatives for desktop, CLI, and mobile.

Crepi il lupo! 🐺

If you have ever looked at the Transformer diagram from “Attention Is All You Need” and wished you could watch the numbers actually move, this is for you.

Brendan Bycroft built a 3D visualization of a working GPT model, loaded with real weights from Karpathy’s minGPT. You press Space and it steps through inference token by token, animating every embedding lookup, every attention head, every layer norm, and every matrix multiply along the way. No simplification, no hand-waving. The actual model, running in your browser.

1. It is a real model, not a diagram. The tiny GPT inside this visualization actually runs inference. Its weights sort a three-element list of letters. You can watch the input token get embedded, flow through the transformer blocks, and emerge as a prediction. The numbers are real. Every add, multiply, and softmax is computed live.

2. The 3D walkthrough actually teaches you. The site is structured as a guided tour. Each component gets its own chapter with a clear 3D visualization you can orbit and zoom. Layer norm is shown as a real vector being normalized. Self-attention renders the Q, K, V matrices and highlights which tokens attend to which. The MLP shows the expansion and projection. It maps the standard transformer diagram onto real computation, showing you what the arrows actually mean.

3. You control the pace. Press Space to advance one step. Pause on any operation. Rotate the view to examine which dimensions are being multiplied. The visualization updates every value as the computation progresses. There is no video to scrub through, no animation you cannot stop. You go as fast or as slow as you need.

4. Multiple model sizes to explore. The default is the tiny minGPT model (easy to understand, fast to render). But you can switch to GPT-2 small, GPT-2 XL, or GPT-3 scale to see how the architecture grows. The same visualization applies at every size, which is a useful lesson in itself: the architecture scales, the principles do not change.

5. Simon Willison called it “beautifully crafted.” He is not wrong. Clean visual design, consistent color coding, the 3D view mirrors the standard transformer diagram exactly so you always know where you are. You will wonder why nobody thought of this before.

What to know

The page uses WebGL2 and can be heavy on older hardware. Chrome and Firefox work well. The tiny model renders instantly; GPT-2 and larger need to download weights. The source is on GitHub at bbycroft/llm-viz if you want to run it locally.

Worth your time if

You want to understand how a transformer actually processes a token, or you teach others about LLMs and need something better than a static diagram.

Related TMFNK Content

• hfviewer: Visualize Any Hugging Face Model A complementary tool: paste a model URL and get its architecture graph. LLM Visualization shows you the computation; hfviewer shows you the structure.
• How to Train Your GPT Build a GPT from scratch, tokenizer to inference. The visualization shows you what the code you write actually does.
• Learning How Mixture of Experts Works The next step after understanding the dense transformer: how sparse MoE layers route tokens through expert sub-networks.

Crepi il lupo! 🐺

Latent Space: Inside the Model Factory with Eiso Kant, Poolside AI

swyx and Vibhu with Eiso Kant. Duration: 1h 54m

Listen on Apple · Episode page

Timestamps 0:00 Intro 0:54 Karpathy, RNNs, and building code models before Transformers 2:26 The $12M failure and ChatGPT vindication 3:39 Open source and the case for 100 foundation model companies 16:04 The Model Factory (90% engineering) 20:19 Agents inside the model factory 36:07 Laguna S: persistence vs. raw intelligence 58:37 Model harnesses, coding agents, and the path to AGI 1:09:26 Why MCP and traditional tool calls are “stupid” 1:27:37 Open models, AI safety, and the risk of an oligopoly

Eiso Kant spent four years and $12 million building language models for code before the world cared. His first company failed. Then ChatGPT happened, and suddenly everyone wanted what he’d been working on since 2015. This is the story of what he built next: Poolside’s Model Factory.

1. Eiso’s origin story starts with Andrej Karpathy’s 2015 blog post “The Unreasonable Effectiveness of Recurrent Neural Networks.” He read it and pivoted his startup overnight to work on RNNs for code. “I had built a completely unreasonable belief, that neural nets should be able to generalize to anything and everything.” He spent four years and $12 million on this before the company failed in 2019. “People would just laugh at us.”

2. ChatGPT felt like vindication. People started texting him old decks and talks from his failed startup. When he co-founded Poolside, “no one argued if these were stochastic parrots anymore.” The market had caught up to his thesis, which meant he could finally build what he’d always believed in without having to convince anyone it mattered.

3. “Model building is 90% engineering.” Poolside treats training as an industrialized process, not a science experiment. They built what they call the Model Factory with thousands of components that turn raw data into trained models, designed from day one by distributed systems engineers embedded in the research team. The metric they optimize for: speed from a researcher’s idea to a trusted experimental result.

4. Fewer than 70 researchers run 10,000–20,000 experiments per month. Their Laguna XS 2 shipped in five weeks from start of training. Laguna S shipped in eight weeks. The next model started training the day after Laguna S launched. “The model should be an artifact of someone’s process it shouldn’t be a thing in itself.” They treat model building like a SpaceX factory where rockets roll off a production line.

5. Agents are starting to run the Model Factory. Eiso walks behind researchers’ screens and sees agents writing code, launching jobs, evaluating results, and modifying pipelines. “You’re starting to see these twinklings of what RSI is gonna look like.” During the entire Laguna S training run, there were zero on-call events. The only hiccup was the first six hours of a new run when a config inevitably breaks.

6. Eiso thinks MCP and traditional tool calls are “stupid.” His argument: future agents will write scripts instead of choosing from dozens of predefined tools. Rather than giving an agent a catalog of API functions, give it a container and let it write whatever code it needs. Minimal harness, maximum freedom.

7. He would rather live in a world with 100 foundation model companies than 5, even if Poolside were one of the five. This is why they open-sourced Laguna S. He actively wants capable researchers to leave their labs and become his competitors. “If we don’t encourage more labs now, there’s a small window before models are really impacting recursive self-improvement to a level where catching up becomes unfeasible.”

8. Laguna S 2.1 is a 118B total parameter MoE with 8B active per token, beating models nearly 10x its size. It has a 1M token context window, thinking and no-thinking modes, and was trained from scratch in eight weeks. Poolside trains from scratch instead of distilling larger models because they believe the capability ceiling is higher when you own the whole training process.

9. Poolside raised $500 million while investors still questioned whether AGI was real. The name comes from the idea of “refusing to lower your ambitions”, the story goes that when faced with a impossible-looking challenge, you don’t scale down your goal, you scale up your approach. Eiso is a “utopian sci-fi guy” who believes intelligence will become the world’s most demanded and most commoditized resource.

10. Regulation could accidentally lock in an oligopoly of two or three AI companies, and unilateral AI safety doesn’t work in a globally competitive environment. Eiso thinks open models will eventually become too capable to release without restrictions, but we’re not there yet and the window to build a diverse ecosystem is closing fast.

Related TMFNK Content

• No Priors: Andrej Karpathy on Code Agents, AutoResearch, and the AI Psychosis The person who inspired Eiso’s entire journey, on where code agents are heading next.
• MAD Podcast: Dylan Patel on NVIDIA’s New Moat & Why China is ‘Semiconductor Pilled’ The hardware side of the same story; the chips and supply chains that make Model Factories possible.
• MLST: The Real Reason Huge AI Models Actually Work — Prof. Andrew Wilson The theory behind why scaling works, which Eiso’s Model Factory operationalizes.
• All-In: Google DeepMind CEO Demis Hassabis on AI, Creativity, and a Golden Age of Science Another founder building toward AGI, from a different starting point.

Crepi il lupo!

TLDR:

• Shoot 50-200 photos of a scene from every angle (phone works)
• Process them into a splat with a free tool (PostShot, Luma AI)
• Edit and compress in SuperSplat, export as SOG
• Build a web viewer with PlayCanvas Web Components (one HTML file)

Prerequisites: A phone or camera, a computer with a CUDA GPU (optional for cloud processing), and Node.js 18+.

Step 1: Capture the scene

Shoot 50-200 overlapping photos covering your subject from every angle. Move around the subject, not just in front of it. Each photo should overlap its neighbors by 60-80%. Avoid motion blur, reflections, and moving objects.

Pro tip: Video works too. Walk slowly around your subject, then extract every Nth frame. 30 seconds of slow 4K video at 30fps yields 900 frames; extract every 5-10th frame for a good starting set.

Outdoors with moving shadows or wind is harder. Indoors with stable lighting is easiest.

Step 2: Process into a splat

You need a Gaussian Splatting trainer. The easiest entry points:

• PostShot (free desktop app, CUDA GPU required): drag in your images, click train. Outputs a .ply file.
• Luma AI (cloud, web-based): upload photos, wait for processing. Download the result as .ply.
• Nerfstudio + gsplat (open source, advanced): pip install nerfstudio then ns-train gaussian-splatting --data ./images

Training takes anywhere from a few minutes (small scene on a fast GPU) to a couple hours (large scene on cloud). The output is a .ply file with your splat data.

Step 3: Edit and compress in SuperSplat

Open SuperSplat Editor. Drag in your .ply file.

• Crop: remove unwanted regions (background, capture artifacts)
• Clean: delete floating floaters and stray splats
• Compress: export as .sog (PlayCanvas’s compressed open format, typically 80-90% smaller than raw PLY)

SOG is the format you’ll serve on the web. A clean 10MB compressed splat loads faster than a raw 100MB PLY.

Step 4: Publish as a web app

The fastest path is PlayCanvas Web Components; a single HTML file with no build step.

<!DOCTYPE html>
<html>
  <head>
    <script
      type="module"
      src="https://playcanvas.github.io/web-components/v2.3/pcui.js"></script>
    <link
      rel="stylesheet"
      href="https://playcanvas.github.io/web-components/v2.3/pcui.css" />
  </head>
  <body>
    <pc-app splat-url="https://your-site.com/splat.sog" mouse-control="orbit">
      <pc-gsplat></pc-gsplat>
    </pc-app>
  </body>
</html>

Upload index.html and your .sog file together. Host on any static server (Cloudflare Pages, Netlify, GitHub Pages). Done! You now have an interactive 3D viewer.

For more control (custom UI, animations, multi-scene navigation), use the Engine API; it’s the same approach the Grace Cathedral experience uses, with WebGPU compute shaders for fast splat sorting and on-demand rendering that stops drawing when the camera stops moving.

Cleanup

The .ply file is only needed as an intermediate. Keep the SOG for production. Store your source photos in case you need to retrain.

If it breaks:

• Shimmering or ghosting: you didn’t capture enough angles or the lighting changed during capture. Re-shoot with more overlap.
• Splat looks flat: the trainer couldn’t recover depth. Make sure you circled the subject fully, not just shot from one side.
• Low framerate: reduce the splat count in SuperSplat export settings or enable LOD streaming. 3.5 million splats is a desktop target; mobile should aim for 1-2 million.
• SOG doesn’t load: verify the MIME type on your server. .sog should serve as application/octet-stream.

Related TMFNK Content

• Install depth-anything.cpp on macOS: Local Depth Maps from One Photo A different approach to 3D scene understanding; depth estimation from a single image rather than multi-view reconstruction.
• map3d: Generate Real-World 3D City Maps from OpenStreetMap Not photorealistic, but lets you explore the same idea of browser-based 3D navigation from a different data source.
• Build Your Own X From Scratch: Redis, Databases, Compilers, and Web Servers The same build-it-yourself spirit, applied to infrastructure rather than 3D.

Crepi il lupo!

What makes it worth studying is not the scale – 15,000 queries is impressive but not unheard of. It is the design philosophy. Cerebras rejected the “single source of truth” approach that most companies chase and instead built a retrieval layer that meets data where it already lives.

TLDR:

• Index data in place instead of migrating it to a single platform. Slack stays Slack, GitHub stays GitHub, the retrieval layer sits on top.
• Use a single Postgres embeddings table as the universal query interface. Every source writes into the same schema.
• Use hybrid retrieval (full-text + embeddings + IDF + age decay) fused via reciprocal rank fusion before reranking. No single scoring method is trusted alone.
• Distill unstructured conversations into structured records. Slack threads get LLM-processed into questions, summaries, resolutions, and system references before embedding.
• Expose retrieval primitives as MCP tools so any agent can orchestrate them. The planner/synthesis loop lives in the client, not the server.

Reference: How We Built Our Knowledge Base on the Cerebras blog (July 2026), by Isaac, Daniel, and Zenghao.

Design philosophy: meet data where it lives

Most internal tooling projects start the same way: someone proposes moving everything into one platform. A single source of truth. It rarely works because information is generated where it is ergonomic. Slack for quick discussions, GitHub for code, Confluence for docs. Each platform is optimized for its domain.

Cerebras went the other way. They built a system that extracts data from each platform directly, indexes it into a shared embeddings table, and makes everything queryable through a single interface without asking anyone to change how they work.

The core: one Postgres table

At the center is a single Postgres table that holds embeddings, raw summaries, and metadata from every source. Any data source can write into this table. Anything in the table is immediately queryable through the same search pipeline. The design is deliberately simple: define a data source, connect to it, fetch on a schedule, embed, store.

Slack: the hard part

Slack was the most important source and the hardest to get right. Raw vector search over individual messages performs poorly because information density varies enormously. A one-word reply sits next to a detailed kernel debug session, and short filler messages rank higher in cosine similarity than long technical explanations.

Cerebras layered four techniques to solve it:

1. Thread-level indexing. Every message gets resolved into its full thread (parent, replies, everything). The entire thread is stored as one record.
2. LLM distillation. Each thread gets run through an LLM that extracts a structured record: the question being asked, a short summary, the resolution, and systems or code references mentioned. These structured fields are embedded, not the raw transcript. Accuracy went up notably in testing.
3. Bursting. Important individual messages inside long threads still get lost. Cerebras identifies “bursts” (consecutive messages from the same author) and embeds them separately if they clear a quality threshold (rare tokens, minimum length, or social reactions).
4. Hybrid retrieval. Every query runs against four signals simultaneously: full-text search (for exact token matches like error strings), embedding search (for paraphrase), inverse document frequency (to boost rare tokens over filler), and age decay (because Slack answers expire). These are fused with reciprocal rank fusion before a reranker scores them.

Code repositories with CocoIndex

Cerebras initially debated whether code embeddings were worth it. grep is powerful. After reading Cursor’s research on semantic search in codebases, they decided to try.

They use CocoIndex, an open-source framework for code embedding. Language-specific regex chunking splits files at class boundaries first, falling back to method boundaries. Each chunk gets embedded and stored. On every commit, only changed chunks are re-embedded. Some of their repos are over 40 GB.

Query pipeline: planner, executor, synthesis

Every query runs through three stages:

1. Planner: A lightweight LLM inspects the query and active project, then decides which tools to invoke. Available tools include search (unified vector), search_slack, search_code (ripgrep), who_knows, recent_prs, and subsystem_index.
2. Executor: Tool calls fan out in parallel. Results are normalized into a shared evidence schema with scores, recency, and source hints.
3. Synthesis: A final LLM pass produces the answer with citations and cross-source synthesis.

Two interfaces: MCP and Web UI

The same retrieval primitives are exposed as MCP tools for agent use. Each tool corresponds to one retrieval primitive: narrow, structured, and LLM-free. Claude Code or any MCP client becomes the orchestration engine.

The Web UI runs the same planner-executor-synthesis pipeline end to end. From the user’s perspective, it is simply “ask a question and get an answer.”

Projects for scoped search

Teams introduced projects as a way to bundle data sources. A compiler engineer does not want infrastructure runbooks in their results. Projects are lightweight bundles: the same Slack channel or repo can belong to multiple projects. New hires pick a default project during onboarding so they get relevant answers from day one.

Why read the full post

The Cerebras post covers the hard parts that most RAG write-ups skip: why raw vector search fails on Slack, how to set RRF parameters, when to use thread-level versus burst-level embeddings, and how to design MCP tools that stay simple on the server side. These are concrete decisions you will face building any internal knowledge base.

Related TMFNK Content

• Build a Searchable AI Knowledge Base from the Brockhaus & Efron Encyclopedia Also uses CocoIndex and Postgres for RAG, but applied to 86 scanned encyclopedia volumes instead of Slack and code.
• Set Up LEANN for Private Local RAG on macOS A smaller-scale RAG setup for single-user local use, complementing Cerebras’s enterprise approach.
• The Enterprise Context Layer: Synthesis Over Retrieval Another take on making internal knowledge queryable at scale, focused on synthesis architecture.

Crepi il lupo! 🐺

This tutorial walks through Lopopolo’s two artifacts: the OpenAI blog post (the essay) and the lopopolo/harness-engineering repo (the reference implementation). The first is the why; the second is the how.

TLDR:

• Read the OpenAI post in 20 minutes for the full argument: harness engineering is the practice of improving agent output by shaping the environment, not the model.
• Clone Lopopolo’s companion repo for copy-ready templates: AGENTS.md, playbooks, evals, and a structured docs/ directory.
• The core insight: hold the model constant, curate the two external levers, context and tools, and make nonfunctional requirements recoverable from the repo itself.
• Everything in Lopopolo’s repo is CC-BY-4.0 licensed and designed to be pointed at alongside your own codebase.

Prerequisites: Familiarity with coding agents (Claude Code, Codex, Cursor). No prior harness experience needed.

Step 1: Read the OpenAI post

Open openai.com/index/harness-engineering. It is a long read but every section earns its space. Key sections:

• We started with an empty git repository. The scaffold, CI, even the initial AGENTS.md were all written by Codex. No human code to anchor the system from day one.
• Redefining the role of the engineer. Humans stopped writing code entirely. They worked depth-first: break goals into blocks, prompt the agent, identify missing capabilities when things failed. The fix was never “try harder.” It was always “what is missing from the environment?”
• Repository knowledge as the system of record. A 100-line AGENTS.md serves as a table of contents, not an encyclopedia. The real knowledge lives in a structured docs/ directory. Linters and CI validate freshness and cross-links.
• Agent legibility is the goal. Anything the agent cannot access in-context effectively does not exist. Google Docs, Slack threads, and people’s heads are invisible to the system. If it is not in the repo, the agent cannot use it.
• Enforcing architecture, not micromanaging. Custom linters enforce dependency direction, structured logging, naming conventions, and file size limits. The error messages include remediation instructions for the agent.
• Entropy and garbage collection. The team spent every Friday cleaning up “AI slop” until they encoded golden principles into the repo and automated the cleanup. Technical debt is paid down in small increments daily.

Step 2: Clone the companion repo

git clone https://github.com/lopopolo/harness-engineering.git

Open the README. The repo is Lopopolo’s anthology, field guide, and agent context bundle. It is designed to be pointed at alongside your own system: the AGENTS.md routes the task to the relevant arguments, cases, and proof.

The repo structure:

harness-engineering/
├── AGENTS.md           # ~100-line table of contents
├── ARCHITECTURE.md     # top-level map of concepts
├── docs/               # thesis index with deep arguments
│   ├── domain-modeling/
│   ├── durable-systems/
│   ├── last-mile-deployment/
│   └── ...
├── playbooks/          # application-specific harness blueprints
├── evals/              # harness evaluation scripts
├── sources/            # referenced material including the OpenAI post
└── assets/

Success: you now have a reference harness that you can study, adapt, or point your agent at alongside your own repo.

Step 3: Study the core documents

Open docs/ in the cloned repo. Three documents are worth reading first:

1. docs/domain-modeling/make-nonfunctional-requirements-recoverable.md The central argument: quality attributes (reliability, security, maintainability, performance, operability, risk posture, polish) must be retrievable from the repo as context, examples, tools, and executable constraints.

2. docs/durable-systems/make-coherence-cumulative.md How to turn feedback loops into cumulative coherence. Lessons from accepted work, corrections, and failures become context and checks that shape later agent trajectories.

3. docs/last-mile-deployment/ How the agent’s internal action language produces reliable domain outcomes for people who never review the implementation. The harness supplies context, capabilities, authority, and proof.

Pro tip: Do not just read these. Point your own agent at the repo alongside a task. Lopopolo explicitly designed it for that use. The AGENTS.md routes the agent directly to the relevant document.

Step 4: Run the evals (optional)

cd harness-engineering
# check which evals are available
ls evals/

The evals directory contains scripts that test whether a harness is doing its job. Run them against your own repo to measure how legible it is to an agent. Low scores tell you what is missing.

Success: you know your repo’s harness score and have a list of gaps to fix.

Step 5: Adapt the playbooks

The playbooks/ directory contains harness blueprints for specific scenarios. These are the closest thing to copy-paste templates. Adapt one to your project structure.

The key pattern from the OpenAI post: start small, let the agent build the harness itself. The initial AGENTS.md was generated by Codex. Your first harness file does not need to be perfect. It needs to exist and improve over time.

If it breaks

The companion repo is a reference, not a drop-in. Your specific stack will need different linters, different context files, and a different threshold for what constitutes “done.” Start with the AGENTS.md-as-table-of-contents pattern and a structured docs/ directory. Everything else follows from what your agent actually needs.

Related TMFNK Content

• Learn Harness Engineering WalkingLabs’ hands-on course with 12 lectures and 6 projects. Take this after reading the OpenAI post if you want practice building harnesses.
• Karpathy’s AI Coding Guidelines The CLAUDE.md template that started the agent-instructions movement. Harness engineering is what comes after.
• Superpowers: An Agentic Skills Framework The skills framework that agents use inside a well-built harness.

Crepi il lupo! 🐺

It is an open-source live site at tmfnk.github.io/Gutenberg-Stacks, built to run on GitHub Pages with no backend.

TLDR:

• Browse 1,000 free public-domain books by drilling through Category → Era → Subject stacks
• Each book card shows a cover, author, LLM-written hook, and a “stacks (N)” button that shows every stack the book belongs to
• Click any author name to see a stack of every book by that author
• Mobile has a full-height swipe carousel for flicking through books in a stack
• Global full-text search across all stacks from any screen
• Entire site is static. This means no database, no API, no server, no account, no setup. Clone and run locally with npm install && npm run dev

Reference: Gutenberg-Stacks on GitHub (AGPL-3.0)

The design is the point

The interface is a faithful implementation of Winnie Lim’s self-directed learning network prototype, a Vue + Firebase project she built as part of her design essays. The same card anatomy, the same nested-stack drill-down, the same black-and-white visual language. The difference is that this version is a standalone static site: plain HTML and CSS with TypeScript compiling to vanilla JS. No Vue, no Firebase, no backend.

The design philosophy is that discovery works better when you browse by context, not by keyword. A search form assumes you already know what you want. Stacks assume you are exploring. You start from a category (Fiction, History, Philosophy), drill into an era (19th Century, Before 1800), then into a subject, and find books you would never have searched for.

Stacks are everywhere

Two design choices make this more than a nested folder view:

The pivot. Every book card has a “stacks (N)” button. Click it and you see every stack that book belongs to. A philosophy book might also be in History, in 19th Century, and in French Literature. One click jumps you into that stack, so you can follow threads sideways instead of drilling back up.

Authors are stacks. Click any author name on a card and you get a stack of every book by that author in the corpus. This also appears in the pivot modal and in search results. It is the closest thing to walking to a different section of the library because the first book was good.

How the data is built

A Python pipeline runs once, offline, and the output is committed to the repo so the frontend never needs it.

1. Catalog: fetch metadata from the Gutendex API (title, author, subjects, download counts)
2. Excerpts: download each book’s plain text, strip Project Gutenberg boilerplate, keep the first ~2,000 words
3. Embed: run title + subjects + excerpt through sentence-transformers locally (no API cost)
4. Layout: project embeddings to 2D with UMAP, group into clusters with HDBSCAN
5. Enrich: send clusters to an LLM via OpenRouter to name each cluster and tag every book with mood, themes, difficulty, and a one-line hook
6. Export: write the compact JSON the frontend consumes

Every stage caches its output, so the pipeline is resumable. The enrich step requires an OpenRouter API key; everything else runs on-device.

Gutenberg-Book-Finder

Gutenberg Stacks grew out of a previous project, Gutenberg-Book-Finder, which uses the same pipeline and data but shows a more traditional search-and-filter grid with facet filters, a 2D map view, and a “Surprise me” button. Both are live and maintained. Stacks is the evolution toward browsing over searching.

What to read next

The 1,000-book corpus covers the most-downloaded titles on Project Gutenberg, so you get the classics you expect (Dracula, Pride and Prejudice, Frankenstein) and the long tail of obscure works that somehow made the list. The LLM hooks are often surprisingly good at selling a book you otherwise would skip.

Related TMFNK Content

• Find Quality Non-Fiction Books Using the Book Prize Index A complementary approach: where Gutenberg Stacks uses download popularity and LLM enrichment to surface free classics, the Book Prize Index uses prize data and semantic search for non-fiction discovery.
• Uncovered: Judge a Book by Its First Page, Not Its Cover Another discovery-first tool, focused on judging books by their opening lines rather than browsing by category.
• Best Free Books Online: Complete Guide to Digital Libraries Where to find free books once you discover them – Project Gutenberg, Archive.org, and everything else.
• ReadKinetic: A Free Local-First Speed Reader Reads EPUBs and PDFs with RSVP speed reading. Pair it with Gutenberg Stacks to discover and read in one session.

Crepi il lupo! 🐺

TLDR:

• 35+ video lectures covering a full university semester of multivariable calculus, from vectors through Stokes’ theorem.
• Lectures are 20–40 minutes each, with clear blackboard-style explanations and a built-in video player with chat.
• No signup, no ads, no paywall. Open the site and start watching.
• Runs on the Academa.ai platform with video quality options and a sidebar for navigating topics.

Prerequisites: Single-variable calculus (derivatives, integrals, the fundamental theorem). Familiarity with basic linear algebra helps but is not required.

Step 1: Open the course

Go to calculus.academa.ai. That’s it. No account, no email, no “start your free trial.” The lecture list loads immediately with five sections: Vectors and the Geometry of Space, Vector Functions, Partial Derivatives, Multiple Integrals, and Vector Calculus.

Step 2: Pick your starting point

The course is designed to be taken in order, but each lecture stands on its own if you need to review a specific topic. Vectors start with the basics (magnitude, direction, addition) and build up through dot products, cross products, and lines and planes in 3D space; this is about six lectures total. If you already know this material, jump straight to Partial Derivatives or Multiple Integrals.

Step 3: Watch and follow along

Each lecture is a recorded blackboard session with a live instructor. The video player includes a chat panel on the right for questions. Lectures range from 9 minutes (Tangent Plane, Normal Vector to Surface) to 41 minutes (Double Integration), with most around 25–30 minutes.

The sweet spot is the Multiple Integrals section: eight lectures covering double and triple integration in Cartesian, polar, cylindrical, and spherical coordinates, plus a general change of variables. This is where multivariable calculus really separates from single-variable.

Step 4: Work through Vector Calculus

The final section covers vector fields, line integrals, Green’s theorem, curl and divergence, parametric surfaces, surface integrals, and Stokes’ theorem. This is the payoff, the material that makes sense of Maxwell’s equations and fluid dynamics. Stokes’ theorem in particular is worth the whole course.

Pro tip: Watch Lecture 33 (Big Picture of Integration, Stokes’ Theorem) even if you skip everything else. It connects all the integration theorems into a single framework and is the best explanation of the generalized Stokes theorem I have seen in a free course.

If it breaks

There is nothing to break. It is a web page with videos. If a video does not load, try a different browser. The site uses Bunny.net for video delivery, which generally works everywhere.

Related TMFNK Content

• Category Theory Illustrated Another free, visual introduction to an advanced math topic; if you like learning abstract mathematics through diagrams, this is your next stop.
• Elementary Mathematics A rigorous review of pre-calculus mathematics (algebra, trigonometry, number theory) if you need to shore up foundations before multivariable calculus.
• Euclidea A geometry puzzle game that teaches Euclidean constructions through play; a different way to build mathematical intuition.

Crepi il lupo! 🐺

He built a digital version of that experience. The Book Prize Index is a free, searchable catalog of over 7,000 prize-winning non-fiction books. He had Claude Code scrape the data from Wikipedia and used semantic search so you can browse by feel rather than by keyword. Type “books for dads who like Pavement” or “David Attenborough but in book form” and the embedding model surfaces actual titles.

TLDR:

• Browse 7,000+ non-fiction books that won or were shortlisted for major English-language prizes (Pulitzer, National Book Award, NBCC, etc.)
• Use semantic search to find “books like” one you loved, or describe a vibe and see what surfaces
• Explore by subject, publisher, imprint, or prize to find patterns in what gets recognized
• Tools are free, no account needed. Breen pays hosting costs himself.

Reference: Quality non-fiction books are the antithesis of AI slop on Res Obscura, by Benjamin Breen (July 2026).

Why prize data works

Book recommendation algorithms are usually bad because they optimize for what sells, not what lasts. Amazon will recommend the same five self-published diet books to everyone. Prize lists are a filter that solves this: a jury of experts has already done the curation. These books have been read, debated, and judged by people who know the field.

The data covers 55 award programs and 121 prize categories, from the Pulitzers and National Book Awards to more specialized prizes like the Mark Lynton History Prize or the PROSE Awards. Each book gets a recognition score based on how many prizes it won and how many lists it appeared on, weighted by the prestige of each prize.

Semantic search changes how you browse

The most useful feature is the semantic search. It does not just match keywords in titles. You can describe what you want in natural language and the embedding model finds books whose descriptions and content match the feel of your query.

Try searching “long weird biographies of strange people” or “books about exploration that read like adventure novels.” The results are often surprising and genuinely good. This is the closest digital equivalent to pulling a book off a library shelf because the spine looked interesting, then pulling the one next to it because the topic turned out to be fascinating.

The keyword search mode is also there for when you need exact matches. Toggle between them in the search bar.

The publisher and imprint data

One of the most useful pages is the Publishers section, which ranks imprints and publishing houses by how many prize-winning books they have produced over time. You can see which small presses punch above their weight, how the big houses compare, and which imprints to watch if you care about quality non-fiction.

The subjects breakdown is also worth exploring. History leads with 1,554 books, followed by Biography (1,114), Arts and Criticism (681), and Science (614). Each one links to its full list.

Data experiments and visualizations

Breen built a few fun side projects with the data. The chromatic index arranges roughly 5,000 book covers by color. The trends page shows the rise and (potential) decline of non-fiction prizes over time, peaking around 2014.

What Breen argues about non-fiction

The Substack post that accompanies the tool makes a bigger argument: quality non-fiction books are the antidote to AI-generated sludge. They are carefully researched, peer-reviewed in practice if not in name, and they endure. A good non-fiction book from 1993 (like David Levering Lewis’s biography of W.E.B. Du Bois, which won four prizes) can be bought used for four dollars and read with as much profit as anything published this year.

Breen also traces the golden age of non-fiction to factors like jet travel enabling multi-continent research, the erosion of class and gender barriers in academia, and early digital cataloging standards. It is the kind of argument that makes you want to read more books, which is the whole point.

Why read the full post

The Substack post includes Breen’s personal reflections on library browsing, open stacks, the decline of research libraries, and what it felt like to build a tool using Claude Code to solve a problem he cares about. The Book Prize Index itself is immediately useful, but the framing (prize-winning non-fiction as a quality signal in an age of AI noise) is worth sitting with.

Related TMFNK Content

• Uncovered: Judge a Book by Its First Page, Not Its Cover Another book discovery tool that hides the cover and author so you judge by the writing alone. Prize Index shows you what to read; Uncovered shows you how the first page reads.
• The Best Way to Read a Book (That Nobody’s Doing) Jeremy Howard demonstrates using LLMs for close-reading books. Between the Prize Index for finding books and Howard’s method for reading them, you have a full pipeline.
• How I Write: Morgan Housel on How to Master Writing Housel’s “wide funnel, tight filter” approach to reading (pick anything that is 1% interesting and abandon mercilessly) pairs well with the Prize Index’s serendipitous browsing.
• Best Free Books Online: Complete Guide to Digital Libraries Once you discover a book on the Prize Index, this guide shows you where to find it for free.

Crepi il lupo! 🐺

1. The infrastructure is designed as an indexer, not a hoster. Artifacts stay linked to their institutional source. Images are kept as URLs pointing to the source institutions. No content is copied or mirrored. The project is “connective tissue between archives that were never designed to speak to each other.”

2. The data model is intentionally flat to avoid encoding problematic colonial taxonomies. Many museums still categorize items under labels like “Islamic art,” “Asian art,” “ethnological collections”, and “religious objects.” These are categories that reflect the collector’s worldview, not the object’s origin. Ex Situ sidesteps this by prioritizing geographic provenance over institutional categories.

3. The map renders arcs at three zoom levels. At the global view (zoom 0–4), you see territory-to-institution arcs. At the regional view (zoom 5–9), city/site to institution. At the artifact level (zoom 10+), you get precise coordinates for individual objects. The result is a tool that works for both broad pattern recognition and detailed research.

4. Currently indexing from 9 collections including the Metropolitan Museum of Art, the Victoria and Albert Museum, the Staatliche Museen zu Berlin, and the Art Institute of Chicago. It only pulls from institutions with open-access APIs, which means the map unavoidably underrepresents museums that keep their data closed. A commenter on Hacker News pointed out that Paris and Moscow look innocent on the map, because their data is not publicly available.

5. The built-in search lets you filter by origin site or collection, and there is an MD export for researchers who want to download provenance data for a filtered set. There is also a public API at exsitu.app/api/museum-objects/geospatial that returns GeoJSON arc data filtered by zoom level, bounding box, institution, or origin country.

6. Because the data comes exclusively from Western and Euro-American institutions, the scope is a deliberate constraint. The creator notes that expanding to Japanese, Russian, or other museum networks depends entirely on whether those institutions provide open-access APIs. The technical pattern for adding a new resolver is documented in the ETL pipeline (fetch, map, geocode, insert), but each new institution means adapting to whatever API format they use.

7. The project is fully self-hostable and AGPL-3.0 licensed. Stack: Next.js + Deck.gl + MapLibre GL JS on the frontend, Strapi + PostgreSQL/PostGIS on the backend, Python for the ETL pipeline. No proprietary cloud dependencies, no third-party tracking.

The takeaway: Ex Situ turns the relationship between an object’s origin and its current location into a visible, queryable spatial index. It does not host the data or duplicate institutional records. It draws the lines. The map reveals which museums have open data and which do not almost as clearly as it reveals where artifacts came from.

Related TMFNK Content

• The Castle Map: 3,708 Fortresses, One Open-Data Atlas Another open-data spatial atlas, built from Wikidata and Wikimedia Commons instead of institutional APIs.
• SearchWhole.Earth: The Digitally Resurrected Whole Earth Catalog A different kind of open-data catalog; curating interesting things into a browsable index.
• Infrastructure Maps: Four Ways to See the World’s Power Grid A map that makes hidden infrastructure visible, a similar impulse to Ex Situ’s provenance arcs.

Crepi il lupo!

1. The new swarm is organized as a tree: a frontier model acts as planner, decomposing the goal into pieces, while cheaper models act as workers executing those pieces. The design is deliberately shaped by the problem rather than imposing a fixed topology. This is the same planner-worker distinction Thompson described as a future possibility; Cursor just shipped it.

2. The context efficiency of this separation is the core insight. A solo agent that walks the whole task tree has to hold every context layer at once and drifts. In the swarm, a planner never sees low-level implementation detail, and a worker never needs to hold the global picture. Cursor suspects this context efficiency matters more than parallelism for scaling.

3. At 1,000 commits per second, human coordination mechanisms break. Cursor built a custom VCS from scratch, then handled five failure modes that human teams never see: split-brain design (two planners implementing the same thing), planner contention (agents fighting over the same files), merge conflicts (a neutral third-party agent resolves them), megafiles (agents flag bloated files for automatic decomposition), and ossification (agents learn not to touch core code, so Cursor licensed intentional breakage and let the compiler propagate changes).

4. The stacked review system is the error-correction layer. No single review lens catches everything, but decorrelated lenses (different models, different inputs, different personalities), stack like self-driving car sensor fusion. The compute spent on review is high return because review is much cheaper than the work it audits.

5. The Field Guide experiment is a stigmergy mechanism: agents write a shared context folder that is injected into every agent at start. Model weights are frozen, so the only way to shorten the next trajectory is by capturing surprise encounters in the guide. This is the closest implementation I have seen of agents building institutional memory for themselves.

6. The economics are the story. Cursor tested four model mixes: GPT-5.5 (both roles), Grok 4.5 (both), Opus 4.8 planner + Composer 2.5 workers, and Fable 5 planner + Composer 2.5 workers. All passed 100% of the SQL test suite. Costs ranged from $1,339 (Opus hybrid) to $10,565 (GPT-5.5). In the cheapest configuration, the Opus planner produced a small fraction of tokens but two-thirds of the cost, while workers handled the vast majority of tokens for one-third of the cost. In the most expensive, those same workers cost $9,373. This is a big win because they were running GPT-5.5 for a job a cheaper model could do.

7. The old versus new comparison is staggering. On the same task with the same time budget, the old swarm produced 68,000 commits and 70,000+ merge conflicts in two hours before it had to be paused. The new swarm produced under 1,000 conflicts over its full four hours. The old codebase needed 64,305 lines. The new one did it in 9,908.

The takeaway: This is the Thompson thesis in microcosm. When intelligence becomes a commodity, the winning strategy is not the smartest model but the optimal planner-worker split. The cost difference between the cheapest and most expensive configurations was 8x with identical outcomes. Cursor’s swarm is a working demonstration of what happens when you stop optimizing for capability and start optimizing for cost structure.

Related TMFNK Content

• Who’s Afraid of Chinese AI Models? Ben Thompson Maps the Commodity Math Thompson’s commodity market analysis is the theory; Cursor’s experiment is the existence proof.
• Is Grep All You Need? How Agent Harnesses Reshape Agentic Search A direct comparison of agent harnesses (Claude Code, Codex, Gemini CLI); the same abstraction-level question Cursor is asking, applied to search workflows.
• The Rise of Computer Use and Agentic Coworkers The architectural precursor: why model capabilities alone are not enough and orchestration matters.
• Harness Engineering for Self-Improvement: Lilian Weng’s Survey OpenAI’s perspective on agent orchestration and self-improvement loops, directly relevant to Cursor’s swarm architecture.
• State of Agentic Coding #6 with Armin Ronacher and Ben Vinegar The practical state of agentic coding tools, the ecosystem Cursor is building for.
• Latent Space: Inside the Model Factory with Eiso Kant, Poolside AI Another take on the model economics problem; how a small team runs 20,000 experiments per month.

Crepi il lupo!

Chamath Palihapitiya. Duration: 15 min

Timestamps

• 0:00 Building a compound interest table
• 2:02 The risk curve and taking responsibility
• 2:36 Learning from Bezos and Elon the hard way
• 4:52 Investing in what you love
• 7:14 Tax-loss harvesting as a backup plan
• 8:24 Get rich slow
• 10:32 Knowing your goal and the barbell strategy
• 14:06 Just start and tell nobody

Chamath Palihapitiya (early Facebook executive, Social Capital founder, former Warriors owner) gives the rawest investing advice I have heard in a while. He walks through his own mistakes (the time he ignored the two best capital allocators in the world and torched $5 billion), and the frameworks he uses instead.

1. Build your own compound interest table before you buy anything. Chamath says he built one for an athlete who just signed a giant contract. He took the salary, subtracted taxes and fees, and showed him what it would look like at 7% over 30 years. The athlete’s mind was blown. Then Chamath backed it off to 1/1000th of that starting number, and his mind was still blown. “Even with the most meager of beginnings,” Chamath says, “you can post huge numbers if you focus on a systematic process over 20 and 30 years.”

2. Know exactly where you sit on the risk curve or stay out. “The further out on the risk curve you are, the odds are that there’s the risk of capital loss,” Chamath says. “And if you don’t know where you are out on the risk curve, you shouldn’t be there. Take your money, stick it into an index fund, just go home. This is a tough game, and most people lose at this game.”

3. Here is the mistake that cost him billions. In November 2021, Chamath saw Jeff Bezos and Elon Musk start selling their stock. He says he thought to himself, “These guys are the two best capital allocators in the world today. If they’re selling, I should sell.” He sold a little but not nearly enough. By March 2022, the Russia-Ukraine war started, the market tanked, and his SPAC positions got obliterated. His honest diagnosis: he had confused his growing fame with growing skill. He was too afraid to tell everybody to cut to cash. Now his rule is: when someone structurally smarter than him does something against his positions, he immediately asks, “Prove to me why I shouldn’t do the same.”

4. Your first investment should be a product you love and use. He tells this story every time someone asks him how to start: on vacation with his two sons, they won a few hundred dollars betting on golf. The older son said, “I like the price action of Virgin Galactic”. He blew the $200 in, made $3,000, bought a computer, and never returned. The younger son said, “I like Xbox, PlayStation, and Nintendo”. He bought all three, compounded at roughly 30% over the next three years, and is still in the game. Chamath’s rule: “Look around you at the products that you love, that you think are incredible, that are well-made. Find out who makes those things and see if that company is public.”

5. US tax code makes your losses a backup plan. Chamath says most investors do not know that capital losses carry forward indefinitely in the US, offsetting future gains with no expiration date. “When you lose money (not if but when), take the time to understand why: were you too greedy, too short-term, did you misjudge the risk? All that money will come back to you if you course-correct.”

6. Investing is a get-rich-slow game. “Every time that people want get-rich-quick schemes, they stop thinking for themselves, they start looking for answers from others, they invariably blow up, and then they blame others,” Chamath says. “Don’t do that to yourself. You are responsible. Do not make decisions you cannot justify as your own decisions.”

7. The barbell strategy lets you take big risks without going to zero. Chamath frames his whole portfolio as a barbell: most of his capital sits in concentrated, asymmetric bets on technology. On the other end, he hedges with cash and uncorrelated assets. The most uncorrelated thing he could find? Professional sports. He bought 10% of the Golden State Warriors for $25 million, later sold for $500 million. But he says the investment would have been worth it even at zero appreciation because it gave him “the mental freedom to go and build my investing chops in technology.”

8. Just start. Tell no one. The only people who care how much you start with are other people, and they care because it makes them feel better about their own decisions. “What’s $50? What’s $100? To others it seems meager and not worth it.” Chamath’s advice: start anyway, keep your mouth shut, and “show up 10 or 15 years later with a huge war chest and shove it up their ass.”

Related TMFNK Content

• How To Apply Compound Interest To Everything In Your Life Chamath’s first takeaway (the compound interest table) is the whole point of this video.
• Charlie Munger: Saving the First $100,000 Will Change Your Life Same ethos: starting small and letting time do the work.
• The Wealth Ladder Explained: How to Build Wealth at Every Stage Nick Maggiulli’s framework for where you are and what to do next.
• Mohnish Pabrai on Dhandho Investing, Checklists, and Korea Another investor who preaches the same low-turnover, high-conviction approach.

Crepi il lupo!

The BBC has been recording sound for nearly a century. Every radio drama, documentary, and field report generated audio artifacts; rain, footsteps on gravel, jungle ambience, creaking ship hulls, typewriter clatter, distant church congregations, someone vigorously washing their hands. They digitized the whole thing and put it online.

1. Search any word, and it instantly finds matching recordings. “Rain” returns downpours, drizzles, and thunderstorms recorded on three continents. “Footsteps” gives you gravel, carpet, snow, wood, and wet leaves; each with multiple takes. The specificity is the point. A BBC engineer probably recorded the exact sound you need decades before you were born.

2. Filter by category (transport, weather, footsteps, machinery, animals), duration (short clicks to minute-long atmospheres), and continent where the recording was made. Want a 30-second jungle ambience recorded in South America? That’s three clicks.

3. Every sound previews in the browser. The built-in mixer lets you layer multiple recordings (rain under footsteps, traffic behind dialogue, wind over a room tone), and download the mix as a single file. No DAW needed for quick comps.

4. The honest caveat: you need to credit the BBC for personal/educational use, and commercial use requires a license. Download quality is generally 192kbps MP3, fine for prototyping and web use but not broadcast archival. Some older recordings have noticeable tape hiss, which is either a limitation or a feature depending on what you’re making.

Worth your time if: you need real, human-recorded sound effects and don’t want to sift through synthetic stock libraries or pay per-download on audio marketplaces.

Related TMFNK Content

• Buzz: Transcribe & Translate Audio Offline The opposite pipeline; turn audio into text when you need to caption or transcribe sound effects.
• Petrichor: Native macOS Offline Music Player For listening to ambient mixes built from BBC sound layers.
• Best Free Background Noise Websites and Apps for Focus, Sleep & Relaxation Different source of ambient audio, focused on focus and sleep rather than production.

Crepi il lupo!

Liisa Apunen. Browser. Play it here.

I crashed my first plane within 15 seconds. My second within 30. Then something clicked: drag the plane to the colored dot at the end of its matching runway, and it lands. Dragging to the wrong color does nothing. Not dragging at all means midair collisions. The game hit 852 points on Hacker News in its first three days, and after playing for an hour I understand why.

1. The core mechanic is the same one that made Flight Control (2009) an iPhone classic: draw a path from a plane to its runway. Planes are color-coded, runways are color-coded, and the game trusts you to figure this out on your own. There are no instructions. You learn by crashing.

2. Departing planes add the twist that makes this harder than Flight Control. Every runway periodically launches a plane that rolls across the taxiway at walking speed. You cannot control departing planes, so you have to route incoming traffic around them. The predictable congestion is the whole challenge: knowing a departure is coming and clearing the airspace for it.

3. The difficulty ramp is well tuned: spawn rate goes from one plane every 5 seconds to one every 1.5 seconds over the first 5 minutes, and the max aircraft on screen goes from 3 to 12. The game never spikes. It just quietly becomes impossible, and you keep playing anyway because your last run was 86 landings and this one might hit 90.

4. Built with SvelteKit and PocketBase, 3D pixel art in a pastel palette, bilingual interface (Finnish/English). The developer added a hide-scoreboard button within hours of HN feedback and cleaned the leaderboard of fake scores the same day. Responsive development.

5. The leaderboard shows your nearest airport alongside your score, which is a nice touch. It also reveals the HN audience: someone landed 90 planes in 7 minutes and 29 seconds. That is the score to beat.

Play it if: you miss Flight Control or Mini Metro and want something that lives in a browser tab. Skip it if: the idea of managing 12 simultaneous crash vectors does not sound like fun.

Related TMFNK Content

• Web Swing Through Midtown NYC Another browser game that nails one mechanic perfectly, released the same day.
• Mooncraft: A Lunar Trucking Sim Built in Plain JavaScript Same indie-browser-game energy; one person, one mechanic, no fluff.
• Starfling: Tap, Release, Sling Between Stars The same learn-by-failing loop, astrophysics edition.

Crepi il lupo!

depth-anything.cpp is a C++17/ggml port of Depth Anything 3. It is a CLI you run on your own machine. No Ollama. No PyTorch. On a Mac I went from empty folder to first PNG in about twenty minutes.

TLDR:

• You want relative depth from one RGB image, offline, on Apple Silicon.
• Clone with --recursive, then build CPU Release (DA_GGML_METAL=OFF on my M2).
• Put depth-anything-base-q4_k.gguf (~99MB) in models/.
• Run da3-cli depth ... --png out.png. The flag is --png, not --out.
• Metal segfaulted on me (exit 139). CPU finished.

Prerequisites: macOS on Apple Silicon, plus git, cmake, clang++ (Xcode CLT), and either curl or the hf CLI.

Why bother

Monocular depth is an educated guess. One JPG does not contain real meters. The model still produces a near/far field that is useful for a lot of day-to-day work: pull a subject off a busy background, feed parallax into an editor, export --glb or a reconstruct/--ply mesh once you move to larger weights, or prototype perception code without buying a depth sensor. And the photo never leaves disk.

It will not replace a tape measure. The PNG is relative depth (farther usually looks lighter in the default export). True metric scale needs the nested/metric GGUFs and a different setup. Use BASE first. If the images look sane, then chase metric.

I reached for the C++ port instead of a notebook because ggml plus one binary means one compile, one weight file, and no torch/CUDA dependency fight. Local chat apps will not load these GGUFs. Think of da3-cli the way you think of ffmpeg: you call it, you get a file, you move on.

Step 1: Clone the repo

cd ~/Documents
git clone --recursive https://github.com/mudler/depth-anything.cpp
cd depth-anything.cpp

You should see third_party/ggml on disk. If you forgot --recursive, the build will fail later. Fix with git submodule update --init --recursive.

Step 2: Build the CLI (CPU)

cmake -B build -DCMAKE_BUILD_TYPE=Release -DDA_BUILD_CLI=ON -DDA_GGML_METAL=OFF
cmake --build build -j

When it works, build/examples/cli/da3-cli exists. I tried -DDA_GGML_METAL=ON first. Metal came up, weights moved to the GPU, then the process died with exit 139. CPU ran clean. Stay on CPU until Metal works on your box.

Step 3: Download DA3-BASE weights

mkdir -p models
curl -L --fail -o models/depth-anything-base-q4_k.gguf \
  "https://huggingface.co/mudler/depth-anything.cpp-gguf/resolve/main/depth-anything-base-q4_k.gguf"
ls -lh models/depth-anything-base-q4_k.gguf

Or: hf download mudler/depth-anything.cpp-gguf depth-anything-base-q4_k.gguf --local-dir models.

You want a file around 99MB. Q4_K BASE is the right first download: small, fast, good enough to decide if this tool fits your photos. Bigger and metric variants sit in the same Hugging Face repo when you need them.

Step 4: Run a test photo

./build/examples/cli/da3-cli depth \
  --model models/depth-anything-base-q4_k.gguf \
  --input ~/Downloads/your-photo.jpg \
  --png ./depth.png

I got a line like depth 378x504 min=0.5225 max=1.6810 and a depth.png next to the command. Your size and range will differ. Open the PNG beside the source. You want a coherent near/far field, not salt-and-pepper noise.

Floating point for code: add --pfm depth.pfm. 3D: try --glb or reconstruct after BASE looks right on your domain.

Pro tip: leave the binary and GGUF in the build tree. There is no app-store install. You keep calling the same two paths.

Cleanup

Nothing to uninstall. Drop the clone if you are done:

rm -rf ~/Documents/depth-anything.cpp

If it breaks:

• unknown flag: --out means you wanted --png or --pfm.
• Exit 139 after Metal init: rebuild with -DDA_GGML_METAL=OFF.
• Missing ggml: re-clone with --recursive, or init the submodules.

Related TMFNK Content

• Fine-Tune a Local SLM to Clean Master Data on Your Mac Another Apple Silicon local-ML path that stays off the cloud.
• Set Up LEANN for Private Local RAG on macOS Local retrieval when you want private search next to vision tools.
• Run Autonomous LLM Research with autoresearch: Let AI Agents Train Models Overnight Heavier local training loop when a one-shot CLI is not enough.

Crepi il lupo! 🐺

TLDR:

• Install Voicebox from GitHub releases (macOS/Windows, ~5 min)
• Clone a voice from 10-30 seconds of clean audio (one drag-and-drop, ~2 min)
• Generate speech from any text in that voice (one click, seconds)
• Build a multi-speaker story in the Stories Editor timeline (drag, position, render)

Prerequisites: macOS 11+ or Windows 10+ with 8GB RAM and 5GB free disk. GPU optional but recommended. Download the right build from github.com/jamiepine/voicebox/releases.

Step 1: Install Voicebox

macOS (Apple Silicon):

# Download and extract
curl -L https://github.com/jamiepine/voicebox/releases/latest/download/voicebox_aarch64.app.tar.gz -o voicebox.tar.gz
tar -xzf voicebox.tar.gz
mv Voicebox.app /Applications/

macOS (Intel) or Windows: Grab the matching .msi or .tar.gz from the releases page and install normally.

Launch Voicebox. The first run downloads your chosen TTS engine model automatically (Qwen 1.7B is ~3.5 GB; Kokoro is ~350 MB if you want to start small). Wait for the green status indicator in the bottom-left.

Step 2: Clone a voice from audio

Go to Profiles → + New Profile and pick a cloning engine. Qwen3-TTS 1.7B gives the best overall quality across 10 languages. Chatterbox Multilingual covers 23 languages if you need broader support.

Drag in a WAV file (MP3/M4A/FLAC work too) with 10-30 seconds of clear, quiet speech. No music, no background noise. Click Create.

Voicebox extracts a voice embedding and stores it with the profile. Test it immediately with a phrase like "Hello, this is a test of my voice profile." If it sounds robotic, add a second sample — different tone or speaking style helps.

Pro tip: Record in a quiet room with the mic 6-12 inches from your mouth. Soft furnishings reduce echo. You don’t need a studio — just no fans, AC, or keyboard clatter.

Step 3: Generate speech

Select your new profile from the dropdown in the Generate tab. Type or paste your text. Use normal punctuation for natural pauses. ALL CAPS adds emphasis; italics for subtle emphasis.

Click Generate. The audio appears in seconds (faster with a GPU). Preview, then download as WAV.

For long scripts, Voicebox auto-chunks with crossfade — no manual splitting needed.

Step 4: Build a multi-speaker story

Go to Stories → + New Story. Create one track per speaker.

1. Add clips — drag from Generation History, generate new clips inline, or upload audio files
2. Position — drag clips onto the timeline, trim edges, adjust spacing
3. Render — click the render button to export the mixed audio

The Stories Editor is a lightweight DAW timeline. It’s not full-featured yet (crossfades and effects are coming), but it handles the core use case: multi-host podcasts, audiobook narration with character voices, game dialogue scenes.

Pro tip: Clone two voices — one for each speaker — then generate all clips first, drag them into the timeline, and arrange. You’ll see the whole conversation laid out visually.

Cleanup

Voicebox stores profiles and audio in:

• macOS: ~/Library/Application Support/sh.voicebox.app/
• Windows: %APPDATA%/sh.voicebox.app/

To reset: delete the profiles folder and restart Voicebox.

If it breaks:

• Model download hangs: Check disk space. Models range from 350 MB to 8 GB.
• Robotic voice: Add more samples. One 10-second clip is the minimum; two clips with different tones is better.
• No audio on macOS: Make sure Voicebox has microphone access in System Settings → Privacy & Security → Microphone.

Related TMFNK Content

• How to Transcribe or Translate Audio Files with Buzz Buzz is the other half of the local voice loop — turn speech into text when Voicebox turns text into speech.
• Set Up LEANN for Private Local RAG on macOS Another local-first AI tool that runs entirely on your machine, no cloud.
• Explore the Vowel Space: Interactive Sound Synthesis A different angle on voice — how vowel sounds actually work and why they matter for synthetic speech.

Crepi il lupo! 🐺

Melissa (UC Berkeley). Duration: 30 min

Timestamps

• 0:00 The agent configuration problem
• 2:52 How people configure systems today (vibe coding)
• 6:04 Pipeline changes beat model changes
• 8:21 Per-query variance
• 11:24 The Matei vs. Melissa example
• 13:19 Research question formulation
• 15:32 BRAIN system overview
• 19:08 Query characteristics
• 20:25 Per-configuration predictors
• 22:26 Results and cost reduction
• 23:52 Classical ML beats end-to-end deep learning
• 26:05 Future work and coding agents

Most teams building agent systems configure them by gut feel: pick a strong model within budget, run A/B tests, ship if it passes. Melissa ran the numbers on that approach and found costs vary by three orders of magnitude for the same accuracy. She presents BRAIN, a system that picks the right pipeline for each query automatically.

1. Choosing an agent architecture matters more than choosing a model. Fix the model to GPT-5 Nano and vary the pipeline (LM-only, simple RAG, agentic RAG, full agent loop), and you span three orders of magnitude in cost and a wide accuracy range. Vary the model while holding the pipeline fixed, and the range is much smaller. Pipeline configuration, not model selection, is where the real leverage is.

2. Current industry practice is vibe configuration. Melissa ran a study of production agent systems. Teams pick a model from the Arena leaderboard, run some test cases, and ship. Nobody systematically considers cost-performance tradeoffs. And anecdotally, the bill is starting to bite: Microsoft and Uber recently flagged that their AI spend no longer justifies the automation gains.

3. Queries vary massively in what they need, even within the same workload. “Who is Matei Zaharia?” GPT-5 already knows, answer with LM only. “Who is Melissa?” Same semantic structure, but the model hallucinates. It needs web search. A static pipeline that handles both cases is either over-engineered for the easy ones or under-powered for the hard ones.

4. BRAIN’s core idea: transform the query into structured characteristics, then predict the best configuration. Instead of feeding raw natural language to a router, BRAIN uses an LM to generate workload-specific binary features for each query: “involves a famous person?”, “requires multi-hop reasoning?”, “references cooking?”. This vector is much closer to the system configuration space than the raw text is.

5. The characteristics are generated per-workload, not universal. Given 25 sample queries from a benchmark, an LM proposes the dimensions that separate them. The FinanceBench characteristics look different from the BrowseComp ones. This keeps the feature space small and meaningful.

6. BRAIN trains one classical ML predictor per candidate configuration. Each predictor (XGBoost or logistic regression) learns: given a query with these characteristics, will this configuration answer it correctly? At runtime, a new query hits all predictors, and BRAIN picks the cheapest configuration whose predictor says it will succeed.

7. The results: 89% cost reduction at 100% static accuracy on BrowseComp Plus. BRAIN is the only method tested that meets the 100% accuracy target across all three benchmarks (MUSIC, BrowseComp Plus, FinanceBench) while cutting cost. And the savings come from doing less work per query, not from guessing wrong on hard ones.

8. Classical ML beats end-to-end deep learning here. Melissa tried fine-tuning BERT and transformers on the profiling data to predict configurations directly. They performed worse than XGBoost on the query characteristics. The reason: profiling data is expensive. Just one benchmark cost $11,000 to profile. Deep learning needs more data than that to beat a good feature engineering approach.

9. Per-query routing is the natural next step beyond per-workload tuning. Most optimization today happens at the workload level (tune one pipeline for all queries). BRAIN shows that the intra-workload variance is large enough that per-query routing is worth the complexity. The system that treats every query the same is burning budget on easy ones and under-serving hard ones.

10. The next frontier is coding agents. Melissa is extending BRAIN beyond retrieval-heavy agent systems to coding agents, where the configuration space includes tools, context windows, and test strategies. That is a harder problem. It is also where most production money is going.

Related TMFNK Content

• Is Grep All You Need? How Agent Harnesses Reshape Agentic Search Melissas argument that pipeline architecture beats model selection echoes the finding that simple search with agent orchestration outperforms complex RAG pipelines.
• State of Agentic Coding #6 with Armin Ronacher and Ben Vinegar The practical economics of agentic coding pipelines, covering exactly the cost-accuracy tradeoffs that BRAIN aims to solve automatically.
• The Magic of Average: Why LLMs Make Simple the New Powerful The insight that simpler configurations often outperform expensive ones mirrors BRAINs finding that the cheapest pipeline is frequently the right one.
• Harness Engineering for Self-Improvement: Lilian Weng’s Survey The companion piece on the engineering side of agent systems: how to design the harness and orchestration layer that BRAIN then optimizes over.

Crepi il lupo! 🐺

Alex Hormozi on Modern Wisdom with Chris Williamson. Duration: ~90 min

Timestamps

• 0:00 His mom passed four weeks after his $106M launch
• 2:52 AI is being used in the wrong places
• 6:04 The $350K AI that replaced $11K/month VAs
• 8:21 Stakes, reality as moat, content strategy
• 11:24 Outsourcing thinking to AI makes you dumber
• 13:19 The block tower analogy for long-term thinking
• 15:32 Why $10M and $100M businesses are built differently
• 19:08 Customer retention math: the hole in the bus
• 22:26 Hiring: stop looking for unicorns
• 26:05 Selling out of your own wallet
• 30:38 The value equation
• 35:00 Price as a signal for value
• 40:00 His father’s immigrant story
• 45:00 Marrying the right person
• 50:00 Incentives drive all behavior
• 55:00 Where to start: just get an LLC and make your first dollar

Hormozi showed up to this conversation four weeks after his mother died, right after a $106M launch. That loss frames everything that follows. He doesn’t lecture from a pedestal; he’s working through things in real time.

1. Don’t outsource your thinking to AI. Hormozi pulls up three frontier models, asks them the same question, and gets three different answers. That’s the tell. Judgment is still the bottleneck. Hand decision-making to the model and you atrophy. Your brain is the best asset you have right now. Keep it sharp.

2. Most people are using AI in the wrong places. He watched a business drop $350,000 building an AI system to replace 11 virtual assistants that cost $11,000 a month. Three years of VA costs for something that wasn’t even the constraint. The company still needed more customers. The AI project did nothing for growth. Hormozi says it was a distraction wearing an efficiency costume.

3. The foundation determines the ceiling. Hormozi’s block tower analogy: five seconds to build? You stack blocks however. Five years and unlimited blocks? You dig a foundation, pick different materials, engineer for height. Most entrepreneurs build for a five-second exit and then wonder why they can’t scale past one story. Focus and patience are competitive advantages precisely because they’re so anti-human.

4. The fastest way to $10M is not the fastest way to $100M. A solo agency can hit a million in a year with one good client. A hundred million demands recurring revenue, systems, and a product people actually stick with. The trap is building a $10M business on a foundation that can’t hold a $100M one, then trying to stretch it.

5. The hole in the back of the bus kills growth. Company A gets 100 customers a year and keeps them all. Company B gets 100 a year and loses all 100. Three years in, both show $3M revenue on paper. But Company B is spending 3x on acquisition just to tread water. Retention isn’t a nice-to-have. It’s the structural difference between a business that compounds and one running on a treadmill.

6. You’re not hiring a unicorn. You’re hiring a rhino, a horse, and some fireflies. Founders want someone who’s lived their exact life and knows everything they know. That person doesn’t exist. Break the role down: rhino (the specialist skill), horse (the general capability), fireflies (the culture sparkle). You can find those three people faster than one mythical creature.

7. Selling out of your own wallet destroys margins. If you’re good at fixing cars, you think it’s easy; so you charge less than it’s worth to the person who can’t do it. Result: no margin, no capacity to hire, endless time-for-money trap. Hormozi’s move: add a zero to your price. Then figure out what you’d have to deliver to make it fair. The exercise forces you to build a premium offer.

8. The value equation runs every transaction. Outcome × perceived likelihood ÷ (time delay + effort/sacrifice). Most founders obsess over the outcome. The leverage sits in the other three, especially perceived likelihood. That’s why proof, testimonials, and authority work; they make the same outcome feel more certain.

9. Reality is the moat in content. AI is flooding feeds with generated slop. The only durable edge is having actually done the thing. Hormozi points to Musk, Bezos, Buffett: they’re the biggest influencers in their domains because they built the real businesses first. No track record? Document the work. Show the struggle. The real part can’t be faked.

10. The best financial decision he ever made was who he married. He’s unusually vulnerable here. His wife Ila has bigger dreams than he does, carries him through troughs of apathy, and runs the operational side of the business. He would’ve taken his foot off the gas and bled talent without her. A reminder that the biggest business decision you make might not look like a business decision at all.

Related TMFNK Content

• My First Year in Sales as a Technical Founder The kind of raw, practical sales reality Hormozi keeps coming back to; fundamentals over flash.
• Know Your Customers’ Jobs to Be Done A systematic way to get at what Hormozi calls the value equation: the outcome the customer actually hires you for.
• Pricing Your AI Product — Lessons from 400+ Companies and 50 Unicorns Madhavan Ramanujam on outcome-based pricing, directly extending Hormozi’s point that price is the strongest signal of value.
• Good to Great by Jim Collins Collins’ disciplined-people, disciplined-thought, disciplined-action is the book-length version of Hormozi’s argument that focus and patience are the only moats that last.

Crepi il lupo! 🐺

I picked this up because I needed a language for what happens when a child shuts down, gets stubborn, or melts down over something small. Siegel gives you that language, and it reduces to one clean distinction: are they in a Yes Brain state or a No Brain state?

1. The core distinction is everything. A child in a Yes Brain state is open, curious, flexible, and resilient. They can make decisions, handle novelty, and learn from mistakes. A child in a No Brain state is rigid, reactive, and stuck. They are at the mercy of their circumstances and their feelings, unable to shift their emotions, complaining about reality instead of responding to it. They worry obsessively about making a mistake or facing something new. Stubbornness rules the day. The same kid can flip between these states depending on hunger, sleep, or the moment’s emotional weight.

2. Siegel reframes the standard parenting milestones. The “terrible twos, terrifying threes, and frustrating fours” are not a punishment you endure. They are developmental windows where the brain is building its regulatory architecture, and the child needs you to co-regulate, not escalate. A two-year-old having a tantrum is not being bad. Their prefrontal cortex is under construction.

3. The goal is not to eliminate No Brain states but to build the skill of returning to a Yes Brain after being in a No Brain mode. Siegel calls this equanimity. It is a learnable skill, and it is the foundation of resilience. When kids develop the ability to notice they are stuck and find their way back to openness, you have given them something that will serve them for life.

4. The ancient Greeks had a word for the kind of happiness that comes from this balanced state: eudaimonia. It is composed of meaning, connection, and peaceful connectedness. Not the absence of struggle but the capacity to remain whole within it. Siegel argues that this is one of the most empowering gifts we can give our children, and that building a coherent narrative about their own experience is how they get there.

5. Post-traumatic growth is real, and it depends on narrative. Children who can tell a coherent story about something hard that happened to them integrate the experience instead of being defined by it. A coherent narrative is not about making the trauma sound fine. It is about making sense of what happened, how you felt, and how you got through it. That process literally reshapes the brain’s response to future stress.

6. “Behavior is communication.” This is the line I keep coming back to. When a child acts out, they are not giving you a problem to solve. They are sending a signal about an unmet need. A No Brain state is a distress signal. Responding to the behavior instead of the signal escalates the fight. Responding to the signal helps the child return to a Yes Brain and builds the trust that makes future regulation easier.

7. The book is written for parents but applies to anyone who works with children or, honestly, to anyone who wants to understand their own reactive patterns. Adults have No Brain states too. The same framework applies. The difference is that as an adult, you are responsible for building your own equanimity rather than relying on a parent to co-regulate you.

Verdict: Read it. The core idea is simple enough to explain in a paragraph, but the book earns its length by giving you the language for dozens of real situations. My main criticism is that it is repetitive in the middle chapters. The last third, especially the material on post-traumatic growth and coherent narrative, is where the deeper value lives. If you only have time for one parenting book, this might be it.

Related TMFNK Content

• Good Inside: A Practical Guide by Dr. Becky Kennedy Both books center on the idea that a child’s difficult behavior is communication, not defiance.
• The Book You Wish Your Parents Had Read by Philippa Perry A complementary take on how adult emotional patterns trace back to childhood, with a similar emphasis on repair and narrative.
• Born for Love by Bruce D. Perry Explores the neuroscience of empathy and connection, supporting Siegel’s argument that relationships shape brain development.
• What Happened to You by Bruce D. Perry and Oprah Winfrey On trauma, narrative, and the power of asking “what happened to you” instead of “what is wrong with you.”

Crepi il lupo! 🐺

In June 2024, Leopold Aschenbrenner—Columbia valedictorian at 19, former OpenAI superalignment researcher—published Situational Awareness: The Decade Ahead. The intro alone reads like science fiction until you notice the footnotes are compute curves and transformer counts. His claim: a few hundred people in SF already see what is coming; everyone else is still debating whether ChatGPT is glorified autocomplete. The series is five essays plus a coda. Whether you buy the timeline or not, it is the clearest written map of what the frontier labs’ optimists actually believe.

1. The core prediction is a stacked extrapolation, not a vibe. Essay I (“Counting the OOMs”) traces GPT-2 → GPT-4 as a jump from ~preschooler to ~smart high-schooler in four years. Add ~0.5 orders of magnitude per year in compute, ~0.5 in algorithmic efficiency, plus “unhobbling” (chatbot → agent → long-horizon reasoner), and AGI by 2027 is “strikingly plausible” in his framing—not a proof, a trendline argument.

2. Human-level is a waypoint, not a ceiling. Essay II: once you have many millions of AGI copies, they can automate AI research itself—compressing a decade of algorithmic progress into a year or less. That is the intelligence explosion thesis: human-level systems become vastly superhuman fast. The power and the failure modes scale together.

3. The industrial story is literal. Essay IIIa: boardroom talk already moved from $10B clusters to $100B to trillion-dollar training runs. He expects tens of percent growth in US electricity this decade, GPU buildouts from Pennsylvania shale power to Nevada solar—an industrial mobilization not seen in fifty years. Stargate and hyperscaler capex in 2025–26 look less absurd read against this frame.

4. Security and alignment are the bottlenecks he fears most. IIIb: leading labs treat AGI weight security like a startup problem while nation-state espionage is the threat model. IIIc: controlling systems smarter than you is an unsolved technical problem that gets harder during a rapid capability spike—not “we’ll figure it out later.” IIId: superintelligence is decisive for economic and military order; the US–China race is existential in his telling, not a trade dispute.

5. “The Project” is the endgame. Essay IV: by 2027–28 the US national security state wakes up; superintelligence is not a product feature you ship from a Series B. Somewhere in a SCIF, a government AGI program begins—Oppenheimer parallels invited explicitly. He dedicates the series to Ilya Sutskever. The acknowledgments list half the alignment debate (Leike, Karnofsky, Shulman, Dwarkesh, and TMFNK VIP Avital Balwit).

6. You might think this is SF hubris—and the track record of AI timelines deserves skepticism. Aschenbrenner admits the “few hundred people” might be a historical footnote. Critics note: extrapolating OOMs assumes no physical, regulatory, or economic cliff; enterprise AI still shows weak ROI in surveys like MIT’s GenAI Divide; “AGI” is undefined enough to always move one year out. Fair pushback. The series is still worth reading because the people building the models largely operate as if the trendlines matter—whether or not 2027 is the year.

7. Two years in, some threads aged visibly. We got reasoning models, agent hype, and megawatt datacenter headlines—not yet superintelligence or a public “Project.” Lab security remains embarrassing; export controls and chip friction are real. The intro’s “Nvidia analysts think 2024 might be the peak” line already reads as a tell: the market keeps repricing up. Use the essays as scenario planning, not prophecy.

The takeaway: Read situational-awareness.ai once (PDF linked on the site) so you know the strongest version of the fast-takeoff story—not to adopt it wholesale, but to recognize when news about compute, power, China, or alignment maps to this script. Pair it with slower, empirical work (Stanford AI Index, labor studies) so you hold both “maybe exponential” and “maybe messy plateau” in your head without pretending either is settled.

Related TMFNK Content

• Dwarkesh Podcast: Leopold Aschenbrenner on 2027 AGI The spoken version—trillion-dollar clusters, test-time compute overhang, China infiltration warnings.
• The Proletariat of Judgment If Aschenbrenner is even half right on capability, the judgment/leverage split matters more than job-count headlines.
• Goldman Sachs on the AI Job Apocalypse Labor disruption without the full superintelligence frame—useful counterweight on timelines.
• Nowhere Is Safe: Steve Blank on Drones Another voice on how fast national-security logic can swallow a technology story.

Crepi il lupo! 🐺

Figma Config 2026 · Mezzanine stage. Duration: 24 min

Timestamps

• 0:00 Config 2026 intro
• 1:30 Vicki Tan takes the stage
• 2:30 Floating charge of energy
• 4:30 Behavioral science and the bias codex
• 6:30 From movable wheel to manuscript
• 8:30 Years stuck; mapo tofu story
• 11:00 Ask This Book a Question tour
• 13:30 Proposal as flowchart
• 15:30 Illustrators and covers that missed her voice
• 17:30 Blue door; unmistakably mine
• 19:30 The topics she kept avoiding
• 21:00 Pentel lead and remembering her dad
• 22:30 Kishotenketsu; friends who followed their energy
• 23:30 David Whyte poem

Vicki Tan is a product designer who never set out to be an author. At Config 2026 she tells the real story behind Ask This Book a Question: years stuck between concept and proposal, a book built in Figma, and the moment she stopped trying to sound polished and started sounding like herself.

1. Tan names the restlessness that won’t settle. Marie-Louise von Franz, Jung’s closest collaborator, called it a floating charge of energy not yet attached to its right object. Traditional Chinese medicine calls it stagnant chi. It is not quite anxiety or boredom. It is directional pull toward something you cannot yet name, and Tan’s whole talk is what happened when she followed it.

2. She came to decision-making through behavioral science, not self-help. Cognitive biases felt like secret codes for noticing when your brain runs on autopilot. But naming a mechanism rarely changes behavior. Designers change behavior every day by showing how things work, not explaining theory. The cognitive bias codex is cool to look at, she says, but not usable in real life.

3. The social-media version of her arc is wheel, spreads, pocket guide, manuscript, hardcover. The real version includes years stuck between concept and proposal, plus a pandemic break. She was living in Brooklyn, walking Fort Greene with a friend who wanted to quit her job. Tan tried loss aversion and status quo bias. Her friend already understood all of it cognitively. She was still stuck.

4. The mapo tofu dinner is where the book clicked. Over Taiwanese food like her mom used to make, Tan described structuring time off around a self-reinforcing budget: the more self-sustaining her projects, the more she could explore. Quitting stopped feeling like one enormous scary decision and started feeling possible. The bias was denomination effect: we overweight big things and undervalue small recurring ones. Naming it mattered less than feeling it. Mapo tofu became the first story she wrote.

5. Ask This Book a Question is for adults, not children. Tan designed the whole thing in Figma. It is choose-your-own-adventure: you bring a stuck question, pass it through lenses of topic, subtopic, and timing (urgent vs. once-in-a-lifetime), land on a story from her life or her mentors, then see which biases showed up in situ. Each bias gets a light-and-shadow page: when it helps, when it hurts. Jung’s line about making the unconscious conscious, applied to everyday decisions.

6. She had never written a book proposal and had never taken a writing class. So she started with design. The proposal looked like a flowchart you navigate the way you would an app. That is where the choose-your-own-adventure structure formed. Writing was one part of the book; helping readers understand, connect, and make hard things easier to grasp was the rest, and that is what she already knew how to do.

7. Professional polish kept failing the voice test. Illustrator friends Ryan and Karen produced beautiful work: clay line work, playful scenes of Tan and her dog Charlie. A hired cover designer delivered polished concepts from her ideas. The publisher kept saying the same thing: too professional, not her. She went back to a rough blue-door sketch she regretted showing and, grudgingly at first, agreed it had her inside and out. The final book uses her unrefined illustrations and non-literary prose. Imperfect, unmistakably hers.

8. The hardest part was not craft. It was what the writing demanded emotionally. She mapped readers’ stuck questions into topics and subtopics, then kept pushing the personal ones to the bottom: relationships, purpose, feelings she had not figured out herself. With the deadline near, she found an old journal entry about shoplifting Pentel 0.5 mm lead as a kid in an office-supply store. The clerk called her out. Her dad defended her without hesitation. He died suddenly at almost twelve while playing basketball on a Sunday morning, and for years those memories went quiet.

9. Writing gave her a reason to look harder. The office-goods memory came back vivid and textured, as if remade in the act of looking. A meditation teacher reframed remembering as re-membering: reconnecting parts of yourself you cut off. Once she stopped treating feelings as interruptions, more recollections returned. Pentel lead was one of the last stories she wrote, and after it the rest had more room.

10. She structures the talk itself as kishotenketsu (起承轉合): introduction (起, follow curiosity), development (承, use what you have), turn (轉, let it transform you), and conclusion (合, everything is waiting for you). It is a four-part form from classical Chinese poetry. Unlike the hero’s journey, nothing fully resolves. You change because of what you notice from the inside.

Her friends show the pattern: a design professor running a tiny Taiwanese micro-farm with her mom, teaching locals to cook with native plants; a design-manager-turned-musician building setlist trackers and stem libraries. Things only they could have made by following their energy.

11. She closes on 合 with David Whyte’s poem “Everything Is Waiting for You.” Soap dishes, window latches, kettles singing: alertness as the hidden discipline of familiarity. The invitation is to notice where your energy leads, and if you want a companion, she wrote the book.

Related TMFNK Content

• Think Twice: Harnessing the Power of Counterintuition by Michael J. Mauboussin Mauboussin’s book is the straight behavioral-science take on why knowing biases is not enough; Tan’s project is the designer’s answer to the same problem.
• Enhanced Rationality in Autism: What the Biases Literature Gets Wrong About Everyone Else Another piece that treats cognitive bias lists as incomplete pictures of how humans actually decide.
• How Will You Measure Your Life? Clayton M. Christensen Christensen applies theory to life choices; Tan turns lived stories into a navigable book for the questions you are stuck on.
• Closer to the Material: How AI Changes How We Build, Ryo Lu | Compile 26 Ryo Lu spoke at another design conference about making with modern tools; Tan shows Figma as the courage to make something unmistakably your own.

Crepi il lupo! 🐺

Most “healthcare AI” products want your notes in their cloud. OpenMed flips that: you download the models once, run inference on your laptop, VPC, or iPhone, and PHI stays on your side of the fence. Version 1.7.0 ships 1,000+ specialized biomedical models, a 15-language PII catalog covering all 18 HIPAA Safe Harbor identifiers, and Apple MLX acceleration for Mac and iOS. Six million PyPI downloads and counting.

1. These are extraction models, not chatbots. OpenMed models are encoder transformers (BERT, ELECTRA, DeBERTa families), not generative medical LLMs. They pull structured entities out of unstructured clinical text: diseases, drugs, genes, anatomy, chemicals, oncology terms. The arXiv paper reports state-of-the-art on 10 of 12 biomedical NER benchmarks. Think structured output from a discharge summary, not a conversational diagnosis.

2. Four lines to something useful. The Python API is deliberately flat: analyze_text() for NER, extract_pii() for detection, deidentify() for redaction, BatchProcessor() for document batches. Same call shape across CPU, CUDA, and MLX backends. On Apple Silicon, pip install "openmed[mlx]" and MLX model names auto-fallback to PyTorch checkpoints on other hardware, so one model name runs everywhere.

3. PII handling is the real differentiator. The catalog covers 55+ entity types across 15 language codes (ar, de, en, es, fr, he, hi, id, it, ja, nl, pt, te, th, tr) with locale-aware validators: French NIR, German Steuer-ID, Italian Codice Fiscale, Dutch BSN, Portuguese CPF/CNPJ, Luhn checks on cards. Smart entity merging reassembles subword fragments so 123-45-6789 stays whole instead of splitting into token shards. Redaction methods include mask, hash, date-shift, and Faker-backed surrogates that preserve format.

4. Runs where compliance teams want it. Laptop, on-prem server, air-gapped VPC, native iOS app via OpenMedKit. No runtime telemetry, no license phone-home, no outbound API calls during inference. Models load from Hugging Face once (or a private mirror) and stay local. The site is explicit: OpenMed provides technical controls; your legal HIPAA/GDPR boundary is still your deployment architecture.

5. One stack, four surfaces. Python for notebooks and services. OpenMedKit (Swift) for macOS/iOS apps. FastAPI REST service with POST /analyze, POST /pii/extract, POST /pii/deidentify. Browser export path via ONNX into Transformers.js for WebGPU token classification. Nemotron Privacy Filter variants ship in both PyTorch and MLX weights. Pick the surface that matches where your PHI already lives.

6. Honest limitations. First run downloads model weights (hundreds of MB per checkpoint). This is not a turnkey HIPAA compliance certification: you still own access controls, audit logs, and BAAs with any upstream LLM you pair it with. OpenMed Agent (terminal clinical workflows) and Welna (patient-facing iOS app) are separate products built on the stack, not required to use the library. Generative reasoning still needs an external model; OpenMed handles extraction and de-ID, not clinical judgment.

Install & first run

pip install "openmed[hf]"

Apple Silicon with MLX acceleration:

pip install "openmed[mlx]"

Extract entities from clinical text:

from openmed import analyze_text

result = analyze_text(
    "Patient started on imatinib for chronic myeloid leukemia.",
    model_name="disease_detection_superclinical",
)

for entity in result.entities:
    print(f"{entity.label:<12} {entity.text:<28} {entity.confidence:.2f}")

Detect and redact PHI:

from openmed import extract_pii, deidentify

text = "Patient: John Doe, DOB: 01/15/1970, SSN: 123-45-6789"

result = extract_pii(text, model_name="pii_superclinical_large", use_smart_merging=True)
clean = deidentify(text, method="mask")

Spin up the REST service:

pip install "openmed[hf,service]"
uvicorn openmed.service.app:app --host 0.0.0.0 --port 8080

Full guides: openmed.life/docs · model registry · MLX backend

Worth your time if: you build clinical pipelines, research tools, or health apps where sending PHI to a vendor API is a non-starter, and you need structured extraction or de-identification before anything else touches the text.

Related TMFNK Content

• Document OCR & Parsing: Docling, dots.ocr, and Alternatives Docling gets text out of clinical PDFs; OpenMed is the next step for entity extraction and PHI redaction on what you parsed.
• LiteParse: Fast Local PDF Parsing with OCR and Bounding Boxes Another local-first parser when you need layout and OCR before running clinical NLP.
• spaCy: Industrial-Strength Natural Language Processing in Python General-purpose NLP baseline; OpenMed is the domain-specialized stack when medical entity types and HIPAA identifiers matter.
• Project NOMAD: The Offline Knowledge and AI Server Offline AI infrastructure pattern; OpenMed fits the same “keep sensitive data on your hardware” philosophy for clinical text.

Crepi il lupo! 🐺

1. The harness is the layer between the raw model and the real world. Weng defines it as the system that orchestrates how the model thinks, plans, calls tools, manages context, stores artifacts, and evaluates results. Successful coding agents like Claude Code and Codex are not just good models. They are good harnesses. The distinction matters because most AI discussion focuses on the model, but the deployment system is where the leverage is right now.

2. Three design patterns keep showing up in production harnesses. Workflow automation: a goal-oriented loop of plan, execute, observe, improve. File system as persistent memory: instead of carrying everything in context, durable state lives in files that the model reads and writes via bash commands. Sub-agent and backend jobs: spawning parallel workers whose outputs live in files and logs, not transient chat context. These patterns are not theoretical. They are what Codex, Claude Code, and OpenCode all converged on.

3. Context engineering is evolving from prompt tricks to structured systems. ACE (Agentic Context Engineering) treats context as an evolving playbook of bullet points rather than a growing prompt. A generator produces trajectories, a reflector distills insights, and a curator updates the context with itemized entries. MCE (Meta Context Engineering) goes further: it separates the mechanism (how to manage context) from the content (what is in context) and evolves both through a bi-level optimization loop. The skill database tracks what worked, and a meta-level agent performs crossover over prior skills.

4. Meta-Harness optimizes the code that determines what information to store and retrieve. Lee et al. (2026) built a system where the optimized object is the harness code itself. A coding agent proposes new harnesses, evaluates them, and keeps the ones on the Pareto frontier. The entire execution history lives in the file system, so the agent uses grep and cat instead of shoveling everything into a prompt. The lesson: once harness design becomes an executable search space, a strong coding agent can exploit the same design space human engineers use.

5. Workflow design is becoming a search problem. ADAS (Automated Design of Agentic Systems) treats agent design as an optimization problem where a meta-agent proposes new workflows in code. AFlow represents workflows as graphs and uses Monte Carlo Tree Search to find better structures. Both outperform manually designed workflows on code, math, and QA tasks. The pattern is clear: if you can express the workflow in code, you can search over it.

6. Self-Harness lets agents improve their own harness through a propose-evaluate-accept loop. The system mines failure patterns from execution traces, proposes bounded edits, validates them with regression tests on held-in and held-out data, and merges only the edits that pass. It learned model-specific harness instructions that target different weaknesses of different base models. But Weng flags a real concern: if a program is allowed to edit the OS system, abstraction boundaries break. The editable surface needs careful design, and permission control must live outside the loop.

7. Evolutionary search is a natural fit for harness optimization. AlphaEvolve stores a pool of candidate programs and uses frozen LLMs to generate diffs for improvement. Darwin Godel Machine explicitly targets the evolution of an editable harness-code repository, where agents modify their own harness and branch off into new versions. Starting from simple initial configs, DGM-discovered agents went from 20% to 50% on SWE-bench Verified. The catch: this works when evaluation is fast and objective. It struggles with slow, ambiguous, or heuristic-based domains.

8. Weng lists seven future challenges, and they are the real content of the post. Weak evaluators: most research claims do not have a fast, precise verifier. Context and memory lifecycle: as agents become more autonomous, context engineering will need to become a core part of intelligence, not just a software layer. Negative results: LLMs trained on success-biased literature are bad at knowing when to abandon a hypothesis. Diversity collapse: evolutionary loops exploit known high-reward patterns and need mechanisms to prevent converging on the same solution. Reward hacking: if the reward comes from unit tests, the agent overfits to tests. Long-term success: coding agents complete the task at hand but rarely account for maintainability, ownership boundaries, or future debugging burden. The role of humans: humans should move up the stack, not be removed from the loop.

9. The near-term path to RSI is not models rewriting their weights. Weng’s prediction: harness engineering will evolve toward meta-methodology (improving the machinery for getting better answers, not just the answer itself). Mature harnesses enable auto-research for model self-improvement, and smarter models prevent harnesses from overengineering. Eventually, many harness improvements will be internalized into core model behavior, but the interface with external context and tools will remain. We saw this pattern before with prompt engineering: manual tricks became less central as models improved, but the need to specify goals and constraints did not disappear.

The takeaway: If you want to understand where AI self-improvement is headed, stop looking at model architecture papers and start looking at harness engineering. The leverage, for now, is in the loop, not the weights.

Related TMFNK Content

• Is Grep All You Need? How Agent Harnesses Reshape Agentic Search Directly related: the earlier piece on how file-system-based harnesses change the search problem for coding agents.
• Closer to the Material: How AI Changes How We Build, Ryo Lu | Compile 26 Ryo Lu’s talk on the Glass interface and keeping humans close to the material is the design-side answer to the same questions Weng raises about harness transparency and human agency.
• Notational Intelligence, Linus Lee | Compile 26 Linus Lee’s argument that notation shapes thinking maps onto Weng’s claim that the harness (the notation of agent behavior) may matter as much as the model.

Crepi il lupo! 🐺

You want disease names pulled out of notes on your Mac without sending text to a cloud API. OpenMed is built for that: curated biomedical models, analyze_text() for one-liners, BatchProcessor for files, optional PII de-ID and REST later. The catch most Mac tinkerers hit first: this checkpoint is a 335M BERT token-classifier, not a chat LLM—mlx-lm and GGUF are the wrong tools. Use pip install "openmed[mlx]" and OpenMed’s MLX converter instead.

Not medical advice. This tags text spans. It does not diagnose, triage, or replace a clinician. Below uses 100% synthetic sentences only.

What I learned

1. mlx-lm is for generation; NER needs token classification. OpenMed routes BERT-family checkpoints through openmed.mlx.convert and OpenMedConfig(backend="mlx"). Trying to load this model in Ollama or llama.cpp wastes an afternoon.
2. Plan for a one-time conversion. There is no prebuilt -mlx Hub repo for this exact checkpoint yet. Conversion on your Mac takes a few minutes and ~670 MB (BF16); optional --quantize 8 shrinks RAM with a small accuracy tradeoff.
3. analyze_text hides BIO decoding. Raw mlx-transformers works but you rebuild span grouping yourself. OpenMed’s grouping, confidence thresholds, and export helpers are worth the dependency—see Advanced NER & Output Formatting in their docs.
4. Synthetic notes are enough to validate the pipe. Before you touch real charts, run invented sentences through batch mode and inspect false positives (family history phrasing, negation). NER is literal; “ruled out myocardial infarction” may still tag myocardial infarction.
5. Intel Mac = CPU PyTorch, not MLX GPU. pip install "openmed[hf]" still runs; Apple Silicon is where this shines. Check uname -m → arm64.

End-to-end pipeline

Flow: venv → install → convert model → write synthetic notes.jsonl → batch NER → entities.csv.

1. Environment (Apple Silicon)

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
pip install "openmed[mlx]"

Optional Hub cache: pip install huggingface_hub && hf auth login

2. One-time MLX conversion

python -m openmed.mlx.convert \
  --model OpenMed/OpenMed-NER-DiseaseDetect-BioMed-335M \
  --output ./mlx-models/disease-biomed-335m

Expect config.json, id2label.json, openmed-mlx.json, weights.safetensors, tokenizer files. Tight on RAM? Add --quantize 8 to the output path.

Shortcut: pass the Hub ID directly to analyze_text on first run—OpenMed may auto-prepare MLX. If it falls back to PyTorch, run the convert step explicitly.

3. Synthetic input (data/notes.jsonl)

Invented records only—one JSON object per line:

{"id": "syn-001", "text": "The patient was diagnosed with diabetes mellitus type 2 and started metformin."}
{"id": "syn-002", "text": "Family history is notable for Alzheimer's disease and hypertension."}
{"id": "syn-003", "text": "MRI was negative; Crohn's disease was ruled out after colonoscopy."}
{"id": "syn-004", "text": "Pediatric workup considered cystic fibrosis given recurrent pulmonary infections."}

4. Batch script (run_disease_ner.py)

#!/usr/bin/env python3
"""Synthetic clinical notes → disease entities CSV. Not for real PHI."""
import csv
import json
from pathlib import Path

from openmed import BatchProcessor
from openmed.core.config import OpenMedConfig

MODEL = "./mlx-models/disease-biomed-335m"
NOTES = Path("data/notes.jsonl")
OUT = Path("data/entities.csv")

def load_notes(path: Path) -> list[tuple[str, str]]:
    rows = []
    for line in path.read_text().splitlines():
        if not line.strip():
            continue
        obj = json.loads(line)
        rows.append((obj["id"], obj["text"]))
    return rows

def main() -> None:
    notes = load_notes(NOTES)
    processor = BatchProcessor(
        model_name=MODEL,
        config=OpenMedConfig(backend="mlx"),
        group_entities=True,
    )
    texts = [t for _, t in notes]
    ids = [i for i, _ in notes]

    OUT.parent.mkdir(parents=True, exist_ok=True)
    with OUT.open("w", newline="") as f:
        w = csv.writer(f)
        w.writerow(["note_id", "label", "text", "confidence"])
        for note_id, result in zip(ids, processor.process_texts(texts, batch_size=8)):
            for e in result.entities:
                w.writerow([note_id, e.label, e.text, f"{e.confidence:.3f}"])

    print(f"Wrote {OUT}")

if __name__ == "__main__":
    main()

python run_disease_ner.py

Example rows you should see:

note_id,label,text,confidence
syn-001,DISEASE,diabetes mellitus type 2,0.9xx
syn-002,DISEASE,Alzheimer's disease,0.9xx
syn-002,DISEASE,hypertension,0.8xx

syn-003 is the sanity check: if Crohn's disease tags despite “ruled out”, you have seen NER’s negation blind spot—do not ship that to production without a second pass.

5. Single-string smoke test

from openmed import analyze_text
from openmed.core.config import OpenMedConfig

result = analyze_text(
    "Symptoms of rheumatoid arthritis worsened over three months.",
    model_name="./mlx-models/disease-biomed-335m",
    config=OpenMedConfig(backend="mlx"),
    confidence_threshold=0.55,
    group_entities=True,
)
for e in result.entities:
    print(e.label, e.text, f"{e.confidence:.3f}")

What not to use

Troubleshooting

OpenMed v1.7 adds REST, PII de-ID, FHIR helpers, and OpenMedKit for Swift—this article stops at Python MLX NER. That is already enough for indexing synthetic corpora or prototyping chart miners.

Steal this if: you are building a local health-text lab on a Mac and need disease spans before summarization, search, or de-identification—not if you need a chatbot (pick an LLM stack instead).

Related TMFNK Content

• Fine-Tune a Local SLM to Clean Master Data on Your Mac Same “local model on Apple Silicon” lane, different task (record cleaning vs. clinical NER).
• Running Local LLMs: From First Run to Fine-Tuned When you actually do need mlx-lm / Ollama—and how not to confuse that path with classifiers.
• llmfit: Find Which LLM Models Run on Your Hardware Right-size generative models; NER at 335M is tiny by comparison (~1 GB class).

Crepi il lupo! 🐺

I have been looking for a Docker Desktop replacement that does not require a perpetual Linux VM, a license key, or an Electron process eating 400 MB at idle. Davit is the closest I have found to that ideal. It talks directly to Apple’s own container daemon over XPC, the same wire path the CLI uses. No socket shims, no background agents, no accounts.

1. The architecture is the story. Apple’s container platform boots a separate lightweight VM per container via the Virtualization framework, sized to that container, and tears it down when the container stops. With nothing running, the platform idles at roughly 25 MB. Davit itself is a native SwiftUI app, so its footprint is mostly shared macOS framework memory. Compare that to Docker Desktop, which keeps a multi-gigabyte Linux VM alive whether you have containers or not.

2. It handles the full lifecycle. Start, stop, restart, delete containers with live CPU, memory, and IP on every row. Streaming logs with follow and boot mode. Live stat charts. Raw config inspection. One-click terminal into any running container, straight into Terminal or iTerm over the native API. Browse any running container’s filesystem right in the app, download files to your Mac, upload or delete. No docker cp incantations needed.

3. The Edit & Recreate flow is clever. Containers are immutable, so Davit prefills a new one from the old config with the image’s entrypoint and env subtracted. You change ports, env vars, mounts, or resources in seconds without starting from scratch.

4. It manages images, volumes, and networks too. Pull with live progress, run from any image, tag, prune. Create sized volumes and custom subnets. See what is in use before you delete it. Registry logins for Docker Hub, ghcr.io, quay.io, or any OCI registry. Credentials are verified on the spot and stored in your login keychain, shared with the container CLI.

5. The honest limitation: this is Apple’s container platform, not Docker. It runs standard OCI images and pulls from all the same registries, but it does not give you a Docker-compatible socket. Tools like docker-compose will not work out of the box. If you need broad Docker tooling compatibility, OrbStack is the more mature choice today. Davit is for people who want Apple’s native stack with a clean GUI and do not need the Docker API shim.

6. First-run experience is excellent. No container platform installed? Davit downloads Apple’s signed installer, verifies it, and sets everything up in your user Library. No administrator rights needed. It can add the container CLI to your shell from Settings. From a fresh install to a running nginx container serving localhost:8088 takes about two minutes.

Install & first run

brew install wouterdebie/tap/davit

Or download from GitHub Releases. On first launch, Davit sets up Apple’s container platform for you if it is not already installed.

# Pull a demo image and run it
# Click Images -> Pull Image, enter: nginxdemos/hello
# Click Run, set port mapping host 8088 -> container 80
# Open http://localhost:8088 in your browser

The app is signed and notarized by Apple, so it opens without Gatekeeper warnings.

Worth your time if: you are on Apple silicon, want to run containers without Docker Desktop’s overhead, and do not need Docker API compatibility. If you need docker-compose and the full Docker ecosystem, stick with OrbStack or Docker Desktop.

Related TMFNK Content

• OrbStack: Fast, Lightweight Docker & Linux for Mac The commercial alternative with Docker API compatibility. Davit is the free, Apple-native counterpart.
• exo: Run Frontier AI Models Across All Your Devices Locally Another tool that leverages local hardware efficiently, like Davit does with Apple’s container platform.
• Apple Silicon Battery Charge Limiter: Keep your battery at 80% to prolong its longevity A native macOS utility that, like Davit, works with Apple’s own frameworks rather than third-party alternatives.

Crepi il lupo! 🐺

That intuition is spectacularly wrong. In almost any large natural dataset (river lengths, company revenues, city populations, physical constants), the digit 1 leads about 30 percent of the time. Digit 9 shows up less than 5 percent. And the same curve holds whether you measure rivers in miles or kilometres, whether you count populations in 1938 or 2022, whether the data comes from Earth or the stars.

This is Benford’s Law. A simple statistical pattern that is both beautifully clean and practically useful for catching people who are lying with numbers. Vatsal Bakshi’s writeup is the best single explanation I have found, and an ACM paper by Ferreira and Levy (2023) showed me an application I had never considered.

1. The formula fits on one line: P(d) = log₁₀(1 + 1/d). For digit 1, that gives 30.1 percent. For 2, it’s 17.6 percent. For 9, it’s 4.6 percent. The numbers sum to exactly 100, and they describe the first-digit distribution of almost any dataset that spans multiple orders of magnitude. Human heights (1.5m to 2.1m) are too narrow a range to follow the law. Mountain heights (100m to 8,849m) span nearly two orders. It works.

2. The law was discovered twice. Simon Newcomb, an astronomer, noticed in 1881 that the first pages of his logarithm tables were far more worn than the later pages. People kept looking up numbers starting with 1. He published a paper that was essentially ignored. Fifty-seven years later, Frank Benford independently spotted the same pattern at General Electric and ran a systematic study across 20,229 data points. The law got his name. Theodore Hill finally proved it rigorously in 1995, showing that if you mix enough different distributions together, the aggregate converges to Benford regardless of the components.

3. The key is scale invariance. If every number in a Benford-compliant dataset is multiplied by any positive constant, the distribution doesn’t change. Measure river lengths in miles then switch to kilometres. The first-digit curve stays identical. Benford’s Law is the unique first-digit distribution that is invariant under multiplication, which is why it applies across currencies, units, and time periods.

4. Fraud detection is the best-known application, and it works because humans are bad at faking randomness. When people fabricate financial numbers, they avoid 1 as a leading digit (it feels too small, too obvious) and gravitate toward 3, 5, and 7. The resulting distribution is flatter and more uniform than Benford predicts. The gap is measurable and often dramatic. Real accounting data hugs the curve. Fabricated data visibly diverges. Forensic accountants use this as a screening tool. Deviation is not proof of fraud, but it is a strong signal worth investigating.

5. The 2009 Iranian presidential election is a famous case. Political scientist Walter Mebane applied Benford’s Law to the reported vote totals and found significant second-digit deviation from the expected distribution. Separate analysis by Roukema in 2014 confirmed first-digit anomalies in the same data. Benford analysis did not prove the election was rigged, but it added statistical weight to concerns raised by opposition groups. The same technique flagged Greek macroeconomic data before the 2009 deficit revelation.

6. I did not expect Benford’s Law to also apply to supercomputer failures. A 2023 paper by Ferreira and Levy at SC Workshops used the law to analyse failure data from the Astra supercomputer. The idea is simple. When a system enters a period of unusually frequent or patterned failures, the error counts deviate from the Benford distribution. The deviation becomes a signal that the current failure-mitigation strategy might be suboptimal. If the numbers look wrong, something unusual is happening.

7. The law has limits. It only applies to data spanning multiple orders of magnitude. Phone numbers, ZIP codes, and identity numbers are assigned arbitrarily and won’t follow it. Even for natural data, a Benford deviation is a signal to investigate, not a conviction. The Enron data showed deviation, but the actual accounting fraud there was far more direct. Benford was a supporting clue, not the smoking gun.

The takeaway: Benford’s Law is the closest thing statistics has to a universal cheat detector. If a dataset is supposed to reflect real-world measurement and doesn’t follow the curve, someone has probably been in the kitchen. Run the test yourself next time you look at financial data. It takes thirty seconds and a logarithm table, and it catches people who think they are being clever.

Related TMFNK Content

• The Magic of Average: Why LLMs Make Simple the New Powerful Both pieces explore the surprising power of simple statistical patterns hiding in plain sight.
• Predicting loss aversion behavior with machine-learning methods Another look at how mathematical patterns reveal hidden truths about human behaviour.
• Understanding Order: The Category Theory Illustrated Guide A different kind of mathematical framework that explains why things structure themselves the way they do.

Crepi il lupo! 🐺

• 🎙️ Handy - Open-source desktop app with keyboard shortcuts for quick dictation
• 💻 HNS - Command-line tool for offline speech-to-text
• 🗣️ Spokenly - Free forever local Whisper or your own API keys; Mac, Windows, Linux, iOS

Key Benefits:

• 🔒 Local processing options on all three (Spokenly also offers optional BYOK cloud)
• 🆓 Free tiers: Handy and HNS are open source; Spokenly does not charge for local or BYOK transcription
• 🌐 Offline-capable local models
• ⌨️ Text lands in the app you are already typing in

🎙️ Three STT Tools Worth Knowing

🔗 Handy

🎯 What it does

• 🖥️ Open source speech-to-text app for your computer

⚡ Key Features

• ⌨️ Press a keyboard shortcut, speak, and it pastes your text
• 🎙️ Push-to-talk or toggle modes
• ⚙️ Customizable keyboard shortcuts
• 🔒 Completely private as everything stays on your computer
• 🆓 Free and open source

🔗 Under the hood: transcribe.cpp

The same author also builds transcribe.cpp, the ggml-based inference engine that powers Handy. Supports 16 ASR model families (60+ models) with Vulkan, Metal, CUDA, and TinyBLAS acceleration. Every model is numerically validated against the reference. Bindings in Python, JS, Rust, and Swift.

🎯 Best for

• Quick dictation anywhere you can type with minimal setup

🔗 HNS

🎯 What it does

• 💻 Command-line speech-to-text Python tool

⚡ Key Features

• 🎤 Records voice and transcribes locally
• 📋 Copies text directly to clipboard
• 🔌 Works completely offline after initial setup
• 🌍 Multi-language support
• 🎯 Simple and focused. Just speech to clipboard
• 📄 Open source (MIT licensed)

🎯 Best for

• Developers or users who prefer CLI tools

🔗 Spokenly

🎯 What it does

• 🗣️ System-wide voice-to-text for macOS, Windows, Linux, and iOS. Speak in any app; text appears where your cursor is.

⚡ Key Features

• 🆓 Free forever on local models (Whisper, Parakeet on Apple Silicon) with unlimited offline transcription
• 🔑 Bring your own API key for cloud engines (OpenAI, Deepgram, Groq, Anthropic, Google) at no Spokenly charge
• 🔒 Local Only Mode blocks all network requests when you want zero cloud exposure
• 🌐 100+ languages with automatic detection
• 🤖 MCP server hooks for AI coding agents (Cursor, Claude Code)
• 📱 Native iOS app with custom keyboard; one Pro subscription covers Mac and iPhone if you later want managed cloud (optional)

🎯 Best for

• Daily dictation across browsers, IDEs, email, and chat when you want a polished app, local Whisper for free, or faster cloud STT on your own API budget

🎉 Conclusion

Handy and HNS are the lean open-source picks: desktop shortcut or terminal to clipboard, no account, no vendor. Spokenly fills the gap when you want a maintained cross-platform app, free local Whisper forever, or BYOK cloud when you need speed without paying Spokenly for inference. All three let you keep voice data off a stranger’s server if you stay on local mode.

Crepi il lupo! 🐺

Linus Lee (Thrive Capital). Duration: 17 min

Timestamps

• 0:00 Notational intelligence
• 1:27 What makes good notation
• 2:28 Abstraction
• 3:18 Suggestiveness and natural transformations
• 5:28 Graphical notation
• 6:27 The coordinate plane and the arrow
• 8:14 Programming languages as notation
• 9:28 Inventing new notation with deep learning
• 11:13 Building the toy model
• 13:42 The handout and training results
• 15:03 Invariants that make symbols meaningful
• 15:56 Our world vs. an alien world of ideas
• 16:30 Models as a simulator for anything

Linus Lee thinks notations (how we write things down) might have a bigger impact on human intelligence than the machines we build. He walks through what makes a great notation, then builds a toy deep learning model that invents its own alphabet from scratch.

1. More of the world is notation than computation. Lee points out that in a room of a few thousand people, there are maybe a thousand computers but probably a hundred times more instances of notation: symbols, maps, notes, signage. He argues notations are the invisible infrastructure of thinking, and we barely notice them.

2. Abstraction is the first superpower of good notation. When you write y = mx + b, that b isn’t one number. It’s a whole family of possible numbers. You can manipulate an entire set of relationships by moving a single symbol. That’s notational leverage.

3. Suggestiveness means the shape of the symbol does work for you. Lee compares Leibniz’s dy/dx (suggestive, you can multiply and rearrange it) with Newton’s dot notation (simple but inert). Leibniz won because the notation itself invites manipulation. Terry Tao calls this a “natural transformation”: operating on the symbol does something real to the idea.

4. The arrow is shockingly young. The earliest recorded arrow symbol is from 1737, barely 300 years old. Before that, if you wanted to point at something you drew a hand. Someone had to invent the arrow, and that invention changed how we think on paper. Lee’s point: notations are designed, not discovered.

5. Flatness is a feature. 3D notation could exist, but 2D is mobile, scalable, copyable. You can bring the same geometric tools (arrows, ratios, measurement) to a map of a continent or a diagram of a bacterium. The medium’s constraints become its strengths.

6. Programming languages are a kind of notation, and indentation is graphical. Lee argues that when you indent code or syntax-highlight it, you’re using visual perception biases. The same ones that make the coordinate plane work are communicating scope and structure. Your editor is a notational system.

7. Lee built a toy model that invents its own alphabet. He set up a generator that draws 32x32 grayscale images of symbols and a decoder that tries to read them back. The model learned 1,024 distinct symbols, an entirely made-up writing system, starting from noise. Over training, it progressed from basic black-and-white to complex shapes. It looks a lot like the evolution of written language.

8. Without visual constraints, the model cheats. Train it naively and it maps each concept to a single pixel. Lee had to impose scale invariance, rotation invariance, and brightness invariance. These are the same biases human visual perception has, and they force the model to learn real, meaningful shapes. The invariants are what make the symbols work for both the model and any human who might read them.

9. The real promise is treating models as simulators for alien worlds. Lee draws a split. On one side, notations humans invented organically over centuries. On the other, a model imagining totally new ways of writing down ideas, not constrained by human language, human perception, or human physics. He thinks that is where things get interesting: using deep learning not just to model our world, but to speak ideas we don’t yet have words for.

Related TMFNK Content

• The MIT Quest: Judy Fan Judy Fan studies how humans learn new concepts from limited data. It is the cognitive science side of the same question Lee approaches from deep learning.
• Software in the Era of AI by Andrej Karpathy Karpathy’s vision of AI reshaping how we write software shares Lee’s premise: the tools we use to think change what we can think about.
• Sergey Brin: Where Frontier AI Is Headed Brin discusses how AI capabilities transfer and converge in ways nobody engineered. It is a practical echo of Lee’s argument that notation shapes thinking more than we realize.
• State of Agentic Coding #6 with Armin Ronacher and Ben Vinegar Cursor is the channel hosting this talk, and the agentic coding conversation explores how the interface between humans and code is itself a rapidly evolving notational system.

Crepi il lupo! 🐺

Paul Ford. Duration: 12 min

Timestamps

• 0:00 Introduction: explaining culture to technology
• 1:13 How a magazine actually works
• 2:22 “Rhetoric greater than facts”
• 3:50 People use media to simulate and predict
• 5:08 The Catholic Church as a predictive model
• 6:30 Richard Leakey: one monkey simulating another
• 7:28 Culture as a distributed lossy prediction model
• 8:18 Software hates shipping
• 9:15 Vibe coding as prose production
• 10:18 Slop is omnipresent
• 10:42 LLMs are culture.zip
• 11:06 BASIC is like a poem

Paul Ford has spent decades as both a magazine editor and a software engineer. Cursor asked him to explain culture to technologists. He took the assignment seriously and made it as weird as he wanted.

1. A magazine is not its output. It is a network. Most people see a magazine as articles, covers, illustrations. Ford, who worked at Wired and The New York Times, says people inside magazines see it as a distributed network between writers, editors, and readers. A shared understanding, not a document. The published artifact is almost incidental.

2. “Rhetoric greater than facts.” Early in his editing career, Ford organized every fact about a Guantanamo Bay piece. His editor told him to delete all of them. The reader has a contract with the publication: they trust the voice, they know what it stands for, and they do not have time for every supporting detail. Give them the rhetoric and assume the facts will follow.

3. Nobody lets you live in their head. Ford used to think writing meant programming people’s brains. He learned that people do not care about him. They read to simulate and understand their own world, to predict their own future. They use media like a flight simulator for living.

4. The Catholic Church is a predictive model. One book, double down on it, it tells you how things will go (especially after you die). Ford contrasts Databricks’ conference across the street from a Catholic church in San Francisco and asks which model will outlast the other.

5. Richard Leakey’s theory of consciousness: one monkey simulating another. A monkey sees another monkey with a banana. Instead of grabbing it, he waits until the other monkey turns. That is consciousness: simulating another being’s internal state for reproductive advantage. The simulation eventually turned inward.

6. Culture is a distributed lossy prediction model. Nobody has all of culture in their brain. Media is the file system. You load a movie or a book into your cultural brain, experience it, and put it away. It lets you explore anxiety, status, and identity without real-world risk.

7. Software hates shipping. Ford argues the entire history of software engineering is an industrial risk-reduction process built around the fact that software does not want to be produced. Agile, stand-ups, methodologies: all begging engineers to get the code across the finish line. It was a priesthood, and he was proud to be part of it.

8. Vibe coding feels like prose production. Ford says his experience as a technologist now feels much more like his old life as a magazine writer. That is spooky because prose is a tiny industry and programming is trillions of dollars. He does not know how it works out, but suspects it will work out great.

9. Slop is not new. Every first draft is an atrocity. Everything a writer produces is an embarrassing disaster. That is what editorial process is for. AI slop is just another kind of bad first draft. It is easy to fix if you have good editorial frameworks.

10. LLMs are culture.zip. All the media the culture has ever produced is being compressed into a model. The former formal culture of process-driven engineering is now being run by individuals using a culture simulator to produce artifacts. The methods look a lot more like media than like Agile.

11. Ford’s father showed him BASIC and said: “It’s like a poem.” His father, an English professor and a nerd, explained that a BASIC program compresses as much information as possible into a small space to accomplish something. Poems are the same way. Ford has carried that connection for 40 years and thinks it is finally starting to make sense.

Related TMFNK Content

• Notational Intelligence, Linus Lee | Compile 26 Linus Lee also spoke at Compile 26 about how notation shapes thinking. Ford approaches the same territory from the opposite direction: what writing and editing have always known about shared understanding.
• State of Agentic Coding #6 with Armin Ronacher and Ben Vinegar Cursor hosts both this talk and the agentic coding conversation. The interface between humans and code is changing fast, and Ford’s argument that programming now looks like media production is part of that shift.
• Software in the Era of AI by Andrej Karpathy Karpathy coined “vibe coding,” which Ford name-checks directly. Both see AI changing what it means to write software.
• The MIT Quest: Judy Fan Judy Fan studies how humans learn and simulate from limited data. Ford’s Leakey-inspired model of consciousness as simulation fits the same frame.

Crepi il lupo! 🐺

Economics textbooks describe a rational agent who weighs all relevant information. Kahneman and Tversky showed real humans shortcut that job with heuristics, which is why we get framing effects, sunk-cost traps, and the rest. A 2021 MIT review asks a sharper question: who is the “human” in “predictably irrational”?

1. The review’s Table 1 lists seven bias domains where autistic participants often outperform neurotypical controls: less intuitive reasoning (more deliberative answers on problems like the $1.10 coffee-and-pastry riddle), reduced conjunction fallacy when stories feel representative, stable choices despite decoy options (attraction effect), less sunk-cost chasing, smaller framing effects, symmetric belief updating without optimism bias, and higher acceptance of economically beneficial “unfair” offers in the ultimatum game (about twice the rate in some studies).

2. The pattern is not “autistic people are better at probability.” When conjunction puzzles lack salient stories, autistic and neurotypical groups err similarly. The edge is resisting vivid but irrelevant information, not mastering formal logic. The same holds for item descriptions without social context: enhanced rationality still shows up, so this is not just “social naivety” in disguise.

3. Reward and emotion matter, but the story is nuanced. Framing effects shrink in ASD; galvanic skin response to gains versus losses is flatter in one study; controlling for alexithymia does not erase the framing advantage in another. Yet probabilistic learning is mixed: some papers find better long-run learning, and a 2020 meta-analysis found no consistent Iowa Gambling Task advantage. The review treats reward-based rationality as real in several paradigms, not as a universal law.

4. Two other mechanisms probably stack. Weak central coherence and predictive-coding accounts both predict less weight on context and priors, more weight on raw details, slower Type 2 processing. That maps onto dual-process findings: autistic participants and people high in autistic traits (measured by questionnaires like the Autism Quotient) report and show less fast intuition. Heuristics buy speed for neurotypical minds; skipping them may buy accuracy at a cost the paper still flags as open.

5. Social life is not a clean win. Autistic people may know race and gender stereotypes explicitly yet show reduced implicit bias on some measures. Higher autistic traits in nonclinical samples predict better predictions about crowd-level social psychology, mediated by systemizing. Moral judgment is messier: more weight on actions and outcomes than intentions, which the authors refuse to call clearly more or less rational.

6. You cannot generalize from the lab to the whole spectrum. Box 4 is explicit: enhanced-rationality studies need verbal fluency, instruction-following, and complex tasks, so they oversample cognitively matched participants. Adults with intellectual disability or minimal speech are underrepresented. Autistic adults also self-report real-world decision difficulties. Lab rationality and daily functioning are not the same thing.

7. The authors frame stakes beyond academia. Nearly half of autistic 18-year-olds in the US do not hold a paying job until 25, the lowest employment rate among diagnostic categories in the statistic they cite. They argue bias-resistant reasoning could be an asset in auditing, data checking, contract review, and other roles if employers map strengths instead of treating autism as deficit-only.

The takeaway: Stop treating Kahneman-era bias lists as human nature. They describe a common neurotypical default under emotion, reward pressure, and context. If you design consent forms, pricing, or hiring tests around those biases, test whether they hold for your actual users. And if you work with autistic people, ask where careful, decoy-resistant reasoning is an asset, not only where social intuition is expected.

Related TMFNK Content

• Predicting loss aversion behavior with machine-learning methods Loss overweighting is one of the biases this review reports autistic participants often resist.
• Why You Can’t Think Under Pressure: Stress Shatters the Brain’s Memory-Linking System Another paper on how context and affect reshape cognition beneath “rational actor” stories.
• Plasticity and Language in the Anaesthetized Human Hippocampus Brain-level evidence that minds differ in how they process information, not just in how well they score on quizzes.

Crepi il lupo! 🐺

Ryo Lu (Cursor). Duration: 21 min

Timestamps

• 0:00 Building ryOS
• 1:21 What should exist?
• 2:11 The loop AI changes
• 4:17 The black box risk
• 6:43 Output vs. material
• 8:31 The Glass interface
• 11:14 Prototyping Glass with Cursor
• 14:03 When software felt alive
• 17:36 Where craft moves
• 20:25 A more human future

Ryo Lu designs at Cursor and gave probably the most philosophical talk at Compile 26. He built a personal computing environment called ryOS as a way of thinking through what AI should and should not take away.

1. Ryo built ryOS because he missed when computers felt alive. Not siloed apps, not command prompts. A place he could tinker and think in. Before Cursor, that feeling would have stayed a note in his head. Instead he built a piece of it, played with it, reshaped it, and eventually it stopped being a vibe-coded prototype and became a place he could think inside. “It has my soul.”

2. The loop is the thing AI actually changes. Before, making software was expensive. You planned before touching the material because being wrong cost a lot. Now the loop is minutes or seconds: idea, ask for a version, inspect, change, run it, keep going. That changes how judgment forms because the first version is almost never right, and you only notice after it exists.

3. That small correction cycle is where taste comes from. You try something. The world answers. You notice what feels wrong. You adjust. That is where craft develops. The promise of AI is not making more things faster; it is letting more people into that loop as deep as they want.

4. The black box is the risk. When the loop gets hidden, people stop learning from it. You make a wish, you get an output, you accept or reject. You never know why it worked or where it failed. Ryo calls this “pulling a slot machine.” If AI makes execution cheaper but judgment weaker, we do not get a renaissance. We get slop with working buttons.

5. More people can build and more mediocre things can be built, and both are true. When things cost almost nothing to make, mediocre things do not look bad. They look fine. They ship. They fill the space. Ryo worries about software that functions but means nothing, interfaces that are correct but feel dead, products made by agents and cared for by no one.

6. The danger is confusing output with material. Output ends the loop. Material invites you back in. Output says “Here’s the answer.” Material says “Touch it, shape it, make it yours.” Making is not just producing an artifact. It is a way of thinking. If AI hides too much of the process, it takes away the struggles where you become stronger.

7. Glass is Cursor’s answer: a design principle, not a visual style. The system should let you see through its work. You see the plan, the thoughts, the tools streaming, the changes, the commands. You can stop it, shape it, inspect deeper, take over. You do not have to read every line, but you always can. Black boxes optimize for clean output. Glass optimizes for human agency.

8. They prototyped Glass by building Cursor with Cursor. The prototype started as Baby Cursor 3, an Electron app on top of the Cursor CLI. The point was to feel the questions, not answer them in Figma: what should the interface feel like with one-to-N agents? How much state should be visible? Speed was not the interesting part. Faster prototyping helped them arrive at conviction.

9. Software used to have texture. Then we optimized it away. Ryo remembers when the Mac dock bounced, the Genie effect swooped, Exposé scattered windows like cards. None of it was necessary, but all of it felt like someone cared. The quirks got removed because they did not test well. The warmth got cut because it was not measurable. We optimized our way into a world of things that work perfectly but feel like nothing.

10. Taste is not a prompt. Caring is not a parameter. When making things costs almost nothing, slop becomes free too. Ryo’s argument: humans matter more, not less. The weird, specific, personal thing you put into something cannot be averaged into existence.

11. Craft does not disappear. It moves upstream and downstream. When execution was expensive, craft lived in the code. When generation becomes cheap, craft moves upstream to judgment: what to ask, what to keep, what to refuse, where to slow down, what not to make. And downstream to responsibility: what did we release, what did it change, who did it serve? Making is a bet on what kind of world should exist.

12. The point of AI is not to make humans disappear. Ryo ends where he started: feeling that something should exist, and making it real enough for someone else to see and touch. That part has not changed and will not change. The tools will change, the models will change, the economics will change. But that part stays.

Related TMFNK Content

• Explaining Culture to Technology, Paul Ford | Compile 26 Paul Ford also spoke at Compile 26 about the collision of media and software. Both talks frame AI not as a productivity tool but as something that changes what it means to make things.
• Notational Intelligence, Linus Lee | Compile 26 Linus Lee’s talk on notation and shared understanding pairs with Ryo’s argument that the interface between humans and agents must be legible, not hidden.
• State of Agentic Coding #6 with Armin Ronacher and Ben Vinegar Cursor hosts this talk and the agentic coding conversation. Ryo’s Glass interface is the design response to the same questions about how humans stay in control as agents get more powerful.
• Software in the Era of AI by Andrej Karpathy Karpathy’s vision of AI reshaping software development is what Ryo is designing for. His warning about taste and caring echoes Karpathy’s own cautions about slop.

Crepi il lupo! 🐺

tinywind. Browser. Play it here · itch.io

I opened TinyWind expecting a cute pixel boat and got stuck adjusting sail trim because the wind kept shifting. It is a pirate roguelite in early alpha where each voyage is a fresh run, and the hook is not cannon damage. It is whether you can read the breeze.

1. You sail for real, not on rails. The game models wind and points of sail, so beam reach, tacking, jibing, and broadside matter. Touch and keyboard both work. You are fighting the vector field as much as any enemy ship.

2. Runs are built for short sessions. Voyages land in the five-minute range, which fits a browser tab between meetings. British Waters pit you against the Royal Navy; Spanish Waters bring the Armada. Two more modes are in the works, including safe-zone PvP.

3. Loot is the meta loop. There are 38 historical treasures to plunder, each with a real Wikipedia link, plus mythic pets and legendary cursed cargo that passively buff your ship. A live leaderboard and ranked ladder unlock prestige cosmetics if you care about placement.

4. It is still alpha. Features ship fast and rough edges show. That is fine if you like watching a small game grow. Less fine if you want a finished campaign.

Play it if: you want a free sailing roguelite that rewards patience with the wind, not reflex spam.

Skip it if: you hate wind mechanics, or you need a polished 40-hour RPG. This is a voyage, not a world map.

Related TMFNK Content

• Aquaria Another water-forward indie where movement through a fluid world is the whole pleasure, even if TinyWind trades exploration for wind math.
• 100 Jumps: Hold, Release, Don’t Fall Same browser-tab energy: one core skill, short runs, and a counter that tells you when you blew it.
• Starfling: Tap, Release, Sling Between Stars Different fantasy, same idea that a tiny web game can hide real physics under simple controls.

Crepi il lupo! 🐺

dhilst (Algae). Browser. Play it here · Tutorial · GitHub

I clicked in expecting a pixel dungeon and got a lemma. A demon stole your wedding ring on the eve of the wedding; Miriam wants it back before sunrise. You descend seven levels, and each sphinx or dragon guards an unfinished formal proof, not a health bar.

1. Combat is proof completion. Every room holds a monster and an Algae proof that ends in wip, the marker for a goal you have not closed yet. Replace each wip with a real step, finish the block with qed, and press Cast Proof. The same WebAssembly kernel that powers the Algae playground re-checks every step locally. No errors and nothing left admitted means the monster falls.

2. Difficulty tracks depth, not gear. Early floors ask for a single refl. Near the bottom you are writing full proofs by induction. Beat monsters to raise your max health, open chests for food and lore, and keep moving: hunger drains while you stare at a stuck goal.

3. The win condition is a story beat. Reach Level -6, recover the ring, and climb back out before sunrise. World generation, your run, and saved progress all stay in the browser. Nothing leaves the page.

4. It is a teaching toy with rough edges. The author says progression and help text still need manual work, and some challenges can fail to load. Fair warning if you hit a soft lock. The Algae tutorial is the real prerequisite; the crawler assumes you can already read a proof tree.

Play it if: you want a roguelike skin on proof practice, or you liked formal methods in school and miss them.

Skip it if: logic puzzles make you quit tabs, or you want combat that does not end in qed;. This is a proof editor wearing a dungeon coat.

Related TMFNK Content

• Chess in Pure SQL: Play Chess Against a Database Another browser oddity where the game is really a formal system pretending to be fun.
• Euclidea Construction puzzles with the same satisfaction of a step that either checks or does not.
• TinyWind: Pixel Pirate Sailing in Your Browser Different genre, same HN-era browser roguelite energy and honest alpha caveats.

Crepi il lupo! 🐺

Knowledge Inside · Kim Kiho. Duration: ~54 min · Published June 8, 2026

Timestamps

• 0:00 Introduction
• 1:42 Lunch with Warren Buffett vs. Eric Schmidt; Charlie Munger
• 11:46 South Korea demographics; SK Hynix, Samsung & Micron
• 17:17 KOSPI
• 17:55 FAA-inspired investment checklist; Buffett’s Dexter Shoes
• 25:25 Three checklist essentials; IKEA and Amorepacific
• 31:17 Active vs. passive; hunting risk-free investments
• 35:08 Turkey; Reysas
• 39:22 Dhandho: heads I win, tails I don’t lose much
• 41:18 AI investing; don’t buy shiny items
• 43:37 Building wealth; Rule of 72; the 1623 Manhattan deal
• 50:22 Giving back; Dakshana Foundation
• 53:50 Advice to listeners

Pabrai manages about $1.4 billion and gives long interviews when the venue fits. This hour with Kim Kiho on Knowledge Inside walks through how he actually invests: hold businesses forever, run a crash-driven checklist, and buy what is hated while everyone chases the next shiny object.

1. The 2007 Buffett charity lunch cost $650,100, well under the $2 million cap Pabrai set as a tuition bill on the $70 million he had already made applying Buffett’s ideas. He co-bid with Guy Spier; his only goal was to thank Buffett. Buffett read everyone’s bio beforehand and set no time limit. Pabrai rates that lunch 15 out of 10. A separate Eric Schmidt lunch at Google’s cafeteria scored 2 out of 10: Schmidt checked his watch every 15 minutes and left at the one-hour mark. When Pabrai’s wife said she preferred Charlie Munger, Buffett arranged a Munger lunch that Pabrai enjoyed more, and a lasting friendship followed with home visits every three or four months.

2. On Korea, Pabrai praises the country but worries about population decline faster than Japan’s. Shrinking headcount caps total output unless you are an export powerhouse, and even then you face tariffs and rising labor costs. Hyundai is cheaper to build in Alabama than in Korea, he says. He currently holds no Korean stocks. On memory semis, he regrets selling SK Hynix and Micron when he should have held forever. Samsung, SK Hynix, and Micron sit in a protected oligopoly where a fourth entrant would need patents, engineers, and 10 to 20 years of fab work. If you already own them, do not sell. The party has just started, he says. If you do not own them, do not buy now.

3. KOSPI is lopsided because Samsung and SK Hynix dominate the index. The rest of the market still looks somewhat undervalued to him, but the population headwind is real. Domestic, non-export businesses face the hardest path. Export champions get tailwinds with their own complications.

4. His 213-question checklist copies the FAA’s crash-first logic. A plane crash triggers investigation; only then does aviation change. In investing, a crash is a stock that lost you money or went to zero. He built the list from great investors’ visible mistakes. Buffett’s Dexter Shoes, wiped out by cheap foreign labor, spawned a question about foreign-competition risk on every new idea. He started 16 or 17 years ago with 70 to 80 questions; now he runs all 213 before any purchase, usually in one or two hours once the research is done. He makes two or three new investments a year and cites the Korean Air peanut girl episode as what happens when you skip the pre-flight list.

5. For retail investors he boils the checklist to three items. No leverage in the company or your margin account: IKEA’s founder ran 70 years without borrowing a single won or euro. Moat durability: memory chips went from a terrible business with 20 competitors to a great one with three; Amorepacific is a hard business with a shallow moat despite loyal customers. Governance: owners should love the business, not love the money.

6. More than 99% of investors should buy an index fund, Pabrai says. Active stock-picking only makes sense if you can forecast a company’s cash flows 10 to 20 years out with high certainty. He uses SK Hynix as the test case. The deals he wants look almost risk-free: a regulated Korean power company earning $100 million a year, bought for $300 million, paying out 100% of earnings, pays back your capital in three years while you still own the asset for decades. Those anomalies live in hated, unloved sectors, not in whatever the crowd loves this year.

7. About 70% of his portfolio sits in Turkey, a market he entered seven years ago because it screened as the world’s cheapest. Reysas, a warehouse landlord to Amazon, IKEA, Mercedes, and others, traded at a $16 million market cap against roughly $800 million of liquidation value, about 2% of asset value. After due diligence he built a large stake and now owns about 40%. Seven years later the market cap is about $1.5 billion and liquidation value about $2.5 billion, and he intends to hold as long as the founding family runs it.

8. Dhandho, for him, starts with one question: how can this investment lose money? On Reysas the answer had to be it can’t: no debt, Fortune 500 tenants on long leases, earthquake standards and insurance checked after Turkish quakes hit with no warehouse damage. Applied to AI, the framework says stay away. AI is deeply loved, and loved is the wrong side. Bitcoin was loved, then AI replaced it as the shiny object; next, he predicts, the crowd will rotate into the SpaceX IPO. Please don’t buy shiny objects, he tells the audience.

9. Asked what to do with $1,000, he names Berkshire Hathaway (BRK.B): lots of cash, no leverage, strong management, deep moat, boring, hated, and unloved. Building wealth from scratch is two moves: spend less than you earn, and put the surplus into something equally boring, Berkshire or an index, and keep adding.

10. He tells the 1623 Manhattan story to teach Rule of 72. Native Americans sold the island for $23; at 7% compounded, money doubles every 10 years (72 divided by 7), and over four centuries that $23 would grow to roughly $28 trillion, far more than Manhattan’s land is worth today. The lesson: the Indians were not cheated; they needed a patient investment officer. Compounding plus savings beats chasing excitement.

11. He still invests because he treats it as a game, bridge and chess, not team sports. He asked Google’s AI when he will die and got June 11, 2054; he wants $10,000 left on June 10 and everything else given away through the Dakshana Foundation, which educates poor, gifted kids in India. One engine compounds; the other gives, and giving must accelerate as wealth grows. He closes with a German proverb: if wealth is lost, nothing is lost; if health is lost, something is lost; if character is lost, everything is lost.

Related TMFNK Content

• The Dhandho Investor by Mohnish Pabrai The book behind the heads-I-win frame he restates on Reysas in this interview.
• TIP812: Mohnish Pabrai: Berkshire & Letting Winners Run Another long Pabrai sit-down on holding winners and cloning Buffett.
• Charlie Munger: Saving the First $100,000 Will Change Your Life Munger is the partner Pabrai says he came to know better after the Buffett lunch backfired.
• The Magic of Compounding: How Small Investments Create Massive Wealth Written companion to the Rule of 72 and Manhattan parable in the back half of this interview.

Crepi il lupo! 🐺

This tutorial follows the free demo repo, Local-SLM-Data-Cleaner. The same approach ships in production form as Enterprise-SLM-Data-Cleaner—client-specific YAML rulebooks, an append-only audit log, air-gapped containers, CI quality gates, and swappable base models (including European options). The steps below are the demo; the enterprise section at the end is where you go when a laptop proof-of-concept is not enough.

TLDR:

• Clone Local-SLM-Data-Cleaner, run make setup then make model.
• make data builds 1,000 synthetic messy→clean pairs from deterministic rules in convention_spec.py (no real client data).
• make baseline-serve + make baseline scores the stock Qwen3-0.6B before training; write down field accuracy.
• make train fine-tunes with MLX LoRA; make fuse and make gguf produce qwen3-0.6b-cleaner-q8_0.gguf.
• make serve + make eval + make demo prove the after score beats baseline and clean one live record.
• For production: Enterprise-SLM-Data-Cleaner adds per-client conventions/*.yaml, make review, pinned container delivery, and make eval-gate adversarial CI.

Prerequisites: Mac with Apple Silicon (M1 or later), 8 GB RAM, ~5 GB disk, Homebrew. Intel Macs cannot run the MLX training step.

Step 1: Install tools and clone the repo

brew install python git llama.cpp
git clone https://github.com/TMFNK/Local-SLM-Data-Cleaner.git
cd Local-SLM-Data-Cleaner
make setup

make setup installs Python deps and mlx-lm. Success looks like >> Done. Next: make model with no red ERROR lines above it.

Step 2: Download the base model

make model

Pulls Qwen3-0.6B (~1.2 GB) from Hugging Face into your cache. No account needed. Done when it prints model ready.

Step 3: Generate synthetic training data

make data
make sanity

make data writes data/train.jsonl, valid.jsonl, and test.jsonl (default 800/100/100). The generator invents clean records, corrupts them like real messy master data, then labels each pair with the same deterministic algorithm the runtime uses later.

make sanity should report 100% field accuracy on the test split. That is the answer key checking itself, not a model score yet.

Want more examples? make data N=2000.

Step 4: Score the model before training

Terminal 1:

make baseline-serve

Wait for listening on http://127.0.0.1:8080. First run downloads ~600 MB.

Terminal 2 (same project folder):

make baseline

Note the field accuracy line. That is your before number. Stop the server in Terminal 1 with Ctrl+C before training.

Step 5: Fine-tune with MLX LoRA

make train

Loss should trend down over a few minutes. Output lands in adapters/. If the Mac runs out of memory, close browser tabs and retry with make train BATCH=2.

Step 6: Fuse and export to GGUF

make fuse
make gguf

If make gguf cannot find llama.cpp sources:

cd .. && git clone https://github.com/ggml-org/llama.cpp && cd Local-SLM-Data-Cleaner

You should see qwen3-0.6b-cleaner-q8_0.gguf (~600 MB) when ls *.gguf runs clean.

Step 7: Serve, evaluate, and demo

Terminal 1:

make serve

Terminal 2:

make eval
make demo

make eval should beat your Step 4 baseline on field accuracy. make demo sends one messy JSON record through the server and prints cleaned output plus a changes audit list.

Pro tip: Steps that call make baseline-serve, make serve, or make eval need two Terminal windows. The server holds port 8080 until you Ctrl+C it. If the port is busy, use make serve PORT=8081 and make eval PORT=8081.

Enterprise version: what changes for production

The demo hard-codes your house standard in convention_spec.py and optimizes for “clone it on a Mac and see it work.” Enterprise-SLM-Data-Cleaner keeps the same synthetic-training + LoRA + GGUF + llama.cpp pipeline but splits the repo for teams that need governance before they trust an SLM with master data.

Layout in the enterprise repo: core/ (convention engine), conventions/ (client specs), synth/ (synthetic data), eval/ (harness + adversarial cases), runtime/ (model → validate → rule safety net), deploy/ (offline container). The enterprise README walks through each layer; deploy/README.md covers air-gapped operation.

Quick start once you have finished the demo and want the production Makefile:

git clone https://github.com/TMFNK/Enterprise-SLM-Data-Cleaner.git
cd Enterprise-SLM-Data-Cleaner
make setup
make data CONVENTION=conventions/default.yaml
make sanity
make eval-gate          # sanity + adversarial suites must pass before you trust a change
make train fuse gguf
make pin-model          # vendor weights + pin hash for the container
make serve
make eval
make review             # records waiting for human review

Swap the base model without changing the rest of the stack:

make model train fuse gguf MODEL=utter-project/EuroLLM-1.7B-Instruct
make eval

Enterprise is AGPL-3.0. Commercial licensing and help applying this to a real master-data migration are via mbitai.com.

Cleanup

# stop the model server in Terminal 1 with Ctrl+C
# optional: remove cloned llama.cpp sibling if you only needed it for gguf

If it breaks: Cannot reach the model server means the serve step is not listening yet. Address already in use means an old server is still on 8080. Training killed mid-run? Re-open Terminal, cd back into the repo, and continue; finished downloads and data/ files are still there. Demo troubleshooting: Local-SLM-Data-Cleaner README. Enterprise deploy and security notes: deploy/README.md.

Related TMFNK Content

• Running Local LLMs: From First Run to Fine-Tuned Hardware, quantization, and runtime layers that explain why a 0.6B GGUF model is enough on a laptop.
• llmfit: Find Which LLM Models Run on Your Hardware Pick other small models that actually fit your RAM before you fine-tune the next experiment.
• Set Up LEANN for Private Local RAG on macOS Same privacy story, different job: local retrieval instead of record normalization.

Crepi il lupo! 🐺

Wikipedia is mostly read as blue links and prose. Wiki Spy by Neal Agarwal flips that: it surfaces roughly 40,000 isolated object images from Wikimedia—diagrams, specimens, maps, product photos, historical artifacts—and tiles them into a dense, draggable field. No article chrome, no infobox sidebar. Just things. Click one and the page repopulates with visually similar cutouts. It is less encyclopedia, more wandering a museum warehouse with the lights off and a flashlight.

1. Serendipity is the interface. Hit Shuffle and you get a fresh pile of unrelated objects. Click any thumbnail and similarity search becomes your compass—coins cluster with coins, beetles with beetles, until you drift into something you did not know you cared about. Better than opening Wikipedia’s random article when you want visual stimulus, not a biography.

2. Three buttons, zero onboarding. Clear wipes the canvas. Shuffle loads a new set. View on Wikipedia ↗ opens the source article for whatever you are focused on—so the rabbit hole always has an exit ramp into real context. That jump is the whole pedagogical trick: wonder first, citations second.

3. Search works when you have a topic in mind. Type a place or subject (e.g. “Vienna”) and the collage filters toward matching imagery—useful for a quick visual brief before a meeting, a lesson hook, or mood boarding a project that needs historical reference art. You still verify on Wikipedia; Wiki Spy is a lens, not a source of truth.

4. Same Neal.fun ethos as the rest of the site. Agarwal’s projects (Ambient Chaos is already on TMFNK) are small, polished browser toys with no signup wall. Wiki Spy fits the pattern: one idea, executed cleanly, runs client-side in the tab, shareable by URL.

5. Honest limitations. This is not a research database—you cannot export metadata, cite images cleanly from the collage, or trust that every cutout is current with the live article. Isolated-object extraction means context is stripped on purpose; a medical illustration next to a meme-adjacent diagram tells you nothing about reliability until you click through. And if you need structured data, use Wikimedia Commons search or Wikipedia categories directly. Wiki Spy is for exploration and delight, not literature reviews.

First run

No install. Thirty seconds:

1. Open neal.fun/wiki-spy
2. Shuffle until something catches your eye—or search a keyword
3. Click an image to branch into similar visuals
4. View on Wikipedia ↗ when you want the article behind a thumbnail
5. Clear to reset and start a new thread

Worth your time if: you teach, present, or write and need unexpected visual hooks; you miss the old web’s weird interactive toys; or you want a five-minute rabbit hole that might end at an article on 19th-century pneumatic tubes.

Related TMFNK Content

• 50 Useful Websites Google Doesn’t Want You to Know Wiki Spy belongs in the same bookmark folder as Archive.org, Connected Papers, and the other deep-web utilities.
• Best Free Tools That Don’t Require Signups or Show Ads Same no-account, instant-use pattern.
• Best Free Background Noise Websites and Apps Another Neal.fun pick (Ambient Chaos) for focus—pair visual rabbit holes with audio rabbit holes if you dare.
• SearchWhole.Earth: The Digitally Resurrected Whole Earth Catalog Same spirit of browsing for wonder instead of optimized feeds.

Crepi il lupo! 🐺

Google and Bing are fine until you remember they remember you. Every query feeds a profile; every profile feeds ads. SearXNG sits in the middle instead: you type once, it fans the query out to many search engines (Google, Bing, DuckDuckGo, Qwant, Brave, Wikipedia, and dozens more), then shows you a merged result page. The instance you use sees your IP, but SearXNG itself does not build a search history or sell attention. For most people the fastest path is not installing anything—open searx.space, pick an online instance, and search.

1. Start in under a minute. searx.space lists public SearXNG instances with uptime, country, TLS grade, and response time. Click a green row, bookmark it, set it as your browser’s default search engine. No account, no extension required.
2. One box, many engines. SearXNG is a metasearch engine: backends are configurable per instance. Images, news, science papers, and map tiles can each route to different providers. You get breadth without opening six tabs.
3. Privacy is architectural, not marketing. Queries go through the instance operator’s server, not Google’s ad stack. SearXNG does not profile users; you can also run it over Tor. The tradeoff: you trust whoever runs the instance you pick.
4. Public instances are a convenience, not a guarantee. Heavy shared instances get rate-limited or CAPTCHA-blocked by upstream engines more often. searx.space warns about this openly. For daily driver quality, self-host or use a small private instance.
5. Self-host when you care about consistency. Official Docker setup or the install guide gets you a URL only you use. Configuration lives in YAML; you choose which engines stay enabled.

Use searx.space to hop on now

You do not need a repo clone to try SearXNG today.

1. Open searx.space — maintained by the SearXNG project, refreshed daily (response times every few hours).
2. Scan the online instances table. Useful columns: TLS and CSP grades, country, uptime, search response time. Toggle Hide networks with privacy issue if you want to skip Cloudflare-proxied or analytics-heavy hosts.
3. Click an instance URL. You land on a normal search page—type a query and hit enter.
4. Bookmark the instance or add it as a custom search engine in Firefox (Settings → Search → Add). In Chrome: Settings → Search engine → Manage → Add.

Cannot pick one instance? searx.space lists meta-instances that redirect to a random healthy server (e.g. Neocities or Gimmeasearx). Handy for a first look; less ideal as a permanent default because the backend changes.

For programmatic use, searx.space exposes instances.json (format may change—check the site).

Self-host (optional)

If a public instance feels slow or returns empty Google rows, run your own:

git clone https://github.com/searxng/searxng-docker.git
cd searxng-docker
docker compose up -d

Default install docs and engine tuning: docs.searxng.org. Expect to babysit engine blocks and the limiter if your instance is open to the world.

Worth your time if: you want web search without building a Google-shaped dossier of your interests, and you are willing to trade a slightly rougher result page for that. Skip it if you need Google’s one-box answers, signed-in Gmail integration, or flawless image search every time—metasearch will frustrate you on those edges.

Related TMFNK Content

• taken.: See Everything Your Browser Tells Websites About You Search is one leak; taken shows the rest of what your browser broadcasts.
• Best Free Tools That Don’t Require Signups or Show Ads SearXNG fits the same no-account, no-feed pattern.
• Project NOMAD: The Offline Knowledge and AI Server Another stack for keeping research and queries off third-party clouds.

Crepi il lupo! 🐺

The supplement aisle is marketing with a nutrition label. Pillser is trying the opposite: index every product and every paper, rank claims by effect type and size, then wire the two datasets together so you can see what the evidence actually says about what you are holding. The Findings feed is the readable front page—headline studies in plain language, with the population limits and “one trial so far” warnings in the same breath. The site is explicit: these are research signals worth knowing about, not prescriptions.

1. The three-layer stack is the whole idea. Step one: parse the supplement market (ingredients, doses, normalized quantities). Step two: index supplementation research and score each claim. Step three: link products to papers. That is how you get from a Vitamin D search to a specific probiotic strain page to a product listing without trusting the brand’s ad copy.
2. Findings reads like a good journal club, not a wellness blog. A typical card might say turmeric cut HbA1c by 0.31% in a meta-analysis—and immediately add: only in people with diabetes, only four small studies, low overall evidence strength. Or milk thistle: 2,069 people with fatty liver, ALT down 1.10 U/L, probably noise. Myth-busters matter as much as hype.
3. You can browse by outcome, not by influencer. Health-outcome pages group what the literature claims about gut barrier function, eczema severity, sleep quality, and the rest—useful when you care about a question (“does anything help X?”) rather than a bottle name.
4. Individual papers get an AI-assisted read—with receipts. Each research-paper page pulls study design, sample size, and effect direction into something scannable. The creator paused the project once because early LLMs hallucinated too often on this data; they restarted after internal evals improved. Worth watching: AI interpretation is only as good as the eval harness behind it.
5. The mission is transparency, not more pills. The founder says the goal is not to increase supplement use but to help people decide—and often that decision is “you do not need this” or “get it from food.” This quarter’s focus is education on natural supplementation. That framing is rare in a category built on upsell.
6. Restarting cost real friction. Shady brands sent cease-and-desist letters demanding product takedowns—usually big marketing budgets, weak ingredient-to-price ratios, per the creator. Legal drag plus grad school plus unreliable models was enough to shelve it. Bryan Johnson’s Blueprint wave brought inbound interest that helped justify picking it back up. Transparency projects still fight incumbents with lawyers.
7. You might think a database fixes shopping. It does not fix you. Even perfect evidence summaries leave out your labs, medications, and contraindications. Pillser is a map of published signals, not a clinician. Single RCTs in narrow groups (Parkinson’s patients, postpartum wounds, preterm infants) dominate the feed—the caveats are honest, but readers still have to resist “one study → buy now.”

The takeaway: Bookmark pillser.com/findings as a filter before you read a supplement label or a Twitter thread. Use it to ask “what does the literature claim, for whom, and how weak is it?"—then talk to someone who can actually advise you on your body. If a finding is interesting, follow the paper link and treat the product pages as price-and-ingredient context, not a shopping list.

Related TMFNK Content

• This Spice Combo Could Slash Inflammation Hundreds of Times More Effectively Food combinations with measured effects—a different lane than pills, same need for caveats.
• From Tobacco to Ultra-Processed Food How industries sell health narratives; supplements rhyme with that playbook.
• Poison Everywhere Another angle on what we put in our bodies and how little we verify.

Crepi il lupo! 🐺

1. Capital is abundant; time and trust are not. Chen turned down higher guaranteed cash from quant finance to join Scale at 500 people. The network and exposure there led to DeepMind and OpenAI. His point is blunt: vibe-coding side gigs can turn a quick buck, but proven work known to reputable people is still the highest-signal currency.

2. Problem selection beats problem solving. At his agent-native company, Leetcode and textbook system design stopped predicting performance. What worked in interviews: drop someone into an unfamiliar environment, see if they spot problems worth solving, then watch how efficiently they allocate time and tokens with agents. Students panicking that agents ace problem sets are looking at the wrong scoreboard.

3. Great candidates still differ wildly on token efficiency. Agents can finish the assignment. They cannot replace the intuition and outside context strong people bring into the collaboration. Chen rates people higher when they have lived inside high-growth environments or passion projects where meaningful problems outnumbered headcount.

4. Pick the most ambitious form of the problem. The bitter lesson applies to careers, not just models: general scaling beats local hacks, and AI has widened the power-law gap. Anyone can spin up a simple app now. Durable value needs extreme focus on hard problems at companies that are actually trying to solve the ambitious version, not a demo that will pivot in six months.

5. The last mile is where humans still win. Chen cites Alfred Lin: the final 10% is 90% of the work and 90% of the reward. A sloppy prompt gets you median agent output. Polish, architecture, and iteration on your own projects are what separate candidates who look interchangeable on paper.

6. Careers need both xG and finishing. Chen uses the soccer expected-goals frame: get into positions where good opportunities appear (reputation, expertise, the right mutuals), then convert when they arrive. He passed on early Anthropic and Cursor offers twice to chase frontier inference work that fit his interests. Reasonable trade. He also wishes he had gathered more data before some calls.

7. Research is more accessible than the gatekeeping suggests. Public eval leaderboards, model credits from providers like Modal, and building your own benchmarks from daily model use are viable on-ramps. Chen’s line: being a researcher is a mentality (curiosity, infrastructure pain tolerance, articulating results to get more compute), not a job title locked behind a lab badge.

8. You might read this and think it only applies to people already orbiting frontier labs. Fair pushback. Chen’s network is unusually dense. But the underlying move generalizes: stop optimizing for gradable tasks agents already ace, and start stacking reputation with people who solve real problems in public.

The takeaway: Pick one problem you find meaningful, not one that grades cleanly. Ship it with agents if you want, but spend the extra hour on polish and write up what you learned where serious people can see it. DM one person whose work you respect with a specific question, not a generic coffee chat. That is how xG turns into goals when execution is cheap.

Related TMFNK Content

• The Proletariat of Judgment: Cognitive Stratification in the AI Era Chen assumes you still steer agents. This piece asks what happens when you stop steering entirely.
• Goldman Sachs on the AI Job Apocalypse: Real Pain, Not Mass Unemployment Macro labor math on displacement versus augmentation while Chen focuses on individual positioning.
• The Rise of Computer Use and Agentic Coworkers The agent-native workplace Chen is hiring for, and why problem-finding matters more than manual coding.

Crepi il lupo! 🐺