Project Info

debAIDe

Inspiration

We referenced how people enjoy playing on Chess.com, and the competitive element to it was applicable to many fields. In addition, it is often common to see people pointlessly arguing on social media, without proper moderation, and often unwarranted. It is clear that people need an avenue to argue, but it would also be good to be able to concurrently improve their argumentation and logical reasoning skills. Thus, we believe that a debating app, similar to Chess.com app, would be able to bring people of opposing views together, to come to possible resolutions. We aimed to create a mobile app so it would be accessible and usable for the average person.

What it does

Our debating app, debAIDe, pairs individuals of similar debating skill, and assigns each individual with a stand to defend. Individuals will then take turns proposing arguments and countering their opponent’s arguments, and an AI judge will determine a winner. The winner will have an increase in rating, and the loser will be given advice on how to improve their arguments.

How we built it

For our frontend, we used React Native (Expo) using Expo AV to record audio, Zustand for global state management, React Query to fetch and cache data, and TypeScript for type-safe development. For our backend, we used FastAPI, PostgreSQL, SQLAlchemy, Google Gemini AI (for scoring), Whisper for speech-to-text transcription, and Uvicorn for our server.

Challenges we ran into

The toughest challenge was actually coming up with a good idea. Our society is constantly filled with problems that we would love to solve, so we wanted to create something that would benefit society while also making sure to use AI meaningfully.

Accomplishments we're proud of

Creating a mobile app was a challenge for us, as we were not very experienced in app development, and had to learn a lot in our creation process. We are proud that we created a fully-functional mobile app that looks and works well.

What we learned

We learned how to send information to be processed by Gemini, and to curate our prompts to ensure proper output formats. We also learned how to create an app that stored data from different users, and that could coordinate between different users concurrently.

What's next

We are considering more interesting formats, such as 2v2, clan battles or even “battle royale”. We are also considering moving into educational mode, where the user can directly pick apart arguments with fallacies.

🎤 debAIDe

AI-powered debate practice platform with real-time feedback and 1v1 battle mode

debAIDe helps you master the art of debate through AI-powered coaching, instant feedback, and competitive battles with other debaters. Practice solo or challenge opponents in real-time debates.

✨ Features

🎯 Practice Mode

AI-Powered Topics - Choose from curated topics or get daily AI-generated suggestions
Voice Recording - Record your opening, rebuttal, and closing statements
Auto-Transcription - Automatic speech-to-text conversion
Instant AI Feedback - Get detailed scores on structure, logic, delivery, and time management
Personalized Coaching - Receive strengths, improvement areas, and targeted practice drills
Key Moments - AI identifies and highlights your best arguments with timestamps

⚔️ Battle Mode

1v1 Debates - Challenge other users in real-time debates
Matchmaking - Find opponents or join existing battle rooms
Turn-Based System - Take turns presenting arguments in structured debate rounds
AI Judging - Automated scoring and winner determination
Leaderboards - Track your win rate, streaks, and climb the rankings
Battle History - Review past debates and learn from your performances

🎨 User Experience

Dark/Light Mode - Beautiful theme switching throughout the app
Cross-Platform - iOS, Android, and Web support via Expo
Real-Time Updates - Live battle status and instant feedback
User Stats - Comprehensive statistics tracking your progress

🚀 Tech Stack

Frontend

React Native (Expo) - Cross-platform mobile framework
TypeScript - Type-safe development
React Query - Server state management
Zustand - Global state management
Expo AV - Audio recording and playback

Backend

FastAPI - High-performance Python API framework
PostgreSQL - Relational database
SQLAlchemy - Async ORM
Google Gemini AI - Scoring, feedback, and judging
Whisper - Speech-to-text transcription
Uvicorn - ASGI server

� Screenshots

Practice Mode - Topic Selection
Choose from diverse debate topics or try the AI-generated topic of the day.

Battle Mode - Live Debate
Compete against real opponents in structured, turn-based debates.

Results - AI Feedback
Get detailed scoring and personalized improvement suggestions.

Project Structure

