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!

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!

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!

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

🎯 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! 🐺

1. The old site mattered. Robert Stojnic and Ross Taylor built Papers with Code into the default map of state-of-the-art ML. Meta bought it for a reported $40 million in 2019. Updates slowed. Leaderboards aged. The team behind it went on to LLaMA. Niels Rogge at Hugging Face relaunched paperswithcode.co in 2026 as an independent revival, not a corporate rebrand.

2. The core loop is still paper → code → benchmark, but the surface area grew. Domains span vision, speech, embeddings, agents, time-series, and more. Each area gets leaderboards (COCO, MMTEB, Open ASR, coding-agent suites like Terminal Bench). Trending papers rank by GitHub star velocity, not just citation count. You can see what is moving this week, not what moved in 2021.

3. Methods are first-class again. RLVR, Mamba variants, Gated DeltaNet, and similar tags link papers that share a technique. Paper pages show lineage banners when a model has a clear predecessor or follow-up (DINOv2, GLM-4.5, Mamba-3). That context is half the value when you are trying to understand why a benchmark jumped.

4. Submission is open and AI-assisted. paperswithcode.co/submit accepts arXiv, bioRxiv, GitHub repos, and blog posts. The site auto-tags tasks, pulls linked repos and Hugging Face artifacts, and attaches evals where it can. Rogge reported roughly 3,000 eval rows so far, growing from Transformers-supported models. Multi-metric leaderboards now cover WER and latency on ASR, mAP and FPS on detection, and similar tradeoffs elsewhere.

5. You might ask whether another leaderboard site adds noise in 2026. Fair. Hugging Face already hosts millions of models. The point of PwC was never storage. It is curation with evidence: which paper, which repo, which number, on which benchmark. When you need “best open model for X under constraint Y,” this beats scrolling model cards.

6. It is early and community-maintained. Coverage gaps exist. Some domains are thin until someone adds results via the edit flow or GitHub tutorials. Sign-in with Hugging Face handles accounts. Treat it as a living index, not a finished encyclopedia.

The takeaway: Bookmark one domain you actually work in (agents, OCR, ASR, whatever). Pick a leaderboard, read the top three papers, clone the repo that matches your constraint. Submit a missing result if you have one. The site gets better when practitioners feed it numbers, not when you treat it as read-only wallpaper.

Related TMFNK Content

• Stanford AI Index 2026: Key Takeaways from the State of AI Macro view of where models are improving; Papers with Code is the micro view with repos and benchmark rows attached.
• Is Grep All You Need? How Agent Harnesses Reshape Agentic Search Agent benchmark culture Papers with Code now tracks alongside classic vision and NLP leaderboards.
• The Rise of Computer Use and Agentic Coworkers Why coding-agent evals on sites like PwC matter if you are picking tools, not just reading papers.

Crepi il lupo! 🐺

Fabian Dietrich is a technical founder (programming and design background) who spent a year learning sales because paying customers—not features—were the bottleneck. His write-up is rare: a funnel with real numbers, not a LinkedIn guru thread. Last 30 days on LinkedIn cold outreach: 487 connection requests → 175 accepted → 43 replies → 15 interested → 11 discovery calls → 8 held → 4 signed pilot agreements → 2 paid clients. That is a 0.4% close rate from top of funnel. Brutal, honest, and exactly why tech people need to read it. Sales is a life skill engineers keep hoping to route around. Most cannot forever.

1. High-touch beats self-serve when you are early and underpriced. Low-end B2B SaaS ($10–50/mo) can live on marketing alone—the indie hacker dream—but Dietrich argues it leaves money on the table and is harder than it looks. Video calls, 1:1 email, even tailored product work built trust and let him charge more. The risk is the “agency trap”: every customer becomes a custom project. He thinks more startups die from weak marketing and never talking to buyers than from over-selling.
2. ICP is earned, not assumed. Ideal Customer Profile work meant asking who benefits, who pays, and who will actually buy—then iterating with unpaid pilots and A/B tests on offers and segments. Generous pilots filtered serious buyers: a friendly two-page agreement before 10+ hours of setup and AI credits per prospect. They still have not nailed ICP; that honesty is the point.
3. The funnel is a numbers game; rejection is the default. HN reader Gooblebrai called this out explicitly: 487 to 2 paid makes ghosting normal, not personal. Dietrich says the same—thick skin, rejection as data. Fellow founder jackconsidine added the iteration angle: SEO and ads are slow signal for early products; a hundred emails can tell you in a night whether the offer lands.
4. You do not need a sales persona—you need curiosity. Dietrich dreaded calls, tried weather small talk, felt awkward. What worked: being his slightly introverted self, explaining the product honestly, and asking prospects about their business, industry, and ICP. Calendly cut scheduling friction; pen-and-paper notes beat AI meeting summaries for CRM entry. retube on HN hates Calendly links in cold outreach—feels like the seller will not do the tiny work of proposing a time. Worth A/B testing; the principle is remove friction without signaling you do not care.
5. Channel choice has legal and creep boundaries. Dietrich favors LinkedIn for intent (comments, reactions, in-house AI lists) over saturated cold email. mrfumier pushed back hard on scaling email in the EU: GDPR consent rules, fines, blacklisting—not “democratic outreach.” elorant called personalized outreach from scraped public comments intrusive. Tech founders love automation; compliance and trust are part of the stack too.
6. Coaching beats heroics for many introverts. amoorthy (technical co-founder) paid ~$2k/month for a sales coach, used Objective Management Group-style aptitude assessment, and felt competent after ~4 months. Suggests recording calls and using AI critique with that assessment as context—cheaper than coaching, not a full substitute. anitil noted HN skews introverted; moomoo11’s “just talk to people” misses that gap. elemdos: impossible if you fear rejection—which is trainable, not a character flaw.
7. HN’s cynical thread is worth sitting with. AndrewKemendo and pramsey describe enterprise sales as personal promises you cannot always guarantee—staring at the ceiling after saying “we’ll get it done.” brazukadev flips it: selling a good product is easy; building one is hard. Dietrich’s post is the messy middle—still proving the product through pilots, not closing Fortune 500 on faith. coole-wurst asked if 2/487 is worth imitating; fair question. The answer is not “copy his conversion rate” but “copy the loop”: talk → qualify → pilot → learn.
8. Founders never fully outsource the biggest deals. tschellenbach (Stream, ~$2M ARR solo early on) still shows up for large deals at a 140-person company. Sales at scale is a team sport; at the start it is founder sport.

