DEV Community: BigBang001

Strikethrough

BigBang001 — Mon, 05 Oct 2026 06:59:14 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built Strikethrough for a friend while we were planning a group trip through WhatsApp.

As the chat grew, plans kept changing, the times, places, bookings etc, while all the old messages stayed there. At some point, figuring out the latest plan meant scrolling through a wall of messages and asking:

“Wait, what did we finally decide?”

That was the problem I wanted to solve.

Strikethrough treats a group chat like a document with revision history.

Paste the conversation and it identifies information that was later changed, cancelled, corrected, or replaced. Those messages are crossed out, while the information that survived becomes the Current Reality.

Every current fact links back to the message that established it, so you can check the source instead of trusting a generated summary.

The idea is simple:

Group chats have version history, but no version control.

Demo

Live: https://strikethrough.onrender.com

The app opens with a sample conversation ready to resolve.

Press Resolve to watch outdated messages get crossed out and the latest confirmed information collected into Current Reality.

You can also paste your own conversation.

Code

GitHub: https://github.com/BigBang001/Strikethrough

The project is intentionally small: a single-page frontend and a lightweight Node.js server.

How I Built It

The core reasoning is handled by Gemma.

I didn't use the model to generate another chat summary. I gave it a more specific job: understand how facts change across a conversation.

For each message, Gemma determines whether it is:

live — still current
superseded — later information replaced it
noise — not part of the changing state

For superseded messages, it identifies the later message that replaced them. It also extracts the current facts and the source message for each one.

For example:

“Dinner is at 8.”

followed later by:

“Actually, make it 9.”

The interesting task is not to repeat both messages. It is to understand that 8 PM is now obsolete and 9 PM is the current value.

The server validates Gemma's structured output before rendering it, including checking source-message references and handling malformed responses.

The interface makes that reasoning visible. Instead of hiding the result in a paragraph, outdated messages are crossed out with a red proofreader-style mark, and the surviving information becomes the current state.

The implementation is deliberately lightweight: plain HTML, CSS and JavaScript with a small zero-dependency Node.js server. There is no database, authentication, or unnecessary backend infrastructure.

The built-in example also uses a cached result, so the main product experience remains available even without a model request. Custom conversations are resolved through Gemma.

Why Does Open Innovation Matter?

Group chats can contain private plans, addresses, schedules, family information, and other personal details.

An open-weight model gives this kind of tool an important option: it can be self-hosted and controlled, rather than requiring personal conversations to always be processed by a proprietary model.

The reasoning model can also be swapped, adapted, or fine-tuned without redesigning the product around one closed provider.

For this submission, the deployed version uses a hosted Gemma endpoint through Google AI Studio. I am being explicit about that rather than calling the deployment local.

What matters is that Gemma is doing the core reasoning: deciding which information in a conversation survived later changes and which became obsolete.

Prize Categories

Gemma — Gemma powers the core conversation reasoning and supersession detection.

Render — Render hosts the public web application and its backend endpoint.

Building an AI Agent for Hands-Free Software Control Using Python and OpenCV

BigBang001 — Tue, 25 Mar 2025 04:23:51 +0000

Introduction

Imagine controlling your desktop, apps, and tasks without touching a keyboard or mouse—just using your voice and hand gestures. With advancements in computer vision, NLP, and AI automation, this is now possible!

In this blog, we’ll build an AI-powered agent that allows users to open apps, switch windows, and control tasks hands-free using Python, OpenCV, and TensorFlow.

How It Works

Hand Gesture Recognition: Detect gestures using OpenCV & MediaPipe.
Voice Commands: Use NLP to interpret user speech.
Automate Tasks: Open apps, close windows, switch tabs using automation scripts.

Step 1: Install Dependencies

pip install opencv-python mediapipe pyttsx3 speechrecognition pyautogui

Step 2: Implement Hand Gesture Control

We’ll use MediaPipe for real-time hand tracking and map gestures to actions.

import cv2
import mediapipe as mp
import pyautogui

mp_hands = mp.solutions.hands
hands = mp_hands.Hands()
mp_draw = mp.solutions.drawing_utils

cap = cv2.VideoCapture(0)

