Hacker
Harshendra M
@harshendra
Elsewhere
Stack
- TypeScript
- JavaScript
- Python
- Java
- Go
- Rust
- C++
- C
- C#
- F#
BenchWitness: a hands-free IoT test bench that hears you through Wispr Flow and proves it with live sensor data
No Hands: The Wispr ChallengeOct 2026
BenchWitness Who It’s For BenchWitness is for the person whose hands are on a board while the interesting moment happens. I test IoT devices at work. During a test I am holding a probe, reseating a wire, or breathing on a sensor. I cannot type. The observation stays in my head, the serial log scrolls away, and afterwards I spend 30–45 minutes rebuilding the report from memory, with no record of what the sensor actually read when something failed. That is every test session, several times a week. The same loop is the job of IoT and embedded developers, hardware QA and bring-up engineers, and electronics students who have to keep a lab record. What it replaces is a notebook balanced on the bench, a serial monitor nobody scrolls back through, and a write-up done from memory. The device can be any ESPHome board over Wi-Fi, or any board that prints on USB serial: ESP32, ESP8266, a Pico running MicroPython, an Arduino, or a bare UART adapter. It was tested end to end on my reference bench, an ESP32 DevKit (`homeos-room`) running ESPHome, with a DHT11, a digital light sensor, and a demo LED sharing a paper tube with that sensor. One device per laptop. The device itself never goes on the internet. A small bridge on the laptop next to the bench is the only thing that talks to it. How Wispr Flow Is Used Flow is the whole voice layer. BenchWitness has no microphone and no speech recognition of its own. Hold `Ctrl+Win` (or `Fn` on a Mac), talk, let go. Flow types into whichever window has focus, which is how a bench actually works: the page, the serial monitor, the IDE, and the issue tracker are all open at once. The product is built around how Flow inserts and formats text, not around a generic text box. While You Test On the desktop, Flow inserts a finished dictation as one paste. The bench tells that apart from typing (one character per keystroke) and from a predictive-text tap (one word). A paste of three or more words from the Flow keyboard on a phone counts the same way, so a phone propped next to the board is a full bench. The dictation submits itself 600 ms after it lands. Nothing to press. Typed text still waits for Enter, so someone without Flow can use the page. A paste anywhere on the page is caught and put in the box, so a click that moved focus does not lose the sentence. Every card records whether it came from Flow, the keyboard, or an example phrase. Flow inserts the words when you stop talking, which is after you said them. Each sentence is placed back at the moment it was spoken, about 2.5 words per second from its place in the dictation, and its check starts from that moment in the sensor history. A note keeps every reading at that instant. The card shows how many seconds it was back-dated. Hands-free mode (`Ctrl+Win+Space`) can run up to 20 minutes. A long dictation is split at sentence ends into pieces of at most 1,500 characters, each an exact piece of the original, so the timing still finds every sentence. If the speech was longer than a minute, the cards say the times are estimates. A command said more than 30 seconds before the text arrived is held and not run. “Turn the pump on” from the start of a long monologue does not fire minutes later. `Alt+Shift+Z` re-pastes the last transcript. The same text within 10 seconds is ignored, so a hardware command is not sent twice. Running a Whole Test by Voice A Flow snippet whose expansion starts with `Procedure <name>:` is one spoken cue for a full test. Steps run in order. Each one starts when the previous one is decided, not at a back-dated time. `Wait 5 seconds.` and `Stop.` work inside it. The result is a spoken pass count that goes into the report. The `/flow` page builds the snippet kit from the device on the bench: an on/off test for each output, a rise test for the main sensor, a reboot test when USB reset is available, and `bench report` which expands to `Wrap up.`. On the reference bench that is `LED test`, `temperature rise test`, and `reboot test`. Every generated step is a sentence the instant parser understands, so a snippet does not wait on the model. Flow’s list formatting does the same job without a saved snippet. “First turn the pump on, then wait 5 seconds, then the flow sensor should read flowing” arrives as a numbered list. Two or more numbered or bulleted items run as a procedure. The report counts how many procedures came from a spoken list. Getting the Words Right `/flow` also builds a personal dictionary from the device: part names, chip names, `ESPHome`, `BenchWitness`, and the device id, plus the mishearings to correct (`DHT 11` and `D H T 11` become `DHT11`, `GPIO 4` becomes `GPIO4`, `ESP home` becomes `ESPHome`). Those download as CSV, TXT, or JSON. The same part names are printed beside the dictation box, so Flow’s Context Awareness sees `Temperature (DHT11)`, `Demo light`, `Light sensor` and spells them the way the parser expects. The setup checklist asks for Casual or Formal style, because the bench splits sentences on punctuation. English, Hinglish, and Hindi all parse. “Demo light ko 50 percent kar do” is a command. “Humidity 70 ke upar jaani chahiye 20 second mein” is a check. “5 second ruko” is a wait inside a procedure. Spelled-out numbers (“within ten seconds”, “forty degrees”) become digits. On 30 bench dictations in those three languages, the same parser the live site uses understood 30/30. 24 of them were instant, with no model. The other 6 took a median 1.4 seconds. After the Test, Still by Voice “Wrap up.” writes the report: results, procedures, timeline, likely causes, next steps, and a pre-filled GitHub issue for each failure. The summary, causes, and next steps stay editable. Select the summary, hold `Ctrl+Win+Alt` (Flow Command Mode), and say “make this two sentences and mention the loose wire.” Flow’s rewrite comes back as a paste, is saved, syncs to the shared report, and is counted. Regenerating the report keeps the fields you already changed. The `/device` description editor takes the same kind of paste. Two generated Transforms sit beside that: Bench shorthand turns rambling narration into short sentences the parser acts on, and GitHub issue turns a selected failure into a bug report, keeping every number as said. Every result is spoken back and shown as a caption (`°C` is read as “degrees”), so the loop does not need a look at the screen. The report itself says how the session was driven, computed from the tag on every card. A real line looks like: “14 dictations through Wispr Flow (212 words), nothing typed, 2 procedures (1 from a spoken list), 1 dictated or pasted report edit.” ## While Building It I built BenchWitness by dictating to Claude Code through Wispr Flow: specs, bug reports, fixes, and commit notes. The same dictionary holds `ESPHome`, `DHT11`, `GPIO4`, and `homeos-room`, so those names come out right in dictated specs. Contributors are pointed at the same kit: dictionary from `/flow`, Command Mode for tidying a PR description, and the GitHub-issue Transform for a dictated failure.
HomeOS — a home that remembers what helps you
Graph HacksOct 2026
Wearables already know a great deal about a person. A watch can see that their heart rate has climbed. A ring can see that they slept badly, that their heart-rate variability dropped, or that they have been still for too long. The home they walk into does not know any of this. It runs a timer, a fixed temperature, or a routine that belongs to one brand. It cannot tell a bad night from an ordinary one, it cannot remember which action helped this person last time, and it cannot explain itself when someone asks why the room changed. The information stops at the wrist. That gap matters most inside a family. An older parent living on their own, or with their children nearby, should not have to open an app and build a scene when they are unwell, overtired, or too warm. The house ought to notice and act, and a son or daughter should be able to trust that the home is looking after them without receiving a feed of their medical details. The same problem runs the other way. Parents who want to look after their kids need the home to care for more than one body at once. A child who is unwell needs the room warmer and quieter. A parent who has just exercised, or who is trying to sleep, has a different need. A fixed rule serves whoever was configured last. It cannot keep a parent and a child in mind together, and it cannot do that without turning the child’s health, or the parent’s, into something the whole household can read. HomeOS is for those families. It is a wellness system, not a medical device. It connects a Galaxy Watch, a Gabit smart ring, and a small room sensor to a team of agents whose memory is a knowledge graph. The watch brings the live signal: heart rate, a spoken question, a simple report such as “I’m feeling sick” or “I just finished a workout.” The ring, through the official app and Android Health Connect, brings the slower record: heart rate, heart-rate variability, steps, and sleep. The room node brings temperature, humidity, and light. From those, the agents notice when someone has drifted from their own baseline, choose the action that has worked for them in similar situations, and carry it out. The room can warm or cool, a fan can come on, the light can dim, or the watch can pace their breathing. A few minutes later the system measures how their body actually responded and remembers that outcome, so the next decision is based on their history rather than a generic rule. The part a family cannot do without is privacy. Each person has a private memory. The home has a separate shared memory. A condition such as being unwell stays in that person’s own graph. The shared home learns only an anonymous limit, for example that the room should stay at 26 °C or warmer, and how important that limit is. An older parent’s reason for needing the room warm never appears on a child’s screen. A child’s reason never appears on a parent’s. When someone asks why the room is not colder, the answer is that someone present needs it warmer. Who they are, and why, stays private, and another person’s agent is denied that graph by the database itself. That is how an adult child can look after an ageing parent, and how a parent can look after a child, in the same house, without sharing a health record. HomeOS is for a household that already has a wearable and a few home devices and wants the house to act on each person’s body, remember what helped, and still explain itself. It is especially for older parents who should not have to manage the house by hand, and for parents looking after their children, where two people must be cared for at once and neither person’s health should become something the rest of the family can see.
Team Rocket@thatoneuke,@shash1278
- Ship It
Suraksha - An Agentic Companion for an aging parent
First CommitSep 2026
https://builder.aws.com/content/3Jaz74XYXUmUUXxqCsvzktGEAEt/firstcommithack https://builder.aws.com/content/3Jas4G437kCVgp5uYso0tv64Wby/first-commit-hack
StarBugs@thatoneuke,@shash1278