The takeaway: If you build things for a living, schedule one sales experiment this month—not a landing page tweak, ten real conversations with people who might pay. Use Dietrich’s funnel as a sanity check: hundreds of nos per yes is normal. Track stages. Iterate the offer before you iterate the code. Read the HN thread for GDPR, ethics, and temperament—not to scare yourself out of selling, but to sell without becoming either a spam cannon or a wolf-of-Wall-Street caricature.

Related TMFNK Content

• Thinkism and the Teacher’s Dilemma Understanding follows doing—same shape as learning sales by talking to prospects, not reading one more framework post.
• Know Your Customers’ Jobs to Be Done Why “fit” on discovery calls is not performative; customers hire products to make progress in a circumstance.
• The Hard Truth About Business Model Innovation When the business model—not the feature set—is what you are actually selling.
• MIT GenAI Divide: State of AI in Business 2025 Enterprises pour budget into customer-facing sales and marketing while most AI pilots never ship—signal vs. spend.
• ACQ2: The Art of Selling Enterprise Software with ServiceNow CEO Bill McDermott The other end of the spectrum: career sales leadership at scale, useful once your two paid clients become twenty.
• The Enterprise Context Layer Why GTM reps fail when retrieval tools cannot answer “should I even promise this?"—sales is judgment, not scripts.

Also worth a look on TMFNK: Optimal Interview Preparation (feedback loops under pressure), Collaboration Inflation (when talking to people is the work), Jeff Bezos 2020 Letter to Shareholders (customer obsession as operating principle), Principles and Practices of Gap-Closing Investing (founder-market fit and “distance traveled”—parallel to ICP iteration).

Crepi il lupo! 🐺

Patrick Galbraith built Map of Metal with a friend studying multimedia: one person on the data, one on the code, about a week or two total. That was 2009. The site became the map a generation of metal-curious listeners used to see how thrash split into death, how doom fed stoner, why power metal sounds nothing like black. It resurfaced on Hacker News in May 2026 while Galbraith’s wife was picking something on TV. His comment thread is half technical history, half lament for the old web.

1. The map is the interface. You pan and zoom a stylized terrain where regions are subgenres and paths show influence. Click a node and you get a write-up plus a tracklist with YouTube clips for each exemplar band. Hear the difference between NWOBHM and melodeath instead of reading a Wikipedia wall of adjectives.

2. Flash soul, HTML5 body. The original ran in Adobe Flash. Galbraith ported it to HTML5 a few years back and posted the source mostly to keep the thing alive. Genre data lives as JSON files under data/genre-info/ in the repo, each with title, description, decade, and fallback video IDs if a clip dies.

3. YouTube embedding used to be the easy part. When the Flash version launched, YouTube had tiny text ads and Galbraith could hide the player chrome entirely. YouTube blacklisted the site anyway. He got unblocked after asking a Google engineer on a dev forum. “Very different times,” he wrote on HN. Today the visible player and pre-roll ads are part of the tradeoff for free hosting.

4. Mobile never shipped. Galbraith started a custom WebGL renderer because phone performance was rough, then life intervened. The site still shows “Mobile support coming soon.” Use a laptop or tablet. He has sketches for a much larger map (2m x 1.5m unfolded) with more subgenres and historical events. That version exists on paper, not in production.

5. The canon has gaps and that is fine. HN commenters flagged missing branches (blackgaze, grey metal, metalstep). The map is metal-only by design, not a map of all music. Treat it as a curated rabbit hole, not a complete taxonomy. You can suggest genres via the GitHub repo if you bring descriptions and 8–10 exemplar tracks.

First run

1. Open mapofmetal.com on desktop and hit ENTER.
2. Pan the map and click any genre region that catches your eye.
3. Read the blurb, then play tracks from the embedded list.
4. Follow connected paths to see how one sound forked into another.

No account, no install. Prints are sold on Zazzle if you want to support the project.

Worth your time if: you like metal even a little and want a visual tour with samples attached, or you miss the Flash-era web when two people could ship something weird in two weeks.

Related TMFNK Content

• Channel Surfer: Watch YouTube Like Cable TV Another browser experiment wrestling with how YouTube embeds and discovery feel today versus a decade ago.
• 50 Useful Websites Google Doesn’t Want You to Know Curated odd corners of the web; Map of Metal is exactly that kind of site.
• Flashpoint Archive: Preserve and Play the Lost History of the Web What preservation looks like when the original runtime (Flash) is gone but the culture is worth keeping.

Crepi il lupo! 🐺

TLDR:

• WalkingLabs teaches harness engineering: the repo environment that makes Codex and Claude Code reliable, not smarter prompts alone.
• Five subsystems: instructions, state, verification, scope, session lifecycle.
• Copy templates from the Resource Library (AGENTS.md, feature_list.json, claude-progress.md, init.sh).
• Audit any repo with audit-harness.sh (no Node required).
• Six projects build the same Electron knowledge-base app while you add harness layers; capstone includes benchmark and ablation scripts.

Prerequisites: A real repo you use with Claude Code, Cursor, or Codex. For hands-on projects: Git, Node.js, and an agent CLI. No paid course account; everything is free on GitHub and the docs site (15 languages).

Step 1: Read the core idea (10 minutes)

Open Lecture 01 and Lecture 02.

Success looks like you can explain this in one sentence: the model writes code; the harness governs when, where, how, and when “done” is allowed. Anthropic’s long-running agent experiments and OpenAI’s Codex harness writeups are the cited sources. Same model, weak harness vs strong harness is the difference between cleanup duty and review duty.

Step 2: Drop the minimal harness into your project

Browse the English Resource Library. Download or copy these into your project root:

your-repo/
├── AGENTS.md              # operating manual for the agent
├── feature_list.json      # scope: features and done/not-done
├── claude-progress.md     # session log (rename if you use Codex)
└── init.sh                # install + verify before work starts

Adapt names to your stack (CLAUDE.md if you prefer Claude Code conventions). Fill feature_list.json with real features, not placeholders. Point AGENTS.md at your test command and definition of done.

Success: your next agent session starts by reading these files instead of guessing repo rules from scratch.

Step 3: Audit what you have

curl -fsSL https://raw.githubusercontent.com/walkinglabs/learn-harness-engineering/main/tools/audit-harness.sh | bash -s -- /path/to/your/repo

Or clone the course repo and run locally:

git clone https://github.com/walkinglabs/learn-harness-engineering.git
bash learn-harness-engineering/tools/audit-harness.sh /path/to/your/repo

Success: script exits 0 when critical harness items pass. Failures list missing files or weak spots (no progress log, no verification hook, etc.).

Pro tip: The repo also ships a skills/harness-creator/ skill that scaffolds a production-grade harness in one agent session. Use it if blank templates feel too abstract.

Step 4: Run Project 01 (optional but worth it)

Clone the repo if you have not already. Open projects/project-01/ in the docs: Baseline vs Minimal Harness.

Work inside projects/project-01/starter/ with your agent. Run the same task twice: prompt-only first, then rules-first with the harness files. Compare how often the agent declares victory before tests pass.

Success: you have a side-by-side note on what changed when the repo carried state and scope, not just a chat prompt.

Step 5: Follow the full path if you want the system

The course order is fixed: 12 lectures, 6 projects, each project building on the last. All six projects evolve one Electron personal knowledge-base app (import docs, index, citation Q&A). Project 06 capstone adds benchmark scripts, cleanup scanner, and harness ablation (remove one subsystem at a time and measure what breaks).

Docs: walkinglabs.github.io/learn-harness-engineering/en/
Repo: github.com/walkinglabs/learn-harness-engineering

Optional offline: npm run pdf:build inside the cloned repo writes PDF coursebooks to artifacts/pdfs/.

Cleanup

No cloud resources to tear down. If you cloned only for templates, delete the clone when done:

rm -rf learn-harness-engineering

Keep the four harness files in your actual project.

If it breaks: Agent still skips tests? Add an explicit “cannot mark done until X passes” line in AGENTS.md and wire init.sh to run your test suite. Agent loses context between sessions? You are missing claude-progress.md updates or session handoff notes (Lecture 05–06). Audit script fails on a Hugo or docs-only repo? That is expected for some checks; fix what applies, ignore template fields that assume a Node app.

Related TMFNK Content

• Karpathy’s AI Coding Guidelines: Install the CLAUDE.md That Developers Use Behavioral guardrails for agents; harness files add state, scope, and verification on top.
• Hugo Agent Readiness Playbook: From Score 8 to 83 Same problem domain for this site: make a repo legible and safe for agents.
• Superpowers: An Agentic Skills Framework for Coding Agents Disciplined agent workflows (TDD, debugging); harness engineering is the repo infrastructure those workflows assume.

Crepi il lupo! 🐺

I finished Project Hail Mary wanting the stellar chart from the movie on my screen, not a static screenshot. GAIA Mary is Val Hovey’s answer: a browser map where you spin through local space, jump between named stars, and toggle views that separate real astronomy from story fiction. Val posted it on Hacker News with the receipts. Positions and colors come from ESA’s GAIA DR3 release, a survey of 1.8+ billion stars. A Python script pre-renders those stars into custom skybox images so the backdrop is actual survey data, not a painted texture.

1. The near field is real. Within about 17.72 parsecs (57.8 light-years), the map plots 53,836 stars from GAIA. Named waypoints match the book and film: Tau Ceti, Alpha Centauri, Sirius, Barnard’s Star, Wolf 359, and the rest. Val confirmed on HN that the featured stars reflect known science. Astrophage routes are fiction layered on top.

2. Two views, two purposes. Color mode shows star colors from GAIA photometry. Petrova mode overlays the astrophage infection path from the story (Val credits David A. Wheeler’s writeup for getting that arc right). You can appreciate the fan detail and still trust the stellar positions underneath.

3. The skybox pipeline is the technical flex. You cannot ship 1.8 billion points to a browser tab and expect smooth orbit controls. Val’s approach: offline Python rendering into image tiles, then load the result as the all-sky backdrop labeled “Gaia DR3 All-Sky.” A handful of very bright stars missing from the cut get handled separately. Smart preprocessing beats brute force.

4. Zero setup, heavy GPU. Open the URL, pick a destination star, drag to rotate. An About modal on the site covers credits and data sources. No account, no install. On older hardware the 3D view may stutter. This is a demo, not a planetarium app.

5. Val shipped a bigger follow-up. If you want more than the Hail Mary route, Gaia Atlas adds dozens of named stars, exoplanet systems, shareable travel links, and 600k stars rendered in-browser. GAIA Mary is the focused fan piece; Gaia Atlas is the sandbox.

First run

1. Open valhovey.github.io/gaia-mary.
2. Click About for the data blurb and credits.
3. Select a destination (Tau Ceti is the default story endpoint).
4. Toggle Color vs Petrova to compare science view and plot view.
5. Drag to rotate; click named stars in the list to jump.

Want to build your own thing? Start at the GAIA DR3 archive. Val’s HN comment is basically an invitation: the dataset is public, the rendering problem is interesting, and fan projects do not need a lab badge.

Worth your time if: you read or watched Project Hail Mary and want to see local stellar space with real coordinates, or you are looking for a weekend open-data project with a gorgeous payoff.

Related TMFNK Content

• How The Heck Does GPS Work? (An Interactive Exploration) Another browser explainer that turns abstract positioning science into something you can click through.
• map3d: Generate Real-World 3D City Maps from OpenStreetMap Data Same open-data instinct on Earth: pull a public dataset, render it interactively in the browser.
• Atom Animation: Visualizing the Quantum World Science visualization that rewards curiosity without requiring a physics degree to enjoy the first five minutes.

Crepi il lupo! 🐺