debaide/
├── backend/
│   ├── main.py                  # FastAPI application
│   ├── models.py                # Database models (Users, Topics, Sessions, Battles)
│   ├── database.py              # PostgreSQL configuration
│   ├── schemas.py               # Pydantic request/response schemas
│   ├── services/
│   │   ├── gemini_service.py    # AI scoring, feedback & judging
│   │   ├── storage_service.py   # Audio file management
│   │   ├── stt_service.py       # Speech-to-text transcription
│   │   └── auth_service.py      # JWT authentication
│   ├── requirements.txt
│   └── .env.example
│
└── frontend/
    ├── app/
    │   ├── _layout.tsx          # Root navigation
    │   ├── index.tsx            # Auth redirect
    │   ├── home.tsx             # Main dashboard
    │   ├── topics.tsx           # Topic selection
    │   ├── session.tsx          # Practice recording
    │   ├── results.tsx          # Practice feedback
    │   ├── auth/                # Login & registration
    │   └── battle/              # Battle mode screens
    │       ├── lobby.tsx        # Matchmaking
    │       ├── room.tsx         # Live battle
    │       └── results.tsx      # Battle outcome
    ├── components/
    │   ├── NavBar.tsx           # Navigation component
    │   └── ThemeToggle.tsx      # Dark mode toggle
    ├── lib/
    │   ├── api.ts               # API client
    │   ├── theme.tsx            # Theme configuration
    │   ├── authStore.ts         # Auth state
    │   └── store.ts             # Global state
    ├── package.json
    └── .env.example

🛠️ Setup Instructions

Prerequisites

Python 3.11+
Node.js 18+
PostgreSQL 14+ (or use Neon DB, Supabase)
Gemini API Key (get from Google AI Studio)

Quick Start (Recommended)

Clone the repository:

git clone https://github.com/juliezyli/debaide.git
cd debaide

Set up backend:

cd backend
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
pip install -r requirements.txt
cp .env.example .env
# Edit .env with your DATABASE_URL and GEMINI_API_KEY
python main.py

Backend runs at http://localhost:8000 • API docs at /docs

Set up frontend (in a new terminal):

cd frontend
npm install
cp .env.example .env
# Edit .env if backend is not on localhost:8000
npx expo start

Then scan the QR code with Expo Go app or press w for web

Detailed Setup

Install Python 3.11+ and PostgreSQL 14+
Set up database:
- Option A: Local PostgreSQL
```
psql postgres
CREATE DATABASE debaide;
```
- Option B: Neon DB (recommended - free serverless)
- Option C: Supabase
Get Gemini API Key:
- Visit Google AI Studio
- Sign in and create a new API key (free tier available)

Configure .env:

DATABASE_URL=postgresql+asyncpg://user:password@localhost:5432/debaide
GEMINI_API_KEY=your_gemini_api_key_here
SECRET_KEY=your_secret_key_for_jwt
API_BASE_URL=http://localhost:8000

Run the server:

uvicorn main:app --host 0.0.0.0 --port 8000 --reload

Install Node.js 18+

Configure .env:

EXPO_PUBLIC_API_URL=http://localhost:8000

Run on different platforms:
```
npx expo start
```
- iOS: Press i (requires Xcode on macOS)
- Android: Press a (requires Android Studio)
- Web: Press w
- Mobile device: Scan QR with Expo Go app

🛠️ Setup Instructions

Prerequisites

Python 3.11+
Node.js 18+
PostgreSQL 14+ (or use Neon DB, Supabase)
Gemini API Key (Get it here) cd frontend

Install dependencies:
```
npm install
```

Configure environment:

cp .env.example .env
# Edit .env if your backend is not on localhost:8000

Start Expo:
```
npm start
```
Run on device:
- Scan QR code with Expo Go app (iOS/Android)
- Press i for iOS simulator
- Press a for Android emulator
- Press w for web

🎮 How to Use

Practice Mode

Sign up / Log in to your account
Choose a topic from the list or try the daily AI-generated topic
Get your stance - System assigns you PRO or CON position
Record your debate in three segments:
- Opening Statement (introduce your position)
- Rebuttal (counter opposing arguments)
- Closing Argument (summarize and conclude)
Review AI feedback - Get scores, strengths, improvements, and practice drills

Battle Mode

Enter the lobby and see available battles
Create a room or join an existing one
Wait for opponent to join
Take turns debating:
- Each player records their segments
- AI transcribes in real-time
- Follow turn-based structure
Get AI judgment - Winner determined by overall performance
Check leaderboard to see your ranking

