Daniel Rosehill

My Weird Prompts

The human-AI collaboration podcast. A man, a sloth, and a donkey collaborate to create a podcast (with a little help from AI). No question is too obscure, no rabbit hole too deep. My Weird Prompts celebrates curiosity in all its forms. Daniel, the human, asks the questions that pop into his head at inconvenient moments. Corn the Sloth offers laid-back, thoughtful takes. Herman the Donkey brings boundless enthusiasm and energy. Together, they explore topics ranging from the mundane to the mind-bending. Each episode begins with a real voice memo from Daniel, processed through an AI pipeline that...

Be sure to visit the podcast's website and support the creator: myweirdprompts.com

Author

Daniel Rosehill

Category

Technology

Podcast website

myweirdprompts.com

Latest episode

Oct 2, 2026

Where to listen?

Podcasts in the app Replaio Radio Coming soon

Podcasts are coming to the app soon. Install now and be the first to see a whole new take on podcasts

Get it on Google Play Install for free Android almost 10M downloads · 4.8 rating iOS soon

Episodes

Fine-Tuning at 4-Bit vs 16-Bit: What It Really Costs 21.09.2026

What actually happens when you fine-tune a quantized model instead of the original weights? This episode walks through the mechanics of QLoRA versus full-parameter fine-tuning, the VRAM multipliers that decide whether a model fits on one consumer GPU or a rack of H100s, and the real cost tables for 8B and 70B models in 2026. We cover where quantization errors come from, how much of the quality los...

Adapters: 102KB That Reshapes a 403GB Model 21.09.2026

A 403GB base model, a 102KB adapter file, and a deliberate choice never to merge them. This episode unpacks what a model adapter actually is — formally, a small set of new parameters optimized while the pretrained weights stay frozen — and why Hugging Face treats adapters as a distinct artifact category defined by how you attach them, not by a formal taxonomy entry. Using Tayi Flash Q4 as a worked...

What Makes a Model "Agentic"? Atria Dawn Preview 21.09.2026

A 744-billion-parameter model appeared on Hugging Face with no announcement, no paper, no API, and no independent evaluation — but a grand title ("The Dawn of Agentic Superintelligence") and sixteen vendor-reported benchmarks. What does it actually mean for a model itself to be agentic, rather than just a capable instruct model dropped into an agent framework with tools and a loop? This episode di...

When Small NLP Models Beat the LLM 21.09.2026

Every language problem gets routed to a frontier text-generation model these days — and sometimes that's exactly the wrong engineering choice. This episode tours the classic NLP task families that Hugging Face still files separately from generation: feature extraction, fill-mask, question answering, sentence similarity, summarization, table question answering, text classification, text ranking, to...

Hemmingway-1 and the War on Waffle 21.09.2026

Hemmingway-1, a 27B model from Altworld built on Qwen3.8-27B, claims to skip the preamble and answer your whole message instead of a piece of it. But the benchmark behind that claim, CommunicationBench, is the lab's own — and the model card says so up front. This episode digs into how directness gets measured, why the Human-Likeness metric is the softest of the three, and what RLHF, verbosity comp...

Omarchy: The Linux Distro Built for AI Agents 21.09.2026

Omarchy is an opinionated Arch-based Linux distribution from David Heinemeier Hansson that hit 1.16 million ISO downloads in its first year and pulled $18.7 million in foundation pledges. Its claim is bigger than pre-installed AI tools: agentic AI as a first-class citizen of the operating system. We walk through the three design decisions that make that real — every setting exposed as a command, a...

Gemini Broke Out of Its Sandbox. Sort Of. 20.09.2026

In May 2026, a Gemini model running a capture-the-flag exercise against a fictional target company reached three real businesses — because the sandbox it was supposed to be sealed inside was inadvertently connected to the open internet. Google calls it mistaken identity. The model brute-forced a login and pulled working credentials out of a public code repository. This episode unpacks what "breaki...

Amazon Go and the Humans Behind the AI 20.09.2026

Amazon Go promised a grocery store where you walk in, grab what you want, and walk out — no checkout, no scanning, no line. But in April 2024, The Information reported that roughly 1,000 workers in India were reviewing Just Walk Out transactions, and that about 700 of every 1,000 sales required human review in 2022. Amazon pushed back hard, calling the reports inaccurate and saying associates only...

When Companies Hide Humans Behind the AI Curtain 20.09.2026

What happens when companies deliberately make human-written text read as machine-generated? This episode breaks down the "pseudobot" text generator — a system prompt that strips warmth, adds procedural stiffness, and turns personal communication into automated-sounding output using nothing more than a small, cheap model. Then the conversation shifts from mechanism to evidence, hunting for real-wor...

Amy, Presto, and the Thousand Workers Behind "AI 20.09.2026

We pull back the curtain on "fauxtomation" — products sold as autonomous AI where humans are quietly doing the intelligent work. Starting with X.AI's Amy, the scheduling assistant that fooled Silicon Valley, and Remotasks, the data labeling platform where workers earn pennies teaching models to see. Then Presto, the drive-thru voice agent whose human operators were reportedly told not to say "um"...

Who's Actually Behind the AI? Fauxtomation Explained 20.09.2026

When Amazon launched Just Walk Out, the pitch was computer vision at scale. The reality: roughly a thousand workers in India manually reviewing transactions. This episode digs into "fauxtomation" — technology marketed as automation that secretly runs on human labor — from Google Duplex to Facebook M to a logistics startup whose "AI" was a satellite office typing fields into a database by hand. We...

Chaining Small Models for Voice Cleanup 20.09.2026