I open YouTube with a specific video in mind and twenty minutes later I’m watching a guy restore a tractor I will never own. The homepage is a slot machine. Channel Surfer fixes the mood, not the catalog: London developer Steven Irby built it to recreate cable TV for YouTube. It runs entirely in the browser. You import subscriptions through a bookmarklet. No accounts, no sign-ins. Your data stays local.

1. The grid kills choice paralysis. You get a channel guide with themed rows (music, science, cooking, whatever Irby curated) instead of an infinite recommendation feed. Pick a number, tune in. Videos start at the point they’d be at if the channel were broadcasting live right now, which is weirdly satisfying.

2. Subscription import is a bookmarklet, not OAuth. Drag the bookmarklet to your bar, open your YouTube subscriptions page, click it. JSON lands on your clipboard. Paste into Channel Surfer and your channels join the lineup. No YouTube API key, no Channel Surfer account. Irby said it plainly on Hacker News: “Just quickly import your data locally.”

3. The nostalgia layer is real but not fake. Scan lines and interlace are CSS, not a filter slapped on for Instagram. Comments and sidebar junk disappear. What remains feels like flipping through a hotel TV at 11pm. Irby told TechCrunch he built it because he misses channel surfing and “not having to decide what to watch next.”

4. You still get YouTube’s embed player, which means YouTube ads unless you have Premium. Some reviewers got ad-free playback; your mileage depends on how YouTube serves that embed. The curated channels are Irby’s taste. Great if you trust a human editor. Less great if you want full control from day one without importing your own list.

5. Mobile and TV are getting there. It works on tablets today but feels built for a couch setup. Irby has talked about Fire TV and Google TV apps. For now, a laptop plugged into the TV does the job.

Import your subscriptions

1. Open channelsurfer.tv and choose Import Your Channels from the menu.
2. Drag the Channel Surfer bookmarklet to your bookmarks bar.
3. Go to your YouTube subscriptions page (must be logged into YouTube in that browser).
4. Click the bookmarklet. Wait for the JSON to copy.
5. Return to Channel Surfer, paste, hit Import.

That is the whole setup. No install, no config file.

Worth your time if: you have a fat subscription list and want to watch YouTube without the algorithm picking your mood for you.

Also try: YTCH

Before Channel Surfer blew up on Hacker News, YTCH was the project people kept linking in the comments. Same idea, different execution. Hadi Safa built a lean broadcast simulator: open the site and a video is already playing on a random channel. You cannot pause. You cannot scrub. Switch channels with the number keys (or the on-screen pad). Leave channel 4 and it keeps running without you, so you might miss the good part. That is the point.

YTCH ships about a dozen curated channels, not hundreds. No subscription import. What it wins on is simplicity and keyboard control. HN commenters run it in Chromium kiosk mode on a Raspberry Pi with a TV remote. If Channel Surfer feels like a full cable package, YTCH is the old TV in the garage with twelve working channels.

Settings let you toggle channel names, captions, and video titles. Support links point to Buy Me a Coffee and Patreon if you want to tip the creator.

Pick Channel Surfer if: you want your own subscriptions in the guide and a proper TV listing layout.

Pick YTCH if: you want zero setup and do not care whose channel is on. Just flip until something catches.

Related TMFNK Content

• How to Block YouTube Shorts: Complete Guide for Desktop and Mobile Pair channel surfing with killing Shorts if the algorithm still pulls you back to vertical doomscrolling.
• WeatherStar 4000+: Relive the 90s Weather Channel in Your Browser Same retro-TV energy, different genre: live NOAA data in a Weather Channel local forecast skin.
• LongCut: Deep Learning from Long YouTube Videos The opposite workflow. Channel Surfer is for passive tuning; LongCut is for when you already know the video and want to study it.

Crepi il lupo! 🐺

Bored Zebra (Perfect Level Games). Browser, iOS, Android. Play it here.

I loaded it on a lunch break expecting a five-minute distraction. Twenty minutes later I was still chasing a clean run, muttering at jump 47 because I held half a second too long. The whole game is hold, release, land. Your counter starts at 100 and ticks down with every platform you reach. Hit zero and you win.

1. One input does everything. Hold to charge distance, release to arc onto the next pad. Platforms vary in spacing so you are constantly recalibrating muscle memory, not memorizing a pattern.

2. Perfect landings matter. Nail the center and you get a golden hit. Chain three in a row and you bank an extra life. That safety net is the only mercy in a game that otherwise punishes a single misread.

3. Stats stick locally. Attempt counts, best runs, trophies. Bored Zebra recently migrated hosts and offers to pull old stats if you had a prior account on the previous domain. Progress lives in your browser, not a login.

4. There is more than Classic mode once you beat it, plus a locked trophy tier and a tease for Exploding Hamsters on the same site. Fine if you want depth. I have not cleared Classic yet.

Play it if: you want a tight one-thumb challenge you can open in a tab and close without guilt.

Skip it if: timing games make you angry, or you need a story. This is pure jump math.

Related TMFNK Content

• Starfling: Tap, Release, Sling Between Stars Same one-input browser loop, different fantasy: orbital slingshots instead of platform hops.
• Globle Game Another daily-fixation game that punishes sloppy guesses and rewards patience.
• Mini Micro: A Neo-Retro Fantasy Computer That Runs in Your Browser If browser games pull you in, Mini Micro is the rabbit hole on the other end of the spectrum.

Crepi il lupo! 🐺

Podcasts are everywhere—Pew puts monthly listenership at 42% of Americans 12+—but academic work on the medium has mostly used hand-picked shows or tiny samples. Litterer, Jurgens, and Card (University of Michigan) close that gap with SPoRC (Structured Podcast Research Corpus): 1.1 million English episodes from public RSS feeds in May–June 2020, 6.6 billion words of transcript text, plus speaker-role labels for every episode and turn-level audio features for 370K diarized episodes. It is the first open corpus meant to do for podcasts what big Twitter or Reddit dumps did for social media research.