📊 API Documentation

Authentication

POST /register - Create new account
POST /login - Get access token
GET /users/me - Get current user info

Practice Mode

GET /topics - List all topics
GET /topics/daily - Get/generate daily topic
POST /session/start - Start practice session
POST /segment/upload - Upload audio segment
POST /segment/text - Submit text segment
POST /session/score - Score completed session
GET /session/{id}/history - Get session details

Battle Mode

GET /battle/available - List open battles
POST /battle/create - Create new battle room
POST /battle/{id}/join - Join a battle
GET /battle/{id} - Get battle status
POST /battle/{id}/segment - Submit battle segment
POST /battle/{id}/complete - Finalize and judge battle

User Stats

GET /user/stats - Get comprehensive user statistics

Full API documentation available at http://localhost:8000/docs when running locally.

🤖 AI-Powered Features

Scoring System

Gemini AI evaluates your debate performance across four dimensions:

Structure (0-5 points) - Organization, clarity, and coherence
Logic (0-5 points) - Reasoning quality, evidence, and argumentation
Delivery (0-5 points) - Confidence, articulation, and engagement
Time Management (0-5 points) - Pacing, completeness, and efficiency

Total Score: 0-20 points

Feedback Includes:

📈 Detailed score breakdown
💪 Your key strengths
🎯 Areas for improvement
⭐ Highlighted best moments with timestamps
🏋️ Personalized practice drills

Battle Judging

In battle mode, AI judges compare both debaters' performance holistically:

Overall argument quality
Rebuttal effectiveness
Consistency and coherence
Delivery and confidence
Determines winner objectively

🚀 Deployment

Railway / Render / Fly.io:

Connect your GitHub repository

Set environment variables:

DATABASE_URL=<your_postgres_url>
GEMINI_API_KEY=<your_api_key>
SECRET_KEY=<random_secret>

Deploy automatically from main branch

Docker:

cd backend
docker build -t debaide-backend .
docker run -p 8000:8000 --env-file .env debaide-backend

Expo Application Services (EAS):

# Install EAS CLI
npm install -g eas-cli

# Login to Expo
eas login

# Configure project
eas build:configure

# Build for iOS/Android
eas build --platform ios
eas build --platform android

# Submit to stores
eas submit --platform ios
eas submit --platform android

Web Deployment:

npx expo export:web
# Deploy the web-build folder to Vercel, Netlify, or any static host

📊 Database Schema

Core Tables:

users - User accounts and authentication
topics - Debate topics with difficulty and category
sessions - Practice debate sessions
segments - Audio recordings and transcripts
scorecards - AI feedback and scoring
battles - 1v1 competitive debates
battle_segments - Battle round recordings
user_stats - Performance statistics and rankings

🛠️ Built With

FastAPI - Modern Python web framework
React Native - Cross-platform mobile development
Expo - React Native tooling
PostgreSQL - Relational database
Google Gemini - AI scoring and judging
Whisper - Speech recognition
Zustand - State management
React Query - Server state

Analysis

Compare with all teams

View

Metric

Julie
2

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

FastAPIIn code
PythonIn code
ReactIn code
TypeScriptIn code
PostgreSQLClaimed

4 of 5 appear in the indexed code. 1 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

No AI coding agent signals were found in this repository.

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

203 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.

debAIDe

Inspiration

What it does

How we built it

Challenges we ran into

Accomplishments we're proud of

What we learned

What's next

🎤 debAIDe

✨ Features

🎯 Practice Mode

⚔️ Battle Mode

🎨 User Experience

🚀 Tech Stack

� Screenshots

Project Structure

🛠️ Setup Instructions

Prerequisites

Quick Start (Recommended)

Detailed Setup

🛠️ Setup Instructions

Prerequisites

🎮 How to Use

Practice Mode

Battle Mode

📊 API Documentation

Authentication

Practice Mode

Battle Mode

User Stats

🤖 AI-Powered Features

Scoring System

Feedback Includes:

Battle Judging

🚀 Deployment

📊 Database Schema

🛠️ Built With

Technology

AI coding agents

Codebase size

Structure

Interface

Application logic

Languages

Dependencies