DeepThink

Practice professional judgment before the stakes are real.

An open-source AI simulation platform for practicing professional judgment, decision-making, and intuition through realistic scenarios.

Live demo · Roadmap · Contributing · Security

Public Alpha: DeepThink is a functional prototype under active development. It is not production-ready and should not be used with sensitive or high-stakes data.

Product preview

Why DeepThink

Many professional decisions are learned only after a costly mistake: handling a client crisis, challenging a weak assumption, prioritizing under uncertainty, or communicating a difficult trade-off. Courses can teach frameworks, but they rarely provide repeated practice in realistic, ambiguous situations.

DeepThink explores a different learning loop: put the learner in a scenario, require a decision and rationale, use AI to produce structured feedback, and turn reflection into another deliberate practice opportunity.

Core product loop

1. Choose a professional field, scenario, and difficulty.
2. Respond to realistic multiple-choice decisions and explain the reasoning.
3. Receive structured AI feedback on strengths, weaknesses, pace, and possible cognitive biases.
4. Reflect through notes, reports, and suggested follow-up practice.
5. Build consistency through progression concepts such as streaks, badges, challenges, and skill paths.

The interface demonstrates this loop today, but persistence, identity, scoring integrity, and several progression features still rely on prototype data paths.

Feature maturity

Area	Maturity	What exists today
Landing and dashboard UI	Functional Prototype	Responsive React interface, theme support, navigation, dashboard views, and product previews
AI scenario generation and session analysis	Functional Prototype	Gemini-backed structured generation and analysis called from browser code; requires a development key
Scenario catalog and session flow	Functional Prototype	Interactive flows backed primarily by local fixtures
Notes, development tasks, reports, and progression views	Prototype	Usable UI concepts; data is in memory, dummy fixtures, or localStorage depending on the feature
Authentication and profiles	Prototype	Simulated login/JWT; profile upload contains partial Supabase client usage
Community challenges, leaderboard, badges, and leagues	Prototype	UI and sample data; not yet a trusted multi-user system
Supabase persistence and Row Level Security	Migration in Progress	Schema/policy draft and client/Edge Function scaffolding exist; app-wide migration is incomplete
Stripe subscriptions	Migration in Progress	Checkout/webhook Edge Function scaffolds exist; frontend uses placeholder configuration
Secure server-side Gemini gateway	Planned	AI calls must move out of the browser before production use
Production observability, automated evaluation, and release process	Planned	Not implemented

Technology stack

Layer	Technology
Web application	React 19, TypeScript, Vite 6
Routing	React Router 7 with hash routing
UI and motion	Tailwind-powered utility classes, Framer Motion, Lucide React, Recharts
AI prototype	Google Gemini through @google/genai
Target data platform	Supabase Auth, Postgres, Storage, and Edge Functions
Payment scaffold	Stripe from Supabase Edge Functions
Deployment	Static web deployment; current demo is hosted on Vercel

Architecture

Current alpha architecture

flowchart LR
    U[User] --> V[React + Vite browser app]
    V --> F[Dummy fixtures and in-memory state]
    V --> L[localStorage]
    V --> G[Gemini API]
    V -. partial / placeholder .-> S[Supabase client]
    V -. placeholder checkout .-> E[Supabase Edge Functions]
    E -. scaffold .-> P[Stripe]

Loading

The browser currently receives the Gemini key at build time and invokes Gemini directly. Authentication uses a dummy user and token, many views import fixtures from constants.ts, and Supabase is not yet the authoritative data source across the application.

Target secure architecture

flowchart LR
    U[User] --> W[React web client]
    W --> A[Supabase Auth]
    W --> D[Supabase Postgres + RLS]
    W --> T[Supabase Storage + policies]
    W --> E[Authenticated Edge Functions]
    E --> G[Gemini API]
    E --> P[Stripe API]
    P --> H[Verified Stripe webhook]
    H --> D
    E --> D

Loading

In the target design, the browser receives only public configuration such as a Supabase anon key and Stripe publishable key. Gemini keys, Stripe secret keys, webhook secrets, and Supabase service-role credentials remain in server-side secret stores. Authenticated functions validate input, authorize access, rate-limit expensive operations, and persist results through tested Row Level Security policies.