1. The pipeline is the product as much as the snapshot. They started from Podcast Index (~273K English shows active that spring), downloaded 1.3M episodes, transcribed with Whisper (whisper-base.en), filtered repetitive ASR glitches, and landed at 1.1M usable transcripts (<10% WER vs. professional transcripts on validation). A random subset got pyannote diarization and openSMILE prosody (pitch, formants, MFCCs). Host/guest names come from a RoBERTa classifier trained on Prolific labels (κ≈0.77)—because RSS metadata is a mess and hosts usually introduce themselves in the first 350 words.
2. Religion is the elephant in the room. Self-assigned category labels are noisy, but Religion turns out the most common category in the corpus—often recorded Christian sermons. LDA over 200 topics surfaces coherent islands (Wrestling, Bitcoin, Judaism) inside broad labels. Sports, Religion, and Business categories hang together topically; COVID and racial justice cut across categories—places where ideas might cross-pollinate even when guest networks do not.
3. Guests wire the graph; not every genre plays. They build a podcast–guest bipartite graph and project it: 10,480 shows, 26,589 edges from shared guests. Business and Sports form tight modules (high modularity)—shows in those lanes reuse the same guest pool. Religion and Society are huge by episode count but invite guests far less often, so they are less connected for cross-show diffusion. Promotional tour guests are a real edge type in this medium.
4. Podcasts do respond to news—slower than cable, wider than you’d guess. May–June 2020 was deliberately chosen (George Floyd, COVID crossing 100K US deaths). After Floyd’s murder, racial-justice topic share spikes over ~10 days (BLM peaks ~4 days after Floyd topics)—a “media storm” pattern, but slower than TV news storms in prior work. 21% of all shows mention “George Floyd” at least once by end of June. Peaks hit ~20% even in Sports and Religion; only News gives heavy weight to policing/protest framing; Society sustains elevated mention longer than Sports.
5. Incidental politics is the implication. Widespread Floyd discussion outside News/Society supports the idea that listeners get political content from trusted hosts they chose for other reasons—aligned with incidental exposure findings on other platforms. That matters for misinformation research too; prior work already flags podcast trust and bad health claims during COVID.
6. What SPoRC is not. Exclusive platform deals drop shows (the paper notes Joe Rogan as a notable omission). Video-only feeds are out of scope. One eight-week slice is thick but not longitudinal—dynamics after June 2020 are unknowable from this release alone. Whisper still confuses ads with hosts (Ryan Reynolds in a sponsorship read labeled HOST). Non-commercial license on the release.
7. You might think transcripts are enough for podcast research. The paper argues otherwise. Long-form audio carries turn structure, prosody, and who speaks—dimensions Twitter text never had. SPoRC is built for computational social science and NLP (summarization, narrative detection, popularity prediction) at a scale Spotify’s deprecated 200K corpus never sustained.

The takeaway: If you study media, health communication, or information diffusion—or you build tools on podcast text—grab SPoRC before reinventing a scrape-and-transcribe pipeline. Read the Floyd case study as a template for event studies on an ecosystem that is fragmented, trusted, and mostly invisible to existing dashboards. And treat any single May 2020 finding as snapshot science: the corpus is a map of one summer, not the whole territory.

Related TMFNK Content

• Xiaoyuzhou Podcast Downloader The listener-side mirror—archiving episodes you care about while researchers archive the ecosystem.
• How People Use ChatGPT Another lens on how people actually consume long-form information, not how platforms wish they would.
• General Guidelines for Search Quality Evaluators Evaluating information quality at scale—adjacent mindset to ranking claims in an audio-heavy web.
• From Tobacco to Ultra-Processed Food How trusted channels shape behavior; podcasts sit in that lineage for wellness and politics.

Crepi il lupo! 🐺

• Original article: https://andychen32.substack.com/p/the-enterprise-context-layer
• TMFNK implementation (updated July 2026): TMFNK/Enterprise-Context-Layer
  • README.md — overview and how to run
  • readme-for-humans.md — design rationale and deep background
  • readme-for-agents.md — full build spec with runnable Python (~70 KB)
  • AGENTS.md — harness grounding hook for Claude Code, Codex, Pi

Andy Chen spent six months building a GTM question-answering bot at Abnormal Security before he realized the problem wasn’t retrieval. Glean (arguably the best document-retrieval system in the world) still couldn’t answer “how long do we keep data after a customer churns?” correctly. Because the right answer isn’t in any document. It’s: don’t answer this yourself, route it to the security team.

His solution: skip the ontology, the knowledge graph, and the semantic layer. Give twenty parallel LLM agents access to a Git repo and every primary source the company has, and tell them to write cited Markdown. Two days later: 6,000 commits, 1,020 files, 11 domains; 100% of every product, process, team, compliance framework, and competitive dynamic mapped, cross-referenced, and verified.

One-sentence takeaway

The Enterprise Context Layer solves synthesis over retrieval by encoding institutional reasoning frameworks as cited, conflict-aware Markdown in a Git repository, autonomously maintained by parallel agents that learn question routing.

Part 1: What Andy Chen built

The problem

Chen’s original task was deceptively simple: build a bot that helps GTM reps answer customer questions accurately. Questions like “Will X feature be available next quarter?”, “How are you different from Y competitor?”, “What’s your data retention policy?”

Four things have to go right simultaneously for an AI to answer any of these correctly:

Glean, which Chen praises explicitly as “really really good”, solves the first dimension through context graphs, trace learning, and per-customer embedding models. What it doesn’t do is synthesize organizational context: the judgment calls, the institutional memory, the “this question is actually dangerous and you shouldn’t answer it” knowledge that lives in Slack threads, Gong call recordings, and engineers’ heads.

The difference is noticeable. Ask “when does customer data get deleted after churn?” and a retrieval system returns the closest policy document. Chen’s system returns: “don’t answer unless you absolutely know what you are doing; this is a high-risk question that should be escalated immediately to the legal team, and if you’re not sure, route to the security team. Here’s why, and here are three cases where reps got this wrong.”

The implementation

Chen’s system is built on two ideas and one architectural trick.

Synthesis over retrieval

The ECL is not a search index. It’s a Git repository of Markdown files that encode how the company actually works, the reasoning frameworks experts use, not just the raw facts they cite. Every file is a synthesis of primary sources: source code, Slack threads, Jira tickets, Gong transcripts, policy docs, ADRs. Every claim carries an inline citation. If an agent can’t cite it, it doesn’t write it.

