AI App Idea Generator

The open-source AI tool that turns raw app ideas into build-ready product specs.

Created by Enterprise DNA -- a leading data and AI education company.

What is it? • Built with AI • Features • Tech Stack • Quick Start • Self-Hosting • Architecture • Dev with AI • Contributing • License

What is AI App Idea Generator?

AI App Idea Generator is an open-source web app that takes a rough idea -- a few sentences describing what you want to build -- and uses AI to produce a complete, build-ready product specification. It's the fastest way to go from "I have an idea" to "I have a plan I can actually hand to a developer (or AI coding agent)."

Think of it as an AI product manager in a box: describe the problem, pick your industry and function, and the app generates:

A clear project title and pitch
A full questionnaire walkthrough that sharpens the concept
A detailed outline document
Functional requirements
Tech stack recommendations
Frontend guidelines
Backend structure
File structure
Implementation plan and task breakdown

All generated content is saved to your own Supabase project, so you can revisit, edit, and export later.

Why another idea tool?

Most "startup idea generators" give you a sentence and walk away. AI App Idea Generator is different:

Full product specs, not hype -- You get a PRD, tech stack, file structure, and tasks. Not just a tagline.
Questionnaire-driven -- The app asks smart follow-up questions to tighten the scope before generating docs.
Industry- and function-aware -- Ideas are tailored to your vertical (Healthcare, Finance, Retail, etc.) and business function (Sales, Operations, HR, etc.)
17 specialized AI endpoints -- Each document type (outline, tech stack, tasks, etc.) has its own dedicated Supabase Edge Function with a tuned prompt.
Self-hostable -- Bring your own OpenAI API key, run it on your own Supabase project, own every generated artifact.
Built to be handed to AI coders -- The output format is designed so you can paste it straight into Claude Code, Cursor, or any other AI coding tool and start building.

Built with AI

This entire application was built using AI-assisted development tools. Enterprise DNA believes in the future of AI-augmented software development, and this project is a reference for what's possible. Every layer -- from the Supabase edge functions to the React UI -- was written collaboratively with AI coding agents.

AI Development Tools Used

Tool	Role
Claude Code by Anthropic	Primary development tool. Claude Code acted as the AI coding agent, building features end-to-end across the full stack -- from Supabase edge functions to React components to page layouts.
Cursor	AI-powered IDE used throughout development for code navigation, inline edits, and rapid iteration.
GitHub Copilot	AI pair programming assistant for code completion and pattern matching.

Enterprise DNA is committed to demonstrating that AI tools are not just productivity boosters -- they are a new way to build software. This project serves as a reference implementation for AI-assisted full-stack development.

Features

Idea Capture

Free-form app idea textarea on the landing page
Guided inspiration flow: pick industry + business function + describe your daily tasks, get tailored idea suggestions
Pre-made templates by industry (Healthcare, Education, Finance, Retail, Manufacturing, Technology, Real Estate, Transportation, Hospitality)
AI-generated project titles from free-form descriptions

Smart Questionnaire

Dynamic AI-generated questions that adapt to your idea
Follow-up question generation based on previous answers
Saves all responses to your Supabase project tied to each user

Document Generation

Seventeen specialized Supabase Edge Functions, one for each document type:

Function	What it produces
`generate-title`	A concise project title from a description
`generate-idea`	A sharpened idea pitch based on industry + function + daily tasks
`generate-questions`	Dynamic follow-up questions for the questionnaire
`generate-answer`	AI-drafted answers for review
`generate-app-ideas`	Multiple app idea suggestions for an industry + function pair
`generate-app-outline`	Full app outline from a template
`generate-app-flow`	User flows and interaction map
`generate-requirements`	Functional and non-functional requirements
`generate-tech-stack`	Recommended tech stack with reasoning
`generate-frontend-guidelines`	Frontend design and component guidelines
`generate-backend-structure`	Backend architecture and data model
`generate-file-structure`	Recommended project file/folder layout
`generate-implementation-plan`	Step-by-step build plan
`generate-tasks`	Individual developer tasks
`generate-document`	Combine generated sections into a polished doc
`analyze-submission`	Sanity-check user input before generation

Project Management

Save every generated project to the Projects page
Drill into any project to see its full document set
Access Details view with deep links to each generated section
Update and delete projects you own

Authentication

Email + password via Supabase Auth
Google OAuth support (optional -- configure in your Supabase dashboard)
Password reset flow with email confirmation
Protected routes for logged-in users
Profile page with account information