Warning

The current Gemini integration is not secret-safe. vite.config.ts injects GEMINI_API_KEY into browser code. Environment variables do not protect a secret once it is bundled into a client application. Assume deployed client-side keys can be extracted. Use only restricted, disposable development credentials and do not deploy this architecture for production workloads.

Target data model

The draft Supabase schema in supabase.md describes the intended relational model. It is a migration target, not proof that every screen is currently connected.

Entity	Purpose
users	Profile data linked to Supabase Auth users
scenarios	Maintained professional simulation templates
custom_scenarios	User-created and optionally published challenges
sessions	Completed attempts, answers, scores, and analysis reports
leaderboard	Points and streak state intended for trusted server-side updates
badges / user_badges	Achievement definitions and awards
tasks	Personal development board items
notes	Learner reflections and notes
feature_requests	Product feedback submitted by authenticated users
subscriptions	Subscription state synchronized from Stripe

erDiagram
    USERS ||--o{ SESSIONS : completes
    USERS ||--o{ CUSTOM_SCENARIOS : creates
    USERS ||--|| LEADERBOARD : has
    USERS ||--o{ TASKS : manages
    USERS ||--o{ NOTES : writes
    USERS ||--o{ USER_BADGES : earns
    BADGES ||--o{ USER_BADGES : awards
    SCENARIOS ||--o{ SESSIONS : provides
    CUSTOM_SCENARIOS ||--o{ SESSIONS : provides
    USERS ||--o| SUBSCRIPTIONS : owns

Loading

Getting started

Prerequisites

• Node.js 20
• npm 10 or the npm version bundled with Node.js 20
• A restricted Gemini development key if you want to exercise AI features

Run locally

git clone https://github.com/robotjaol/deepthink-gamma.git
cd deepthink-gamma
npm ci

Copy the environment template:

# macOS or Linux
cp .env.example .env.local

# Windows PowerShell
Copy-Item .env.example .env.local

Set GEMINI_API_KEY in .env.local only if you understand the client-side exposure warning above. The Supabase and Stripe entries document the migration target; current code still contains placeholders and is not fully wired to those variables.

Start the development server:

npm run dev

Vite serves the app at http://localhost:3000 by default.

Build the application

npm run build
npm run preview

There is not yet a repository-wide automated test or lint script. CI currently verifies a clean dependency install and production build on Node.js 20.

Repository structure

deepthink-gamma/
├── components/          Reusable UI, dashboard, scenario, and landing components
├── contexts/            Prototype auth, notification, scenario, and theme state
├── hooks/               Shared React hooks
├── lib/                 Supabase client scaffold and utilities
├── pages/               Public pages and dashboard routes
├── public/              Static screenshots and media
├── services/            Gemini generation and analysis client
├── supabase/functions/  Stripe-related Edge Function scaffolds
├── .github/             CI, Dependabot, and contribution templates
├── constants.ts         Prototype scenarios and other dummy fixtures
├── supabase.md          Draft database schema and RLS setup
└── todo.md              Prioritized Public Alpha implementation backlog

Security and responsible use

DeepThink generates feedback with an AI model. Model output can be incorrect, inconsistent, or biased and should not be treated as professional, medical, legal, financial, safety, hiring, or other high-stakes advice. Do not submit confidential employer information, personal data, credentials, or regulated data to the alpha.

Before any production launch, the project needs server-side AI access, real authentication, authorization tests, rate limiting, data lifecycle controls, abuse monitoring, dependency review, and a documented incident response process.

To report a vulnerability, follow SECURITY.md. Do not disclose exploitable details in a public issue.

Roadmap

Work is organized around:

1. Phase 0: Open Source Readiness
2. Phase 1: Supabase MVP Migration
3. Phase 2: Learning Intelligence
4. Phase 3: Community Platform
5. Phase 4: Platform Expansion

See ROADMAP.md for goals and current status.

Contributing

Contributions are welcome. Start with CONTRIBUTING.md, follow the Code of Conduct, and use an issue to discuss broad architectural changes before implementation.

License

DeepThink is available under the MIT License. Copyright © 2026 robotjaol.