DEV Community: softalpha

Second Guess: flashcards that notice when you're guessing

softalpha — Wed, 11 Nov 2026 15:48:28 +0000

This is a submission for the Presage SmartSpectra SDK Challenge.

Second Guess helps students find the answers they only guessed right, without trusting their own over-confident self-ratings.

What I Built

The problem. Flashcard apps like Anki and Quizlet decide when you'll see a card again from your own rating — and people overrate lucky guesses. A guess gets scheduled like real knowledge, pushed a week away, and forgotten. You find out in the exam.

What it does. Second Guess watches the few seconds between seeing a question and revealing the answer — the recall window — using the SmartSpectra SDK. If you got it right but hesitated (a long pause, looking away, a held breath), it says "Right — but you hesitated: long pause, looked away" and brings that card back tomorrow instead of next week. Every signal is compared with your own 60-second warm-up, and you can always disagree with one key.

Demo

Live SDK signals on my laptop: breathing trace, blinks, expressions and the 478-point face mesh — numbers only, no video kept.

Camera check: plain hints and a face-points "mirror" instead of a video preview.

Summary, Check mode result and signal replay.

Code

softalpha0 / second-guess

Second Guess

Second Guess helps students find the answers they only guessed right, without trusting their own over-confident self-ratings.

A desktop flashcard app that watches for hesitation while you recall an answer — using your webcam and the Presage SmartSpectra SDK. When a right answer was really a guess, it says "Right — but you hesitated" and brings that card back tomorrow instead of next week.

🎬 Demo video (1:27)	https://youtu.be/Bw7pHNqaJRY
📝 DEV post	https://dev.to/softalpha_0/second-guess-flashcards-that-notice-when-youre-guessing-4d9n
🧾 Evidence	docs/evidence — SDK field report from a real run, honest accuracy results, test results

Built for the Presage SmartSpectra SDK Challenge on DEV · categories: Best Thoughtful Real-World Use, Most Creative or Delightful Use.

⚠️ Second Guess measures study hesitation — not stress, emotion or health. It is not a medical device.

The problem

Spaced-repetition apps (Anki, Quizlet, Brainscape) decide when you see a card again from your own rating of how…

View on GitHub

Run it from source in four commands (see the README). Evidence (SDK field report from a real run, test results, honest accuracy numbers): docs/evidence.

How It Responds to Human Signals

The SDK runs in Electron's main process on the native camera and sends ~20 messages per second. Before writing any feature, I logged every field it sent on my Windows laptop (field report). That spike decided the design: a 478-point face mesh including irises (great for "looking away"), blinks, the chest-breathing trace and 8 expression scores at ~25 readings/s — and pulse only twice in 77 seconds.

Signal	SDK source	What counts as hesitation	Weight
Long pause	app timing	Much slower than your pace on this deck (long questions get a reading allowance)	55
Looking away	`face.landmarks` → head + eye direction	Away from your usual direction > ~1 s	30
Breath hold	`breathing.upperTrace`	Nearly flat for 2–4 s	20
Blinking	`face.blinking`	A burst, or none when some were expected	15
Expression	`face.expression`	Moving away from your resting face	15
Pulse	`cardio.pulseRate`	Not used per card — too slow for a 3-second recall	0

The weighted sum is a 0–100 score (threshold 50, adjustable); the two biggest contributors become the plain-language reasons. When the signal is poor — face lost, too dark, camera stopped — the card is marked "no reading" and scheduled normally. SDK validation codes become plain hints on the camera check ("More light on your face, please").

Does it work? Honest results

Check mode asks "Was that a guess?" after each right answer and hides its own verdict. In a first test of 16 right answers of my own study, Second Guess caught all 5 of my guesses — but it also flagged 8 of the 11 answers I actually knew, so it agreed with me about half the time. That's cautious on purpose (a false alarm costs one extra review; a missed guess costs you in the exam), but it isn't good enough yet. The data already told me what to fix: see Challenges.

Challenges

The warm-up was too easy. "2 + 2" takes a second; real cards take longer even when you know them, so every answer looked like a long pause. Recall time is now compared with your own pace on the real deck.
Looking away pointed the wrong way for me — I glance at the keyboard when I'm sure. Check mode caught it; it's the next signal to re-tune.
Pulse was too sparse per card, so it got weight 0 instead of pretending.
The SDK needs the internet while running. A network drop stops the camera, so the app explains exactly why and offers "Turn camera back on".

How I built it