Document the conflict, not the winner

When sources disagree, the ECL doesn’t pick a side. It documents both, names the conflict explicitly, and records who should resolve it. A documented conflict is more useful than a silently chosen winner because it tells downstream agents and humans exactly why escalation is required.

File-based distributed locking

Chen adapted a task-locking pattern from Anthropic’s C-Compiler project (Nicholas Carlini, Feb 2026), in which parallel Claude agents coordinate through lock files in a shared Git repo, with no external dependencies: no message broker, no coordinator service, no database. In Chen’s adaptation, a maintenance agent continuously scans the ECL for gaps and staleness, writing task files into a tasks/ directory. Worker agents claim tasks by writing a lock file and pushing to main; Git’s push-rejection means only one agent gets a given task. The agent executes, writes or updates ECL files with citations, deletes the task and lock, commits, and pushes. Then it picks up the next task.

Twenty workers. Two days. 6,000 commits.

Infrastructure:

• ~1,000 lines of Python for the harness
• Modal sandbox for compute (plain bash access to the Git repo)
• Glean search API + in-house retrieval for source access (Slack, Jira, Gong, etc.)
• Git as the single source of truth; no message queue, no external database, no vector store

The prompt (Chen’s actual words):

You are an Enterprise Context Layer (ECL) Agent that builds and maintains internal mental models, the reasoning frameworks our experts use, not just raw facts. […] The ECL is not built for readability. It’s built for traceability and verifiability. Every claim, every statement, soft or hard, has to have an inline citation for the source(s) that it directly draws from.

That’s it. The rest emerges.

What emerged

The artifacts Chen describes as “otherwise impossible to produce manually”:

End-to-end customer journey

From first sales contact through deployment, onboarding, renewal, and churn, all annotated with handoff points, common failure modes, and playbooks. Cross-referenced against real support cases and Gong calls.

Detection model lifecycle

A document bridging engineering, support, and customer success into one coherent mental model that previously lived only in a few engineers’ heads. Maps all causes of detection behavior change to customer-visible impact, with Databricks dashboard links and real incident case studies.

Battle cards with closed evidence loops

A Gong call where a competitive claim surfaced, correlated against actual product capabilities, linked to the Salesforce case showing how the deal ended, tied to field team Slack discussion on what messaging worked.

Feature flag inventory

Every flag across proto files, each cited back to specific line numbers in source code, with GovCloud overrides and deprecation status. No human has ever maintained something like this; it would be out of date the moment you finished writing it.

Then there’s the routing behavior. When asked about data retention timelines, the system correctly declines to answer and routes to the security team. This behavior emerged from the citation architecture, not from a hard-coded rule.

Core insights

1. The taxonomy is the folder structure; the context graph is the backlinks.

No ontology engine. No graph database. No semantic layer. Plain folders and plain Markdown. When an agent discovers that data retention questions connect to GTM and privacy and engineering, it writes a backlink in each file, and explains why. Over thousands of runs, backlinks accumulate into a navigable web of cross-domain understanding. The context graph builds itself.

2. Every claim needs a citation; unverified claims are forbidden.

The single most important writing rule. Unsourced assertions are more dangerous than gaps because they create false confidence. This rule is also what makes the system self-correcting: if a claim is wrong, the next agent can find the source, compare, and correct it. Remove citations and you have a confident, uncorrectable error machine.

3. Document the conflict, not the winner.

Two sources disagreeing is more useful information than a silently chosen winner. The ECL’s job is to surface why something requires escalation, not to pretend the ambiguity doesn’t exist.

4. Architecture claims are durable; status claims are ephemeral.

Chen’s agents generalized this from experience: “We use API-based integration” is true for years. “Feature X is coming soon” can be unreliable within days. “This PM announces features before they ship, so we don’t commit to customers” is tribal knowledge that retrieval will never surface. Different claims need different verification cadences.

5. Three independent sources agreeing is the threshold for high confidence.

But five Slack messages from the same channel are one data point, not five. Source diversity matters more than source volume.

6. Meta-awareness emerges from seed files, not prompts.

This is the subtlest insight in the essay. Chen created meta/how-to-get-accurate-information.md with a single line of instruction: “put in here synthesis of how to use tools to cite right sources, what sources or things tend to be out of date.” The agents filled out everything else completely from accumulated experience, over thousands of runs. No prompt changes. No architecture changes. Just a seed and a directory. The system learned which Confluence pages are perpetually stale, which Slack channels are noise vs. signal, which source pairs consistently conflict. Pre-filling that file with expert knowledge would have encoded the expert’s biases. Leaving it empty let the agents discover the truth.

Broader connections

Context layers as practice, not product

Chen’s closing argument is that the ECL pattern is closer to DevOps than to Salesforce or Databricks. It’s something most companies will build in-house rather than buy. The moat is not the tooling. It’s the accumulated, verified, living body of institutional knowledge. That means the company that starts building its context layer today compounds its advantage over time in a way that can’t be replicated by a vendor.

Three layers of context for AI-native companies

Chen sketches a hierarchy that deserves its own treatment: (1) enterprise context layer, company-wide knowledge; (2) team or org context layer, function-specific playbooks; (3) personal context layer, individual preferences and style. Each layer sits above retrieval and below task execution. Agents read from the layer appropriate to the task; the layers accumulate independently and at different rates.

The ECL grounds computer-using agents

The a16z thesis on computer-using agents (The Rise of Computer Use and Agentic Coworkers) describes agents that navigate browsers, desktops, and legacy enterprise software. An agent that can navigate SAP is useful. One that knows when to navigate SAP, which queries require escalation, and who owns what is transformative. The ECL is the organizational memory those agents need to act correctly, not just efficiently.

Foundation Capital’s context graph thesis

Jaya Gupta and Ashu Garg’s December 2025 piece "AI's Trillion-Dollar Opportunity: Context Graphs" argues that the next trillion-dollar platforms will be built not on systems of record (Salesforce, Workday, SAP) but on systems that capture decision traces: the why behind actions, not just the what. The ECL is a working implementation of this thesis at the level of a single company. The folder structure is the taxonomy. The backlinks are the decision trace. The how-to-get-accurate-information.md file is the accumulated judgment.

