DEV Community: Ishan Khan

Socratic Duck

Ishan Khan — Sat, 31 Oct 2026 12:08:29 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

You know the rubber duck trick. You explain your bug out loud to a toy on your desk, and somewhere in the middle of the sentence you hear yourself and the problem just falls out. The duck never says a word. That's the whole trick.

AI tools quietly broke that. Now I paste the error, get a fix, and move on without learning why it broke. I did this for months before I noticed I was getting faster and not any better.

So I built the opposite. Socratic Duck reads your code or a screenshot of your error and asks you questions. Only questions. There's a four step hint ladder, and it starts at "what did you expect to happen?" and slowly gets pointier,It never reaches the fix.

Beg for the answer and the patience meter drops. The duck gets grumpier. When my guard catches a reply that was about to give the game away, a rubber stamp slams down on screen: DUCK ALMOST BLABBED. When you finally work it out yourself, you hit Solved it and get a little case file with the root cause in plain words and one flashcard.

Séance Mode is where the theme comes in. Flip the switch and the duck turns into the ghost of a dead language. COBOL, Fortran, Pascal, BASIC or ALGOL, your pick. The scene goes dark, the patience meter becomes a candle, the stamp becomes a wax seal. The spirit haunts your code and refuses to tell you what's wrong, same as the duck. Only the voice changes, the rules don't. Solve the bug and the case file turns into an ofrenda card, because a bug you actually understand gets laid to rest.

Demo

https://socratic-duck.vercel.app/

Code

pythonperfec / socratic-duck

Most AI tools write your code for you. Socratic Duck does the opposite: it reads your bug (text or screenshot), asks questions until you find the cause yourself, and a guard harness blocks any reply that leaks the fix.

🦆 Socratic Duck

A rubber duck debugging companion engineered to interrogate developers about their bugs using Socratic dialogue, strictly built to never give the fix.
Powered by Gemma 4 with an active two-stage guard harness that intercepts and neutralizes answer leaks before they reach the user.
Wrapped in a tactile bathroom aesthetic—floating soap-bubble chat, an animated tiled bathtub, dynamic patience meter, and a slamming rubber stamp.

🏛️ System Architecture