Electron + TypeScript + Vite, @smartspectra/node-sdk 3.5 in the main process (the API key never reaches the window).
All scoring, scheduling, baseline and import logic is pure TypeScript in src/core with 104 Vitest tests.
Local JSON storage; the API key is encrypted with Windows DPAPI via Electron safeStorage.
Hand-written SVG for the progress chart and signal replay; electron-builder for the Windows installer.

What's next

Re-tune with more Check-mode data and learn each user's weights from their own Y/N answers.
A longer, varied warm-up so the baseline matches real cards from the first card.
Anki export so "hesitated" verdicts can feed existing decks.

Prize Categories

Best Thoughtful Real-World Use — it fixes a real flaw in spaced repetition, with consent first, no recording, "no reading" instead of guessing, and an honest measurement of its own accuracy.
Most Creative or Delightful Use — physiological signals used not for health, but to catch a lucky guess.

Consent and Data Handling

The camera starts only after a consent screen that explains what's measured, kept and sent. A Camera on indicator and Stop camera button are always visible.
No video, frames or images are stored or sent by Second Guess. The app never subscribes to the SDK's video output. Per card it keeps only the hesitation score, the reason labels and the recall time, in local JSON files.
The SmartSpectra SDK processes the camera on the computer. It connects to Presage's servers to verify the API key and download its models — those requests are linked to the key, so I don't call it anonymous. SDK telemetry is off (enableTelemetry: false); per Presage's Telemetry & Privacy page, telemetry never includes frames or measured values anyway.
Settings → Delete all data removes history, schedule, imported decks, settings, the saved key and logs.
It measures study hesitation — never stress, emotion or health. No AI services are used by the app.
No camera or key? It works as plain flashcards, with a clear notice.

Agent Session

I built Second Guess solo with Claude Code, from a written PRD and a CLAUDE.md of rules (plan first, one feature at a time, pure tested core, no video stored, no health words). The riskiest part went first: an SDK spike on my own laptop that logged every field the SDK sends.

Two real prompts from the session:

"read CLAUDE.md and this file. Explain your plan in plain language and wait for approval. Build in the order of §7. The riskiest part (M1: what the SDK really gives us) comes first. Test after each feature, commit, then move on."

"build everything that needs to built today"

Claude Code wrote the code and tests; I tested every feature on my own laptop and webcam, reported bugs from real use (a camera that stopped, a misleading banner, false alarms), and the fixes came from that real data.

Planning a real trip with three Claude Code agents in Telegram, via Switch

softalpha — Sat, 07 Nov 2026 16:44:18 +0000

How three friends and three AI agents picked a destination, a hotel and a day-by-day plan in one hour, without the AI deciding anything.

The problem: group trips die in the group chat
You know how it goes. Someone says "we should travel in December!" Two hundred messages later there are links nobody opened, three different date ranges, and no decision. If the trip does happen, one person pays the deposit and spends the next month chasing everyone for their share.

Asking a chatbot doesn't fix it. ChatGPT isn't in the group chat. It doesn't know who agreed to what, it can't run a vote, and it can't keep a plan that everyone sees.

So for the Flip the Switch hackathon I built TripRoom: three AI agents that live inside our Telegram group and help us plan, while my friends and I keep every decision.

Golden rule: agents propose, people vote, the trip lead confirms. Nothing is final until someone types "confirm".

The idea: one room, three agents, one job each
Switch turns a chat (Telegram, Slack, Mattermost, Discord or Teams) into a room where people and AI agents work together. I gave each agent one job:

Agent Job Owns
scout Researches destinations, stays, transport and food on the web, with sources Research posts
planner Asks the kickoff questions, runs the votes, writes the itinerary Trip brief, Itinerary, Decisions log
treasurer Tracks costs and works out who owes whom Budget and split
All three are Claude Code agents running on my laptop. Each one has its own folder with a short CLAUDE.md saying what it does and what it must never do. The big one: never book, pay, or ask anyone for money.

What actually happened (the real run)
On Saturday 7 November my friends Mufasa and Alina and I planned a real weekend away.

11:43 I typed @planner start a trip. The planner asked six questions in one message: dates, who's coming and from where, budget, style, must-haves and no-gos, and who the trip lead is.

11:49 Mufasa answered. The planner created a shared Trip brief document. When I answered a minute later, it updated it to v2: 4–6 December, from Lagos, $1,500 each, beach and culture, good food, no flights over two hours.

11:51 The planner asked the scout for options by itself. The scout ran a dozen web searches and posted three:

A: Accra, Ghana. About a 1h flight
B: Grand-Bassam, via Abidjan. About a 1h45–2h flight
C: Ouidah, via Cotonou. About a 45 min flight
Every option had a price range and source links. Where it couldn't find something, like a museum entry fee or Sunday flight times, it wrote "Not stated" instead of making it up. That rule, from the room instructions, did more for trust than anything else.

11:54 We both voted B. The planner posted "B wins 2–0", warned me that the flight is right at my 2-hour limit, and waited. I typed confirm, and it went into the Decisions log as decision 1.

12:05 Alina joined late. The planner didn't count her vote until she said she was coming. Then it added her to the brief (v3). We picked the Koral Beach Hotel 3–0.

Then Mufasa asked for a change: swap the museum for a lagoon boat trip. The planner changed only that day, bumped the Itinerary to v5, and waited for my confirm.

Mufasa paid a $200 hotel deposit and told the treasurer. I asked for balances:

Benjamin → Mufasa 67 · Alina → Mufasa 67. Sum: 134 − 67 − 67 = 0

Result: in about an hour we had three decisions made by vote, four shared documents, a three-day itinerary and a settled deposit. Nobody had to be "the spreadsheet person".

How I set it up (first-time Switch user, on Windows)
Here's everything I did, including the parts that went wrong.

Install the basics. You need Docker Desktop, Claude Code (irm https://claude.ai/install.ps1 | iex in PowerShell, then add %USERPROFILE%.local\bin to PATH) and Switch Console from the Switch releases page. In Switch Console, choose Get started → On this computer. It starts its own server and Mattermost in Docker, which takes about 5–10 minutes the first time.
My Claude account hit its weekly limit. Switch said "Claude Code is signed in but could not answer a test prompt (weekly limit)". The fix was an API key from the Claude Console:

claude auth logout
Gotcha: the key only exists in new terminal windows. My test kept saying "Not logged in" until I closed every terminal (or loaded the key with $env:ANTHROPIC_API_KEY = Environment::GetEnvironmentVariable("ANTHROPIC_API_KEY","User")), then restarted Switch Console.

Make a Telegram bot. In @botfather: /newbot, save the token, then /mybots → Bot Settings → Group Privacy → Turn off before adding the bot to any group. In Switch Console go to Home → Messaging apps → Connect → Telegram. Then create a group, add the bot, and send "hello". The group becomes a Switch room on its own.
Linking my Telegram account. Switch searches for your Telegram username, not your display name, and the search fails if you include the @. I typed softalpha, not @SoftalphaX, and it found me.
Create the agents. In Your Agents → +, I made three, named planner.softalpha0, scout.softalpha0 and treasurer.softalpha0. I pasted each one's CLAUDE.md into Agent instructions, set Who can talk to your agent to Anyone so my friends could talk to them, and left Bypass permissions off.

The Directory setting is hidden under Settings, and the folder picker opens in Documents. I pasted the full path, C:\Users\…\triproom\agents\planner, into the Folder box.

Room rules. I pasted the instructions under Your Rooms → weekend_trip → Configuration. Then, in Telegram:

!invite-agent @planner.softalpha0 (and scout, treasurer)
!set-alias @planner.softalpha0 @planner
!assign-agent @planner un-tagged messages go to the planner
!follow-ups off one agent answers per thread
@planner define a shared role called scout, an exclusive role called planner, …
@scout take the scout role (and the other two)
!roles
🚧 Roles vs aliases: I gave the roles the same names as the aliases, so @planner addresses the role. Until each agent took its role, Switch warned "no agent currently holds the planner role". Ask each agent to take its role straight after you create the roles.

Capture it as a template. Under Configuration → Capture as template, Switch turns the room (instructions, roles and agents) into YAML. I cleaned it up for reuse and committed it. Anyone can now import it and get the same room.

What I learned
One job per agent beats one smart agent. The planner asked the scout and the treasurer for help on its own, but none of them stepped on each other's toes.
Shared documents are the killer feature. The Trip brief, Itinerary, Decisions log and Budget live in the room, so every agent reads the same facts and every friend sees the same plan.
"Not stated" builds trust. An agent that admits what it doesn't know is one you can let near your money.
Humans stay in charge. The agents never decided anything. They made deciding easy.
Try it
Everything is in the repo: the agents, the room instructions, the template, the setup guide with Windows fixes, and the real transcript.

Repo:github.com/softalpha0/TripRoom
Demo: https://youtu.be/HfV6ZZXyhB4

Clone it, invite your friends, and type @planner start a trip.

Built for Flip the Switch (WeMakeDevs × DevTools Academy). #HowISwitch****