while cap.isOpened():
    success, frame = cap.read()
    if not success:
        break

    # Convert frame to RGB
    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    results = hands.process(frame_rgb)

    if results.multi_hand_landmarks:
        for hand_landmarks in results.multi_hand_landmarks:
            mp_draw.draw_landmarks(frame, hand_landmarks, mp_hands.HAND_CONNECTIONS)

            # Detect open hand (command to open browser)
            thumb_tip = hand_landmarks.landmark[4].y
            index_tip = hand_landmarks.landmark[8].y

            if index_tip < thumb_tip:
                pyautogui.hotkey('ctrl', 't')  # Open new tab in browser

    cv2.imshow("Hand Gesture Control", frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

This detects hand gestures and opens a new tab when an open-hand gesture is detected.

Step 3: Add Voice Command Recognition

Now, let’s integrate speech commands to open apps and control the system.

import speech_recognition as sr
import pyttsx3
import os

recognizer = sr.Recognizer()
engine = pyttsx3.init()

def listen_and_execute():
    with sr.Microphone() as source:
        print("Listening...")
        audio = recognizer.listen(source)

        try:
            command = recognizer.recognize_google(audio).lower()
            print(f"Command: {command}")

            if "open notepad" in command:
                os.system("notepad")
            elif "open browser" in command:
                os.system("start chrome")
            elif "shutdown" in command:
                os.system("shutdown /s /t 1")

        except sr.UnknownValueError:
            print("Sorry, I didn't catch that.")
        except sr.RequestError:
            print("Error with speech recognition service.")

listen_and_execute()

This AI assistant listens for commands and executes system actions hands-free.

Future Enhancements

Train a custom ML model for gesture classification using TensorFlow.
Create an AI-powered voice assistant with GPT-3 for natural interactions.
Deploy as a cross-platform desktop app using Electron.js + Python.

Why This Matters?

Innovative AI Interaction – Hands-free control is the future of computing.

Improves Accessibility – Helps users with mobility challenges.

Real-World Applications – Can be used in smart homes, AR/VR, and robotics.

Conclusion

This AI-powered assistant combines Computer Vision + NLP + Automation to create a seamless, hands-free desktop experience. With further improvements, it could revolutionize human-computer interaction.

💡 Want to take it further? Try integrating it with LLMs for a conversational AI assistant!

🔮 Daytona + EchoBrain – AI Development Reimagined

BigBang001 — Sat, 28 Dec 2024 10:01:00 +0000

🚀 Introduction: EchoBrain Meets Daytona – A Game Changer in AI Development

AI project development is exhilarating, but let’s be honest—nothing derails momentum like wrestling with environment inconsistencies and endless dependency issues. This is where Daytona steps in and flips the script.

In this piece, I’ll break down how integrating Daytona into my workflow supercharged the development of EchoBrain – a voice-controlled AI desktop assistant that automates tasks, manages apps, and brings hands-free interaction to life.

🔹 Why you should care:

Uniform Dev Environments – Daytona eliminates the age-old “works on my machine” excuse.
Rapid Setup for New Contributors – Cloning and building becomes seamless.
Smooth Deployments – From local dev to production, Daytona streamlines the entire pipeline.

👉 If you’re a developer aiming to build AI-driven projects while keeping environments clean and efficient, this tutorial will unlock a new way to work.

💡 Why Daytona is the Secret Weapon for AI Projects

EchoBrain demanded agility. I needed an environment that matched the pace of AI innovation. Daytona provided:

🚀 Instant Spin-Ups – Daytona handles AI pipelines like a charm, spinning up ready-to-code environments in seconds.
🔧 Modularity at Its Best – No VM overheads; just clean, isolated environments that mimic production setups.
🤝 Collaboration Without Headaches – Contributors can onboard in minutes, ready to build and test AI models immediately.

🌐 Prerequisites:

Basic understanding of AI/ML project pipelines.
Docker and Git proficiency.
Familiarity with TensorFlow and Python environments.

⚙️ 1. EchoBrain + Daytona Setup – Lightning Fast Start

Step 1: Install Daytona (Your New Best Friend)

curl -sf -L https://download.daytona.io/daytona/install.sh | sudo bash

Or without sudo:

curl -sf -L https://download.daytona.io/daytona/install.sh | DAYTONA_PATH=/home/user/bin bash

🎯 Goal: Daytona should now run as dtn.

Step 2: Daytona Initialization

daytona server
daytona git-providers add

🔗 This links Daytona to your GitHub/GitLab for seamless repo integration.

💻 2. Building EchoBrain’s AI Environment with Daytona

Clone and set up the environment – one line, no friction:

daytona create https://github.com/BigBang001/EchoBrain-Daytona

🔹 Boom – A full-fledged dev environment materializes, with dependencies installed from requirements.txt or the Dockerfile.

Prefer manual control? Use:

daytona create --no-ide

👉 This spins up the environment without launching an IDE.

🔄 3. Running and Testing EchoBrain (AI in Action)

dtn serve
python run.py

🎯 Catch AI bugs early – Daytona’s logs help fine-tune EchoBrain’s response accuracy.

🚀 4. Showcasing EchoBrain Live – Daytona as the Demo Engine

Wrapping up development or prepping for a demo?

daytona server restart

🔹 Pro Tip – Use dtn serve during live pitches to demo EchoBrain’s real-time AI prowess.

🌟 5. EchoBrain as a Daytona Sample – Sharing Innovation

Ready to give back to the Daytona community? Let’s contribute EchoBrain as a sample project:

Step 1: Fork Daytona’s GitHub

Fork Daytona’s repository: Daytona GitHub.

Step 2: Add EchoBrain to Daytona’s `index.json`

nano index.json

🚧 Pro Tip – Don’t add it to the start or end. Pick a random spot in the middle to avoid conflicts.

{
   "name": "EchoBrain",
   "description": "AI-powered voice assistant for desktop automation using TensorFlow.",
   "giturl": "https://github.com/BigBang001/EchoBrain-Daytona"
}

Step 3: Commit with Signed Authorship

git checkout -b add-echobrain-sample
git add index.json
git commit -s -m "Add EchoBrain AI assistant as Daytona sample"
git push origin add-echobrain-sample

🔹 -s flag – Ensures commits are signed and authenticated.

Step 4: Pull Request Time

Head to Daytona’s GitHub and open a PR.

PR Description Example:

Added EchoBrain – an AI-powered voice assistant designed to automate desktop tasks using TensorFlow and Python. This project showcases Daytona’s potential in AI development pipelines by streamlining environment setup and scaling contributions.

🔮 Conclusion: Daytona Unlocks AI Potential

Integrating Daytona into EchoBrain’s pipeline transformed AI development into a fast, seamless process. From setting up dev environments to showcasing live demos, Daytona has become the cornerstone of scalable AI projects.

🔹 Next Steps:

Experiment with Daytona on your AI/ML projects.
Fork EchoBrain to kickstart your own assistant project.
PR your AI innovations to the Daytona community.

👉 The future of AI development is modular, scalable, and frictionless – thanks to Daytona.