flowchart TD
    subgraph Client ["Frontend: web/ (Vite + React)"]
        UI["Bathroom Workspace (styles.css)"]
        Tub["Bathtub with Animated Water & SVG Duck (4 Moods)"]
        Chat["Soap-Bubble Dialogue Thread"]
        Meter["Yellow Water-Level Patience Gauge (0-100)"]
        Stamp["Rubber Stamp: DUCK ALMOST BLABBED"]
        Case["Case File Post-Mortem & PDF Print Modal"]
    end
    subgraph Server ["Backend: server/ (Node.js Express ESM)"]
        API["POST /api/chat & POST /api/report"]
        subgraph ExecutionFlow ["Response Generation & Guard Flow"]
            ModelGen["1. Model Inference (generateFn)<br/>Google AI Studio Gemma 4"]
            Rule["2. Stage 1: Rule-Based Heuristic Regex<br/>Code fences, spans >20ch, forbidden phrases"]
            Judge["3.

…

View on GitHub

How It Works

Every reply goes through the same path: the model writes it, a rule check looks at it, a second model call judges it, and if either one says it leaks, the reply gets thrown away and regenerated. Two retries, then the duck falls back to a canned line asking something safe.
The rule check is dumb on purpose. It catches code fences, phrases like "change this to that", "the fix is", things like that. The judge is another Gemma call that reads the reply and answers one question: did this reveal the fix?
I needed both after something I only found by playing with it. The duck was in its squint mood, and it gave the answer away. No code, nothing the rule check could catch. It just explained the problem in a friendly sentence. Prose leaks are the hard ones, and that's the reason the judge exists.
The benchmark taught me a lesson too. My first version reported 0% leaks with the guard off and 0% with it on. It looked great and it meant nothing, because I was grading replies with the guard's own detector. Of course it agreed with itself. I rebuilt it with a separate grader that gets the real fix for each bug, and three modes: a plain coding assistant, the duck prompt alone, and the duck with the guard. In the quick run the plain assistant leaked on 15 out of 15. The duck prompt alone and the full guard both held at 0 out of 15.

Why Does Open Innovation Matter?

Two backends. gemma-4-26b-a4b-it through Google AI Studio, and a small gemma:2b through Ollama for running offline. I want to be straight about this: the 26B one is a hosted call. The weights are open, but I'm not running them. The offline path is the small model, and it is noticeably weaker.

The guard doesn't care which model sits underneath it. Change one line in the env file and the same checks run on a different model. The Socratic rules and hint ladder live in a plain prompt file and a SKILL.md, so anyone can fork the behavior and make a stricter duck or a gentler one.

And it costs nothing to run locally, which let me hammer the benchmark hundreds of times without thinking about a bill.

A hosted assistant is tuned to be as helpful as possible, and here, being helpful is the exact bug. Running my own model behind a guard I can read made it easier to see where it fails and fix that spot.

The Spirit of It

The ghost in the machine, to me, is the bug that's been sitting in your code the whole time. It already knows what's wrong. The duck is the ghost that knows too, and the only thing it will do is ask you the right question until you see it.

Prize Categories

Best Use of Gemma. Gemma 4 does all of the talking: it reads screenshots and code, asks the questions, judges its own replies for leaks, and writes the case file at the end

FreelanceForge AI: Turn Raw Client Chaos into Billable Deliverables

Ishan Khan — Wed, 14 Oct 2026 14:54:16 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

If you’ve ever freelanced or run a boutique consulting business, you know the drill: you finish a client call, look down at a notebook full of messy scribbles, and realize you now have two hours of unpaid admin work ahead of you.

You need to turn those disjointed bullets into a professional proposal, defend invoice hours so a client doesn’t question your bill, figure out how to push back on scope creep without sounding defensive, or draft a polite email chasing an overdue invoice.

Most freelancers** lose between 20% and 30%** of their billable hours to this kind of administrative friction.

I built FreelanceForge AI to solve that problem.

FreelanceForge is a local-first, open-weight AI workspace designed specifically for freelancers, solopreneurs, and independent creators. Instead of relying on rigid SaaS forms or closed, metered AI APIs, it runs privately on your own machine using open weights (Llama 3.1 8B via Ollama), maintains persistent client memory across projects using Backboard, and formats rough thoughts into client-ready documents on an authentic tactile paper canvas.

Demo

freelanceforge-ai.onrender.com
Proposal Draft:

Invoice Value Justifier:

**
Scope Guardian:**

Code

GitHub repository:

pythonperfec / freelanceforge-ai

A local-first, open-weight AI suite that helps freelancers draft winning proposals, defend billable hours, and remember client agreements. For submission to Hacktoberfest 2026 Week 2 Challenge: Side Hustle.

FreelanceForge AI

A local-first, open-weight AI workspace for freelancers to draft proposals, itemize invoices, establish scope boundaries, and manage client communications.

Submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

Overview

Administrative work like drafting proposals, detailing invoices, defining scope, and handling awkward client emails can take up a significant portion of a freelancer's working hours.

FreelanceForge AI is an open-source, local-first application built to handle these tasks directly on your machine. Instead of sending sensitive project notes to third-party proprietary services, it uses local open weights (Llama 3.1 8B via Ollama) and persistent memory via Backboard.io to generate structured, client-ready documents.

Key Tools

Proposal Draft: Converts unorganized meeting notes or audio memos into structured proposals with milestone schedules, deliverable breakdowns, and payment terms.
Invoice Value Justifier: Translates task lists, hours, or Git commits into business-outcome line items for client billing.
Scope Guardian: Analyzes new client requests…

View on GitHub

Who Would Pay For It?

Freelancers, independent developers, designers, copywriters, and agency owners billing $60 to $200/hour.
When you're billing hourly, spending three hours writing a proposal or arguing over an unitemized invoice directly costs you $180 to $600 of lost income. A dedicated freelance workspace that eliminates that overhead is an easy purchase at $19–$39/month as a hosted subscription, or $99 as a standalone offline desktop utility.

How I Built It

The project is built using :
Backend: Node.js (v22), Express.js
Agent Orchestration: Mastra Agent Harness with cascading provider routing
Open-Weight Models: **Meta Llama 3.1 8B (via local Ollama daemon) + Groq **Cloud fallback (llama-3.1-8b-instant)
Long-Term Memory & Rate RAG: Backboard.io (backboard-sdk)
Frontend: Semantic HTML5, Vanilla JavaScript, CSS custom property design system (Paper & Forge themes), Marked.js
Deployment: Render (Infrastructure as Code via render.yaml & render.yml)

How I built it

How it works

Freelancer Input
│
▼
Express.js API Server
│
▼
Backboard Memory Service
├── Fetches remembered client terms, past rates, and interaction history via Backboard.io Cloud Assistant
└── (Falls back to local persistent store if offline)
│
▼
Prompt Construction Engine
├── Merges specialized freelancer persona
├── Injects user's custom system prompt edits (Prompt Transparency)
└── Injects Backboard rate context for commercial continuity
│
▼
Mastra Multi-Tier Dispatcher
├── 1. Priority 1 (Local): Ollama daemon with Llama 3.1 8B (100% private, on-device)
├── 2. Priority 2 (Cloud): Groq open-weight hosted endpoint (fast fallback for cloud demo)
└── 3. Priority 3 (Offline): Deterministic Template Synthesizer (zero external dependency)
│
▼
Server-Sent Events (SSE) Stream
│
▼
Frontend Document Desk
├── Live typewriter token streaming directly onto tactile paper sheet
├── Telemetry strip updates (model, latency, memory status)
└── Auto-saves client rates and deliverables back to Backboard cloud

Why Does Open Innovation Matter?

Strict Client Confidentiality (NDA Protection)
Permanent $0 Marginal Cost:Running open weights locally costs exactly $0 per generation.
No Vendor Lock-In:

My First User

My first user was me,alongside testing the workflow on realistic scenarios encountered by freelance colleagues.

One recurring challenge was dealing with scope creep on sprint deliveries. A client would agree to a core web application, and then halfway through development send a message asking: "Can we also add Google OAuth, an export-to-CSV feature, and support for three extra payment gateways before launch?"

Normally, writing the response takes an hour of careful drafting to avoid sounding confrontational while still protecting your time.

I pasted those requirements into the Scope Guardian tool. Within three seconds, the model:

Outlined the agreed baseline vs. the new out-of-scope requests.
Itemized the deliverables with clear hourly estimations ($950 add-on).
Generated a polite, professional client reply script ready to copy-paste.

What I Learned

Building a raw text generation isnt enough these days,continuity is what creates value . Streaming and visual feedback changes user perception drastically as it is better than waiting 6 seconds on a blank screen which is curbed by (SSE),Server-Sent Events (SSE)

Experienced freelancers don't want a black-box AI dictating how they talk to their clients. Exposing the system prompt and letting users adjust instructions directly in the app makes the tool adapt to the freelancer's voice, rather than forcing them into a generic template.

Prize Categories

Best Use of Backboard — Persistent Client Assistant Automatically creates and syncs with a dedicated cloud assistant on Backboard.io.
RAG Context Injection is useful when returning client name is entered the app queries Backboard memory to inject previously agreed rates and agreements