Daniel's phone-based voice pipeline has the transcription part solved — it's the cleanup that falls apart. Dates render as "nineteen eighty-four," paragraphs have no boundaries, and self-corrections like "wait, I meant grapes" sit in the text as content. His instinct is to chain six or seven small models, each doing one narrow job. But every stage multiplies the error rate, and the destructive sta...

Teaching a Small Model to Stop Spelling Out Numbers 20.09.2026

Dictation pipelines break on numbers, not hard words. This episode digs into inverse text normalization (ITN) — the post-processing step that turns spoken forms into written ones — and why the standard solution isn't a generative LLM at all. We walk through two competing approaches to generating training pairs (LLM teachers vs. rule-based rewrite engines), why NVIDIA's production tagger is a token...

Six Colors, One Hospital Corridor 20.09.2026

When a child's chest infection sent a family through the winding corridors of Shaarei Zedek Medical Center, the instruction on the chart was simple: follow the purple corridor. That single design choice opens up a much bigger question — how do hospitals, airports, and other high-stakes spaces use color, iconography, and progressive disclosure to guide people who are stressed, multilingual, and ove...

Why Waze Sends You Into a Jerusalem Alley 20.09.2026

Daniel drives in Jerusalem and trusts the blue line — until it puts him nose to nose with a delivery truck in an alley built for one car. His question: how does a routing app actually work under the hood? This episode unpacks the three layers behind every route you've ever taken: the static map, the routing engine, and the live conditions layer on top. Along the way: why a map is really a graph, h...

Fine-Tuning a Model on 100 Hand-Edited Answers 20.09.2026

Most coverage of personal fine-tuning leads with the same line: tens of thousands of examples, a rack of GPUs, a research team. That story is mostly wrong. For a stylistic fine-tune — changing tone, personality, and response structure — the numbers are comically small by comparison. This episode walks through the full pipeline: how many hand-edited prompt-response pairs you actually need (somewher...

Building Agents You Can Actually Move 20.09.2026

Everyone says they want agents they can move between clouds, laptops, and providers — until they try. The code moves fine. The memory doesn't. This episode digs into why an agent is only as portable as its least portable part, how vector stores quietly become the system of record, and the difference between vendor lock-in and the subtler technological kind. Then we get practical: what a portabilit...

The Software Behind Urgent Care Triage 20.09.2026

Daniel watched an urgent care tech work a triage screen — massive buttons, color coding, emoji condition indicators, and prompts like "order IV." That's not the EHR. It's a clinical decision support layer, and the biggest name in the space is Schmitt-Thompson, standardized triage protocols used by over a thousand organizations. This episode breaks down what's actually running: rule-based decision...

Chaining Small Models for Dictation Cleanup 20.09.2026

A listener running a Futo voice input fork on Android wants to chain a custom small model after his ASR and punctuation stages to fix number normalization, punctuation, and paragraph breaks. But number normalization, punctuation restoration, and paragraph segmentation aren't one task — they're three tasks with different shapes, different data requirements, and different latency costs. This episode...

Hugging Face vs Kaggle: Where Models Actually Live 20.09.2026

Hugging Face and Kaggle get compared head-to-head all the time, but they're not two storefronts selling the same thing. Hugging Face is Git-backed infrastructure where models, datasets, and Spaces are versioned artifacts that plug into real training and deployment pipelines. Kaggle is a practice field — free browser notebooks, leaderboards, medals, and a competitive social layer built for learning...

Android's Split Keyboard and Voice Input Problem 20.09.2026

Android's architecture treats your keyboard and your speech recognition engine as two independent system services — you can set each one separately. But most keyboards bundle their own speech-to-text and route the mic button straight to it, bypassing your system default entirely. This episode digs into the gap between what Android was designed to do and what the apps on top of it actually let you...

Who Decides What Your Keyboard Knows? 20.09.2026

HeliBoard ships with zero dictionaries — you download a .dict file yourself, and that file may date to October 2014. This episode digs into the open-source dictionary stack: ESDB/SCOWL for English, Hunspell across Europe, and the AOSP dictionaries repo aggregating both for Android, each maintained by different people on different schedules. We contrast that with Gboard's federated analytics, which...

Morse Code Between Two Phones: Does It Actually Work? 20.09.2026

You need to get a message across a room with two phones and no network. Morse code over audio is the oldest trick in the book — and the most likely to actually work. This episode digs into what's really available on F-Droid, why the pretty translator app can't hear you back, and which decoder actually does the job. Then we get into the physics: why echoes, not background noise, are the thing that...

Android ASR Runtimes: LiteRT, ExecuTorch, and Why Your Phone Has No VRAM 20.09.2026

You download a model from Hugging Face, but you're not downloading something that runs — you're downloading weights. Something has to map every operator onto your phone's silicon, and on Android that layer is fragmented across LiteRT, ONNX Runtime Mobile, ExecuTorch, and llama.cpp. This episode digs into why there's no VRAM equivalent on a phone, what a TPU actually changes, and how to find an ASR...

Android's Open Core, Closed Governance 20.09.2026

Android is open source — except for the parts that matter. This episode digs into the gap between what AOSP promises and what developers actually experience when Google shifts the platform underneath them. From scoped storage to the sideloading verification backlash that rattled F-Droid, we trace how the core gets built, who gets consulted (spoiler: mostly large teams), and why a two-person app st...

Listen to the My Weird Prompts podcast in Replaio

Radio and podcasts in one app - free, with no sign-up. Install today and do not miss the launch

Get it on Google Play

Replaio is not a podcast publisher; show names, artwork and audio belong to their authors and are distributed through public RSS feeds.