UI / UX

Enterprise DNA gradient brand colors throughout
Responsive design (mobile-friendly from day one)
Dark mode ready via next-themes
Rich form controls powered by shadcn/ui + Radix
Toast notifications via Sonner
Smooth transitions and micro-interactions via Tailwind animations

Tech Stack

Layer	Technology
Framework	Vite + React 18
Language	TypeScript 5
UI Library	shadcn/ui + Radix UI
Styling	Tailwind CSS 3
Icons	Lucide React
Database	Supabase (PostgreSQL + Row Level Security)
Auth	Supabase Auth (email/password + OAuth)
AI Runtime	Supabase Edge Functions (Deno)
AI Provider	OpenAI API (GPT-4o-mini by default)
State	Zustand + TanStack Query
Forms	React Hook Form + Zod
Routing	React Router DOM
Deployment	Netlify (frontend) + Supabase (backend)

Quick Start

Prerequisites

Node.js 18+ and npm (or bun)
A Supabase account (free tier works)
An OpenAI API key (pay-as-you-go)

Step 1: Clone and Install

git clone https://github.com/Enterprise-DNA-OS/ai-app-idea-generator.git
cd ai-app-idea-generator
npm install

Step 2: Create Your Supabase Project

Sign in at supabase.com and click New Project
Wait for the project to provision (~2 minutes)
From Settings → API, copy:
- Project URL → VITE_SUPABASE_URL
- anon / public key → VITE_SUPABASE_ANON_KEY

Step 3: Configure Environment Variables

cp .env.example .env

Edit .env with your Supabase credentials:

VITE_SUPABASE_URL=https://your-project-id.supabase.co
VITE_SUPABASE_ANON_KEY=your-supabase-anon-key

Step 4: Deploy Edge Functions

Install the Supabase CLI and link your project:

npm install -g supabase
npx supabase login
npx supabase link --project-ref your-project-id

Deploy all 17 generation functions:

npx supabase functions deploy

Step 5: Set Supabase Secrets

AI API keys live in Supabase secrets (not in .env). Set your OpenAI key:

npx supabase secrets set OPENAI_API_KEY=sk-your-openai-key

Step 6: Apply Database Schema

Create the tables the app uses. In your Supabase dashboard, open the SQL editor and create these tables (see Database Schema below), or run:

npx supabase db push

Step 7: Run Locally

npm run dev

Open http://localhost:8080 and sign up for an account. Describe your first app idea and watch the AI generate the full spec.

Self-Hosting

AI App Idea Generator can be deployed anywhere that hosts a static Vite build.

Netlify (recommended)

The repo already includes a netlify.toml. Push to a GitHub repo and connect it to Netlify. Set the environment variables in Netlify's dashboard under Site settings → Environment variables.

npm run build
netlify deploy --prod

Vercel

npm run build
vercel deploy --prod

Set VITE_SUPABASE_URL and VITE_SUPABASE_ANON_KEY in the Vercel project settings.

Static hosting

npm run build produces a dist/ folder you can host anywhere:

Cloudflare Pages
GitHub Pages
Any S3 + CloudFront setup

Production Deployment Checklist

Update environment variables in your hosting platform
Supabase Auth settings -- Add your production domain to the allowed redirect URLs
Google OAuth (if using) -- Add your production URL to the authorized redirect URIs in Google Cloud Console
Enable HTTPS -- required for Supabase Auth to work correctly
Monitor edge function logs in your Supabase dashboard

Architecture

Project Structure

src/
  App.tsx                  Root with providers and routing
  main.tsx                 Entry point
  components/
    auth/                  Auth form and modal
    home/                  Landing page sections (Hero, HowItWorks, Templates, etc.)
    ui/                    shadcn/ui primitives
    ProtectedRoute.tsx     Auth gate for private pages
    Navbar.tsx             Top navigation
    Footer.tsx             Footer
  contexts/
    UserContext.tsx        Current user + loading state from Supabase
  hooks/                   Custom React hooks
  integrations/
    supabase/              Supabase client + generated types
  pages/
    Index.tsx              Landing page
    Auth.tsx               Login page
    Register.tsx           Signup page
    Questionnaire.tsx      Guided questionnaire flow
    Projects.tsx           User project list
    ProjectDetails.tsx     Individual project view
    GenerateDocuments.tsx  Document generation page
    Profile.tsx            Account info
  lib/                     Utilities
  utils/                   Helper functions
  types/                   Shared TypeScript types