Part 2: The TMFNK implementation (updated 2026)

What follows is my extrapolation from Chen’s essay, now shipped as a full template repo. The conceptual core — synthesis over retrieval, empty seed file, folder-as-taxonomy, git push-rejection locking — is still his. The TMFNK/Enterprise-Context-Layer repo grew significantly in 2026: three audience-specific docs, a complete agent build spec (readme-for-agents.md), runnable ecl-runner.py worker and maintenance loops, lean SKILL.md workflows inspired by Waza, RBAC tiers, and drift logging. One way to implement the pattern, not the only way.

What’s in the repo now

Build path: clone the repo, open Claude Code / Codex / Pi, and run:

Read readme-for-agents.md fully. Then follow the Quick-Start Checklist at the bottom of that document.
Before you write any files, ask me the discovery questions in Step 1.

Expect 30–90 minutes of human interview (domains, sources, authority hierarchy) before any worker runs. Stop for human review of meta/system-prompt.md after Step 4. That file governs citations, routing rules, and what counts as a trusted source.

Operate path (after bootstrap):

# one worker to start
uv run ecl-runner.py worker --repo .

# scale out (git is the only coordinator)
for i in $(seq 1 5); do
  ECL_AGENT_ID="agent-$i" uv run ecl-runner.py worker --repo . &
done

# maintenance every 6 hours (cron-friendly)
uv run ecl-runner.py maintenance --repo .

Workers claim YAML tasks in tasks/ by writing a .LOCKED sidecar and pushing; rejected push means another agent won the race. Maintenance scans for stale last_verified dates, missing mapping-notes.md entries, unresolved conflicts, and outdated skills, then drops new tasks for workers.

Frameworks and models

1. Source authority hierarchy

Not all sources are equally trustworthy. The table below is what I distilled from Chen’s essay and from reading the Anthropic C-Compiler post on how agents handle conflicting signals:

Operational reality beats documented ideal. Source code shows what the system does. Confluence shows what someone intended. When they conflict, the code is right and the doc is stale.

2. Staleness by claim type

Different facts have different half-lives. The ECL must encode this to avoid treating a feature flag inventory the same as a founding architecture decision:

3. The ECL architecture (2026 layout)

Data Sources (Slack, Jira, Confluence, GitHub, Gong, CRM, code)
    │
    ▼
Worker Agents (parallel, stateless)
  1. Pull ECL; claim task via .LOCKED + git push
  2. Load matching domains/skills/{name}/SKILL.md if task type matches
  3. Read sources → synthesise with inline citations → document conflicts
  4. Append domains/{domain}/mapping-notes.md; commit; release task
    │
    ▼
Git Repo (single source of truth)
  AGENTS.md           ← harness auto-grounding
  meta/
    system-prompt.md
    how-to-get-accurate-information.md   ← starts empty; agents fill from experience
    domain-index.md                      ← domain → owner → primary sources
  tasks/              ← YAML queue + .LOCKED files
  domains/            ← cited topic files + mapping-notes per domain
    skills/           ← lean SKILL.md workflows (incident response, deals, etc.)
  sources/            ← read-only cited snapshots
  logs/               ← drift reports, agent error logs
    │
    ▼
Query (Claude Code, Pi, or rg + any LLM)
  → cite ECL paths; surface conflicts; obey routing notes

Topic files carry YAML front matter (last_verified, confidence, agent). Conflicts stay visible after resolution. Sensitive questions get routing notes, not answers.

4. Lean skills instead of a heavy skills framework

The repo’s third pattern is Lean Skills (Waza shape): one SKILL.md per workflow under domains/skills/, with trigger phrases in frontmatter. An agent loads the skill only when the task matches, follows it once, and does not auto-chain into a multi-skill pipeline.

Examples in the spec: incident response, closing a deal, customer data requests. Skills are versioned ECL content like anything else: citations, last_verified, re-verified when the process they describe drifts.

Superpowers-style discipline (brainstorm before synthesis, plan before harness changes) still fits as optional agent hygiene. The template itself does not require the Superpowers plugin; domains/skills/ is the built-in mechanism.

5. Recommended worker counts by phase

Tier models by task if you want to save tokens: frontier for synthesise and conflict-review, cheaper models for verify and backlink (Pi makes this a per-invocation setting).

Applications

What to do:

• Start with one hard question, not all knowledge. Chen’s original scope was a GTM bot answering five types of questions. The ECL grew from there. Pick the question that causes the most customer-facing failures and let the system expand from it. Don’t try to map the whole company on day one.
• Seed with an empty template, not expert content. The how-to-get-accurate-information.md file should start with one line of instruction. If you pre-fill it with what you know, you encode your biases and blind spots. Let agents build it bottom-up from accumulated experience.
• Route, don’t answer, for sensitive questions. Build routing rules as first-class artifacts. Which questions should never be answered by reps? Which require legal review? Which require escalation? These should be documented in the ECL before anything else.
• Cross-reference across domains deliberately. When an agent discovers a connection between data retention policy, privacy team, and support case history, it should write that link explicitly in both files, with an explanation. Cross-domain understanding that stays implicit in one agent’s context vanishes the next time a different agent reads the file.
• Store workflows as lean SKILL.md files in domains/skills/, not only in Confluence. Process becomes citable, versioned, and subject to the same staleness checks as product docs.
• Use mapping-notes.md per domain to audit what the fleet actually did. Without it you only see Markdown output, not which sources were read or which conflicts were found.

What to avoid:

• Don’t confuse the ECL with a better wiki. Wikis contain documents. The ECL contains reasoning frameworks. If your “ECL” is organized Confluence pages with better tagging, you’ve built a taxonomy, not a context layer.
• Don’t skip the citation rule. This is the one rule that can’t bend. Without inline citations, agents produce confident, untraceable errors that the next agent will propagate rather than correct. The self-correcting property depends entirely on traceability.
• Don’t pre-fill seed files with expert knowledge. The seed file’s value is precisely that it’s empty; agents fill it with what they actually discover, not what an expert assumes they’ll discover.
• Don’t start too big. One domain, one worker, Claude Code as the query interface. Get that working first. The impressive-looking 1,020-file repo took two days because the pattern was right, not because someone planned 1,020 files.
• Don’t mistake the ECL for finished. Target state is continuous maintenance, not a complete wiki. The maintenance loop and worker loop run indefinitely.
• Don’t skip human review of meta/system-prompt.md. The bootstrap agent will guess at sensitive topics and routing rules; you sign off once, then workers inherit that contract.
• Expect the query side to stay simple. Claude Code or Pi reading the repo is the v1 interface. rg plus an LLM is the lightweight alternative. Dedicated RAG is optional, not required.

References

Primary sources:

• Chen, A. (2026). “The Enterprise Context Layer.” Andy Chen’s Substack. https://andychen32.substack.com/p/the-enterprise-context-layer
• Carlini, N. (2026). “Building a C Compiler with a Team of Parallel Claudes.” Anthropic Engineering Blog. https://www.anthropic.com/engineering/building-c-compiler (Source of the file-based distributed locking pattern.)

TMFNK implementation (GPL-3.0):

• TMFNK/Enterprise-Context-Layer: Full template — readme-for-agents.md build spec, ecl-runner.py, task locking, staleness SLAs, RBAC tiers, lean skills, drift detection

Prior art (three patterns the repo synthesises):

• Chen, A. (2026). The Enterprise Context Layer — synthesis over retrieval; folder taxonomy; backlinks as context graph
• Carlini, N. (2026). Building a C Compiler with Parallel Claudes — git push-rejection task locking
• tw93. Waza — lean SKILL.md shape adapted as the ECL Lean Skills Pattern

Optional agent discipline:

• Vincent, J. (obra). Superpowers: Optional workflow discipline for coding agents building or extending the harness; not required by the template

Related TMFNK content:

• The Rise of Computer Use and Agentic Coworkers Computer-using agents need organizational memory; the ECL is one way to supply it.
• PipesHub: The Open Source Glean Alternative Retrieval stack for finding sources; the ECL synthesises on top of what retrieval surfaces.
• Obsidian Agent Client: Bring Claude Code Into Your Vault Same pattern of grounding agents in a Git-native knowledge base you control.

Complementary reads:

• Gupta, J. & Garg, A. (2025). AI’s Trillion-Dollar Opportunity: Context Graphs — decision traces as the asset; the ECL’s backlinks are a plain-text version
• Glean. https://www.glean.com — Chen used Glean search as a source API; retrieval and synthesis complement each other

Crepi il lupo! 🐺

I picked this up after one too many confident forecasts fell apart within a year. Mauboussin’s pitch is smaller than the subtitle suggests: learn which decisions your gut is actually trained for, and stop letting a polished story pass for evidence.

1. Expert intuition only works in a narrow class of problems. Mauboussin sorts decisions by environment. Gut feeling earns its keep when the setting is stable, feedback is fast, and patterns repeat: chess, firefighting, surgery. Investing, corporate strategy, hiring executives? Different class. That’s where “think twice” is the whole job.

2. The inside view sounds smart and skews optimistic. When you estimate a deadline or judge whether a bet will pay off, you build a narrative from this case’s unique details. That’s the inside view. The outside view asks a blunt question: how did similar situations actually turn out? In Mauboussin’s examples, student project timelines shrink sharply once you anchor to past completion rates instead of the team’s plan.

3. Preparation is what looks like genius in the ring. Mauboussin opens with Muhammad Ali. Spectators saw speed. What they missed was repetition: combinations drilled thousands of times before the bell. Mental models aren’t accessories for clever people. They’re the training that lets you respond correctly when there’s no time to reason from scratch.

4. Coherent stories are not proof of cause and effect. One recurring trap is mistaking narrative fit for explanation. Mauboussin walks through cases where the obvious story (this choice caused that outcome) collapses on closer inspection. A story that hangs together can still be wrong.

5. Individual rationality does not guarantee group sense. Micro-level logic can produce macro-level nonsense: herding, bubbles, organizational drift. You can’t infer crowd behavior from one person’s motives, and you can’t fix group failure by telling everyone to try harder individually.

6. Bad decisions often start with too few options on the table. Narrow framing is the quiet killer. Mauboussin’s fix isn’t louder brainstorming. Generate real alternatives before you commit to the first plan that sounds reasonable. A premortem helps: assume the decision failed, then work backward to explain why.

7. Experts help until you ask them the wrong question. Domain experts with tight feedback loops are valuable. Ask the same person to forecast outside that loop (long-range macro, novel technology, one-off strategy) and confidence often outruns accuracy. Mauboussin isn’t anti-expert. He’s strict about matching the tool to the task.

8. Good group calls need independence more than harmony. For a crowd to add information, people need to think differently and not coordinate before they commit. Meetings that socialize opinions before anyone writes a number down throw away the main benefit of having multiple minds in the room.

Verdict: Short book with a dense framework. The case studies show their age, but the decision-class map still holds. If you’ve read Kahneman or Gawande, you’ll recognize much of the furniture. Read this for Mauboussin’s synthesis: when gut is earned, when to reach for the outside view, and when a checklist beats a confident room. Skim the anecdotes if you’re busy; don’t skip the early chapters on intuition and the prepared mind.

Related TMFNK Content

• Thinking, Fast And Slow By Daniel Kahneman Mauboussin leans on Kahneman’s System 1/System 2 split throughout. Read Kahneman first for the underlying psychology, then Think Twice for the applied decision-class map.
• The Checklist Manifesto: How to Get Things Right by Atul Gawande Gawande’s answer to bad decisions is a checklist. Mauboussin agrees, but only for the narrow class of problems where expert intuition already works. Read both to see where that advice actually applies.
• The Black Swan: The Impact of the Highly Improbable by Nassim Nicholas Taleb Taleb goes further than Mauboussin, arguing rare events make most forecasting theater. Think Twice is the more practical, day-to-day companion to Taleb’s bigger claim.

Crepi il lupo! 🐺