supabase/
  config.toml              Function configuration
  functions/
    _shared/               Shared OpenAI config + CORS helpers
    generate-*/            17 AI generation edge functions
    analyze-submission/    Input validation

AI Flow

User input
  → React form submission
    → Supabase Edge Function (Deno runtime)
      → OpenAI API (GPT-4o-mini)
    ← Structured response
  ← JSON rendered in the UI + saved to Supabase

All AI calls go through Supabase Edge Functions. Your OpenAI API key lives in Supabase secrets -- it never touches the browser.

Database Schema

The app uses a small set of Postgres tables in Supabase:

user_projects -- One row per generated project. Stores title, description, status, and ownership (user_id FK to auth.users)
questionnaire_responses -- Stores user answers to the guided questionnaire, tied to a project
generated_documents -- Stores AI-generated document sections (outlines, requirements, etc.) per project

Row Level Security (RLS) is enforced on every user-facing table so users only ever see their own data.

Developing with AI Tools

This project is designed to work well with AI development tools. Two files make this explicit:

CLAUDE.md -- Project-wide instructions, conventions, and architecture overview. Claude Code reads this automatically.
AGENTS.md -- Defines specialist agents with clear ownership boundaries.

Using Claude Code

Open the project folder in Claude Code. The agent will pick up CLAUDE.md and AGENTS.md automatically and follow the conventions.

Using Cursor

Open the project in Cursor. The CLAUDE.md file serves as context for Cursor's AI features. Use inline edit (Cmd+K) for quick changes and the chat panel for larger refactors.

Using GitHub Copilot

Copilot picks up patterns from the existing codebase (Supabase client usage, auth checks, Tailwind conventions). The consistent conventions in CLAUDE.md make Copilot suggestions more accurate.

Contributing with AI Tools

We encourage contributors to use AI tools. If you submit a PR:

Mention which AI tools you used -- we see it as a positive
Follow the conventions in CLAUDE.md
Use the specialist agent boundaries in AGENTS.md
Run npx tsc --noEmit and npm run build before submitting

Contributing

See CONTRIBUTING.md for detailed guidelines.

TL;DR:

Fork the repo
Create a feature branch (git checkout -b feature/amazing-feature)
Make your changes (AI tools welcome)
Run npx tsc --noEmit and npm run build to verify
Commit with a descriptive message
Push to your fork and open a PR

License

MIT -- use it however you want.

Acknowledgments

Built with Claude Code by Anthropic
Developed in Cursor -- the AI-powered IDE
AI pair programming by GitHub Copilot
AI generation powered by OpenAI
Database, auth, and edge functions by Supabase
UI components from shadcn/ui and Radix UI
Originally released as App Idea Engine by Omni Intelligence

Built with pride by Enterprise DNA
Powered by AI-assisted development with Claude Code, Cursor, and GitHub Copilot

Name		Name	Last commit message	Last commit date
public		public
src		src
supabase		supabase
.env.example		.env.example
.gitignore		.gitignore
AGENTS.md		AGENTS.md
CLAUDE.md		CLAUDE.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
SECURITY.md		SECURITY.md
components.json		components.json
eslint.config.js		eslint.config.js
index.html		index.html
netlify.toml		netlify.toml
package-lock.json		package-lock.json
package.json		package.json
postcss.config.js		postcss.config.js
tailwind.config.ts		tailwind.config.ts
tsconfig.app.json		tsconfig.app.json
tsconfig.json		tsconfig.json
tsconfig.node.json		tsconfig.node.json
vite.config.ts		vite.config.ts

Uh oh!

Latest commit

History

Folders and files

Repository files navigation

AI App Idea Generator

What is AI App Idea Generator?

Why another idea tool?

Built with AI

AI Development Tools Used

Features

Idea Capture

Smart Questionnaire

Document Generation

Project Management

Authentication

UI / UX

Tech Stack

Quick Start

Prerequisites

Step 1: Clone and Install

Step 2: Create Your Supabase Project

Step 3: Configure Environment Variables

Step 4: Deploy Edge Functions

Step 5: Set Supabase Secrets

Step 6: Apply Database Schema

Step 7: Run Locally

Self-Hosting

Netlify (recommended)

Vercel

Static hosting

Production Deployment Checklist

Architecture

Project Structure

AI Flow

Database Schema

Developing with AI Tools

Using Claude Code

Using Cursor

Using GitHub Copilot

Contributing with AI Tools

Contributing

License

Acknowledgments

About

Topics

Resources

Contributing

Security policy

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages