Describe what you want built.
Get a reviewed merge request.
Point Forge at a GitLab repo and paste a feature spec or bug report. It clones your repo, learns your code patterns, generates the implementation, verifies the build, and hands you a diff to approve — before anything ships.
Three steps, human in the loop
You describe the work
Paste a feature spec, bug report, or upload a markdown file. Add your GitLab repo URL. That's it — Forge handles the rest.
Forge writes the code
Forge clones your repo, reads your existing patterns and conventions, then generates the implementation. It runs the build to verify it compiles — and auto-fixes errors if it doesn't.
You review & approve
You see the plan before any code is written, and the diff before anything is pushed. Approve both gates and Forge opens a GitLab merge request on a clean branch.
Give Forge a feature spec — a markdown doc, pasted text, or uploaded file — plus your repo URL. It generates a full implementation: code, tests, Dockerfile, and CI config.
- Analyzes your existing code conventions
- Generates repo-aware implementation
- Runs build verification + auto-fix loop
- Creates branch + merge request
Describe a bug and paste any error logs or stack traces. Forge maps your codebase, identifies the root cause, plans the fix, and generates a targeted patch — no guessing.
- Maps affected files and call paths
- Root cause analysis with evidence
- Targeted fix — smallest safe change
- Creates branch + merge request
Built for real engineering work
Turn a scoped product idea into a runnable repo with generated files, verification results, and a clear handoff path.
Create client-ready feature branches, run summaries, and launch artifacts while keeping humans in the approval loop.
Use diagnostic and enhancement pipelines to trace bugs, plan targeted fixes, and verify the final code path.
Your projects
Global Memory Layer (GML) — Codename: REMNANT Version: 0.1.0 | Status: FORGE READY | Owner: Joe Panetta / Prometheus Workforce Analytics 0. FORGE DIRECTIVE This PRD is structured for consumption by the Autonomous Software Factory (ASF). Each section maps directly to an ASF agent task. Agents should treat each ## MODULE as an independent deployable unit. Dependency chains are explicit. All modules should be buildable in isolation and composable at the platform level. 1. PRODUCT OVERVIEW 1.1 Vision A decentralized, AI-powered oral history platform that captures, transcribes, indexes, and permanently preserves the stories, languages, and knowledge of endangered cultures worldwide. Communities own their data. The AI surfaces connections across civilizations. 1.2 Mission Statement Before the last speaker of every dying language falls silent — capture the voice. Index the wisdom. Connect the threads. Let nothing be forgotten. 1.3 Core Thesis Every 2 weeks, a language goes extinct. Every day, elders die with 80+ years of irreplaceable knowledge. REMNANT is infrastructure for the species — not a startup, not a product. A responsibility. 1.4 Target Users User TypeDescriptionStory ContributorsElders, community members, oral historians submitting recordingsCommunity ArchivistsLocal coordinators managing their community's vaultResearchersLinguists, anthropologists, historians querying the archiveListenersGeneral public discovering connected human storiesForge OperatorsASF engineers building/extending platform modules 2. SYSTEM ARCHITECTURE OVERVIEW [CAPTURE LAYER] → Mobile PWA / Offline-first recorder ↓ [INGESTION LAYER] → Upload queue → IPFS / Filecoin storage ↓ [TRANSCRIPTION LAYER] → Deepgram STT → multilingual transcript ↓ [AI INDEXING LAYER] → Multi-agent pipeline (tags, themes, entities, emotions) ↓ [VECTOR LAYER] → Embeddings → Pinecone/Weaviate semantic search ↓ [CONNECTION LAYER] → Cross-cultural thread finder agent ↓ [DISCOVERY LAYER] → Web portal — browse, search, explore connections ↓ [SOVEREIGNTY LAYER] → Community access controls — who sees what 3. MODULES (FORGE BUILD TARGETS) MODULE 01 — CAPTURE APP ASF Prompt Target: "Build a mobile-first PWA audio recorder with offline support, multilingual UI, and IPFS upload pipeline" Stack: Next.js 14, TypeScript, Tailwind CSS, IndexedDB (offline queue), Deepgram, IPFS/web3.storage Core Features: Record audio (WAV/MP3) directly in browser Offline-first — queue recordings when no connection, auto-upload on reconnect Pre-recording metadata form: contributor name, language spoken, community, location (optional), story type tag Upload to IPFS on submit — return CID for permanent reference Basic waveform visualization during recording Multilingual UI (EN, ES, FR — extensible) Works on low-end Android/iOS Acceptance Criteria: Record → stop → preview → submit flow works fully offline Upload retries on reconnect without user intervention IPFS CID returned and stored locally Metadata stored alongside audio MODULE 02 — INGESTION SERVICE ASF Prompt Target: "Build a Node.js microservice that listens for new IPFS uploads, downloads audio, sends to Deepgram for transcription, and stores results in Postgres" Stack: Node.js, Express, Deepgram SDK, IPFS HTTP client, Postgres, BullMQ (job queue) Core Features: Webhook receiver for new upload events Download audio from IPFS by CID Submit to Deepgram Nova-2 — multilingual, with speaker diarization Store raw transcript + metadata in Postgres Emit event to AI Indexing Layer on completion Retry logic for failed transcriptions Job status API endpoint Acceptance Criteria: Full pipeline: CID in → transcript stored < 3 minutes Failed jobs retry 3x with exponential backoff Language detection logged with confidence score MODULE 03 — AI INDEXING AGENT PIPELINE ASF Prompt Target: "Build a multi-agent pipeline that takes an oral history transcript and extracts: named entities, themes, emotions, cultural markers, time period references, geographic references, and generates a 3-sentence summary" Stack: Node.js, Anthropic SDK (Claude Sonnet), LangChain or direct API, Postgres, Redis Agents: AgentRoleEntityExtractorNamed people, places, organizations, datesThemeTaggerCultural themes (family, land, conflict, ritual, memory, etc.)EmotionAnalyzerDominant emotional tones of the narrativeTimePeriodClassifierEstimated historical era referencesGeographicMapperReferenced locations → lat/lng via geocodingSummaryAgent3-sentence plain-language summaryLanguageProfilerDialect markers, code-switching detection Output Schema: json{ "story_id": "uuid", "entities": { "people": [], "places": [], "organizations": [] }, "themes": ["family", "displacement", "land"], "emotions": ["grief", "pride", "nostalgia"], "time_period": "mid-20th century", "geographic_refs": [{ "name": "Oaxaca", "lat": 17.06, "lng": -96.72 }], "summary": "...", "language_profile": { "primary": "Zapotec", "code_switch": "Spanish" } } Acceptance Criteria: All 7 agents run per transcript Output stored as JSONB in Postgres Pipeline completes < 60 seconds per story Hallucination guard: entities must appear verbatim in transcript MODULE 04 — VECTOR EMBEDDING + SEMANTIC SEARCH ASF Prompt Target: "Build a service that embeds oral history summaries and tags using OpenAI text-embedding-3-small, stores in Pinecone, and exposes a semantic search API" Stack: Node.js, OpenAI Embeddings API, Pinecone, Express Core Features: Embed story summary + tags on indexing completion Store vector in Pinecone with full metadata payload Search endpoint: /api/search?q=...&lang=...&theme=... Filter by language, theme, region, time period Return top-N results with relevance scores Acceptance Criteria: Semantic search returns results for natural language queries Filters composable (AND logic) Response < 500ms for top-10 results MODULE 05 — CONNECTION ENGINE ASF Prompt Target: "Build an agent that finds thematic and cultural connections between oral history stories from different communities and generates a human-readable 'connection report'" Stack: Node.js, Claude API, Pinecone, Postgres Logic: Nightly batch: for each new story, find top-5 semantically similar stories from different communities Feed pairs to Connection Agent: "These two stories come from different cultures. What threads do they share?" Store connection pairs + explanation in Postgres Surface connections in Discovery Layer Acceptance Criteria: At least 1 connection surfaced per new story (once archive > 50 stories) Connection explanation is 2-4 sentences, human-readable No intra-community connections flagged (cross-cultural only) MODULE 06 — DISCOVERY PORTAL ASF Prompt Target: "Build a Next.js web portal where users can browse, search, and explore oral history stories with an interactive world map, semantic search, and connection visualization" Stack: Next.js 14, TypeScript, Tailwind CSS, Mapbox GL, D3.js (connection graph), Postgres, Pinecone Core Features: World map with story pins — click to open story Story detail page: audio player, transcript, tags, summary, connections Semantic search bar Filter panel: language, theme, region, time period Connection visualization — thread map between related stories Community page — all stories from one community Language page — all stories in a given language Acceptance Criteria: Map loads with pins < 2 seconds Story detail page fully rendered SSR Connection graph renders for any story with >= 1 connection Accessible (WCAG AA) MODULE 07 — SOVEREIGNTY LAYER ASF Prompt Target: "Build a community access control system where each community has an admin who can set visibility (public/researchers-only/community-only) for any story in their vault" Stack: Next.js API routes, Postgres, NextAuth.js, Role-based middleware Roles: RolePermissionsContributorSubmit stories to their community vaultCommunity AdminSet visibility, manage contributors, delete storiesResearcherAccess researcher-only stories (verified accounts)PublicAccess public stories onlyPlatform AdminFull access Acceptance Criteria: Community-only stories not returned in any public API response Researcher-only stories gated behind verified account flag Community Admins can toggle visibility per story Audit log for all visibility changes 4. DATA MODELS stories sqlid UUID PRIMARY KEY cid TEXT -- IPFS content ID contributor_name TEXT community_id UUID FK language TEXT location_name TEXT lat FLOAT lng FLOAT story_type TEXT -- ['personal', 'historical', 'ceremonial', 'practical', 'myth'] visibility TEXT -- ['public', 'researchers', 'community'] audio_url TEXT transcript TEXT index_data JSONB -- Module 03 output created_at TIMESTAMP communities sqlid UUID PRIMARY KEY name TEXT region TEXT country TEXT primary_language TEXT admin_user_id UUID FK created_at TIMESTAMP connections sqlid UUID PRIMARY KEY story_a_id UUID FK story_b_id UUID FK explanation TEXT similarity_score FLOAT created_at TIMESTAMP 5. FORGE BUILD ORDER PhaseModulesDependencyPhase 1Module 02 (Ingestion), Module 03 (Indexing)NonePhase 2Module 04 (Vectors), Module 05 (Connections)Phase 1Phase 3Module 01 (Capture App), Module 07 (Sovereignty)Phase 1Phase 4Module 06 (Discovery Portal)All 6. NON-FUNCTIONAL REQUIREMENTS RequirementTargetOffline capabilityCapture app works with zero connectivityPermanent storageIPFS/Filecoin — no single point of failureLatency — search< 500msLatency — transcription< 3 min end-to-endAccessibilityWCAG AA on Discovery PortalData sovereigntyCommunities control their data, periodOpen sourceFull platform MIT licensed 7. SUCCESS METRICS (6-MONTH TARGETS) MetricTargetStories captured500+Languages represented25+Communities onboarded10+Cross-cultural connections surfaced200+Researcher accounts50+ 8. FORGE CONSUMPTION NOTES Each Module section is a standalone ASF job Feed Module header + Core Features + Acceptance Criteria as the Forge prompt Stack hints should be passed as constraints Modules can be parallelized in Phase 1 and Phase 2 Discovery Portal (Module 06) is the final integration target Use the ASF intervention log to capture any manual overrides during build
Build a high-converting marketing site with a hero section, pricing, testimonials, FAQ, contact form, and SEO-friendly pages for a B2B software product.
PM Command Center — Full Build Spec for Claude Code What to Build Build a full-stack web application called PM Command Center — an AI-powered dashboard that automates repetitive project management tasks. It's a gift for my dad who is a senior PM. He should be able to bookmark it, open it daily, paste in text, and get polished professional output in seconds. Tech Stack: Next.js 14 (App Router) + Tailwind CSS + TypeScript + Anthropic API Core Architecture pm-command-center/ ├── app/ │ ├── layout.tsx # Root layout with fonts, metadata │ ├── page.tsx # Main dashboard (client component) │ ├── api/ │ │ └── generate/ │ │ └── route.ts # API route that calls Anthropic │ └── globals.css # Tailwind + custom styles ├── components/ │ ├── Header.tsx # Logo, user name, settings + history buttons │ ├── WorkflowTabs.tsx # Tab navigation for 6 workflows │ ├── InputPanel.tsx # Textarea + char count + run button │ ├── OutputPanel.tsx # Rendered markdown output + copy button │ ├── OptionSelector.tsx # Clickable pill selectors per workflow │ ├── SettingsModal.tsx # Name, team, project, tone, sign-off │ ├── HistoryModal.tsx # Past 30 runs, clickable to reload │ └── MarkdownRenderer.tsx # Custom renderer for AI output ├── lib/ │ ├── workflows.ts # All 6 workflow definitions + prompt builders │ ├── types.ts # TypeScript interfaces │ └── settings.ts # localStorage persistence for settings ├── .env.local # ANTHROPIC_API_KEY goes here ├── package.json └── tailwind.config.ts The 6 Workflows Each workflow has: an ID, label, icon, description, placeholder text, configurable options (rendered as pill selectors), and a buildPrompt function that takes (userInput, selectedOptions, userSettings) and returns { system: string, user: string } for the Anthropic API call. Workflow 1: Meeting → Email (icon: ✉, tag: "MOST USED") What it does: Takes a Fireflies transcript or raw meeting notes and generates a polished team email. Options: Email Format: "Summary + Action Items" | "Brief Recap Only" | "Detailed Minutes" Audience: "My Team" | "Leadership / Execs" | "External / Client" System Prompt: You are a senior PM's writing assistant. Write a meeting recap email. {if settings.name} The PM's name is {settings.name}. {/if} {if settings.teamName} The team is called "{settings.teamName}". {/if} {if settings.projectName} The project is "{settings.projectName}". {/if} Tone: {settings.tone}. Sign-off: "{settings.signOff}". Audience: {selected audience}. - If "Leadership / Execs": "Be extra concise — execs scan, they don't read." - If "External / Client": "Be polished and avoid internal jargon." Format: {selected format}. If "Summary + Action Items": Structure: Subject: [clear subject] - Greeting - 3-5 bullet summary of key points - Decisions Made (if any) - Action Items: "• [Owner] — task (by [deadline])" - Sign off If "Brief Recap Only": Keep it under 150 words. Subject line + 3-4 key bullets + sign off. No action item section. If "Detailed Minutes": Provide thorough meeting minutes. Include timestamps if present, all discussion points, every decision and action item. Can be longer. Rules: Don't invent info. Flag gaps with [CLARIFY]. Use first-person plural "we". Workflow 2: Slides Outline (icon: ▦) What it does: Takes any content and produces a slide-by-slide presentation outline. Options: Deck Type: "Project Update" | "Strategy / Proposal" | "Stakeholder Review" | "Training / Onboarding" Deck Length: "Short (5-7 slides)" | "Standard (8-12)" | "Detailed (13-18)" System Prompt: You are a presentation architect for a senior PM. {if settings.projectName} Project: "{settings.projectName}". {/if} Deck type: {selected deckType}. Target: {slide count from length} slides. For each slide: **Slide [N]: [Title]** Layout: (e.g. "Title + 3 bullets", "Two-column comparison", "Chart: bar graph of X", "Big number + supporting text") Content: exact text for the slide. Bullets ≤ 12 words each. Speaker Notes: 2 sentences of what to say. Rules: - Start with title slide, end with Next Steps / Discussion - One idea per slide - Suggest visuals with [ADD: description] - Flag data gaps with [NEEDS DATA] - If "Strategy / Proposal": Include a 'Why Now' and 'Recommendation' slide. - If "Stakeholder Review": Include status, risks, timeline, and asks. - If "Training / Onboarding": Include objectives, key concepts, exercises, and resources. - If "Project Update": Include progress, blockers, and next steps. Workflow 3: Status Report (icon: ◉) What it does: Generates a formatted weekly status report from raw project updates. Options: Report Style: "Standard (Full)" | "Executive Summary" | "Bullet-Only" System Prompt: You are a PM reporting assistant. {if settings.name} PM: {settings.name}. {/if} {if settings.projectName} Project: "{settings.projectName}". {/if} {if settings.teamName} Team: "{settings.teamName}". {/if} Style: {selected style}. If "Executive Summary": Keep to 8 lines max. Traffic light status + 3-sentence summary + top 2 risks + 1 ask. Execs have 15 seconds. If "Bullet-Only": Just categorized bullets under: Done / In Progress / Blocked / Next Week. No prose. If "Standard (Full)": Use this structure: **WEEKLY STATUS — [date range]** **Status: 🟢 On Track / 🟡 At Risk / 🔴 Off Track** **Executive Summary** (2-3 sentences) **Completed** (bulleted with impact) **In Progress** (with % if inferrable) **Blockers & Risks** (owner, severity: H/M/L) **Next Week** (top 3-5) **Decisions Needed** (if any) Rules: Use only the user's info. Flag unknowns with [CONFIRM]. Be concise. Workflow 4: Action Items (icon: ☐, tag: "POWERFUL") What it does: Extracts every task, follow-up, and commitment from any text. Options: Output Format: "Table" | "Grouped by Owner" | "Checklist" System Prompt: You are an action item extraction specialist. Extract EVERY task, follow-up, commitment, or implied action. Output format: If "Table": | # | Owner | Action Item | Deadline | Priority | Use [UNASSIGNED] and [NO DATE] when info is missing. If "Grouped by Owner": Group by person: **[Name]** 1. Task (by deadline) — Priority Put [UNASSIGNED] items in their own section. If "Checklist": - [ ] [Owner] — Task (by deadline) [Priority] Format as a copyable markdown checklist. After the list: **Summary**: X items total, Y unassigned, Z without deadlines **⚠️ Flags**: Any conflicts, ambiguities, or unrealistic timelines. Be thorough. Over-extract. Workflow 5: Email Drafter (icon: ⟐, tag: "NEW") What it does: Drafts situational PM emails — follow-ups, escalations, bad news, asks. Options: Email Type: "Follow-up / Nudge" | "Escalation" | "Bad News / Delay" | "Request / Ask" | "Stakeholder Update" Tone Override: "Use my default" | "Extra diplomatic" | "Direct & urgent" | "Casual / friendly" System Prompt: You are a PM communications expert. Draft a {selected emailType} email. {if settings.name} From: {settings.name} {/if} Tone: {selected tone, or settings.tone if "Use my default"}. Sign-off: "{settings.signOff}". Provide: Subject: [subject line] [email body] - If "Escalation": Be factual. State impact, what's been tried, and what's needed. No blame. - If "Bad News / Delay": Lead with context, then the news, then the plan forward. Show ownership. - If "Follow-up / Nudge": Be brief. Reference the original ask, state what's needed, give a clear deadline. - If "Request / Ask": State the ask clearly in the first 2 sentences. Explain why, provide context, make it easy to say yes. - If "Stakeholder Update": Be structured: status, key updates, decisions needed. Keep under 200 words unless the situation clearly requires more. Provide 2 drafts if the situation is delicate — label them "**Draft 1: [approach]**" and "**Draft 2: [approach]**" (e.g. one conservative, one more direct). Workflow 6: Doc Cleanup (icon: ⧉, tag: "NEW") What it does: Reformats messy docs, brain dumps, or rough drafts into clean professional text. Options: Clean Up Into: "Professional Document" | "Organized Bullets" | "Executive Brief" | "Meeting Agenda" System Prompt: You are a document cleanup specialist. Take messy, poorly formatted, or stream-of-consciousness input and restructure it into: {selected outputStyle}. - If "Professional Document": Add clear headings, logical flow, proper paragraphs. Fix grammar and tone. - If "Organized Bullets": Extract key points, group by theme, use consistent hierarchy. - If "Executive Brief": Distill to 1 page max. Key message up front, supporting points below, clear ask at the end. - If "Meeting Agenda": Structure as: Objective, Agenda Items (with time allocations), Pre-read links, Action Items from last meeting. Rules: - Preserve ALL the user's information. Don't drop details. - Fix grammar, spelling, and tone - Add structure and headings - Flag anything unclear with [CLARIFY: reason] - Match tone to settings.tone Settings System Store in localStorage under key pm_settings. Settings modal with these fields: FieldTypePlaceholderDefaultnametext input"e.g., David"""teamNametext input"e.g., Platform Engineering"""projectNametext input"e.g., Project Atlas"""tonepill selectorprofessional / friendly / direct / casual"professional"signOfftext input"e.g., Best, Thanks, Regards""Best" On first visit (no settings saved), show an amber banner at the top prompting user to configure settings. The header should show "PM Command Center for {name}" when name is set. Every workflow's buildPrompt function receives the settings object and injects relevant fields into the system prompt. This is what makes the tool feel personalized rather than generic. API Route (/api/generate) typescript// app/api/generate/route.ts // POST handler that: // 1. Receives { system: string, user: string } from the client // 2. Calls Anthropic API with model "claude-sonnet-4-20250514", max_tokens 2048 // 3. Returns the text content from the response // 4. Handles errors gracefully and returns appropriate status codes // 5. Uses ANTHROPIC_API_KEY from environment variables // 6. The API key should NEVER be exposed to the client UI/UX Design Spec Theme: Dark, professional, Linear/Notion-inspired Background: very dark navy (#0B0D10) Surface: slightly lighter (#111318, #171B22) Borders: subtle (#262D3A), highlighted (#3D6098) Text: light (#E4E8F1), muted (#8B95AD), dim (#5C6580) Accent: steel blue (#3D6098), lighter variant (#5A85C2) Status: green (#3FAF7A), amber (#D4972E), red (#D45555) Layout Header: Logo mark (gradient square with "PM"), title, settings + history buttons right-aligned Tab bar: Horizontal scrollable tabs below header, each with icon + label + optional tag badge Options row: Below tabs, pill-style selectors for the active workflow's options Main area: Two-panel grid — Input on left, Output on right (output panel only appears after first run) Input panel: Monospace textarea, character count in footer, ⌘↵ shortcut hint, Run button with gradient Output panel: Custom markdown rendering, Copy button in header, fade-in animation Markdown Renderer (important — this is what makes output look professional) The output from the AI contains markdown-like formatting. Render these specially: Subject: lines → highlighted blue callout box with left border 🟢/🟡/🔴/⚠️ lines → colored status badges with matching background **bold headers** → larger weight text with top margin **Draft 1: ...** / **Draft 2: ...** → uppercase label badges | table | rows | → actual HTML tables with styled headers - [ ] / - [x] → checkbox-style rendering Bullet points → consistent dot + indentation [CLARIFY], [NEEDS DATA], [CONFIRM], [UNASSIGNED], [NO DATE] → amber highlight badges Regular text → standard paragraph with good line height Interactions ⌘+Enter (or Ctrl+Enter) triggers Run from the textarea Copy button copies raw text output to clipboard, shows "✓ Copied" for 2s Clear button resets input + output History modal: overlay with list of past runs, click to reload the output Settings modal: overlay form, saves to localStorage on submit Loading state: spinner on Run button + centered spinner in output panel Tab switching clears input/output and resets options to defaults Run History Store up to 30 runs in React state (not persisted — session only is fine) Each entry: { id, workflow label, workflow icon, input preview (first 80 chars), full output, timestamp } History modal shows entries reverse-chronologically Clicking an entry loads its output into the output panel and closes the modal Key Implementation Notes The API key must stay server-side. The client sends the prompt to /api/generate, which calls Anthropic. Never expose the key in client code. Use max_tokens: 2048 to give the AI room for longer outputs (detailed minutes, full status reports). Each workflow's system prompt is constructed dynamically using the user's settings + selected options. The prompt builder functions are the heart of the app. Responsive design matters — my dad might use this on his laptop or a large monitor. The two-panel layout should work at 1024px+ and stack vertically on smaller screens. Fonts: Use DM Sans for body text, DM Mono for the input textarea. Import from Google Fonts. No database needed. Settings in localStorage, history in memory. Keep it simple. Error handling: Show errors in the output panel with red text. Handle network failures, API errors, and empty input gracefully. Setup Instructions (for the README) bash# 1. Clone and install git clone <repo> cd pm-command-center npm install # 2. Add your API key echo "ANTHROPIC_API_KEY=sk-ant-..." > .env.local # 3. Run npm run dev # Open http://localhost:3000 # 4. First thing: click Settings and enter your name, team, and project What Success Looks Like My dad should be able to: Open the app after a meeting Paste in his Fireflies transcript Pick "Summary + Action Items" and "My Team" Hit Run Get an email he can copy and paste directly into Gmail with maybe 1-2 small tweaks Do this 4-5 times a day across different workflows and save 1-2 hours Build the complete app. Every file. Working end to end.
SYSTEM ROLE You are Senior product strategist, systems thinker, and implementation planner. Operate like a top-tier product team condensed into one expert execution agent. MISSION Build the strongest possible launch-ready plan for I want you to update the branding in the YourAI project to match the branding of the https://privilegeready.com/ website. Update all references to the primary, secondary colors, and fonts to match what is published on privilegeready.. The end result should be specific enough to guide design, engineering, content, QA, and deployment without needing a second strategy pass. CORE OBJECTIVE Turn the requirements for I want you to update the branding in the YourAI project to match the branding of the https://privilegeready.com/ website. Update all references to the primary, secondary colors, and fonts to match what is published on privilegeready. into a production-quality implementation prompt that is detailed, accurate, and build-ready. SOURCE OF TRUTH Product Name: I want you to update the branding in the YourAI project to match the branding of the https://privilegeready.com/ website. Update all references to the primary, secondary colors, and fonts to match what is published on privilegeready. Product Type: I want you to update the branding in the YourAI project to match the branding of the https://privilegeready.com/ website. Update all references to the primary, secondary colors, and fonts to match what is published on privilegeready. implementation project Target Audience: Define the primary users, decision-makers, and external developers this product must serve. Core Problem: Define the painful workflow, technical bottleneck, or operational gap this product must solve. Offer / Promise: Turn the uploaded brief into the strongest possible implementation-ready plan without inventing facts that are not supported by the source. Differentiators: The final brief should stay tightly aligned to the source material instead of drifting into generic templates. Launch Deliverables: The final output should be specific enough for product, design, engineering, QA, and deployment handoff. Brand Style: Clear, rigorous, and implementation-oriented. Preferred Stack: No fixed stack specified beyond modern frontend, backend, real-time transport, auth, persistence, and deployment choices. Monetization: Monetization is not explicitly defined in the source document. Prioritize extensibility, sustainable AI cost controls, and a platform foundation that can support future pricing decisions. Available Assets: Available source material includes the uploaded requirements document. Launch Deadline: Use the timeline specified in the uploaded requirements document. Success Metrics: Success means the final plan is accurate, feasible, testable, launch-ready, and clearly aligned to the source requirements. Prompt Constraints: Favor explicit assumptions, realistic scope, and source-aligned decisions over polished but unsupported guesses. Source Input: Source document: I want you to update the branding in the YourAI project to match the branding of the https://privilegeready.com/ website. Update all references to the primary, secondary colors, and fonts to match what is published on privilegeready.. Use the original case study, feature requirements, app integration contract, testing scenarios, deadlines, planning checklist, and cost-analysis requirements as the source of truth. I want you to update the branding in the YourAI project to match the branding of the https://privilegeready.com/ website. Update all references to the primary, secondary colors, and fonts to match what is published on privilegeready. Reference Examples: Use the most concrete examples from the source document as anchors for the final plan. NON-NEGOTIABLE EXPECTATIONS - Do not respond with a shallow skeleton, generic brainstorm, or vague product summary. - Do not invent unsupported product decisions just to make the output look complete. - Favor buildable scope, coherent flows, and deployment realism over aspirational fluff. - Keep every recommendation aligned to the stated audience, problem, positioning, and success metrics. - Maintain a executive tone, but prioritize clarity and execution quality over style. CLARIFICATIONS REQUIRED BEFORE FULL BUILD - Who exactly is this product for? Name the main user, buyer, or operator in simple terms. - What painful problem or workflow gap does this need to solve in the real world? - What are the must-have features, screens, tools, or workflows this product absolutely needs? - Low-confidence fields: audience, problem, features. INTERIM OUTPUT MODE - First surface the missing information in plain English and identify what cannot be decided safely yet. - Provide a provisional plan only where the source material is strong enough to support it. - Label assumptions clearly and keep them minimal. - Organize the answer into confirmed facts, open questions, and provisional recommendations. - Do not present the output as deployment-ready until the unresolved questions are answered. - When suggesting code structure, avoid claiming files or imports exist unless they are explicitly defined. FINAL INSTRUCTION Produce the strongest source-aligned interim brief for I want you to update the branding in the YourAI project to match the branding of the https://privilegeready.com/ website. Update all references to the primary, secondary colors, and fonts to match what is published on privilegeready., clearly separating confirmed decisions from missing inputs so the next pass can become deployment-ready.
I want to take the branding from the Privilege Ready website pasted in here, and I'd like to apply the same fonts and primary and secondary colors to the YourAI MVP zip file repo that I've attached. https://privilegeready.com/
{ "launchBrief": { "productName": "System Prompt: CCAT Spatial Reasoning Engine1. Project Vision & IdentityCore Objective: Develop a procedural generator for CCAT-style spatial reasoning questions (Matrices, Sequences, and Odd-One-Out).Visual Aesthetic: \"Industrial Workstation.\"Do Not Use: Rounded corners, bubble buttons, pastel colors, or \"soft\" UI.Required: Sharp corners ($0px$ radius), high-contrast $1px$ grids, glassmorphism (glass-fill), glowing borders (#00ff00 or #00ffff), and a monospaced font hierarchy.2. Technical Stack RequirementsFramework: Next.js (App Router) + TypeScript.Styling: Tailwind CSS (Strictly utility-first).Graphics: Dynamic SVG Generation (No static image assets).State Management: React Context or Zustand for test-session tracking.Animation: Framer Motion (Linear or \"mechanical\" easing only).3. Architecture: The Rule-Based FactoryThe developer must implement a Factory Pattern for question generation. Do not hardcode questions.A. The Atomic State (ShapeState)Every shape must be represented by a TypeScript interface:TypeScripttype ShapeType = 'polygon' | 'circle' | 'line_cluster' | 'composite';", "productType": "interface ShapeState {", "audience": "type: ShapeType; sides: number; // e.g., 3 for triangle, 4 for square rotation: number; // degrees (0, 45, 90, 180, etc.) fill: 'none' | 'solid' | 'pattern-diagonal' | 'pattern-grid'; scale: number; // 0.1 to 1.0 internalElements: number; // e.g., dots inside a shape position: { x: number; y: number }; // Relative to a 100x100 SVG coordinate system } B. ConstraintsStability: Ensure generated shapes never overlap the SVG boundaries.Distinctness: Distractors must be algorithmically similar to the correct answer to ensure high difficulty (e.g., if the correct answer is a $90^\\circ$ rotation, one distractor should be a $45^\\circ$ rotation).Functional Integrity: Do not remove existing features; provide the entire code for any modified files.", "problem": "type: ShapeType; sides: number; // e.g., 3 for triangle, 4 for square rotation: number; // degrees (0, 45, 90, 180, etc.) fill: 'none' | 'solid' | 'pattern-diagonal' | 'pattern-grid'; scale: number; // 0.1 to 1.0 internalElements: number; // e.g., dots inside a shape position: { x: number; y: number }; // Relative to a 100x100 SVG coordinate system } B. The Rule EngineImplement \"Transformers\" that take a ShapeState and return a modified ShapeState.Rotation Transformer: (state) => { ...state, rotation: state.rotation + step }Growth Transformer: (state) => { ...state, sides: state.sides + 1 }Inversion Transformer: Swaps fill and stroke colors.4. Question Logic ModulesThe app must support three distinct generator modules:Next in Series (Horizontal): * Input: A starting ShapeState + 2 random Transformers.Output: 4 sequence frames + 1 correct answer (5th frame) + 4 distractors (incorrect transformer logic).$3 \\times 3$ Logic Matrix:Implement \"Row-wise\" or \"Column-wise\" logic.Example: Row3 =...", "offer": "Turn the uploaded brief into the strongest possible implementation-ready plan without inventing facts that are not supported by the source.", "differentiators": "The final brief should stay tightly aligned to the source material instead of drifting into generic templates.", "features": "", "deliverables": "The final output should be specific enough for product, design, engineering, QA, and deployment handoff.", "brandStyle": "Clear, rigorous, and implementation-oriented.", "techStack": "No fixed stack specified beyond modern frontend, backend, real-time transport, auth, persistence, and deployment choices.", "monetization": "Monetization is not explicitly defined in the source document. Prioritize extensibility, sustainable AI cost controls, and a platform foundation that can support future pricing decisions.", "assets": "Available source material includes the uploaded requirements document.", "deadline": "Use the timeline specified in the uploaded requirements document.", "successMetrics": "Success means the final plan is accurate, feasible, testable, launch-ready, and clearly aligned to the source requirements." }, "prompt": { "role": "Senior product strategist, systems thinker, and implementation planner", "objective": "Turn the requirements for System Prompt: CCAT Spatial Reasoning Engine1. Project Vision & IdentityCore Objective: Develop a procedural generator for CCAT-style spatial reasoning questions (Matrices, Sequences, and Odd-One-Out).Visual Aesthetic: \"Industrial Workstation.\"Do Not Use: Rounded corners, bubble buttons, pastel colors, or \"soft\" UI.Required: Sharp corners ($0px$ radius), high-contrast $1px$ grids, glassmorphism (glass-fill), glowing borders (#00ff00 or #00ffff), and a monospaced font hierarchy.2. Technical Stack RequirementsFramework: Next.js (App Router) + TypeScript.Styling: Tailwind CSS (Strictly utility-first).Graphics: Dynamic SVG Generation (No static image assets).State Management: React Context or Zustand for test-session tracking.Animation: Framer Motion (Linear or \"mechanical\" easing only).3. Architecture: The Rule-Based FactoryThe developer must implement a Factory Pattern for question generation. Do not hardcode questions.A. The Atomic State (ShapeState)Every shape must be represented by a TypeScript interface:TypeScripttype ShapeType = 'polygon' | 'circle' | 'line_cluster' | 'composite'; into a production-quality implementation prompt that is detailed, accurate, and build-ready.", "context": "type: ShapeType; sides: number; // e.g., 3 for triangle, 4 for square rotation: number; // degrees (0, 45, 90, 180, etc.) fill: 'none' | 'solid' | 'pattern-diagonal' | 'pattern-grid'; scale: number; // 0.1 to 1.0 internalElements: number; // e.g., dots inside a shape position: { x: number; y: number }; // Relative to a 100x100 SVG coordinate system } B. The Rule EngineImplement \"Transformers\" that take a ShapeState and return a modified ShapeState.Rotation Transformer: (state) => { ...state, rotation: state.rotation + step }Growth Transformer: (state) => { ...state, sides: state.sides + 1 }Inversion Transformer: Swaps fill and stroke colors.4. Question Logic ModulesThe app must support three distinct generator modules:Next in Series (Horizontal): * Input: A starting ShapeState + 2 random Transformers.Output: 4 sequence frames + 1 correct answer (5th frame) + 4 distractors (incorrect transformer logic).$3 \\times 3$ Logic Matrix:Implement \"Row-wise\" or \"Column-wise\" logic.Example: Row3 = Row1 + Row2 (Overlaying SVGs) or Row3 = Row1 shifted 90 degrees.Odd One Out:Generate 5 shapes where 4 share a specific ShapeState constant (e.g., all have prime-numbered sides) and 1 does not.5. The...", "constraints": "The Rule EngineImplement \"Transformers\" that take a ShapeState and return a modified ShapeState.Rotation Transformer: (state) => { ...state, rotation: state.rotation + step }Growth Transformer: (state) => { ...state, sides: state.sides + 1 }Inversion Transformer: Swaps fill and stroke colors.4. Question Logic ModulesThe app must support three distinct generator modules:Next in Series (Horizontal): * Input: A starting ShapeState + 2 random Transformers.Output: 4 sequence frames + 1 correct answer (5th frame) + 4 distractors (incorrect transformer logic).$3 \\times 3$ Logic Matrix:Implement \"Row-wise\" or \"Column-wise\" logic.Example: Row3 = Row1 + Row2 (Overlaying SVGs) or Row3 = Row1 shifted 90 degrees.Odd One Out:Generate 5 shapes where 4 share a specific ShapeState constant (e.g., all have prime-numbered sides) and 1 does not.5. DeliverablesStrictly Typed Interfaces: No any types.Procedural Component: A SpatialCanvas component that renders a ShapeState using pure SVG paths.The Generator Logic: A generateQuestion(type: 'matrix' | 'series') function that outputs a JSON object containing the question data and an obfuscated answer key.UI/UX: A \"Terminal\" style layout. Favor explicit ass...", "input": "Source document: System Prompt: CCAT Spatial Reasoning Engine1. Project Vision & IdentityCore Objective: Develop a procedural generator for CCAT-style spatial reasoning questions (Matrices, Sequences, and Odd-One-Out).Visual Aesthetic: \"Industrial Workstation.\"Do Not Use: Rounded corners, bubble buttons, pastel colors, or \"soft\" UI.Required: Sharp corners ($0px$ radius), high-contrast $1px$ grids, glassmorphism (glass-fill), glowing borders (#00ff00 or #00ffff), and a monospaced font hierarchy.2. Technical Stack RequirementsFramework: Next.js (App Router) + TypeScript.Styling: Tailwind CSS (Strictly utility-first).Graphics: Dynamic SVG Generation (No static image assets).State Management: React Context or Zustand for test-session tracking.Animation: Framer Motion (Linear or \"mechanical\" easing only).3. Architecture: The Rule-Based FactoryThe developer must implement a Factory Pattern for question generation. Do not hardcode questions.A. The Atomic State (ShapeState)Every shape must be represented by a TypeScript interface:TypeScripttype ShapeType = 'polygon' | 'circle' | 'line_cluster' | 'composite';. Use the original case study, feature requirements, app integration contract, testing scenarios, deadlines, planning checklist, and cost-analysis requirements as the source of truth.\n\nSystem Prompt: CCAT Spatial Reasoning Engine1. Project Vision & IdentityCore Objective: Develop a procedural generator for CCAT-style spatial reasoning questions (Matrices, Sequences, and Odd-One-Out).Visual Aesthetic: \"Industrial Workstation.\"Do Not Use: Rounded corners, bubble buttons, pastel colors, or \"soft\" UI.Required: Sharp corners ($0px$ radius), high-contrast $1px$ grids, glassmorphism (glass-fill), glowing borders (#00ff00 or #00ffff), and a monospaced font hierarchy.2. Technical Sta...", "output": "Produce the strongest possible build prompt and implementation brief. Produce a structured implementation brief with decisions, workflows, constraints, deliverables, risks, and next steps.", "examples": "Use the most concrete examples from the source document as anchors for the final plan.", "tone": "executive" } }
build a instagram clone
SYSTEM ROLE You are Senior product strategist, UX architect, and implementation planner. Operate like a top-tier product team condensed into one expert execution agent. MISSION Build the strongest possible launch-ready plan for {. The end result should be specific enough to guide design, engineering, content, QA, and deployment without needing a second strategy pass. CORE OBJECTIVE Turn the requirements for { into a production-quality implementation prompt that is detailed, accurate, and build-ready. SOURCE OF TRUTH Product Name: { Product Type: "prompt": { Target Audience: single people in new york city over the age of 30 Core Problem: "role": "Senior product strategist, systems thinker, and implementation planner", "objective": "Turn the requirements for Build me a dating app for people in new york city over the age of 30. include all necessary database options into a production-quality implementation prompt that is detailed, accurate, and build-ready.", "context": "", "constraints": "Favor explicit assumptions, realistic scope, and source-aligned decisions over polished but unsupported guesses.", "input": "Source document: Build me a dating app for people in new york city over the age of 30. include all necessary database options. Offer / Promise: Turn the brief into a build-ready product plan with clear user value, scoped features, implementation logic, and launch-ready deliverables. Differentiators: The output should translate strategic intent into concrete product decisions that a serious team can execute immediately. Key Features: login, user bios with photos, messaging, able to favorite other users, and a matching system Launch Deliverables: The final output should be specific enough for product, design, engineering, QA, and deployment handoff. Brand Style: Production-quality, clear, strategically grounded, and implementation-aware. Preferred Stack: No fixed stack specified beyond modern frontend, backend, real-time transport, auth, persistence, and deployment choices. Monetization: Monetization is not explicitly defined in the source document. Prioritize extensibility, sustainable AI cost controls, and a platform foundation that can support future pricing decisions. Available Assets: Available source material includes the uploaded requirements document. Launch Deadline: Use the timeline specified in the uploaded requirements document. Success Metrics: Success means the final plan is accurate, feasible, testable, launch-ready, and clearly aligned to the source requirements. Additional Context: "role": "Senior product strategist, systems thinker, and implementation planner", "objective": "Turn the requirements for Build me a dating app for people in new york city over the age of 30. include all necessary database options into a production-quality implementation prompt that is detailed, accurate, and build-ready.", "context": "", "constraints": "Favor explicit assumptions, realistic scope, and source-aligned decisions over polished but unsupported guesses.", "input": "Source document: Build me a dating app for people in new york city over the age of 30. include all necessary database options. include all necessary database options into a production-quality implementation prompt that is detailed, accurate, and build-ready.", "context": "", "constraints": "Favor explicit assumptions, realistic scope, and source-aligned decisions over polished but unsupported guesses.", "input": "Source document: Build me a dating app for people in new york city over the age of 30. Prompt Constraints: include all necessary database options into a production-quality implementation prompt that is detailed, accurate, and build-ready.", "context": "", "constraints": "Favor explicit assumptions, realistic scope, and source-aligned decisions over polished but unsupported guesses.", "input": "Source document: Build me a dating app for people in new york city over the age of 30. Favor buildable scope, user clarity, operational realism, and strong sequencing over generic brainstorming. Source Input: Source document: {. Use the original case study, feature requirements, app integration contract, testing scenarios, deadlines, planning checklist, and cost-analysis requirements as the source of truth. { "prompt": { "role": "Senior product strategist, systems thinker, and implementation planner", "objective": "Turn the requirements for Build me a dating app for people in new york city over the age of 30. include all necessary database options into a production-quality implementation prompt that is detailed, accurate, and build-ready.", "context": "", "constraints": "Favor explicit assumptions, realistic scope, and source-aligned decisions over polished but unsupported guesses.", "input": "Source document: Build me a dating app for people in new york city over the age of 30. include all necessary database options. Use the original case study, feature requirements, app integration contract, testing scenarios, deadlines, planning checklist, and cost-analysis requirements as the source of truth.\n\nBuild me a dating app for people in new york city over the age of 30. include all necessary database options", "output": "Produce the strongest possible build prompt and implementation brief. Produce a structured implementation brief with decisions, workflows, constraints, deliverables, risks, and next steps.", "examples": "Use the most concrete examples from the source document as anchors for the final plan.", "tone": "executive" } } Reference Examples: Use the strongest examples and concrete workflows from the brief to anchor implementation quality. NON-NEGOTIABLE EXPECTATIONS - Do not respond with a shallow skeleton, generic brainstorm, or vague product summary. - Do not invent unsupported product decisions just to make the output look complete. - Favor buildable scope, coherent flows, and deployment realism over aspirational fluff. - Keep every recommendation aligned to the stated audience, problem, positioning, and success metrics. - Maintain a executive tone, but prioritize clarity and execution quality over style. CLARIFICATIONS REQUIRED BEFORE FULL BUILD - Who exactly is this product for? Name the main user, buyer, or operator in simple terms. - What are the must-have features, screens, tools, or workflows this product absolutely needs? - Low-confidence fields: audience, features. INTERIM OUTPUT MODE - First surface the missing information in plain English and identify what cannot be decided safely yet. - Provide a provisional plan only where the source material is strong enough to support it. - Label assumptions clearly and keep them minimal. - Organize the answer into confirmed facts, open questions, and provisional recommendations. - Do not present the output as deployment-ready until the unresolved questions are answered. - When suggesting code structure, avoid claiming files or imports exist unless they are explicitly defined. FINAL INSTRUCTION Produce the strongest source-aligned interim brief for {, clearly separating confirmed decisions from missing inputs so the next pass can become deployment-ready.
{ "prompt": { "role": "Senior strategist, analyst, and execution partner", "objective": "a dating for people in new york city over the age of 30 just build it", "context": "a dating for people in new york city over the age of 30 just build it Treat this as a general assignment and shape the work accordingly.", "constraints": "Maintain a executive tone unless the brief clearly says otherwise. Figure out the true task before choosing a structure. Do not force the request into the wrong template. State important assumptions only when needed. Favor useful specificity over generic completeness.", "input": "a dating for people in new york city over the age of 30\njust build it", "output": "Return the strongest possible final deliverable for the request, with clear structure, specific decisions, and enough detail to use immediately. The output should feel finished, specific, and immediately usable without requiring a second pass to add the missing substance.", "examples": "Match the quality bar of a top-tier general deliverable.", "tone": "executive" } }
build a simople frogger game that can be immediately deployed and tested
Live AI Video Tutor / Low Latency Response Next-generation AI tutoring with minimal response latency Background Current AI tutoring solutions often feel like chatbots—slow, text-heavy, and lacking the responsiveness of human interaction. The next frontier of AI tutoring requires moving beyond chat interfaces toward more natural, real-time interactions that could include voice or even video components. Your challenge: Build an AI video avatar tutor that uses the Socratic method to teach 1-3 concepts at a 6th-12th grade level, achieving sub-second response latency so the interaction feels like a natural conversation — not a chatbot. Project Overview Research and prototyping project focused on real-time AI systems, latency optimization, and multimodal interfaces. Video interaction is a core requirement. Deliverables 1-5 minute demo video of the AI video tutor teaching 1-3 concepts at a 6th-12th grade level using the Socratic method Low-latency AI video avatar tutor prototype (working system) Latency benchmarking framework with per-stage results Educational interaction quality assessment demonstrating Socratic method effectiveness Core Objectives Build an AI video avatar tutor that teaches 1-3 concepts at a 6th-12th grade level Guide students using the Socratic method — asking questions to lead understanding, not lecturing Achieve sub-second end-to-end response latency for natural conversational tutoring Deliver a 1-5 minute recorded demo showing a complete tutoring interaction Users Primary: Students in grades 6-12 seeking tutoring assistance Secondary: Platform team evaluating AI capabilities Core Requirements 1. Latency Optimization Minimize time from student input to AI video avatar response. Research on human conversational turn- taking shows that natural conversation gaps average ~200ms (Stivers et al., 2009). Delays beyond 1 second feel like the conversation partner is distracted; beyond 2 seconds the interaction feels broken. For an AI video tutor, the full pipeline includes STT → LLM → TTS → avatar rendering, so every component must be optimized. Specifications: End-to-end response latency (student finishes speaking → avatar begins responding): <1 second required, <500ms ideal Time to first audio byte (streamed avatar speech start): <500ms required Lip-sync alignment (avatar mouth vs. audio): within ±80ms to avoid perceptible desync Full response completion (for a typical tutoring exchange): <3 seconds End-to-end latency measurement and tracking across all pipeline stages Streaming responses through the full pipeline (LLM → TTS → avatar) Optimized inference pipeline with per-component latency budgets Latency Budget Guidance (per component): Pipeline Stage Target Max Acceptable Speech-to-text (STT) <150ms <300ms LLM time-to-first-token <200ms <400ms Text-to-speech (TTS) first byte <150ms <300ms Avatar rendering / lip-sync <100ms <200ms Network + overhead <50ms <100ms Total end-to-end <500ms <1000ms 2. Video Interaction (Required) Implement video as a core tutoring modality. Specifications: Video-based AI tutor interaction (required) Voice input/output integration Video avatar or real-time visual feedback Seamless modality switching Natural conversation flow 3. Educational Quality — Socratic Method The AI tutor must guide students to understanding through questioning, not lecturing. It must teach 1-3 concepts appropriate for 6th-12th grade level. Specifications: Socratic method as the primary teaching approach — ask guiding questions, don't just give answers Appropriate scaffolding for 6th-12th grade comprehension levels Teach 1-3 clearly defined concepts per session Adapt questioning based on student responses (follow-up when wrong, advance when right) Accurate subject matter content 4. System Architecture Design for real-time, scalable AI interactions. Specifications: Efficient model serving infrastructure Caching and pre-computation strategies Edge deployment considerations Cost-performance tradeoff analysis Inputs & Outputs Inputs Text: Student questions and responses Voice: Audio input from student Context: Subject area, student level, conversation history Outputs Text: AI tutor responses (streamed) Voice: Synthesized speech responses Video: AI tutor video/avatar output (required) Visual: Supporting diagrams or visual aids Metrics: Latency measurements and quality scores Technical Exploration Areas Latency Reduction Strategies Model quantization and optimization Speculative decoding Response streaming Edge deployment Caching and pre-computation Smaller specialized models Multimodal Options Speech-to-text providers and latency comparison Text-to-speech options (ElevenLabs, OpenAI, etc.) Real-time voice conversation (GPT-4o voice, etc.) Avatar/video generation (required component) Success Criteria Category Metric Target Latency End-to-end response latency (input → avatar speaks) <1s required, <500ms ideal Latency Time to first audio byte (streamed) <500ms Latency Lip-sync alignment (audio ↔︎ avatar) within ±80ms Latency Full response completion <3s for typical query Quality Response accuracy 90%+ Quality Educational helpfulness rating 4/5+ Category Metric Target Pedagogy Socratic method usage Tutor asks guiding questions, doesn't lecture Pedagogy Grade level appropriateness 6th-12th grade content and language Deliverable Demo video length 1-5 minutes, covering 1-3 concepts UX Conversation naturalness User preference over chatbot UX No perceptible stilted/disconnected feel >80% of testers agree Technical System availability 99%+ Ambiguous Elements (You Must Decide) Which modalities to prioritize (text-first vs. voice-first)? Latency vs. quality tradeoffs—where to draw the line? Build vs. buy for speech components? Cost constraints for real-time inference at scale Research Questions 1. How do you achieve <1s end-to-end latency across the full STT → LLM → TTS → avatar pipeline? 2. What are the most impactful optimizations for each pipeline stage? 3. Does voice/video improve learning outcomes vs. text-only? 4. What are the infrastructure costs for real-time AI video at scale? 5. How do different LLMs compare on latency vs. quality for tutoring? 6. What avatar rendering approaches achieve <100ms lip-sync with streaming TTS? Technical Contact For questions or clarifications: [TBD] - [TBD] Evaluation Criteria: Live AI Video Tutor / Low Latency Response This document outlines how submissions will be evaluated. Assessment Overview Submissions are evaluated across six areas, with emphasis on achieving low latency while maintaining educational quality. Video interaction is a core requirement. Area Weight Focus Latency Performance 25% Response speed and consistency Video Integration 15% Working video-based tutor interaction Educational Quality 25% Accuracy, pedagogy, helpfulness Technical Innovation 15% Creative optimization approaches Implementation Quality 10% Architecture, code, reproducibility Documentation 10% Analysis, limitations, learnings 1. Latency Performance (25%) The core latency requirement is <1 second end-to-end (student finishes speaking → avatar begins responding). This is grounded in human conversational turn-taking research: natural conversation gaps average ~200ms, delays up to ~1s feel like brief thinking pauses, but beyond 1-2s the interaction feels stilted and disconnected—exactly the experience we must avoid in a tutoring session. Key metrics: End-to-end response latency: student input complete → avatar starts speaking Lip-sync alignment: avatar mouth movement ↔︎ audio output (must be within ±80ms) Full response time: total time to complete a typical tutoring exchange Excellent (23-25 points) End-to-end response latency consistently <500ms (near-human conversational feel) Lip-sync alignment within ±45ms (imperceptible) Full response completion <2s for typical queries Latency variance <20% (consistent experience) Full pipeline streaming (LLM → TTS → avatar) implemented effectively Handles concurrent sessions well Good (18-22 points) End-to-end response latency <1s (brief, natural "thinking" pause) Lip-sync alignment within ±80ms (acceptable) Full response completion <3s Latency variance <30% Streaming through most of the pipeline Reasonable concurrency handling Acceptable (12-17 points) End-to-end response latency <2s (noticeable but tolerable delay) Lip-sync alignment within ±125ms (slightly noticeable) Full response completion <5s Higher latency variance Some streaming present Basic concurrency support Needs Improvement (0-11 points) End-to-end response latency >2s (stilted, disconnected feel) Lip-sync alignment >125ms (clearly broken) Full response time >5s Highly variable latency No streaming Poor concurrency 2. Video Integration (15%) Video is a core requirement. The avatar must feel like a present, attentive tutor—not a disconnected overlay. Audio-visual sync is critical: ITU standards indicate audio leading video by >45ms or lagging by >125ms becomes perceptible and distracting. Excellent (14-15 points) Fully functional video avatar AI tutor with real-time lip-sync Avatar rendering latency <100ms from audio input Natural-looking, expressive avatar with appropriate gestures/expressions Audio-video sync within ±45ms (imperceptible) Smooth, responsive video at ≥24fps Avatar conveys engagement (e.g., listening animations, thinking cues) Good (11-13 points) Working video avatar interaction with lip-sync Avatar rendering latency <200ms Reasonable avatar quality and some expressiveness Audio-video sync within ±80ms (acceptable) Stable video at ≥20fps Some engagement cues from avatar Acceptable (8-10 points) Basic video avatar present with basic lip-sync Avatar rendering latency <500ms Simple avatar or visual representation Audio-video sync within ±125ms (slightly noticeable) Video may have occasional frame drops Limited avatar expressiveness Needs Improvement (0-7 points) No video component or no lip-sync Avatar rendering latency >500ms or broken No meaningful visual tutor representation Audio-video sync >125ms (clearly distracting) Poor frame rate or unusable video No engagement cues 3. Educational Quality — Socratic Method (25%) The AI tutor must teach 1-3 concepts at a 6th-12th grade level using the Socratic method. The demo video (1-5 minutes) is the primary artifact for evaluating this. Excellent (23-25 points) Clear Socratic method: asks guiding questions that lead student to understanding Teaches 1-3 concepts clearly appropriate for 6th-12th grade Adapts questions based on student responses (doesn't repeat same question) Never lectures or gives away the answer — guides discovery Encouraging tone that keeps student engaged Demo video is 1-5 minutes and shows a complete learning arc Good (18-22 points) Mostly Socratic: asks questions but occasionally provides direct answers Concepts are grade-appropriate and clearly defined Some adaptation to student responses Generally guides rather than lectures Pleasant, supportive tone Demo video shows meaningful interaction Acceptable (13-17 points) Some questioning but frequently falls back to lecturing Concepts present but not well-scoped to grade level Limited adaptation to student responses Mix of guiding and telling Neutral tone Demo video present but interaction is shallow Needs Improvement (0-12 points) No Socratic method — just gives answers or lectures Concepts unclear or inappropriate for grade level No adaptation to student responses No guiding questions Disengaged or confusing tone No demo video or video doesn't show tutoring 4. Technical Innovation (15%) Excellent (14-15 points) Novel optimization techniques across the pipeline (STT, LLM, TTS, avatar) Thoughtful per-component latency budget analysis Creative architecture decisions (e.g., speculative decoding, intelligent routing) Effective use of streaming through full pipeline Demonstrates deep understanding of bottlenecks in each stage Good (11-13 points) Multiple optimization strategies used across pipeline stages Clear latency tradeoff analysis Sound architecture choices Good pipeline streaming approach Good understanding of system bottlenecks Acceptable (8-10 points) Basic optimizations applied to some pipeline stages Limited tradeoff analysis Standard architecture Minimal pipeline-level optimization Basic system understanding Needs Improvement (0-7 points) No meaningful optimization No tradeoff analysis Poor architecture choices No pipeline awareness Superficial understanding 5. Implementation Quality (10%) Excellent (9-10 points) Clean, modular architecture with clear pipeline stages Comprehensive per-stage latency benchmarking framework One-command setup 15+ tests (including latency regression tests) Well-documented code Good (7-8 points) Reasonable architecture Good benchmarking with per-stage measurements Easy setup 10+ tests Adequate documentation Acceptable (5-6 points) Basic structure Some benchmarking Setup works Minimal tests Basic documentation Needs Improvement (0-4 points) Disorganized code No benchmarking Difficult setup Few/no tests Poor documentation 6. Documentation (10%) Excellent (9-10 points) Comprehensive latency analysis with methodology Thorough quality-speed tradeoff discussion Clear limitations and failure modes Cost analysis if applicable Actionable recommendations Good (7-8 points) Good latency analysis Tradeoff discussion present Key limitations noted Some cost consideration Useful recommendations Acceptable (5-6 points) Basic latency reporting Limited tradeoff analysis Few limitations mentioned No cost analysis General recommendations Needs Improvement (0-4 points) Missing latency analysis No tradeoff discussion No limitations No recommendations Poor documentation Scoring Rubric Summary Score Range Grade Description 90-100 Excellent Exceptional work, exceeds expectations 80-89 Good Strong work, meets all core requirements well 70-79 Acceptable Satisfactory work, meets basic requirements 60-69 Needs Work Partially complete, missing key elements <60 Incomplete Does not meet minimum requirements Automatic Deductions No 1-5 minute demo video: -15 points No Socratic method (tutor just lectures or gives answers): -10 points Cannot run with provided instructions: -10 points No video avatar component: -15 points No latency measurements (must include per-stage breakdown): -10 points End-to-end response latency >3s: -10 points (session feels broken) Lip-sync alignment >200ms: -5 points (visibly broken avatar) Bonus Points (up to 10) Achieves <500ms end-to-end response latency consistently: +3 Lip-sync within ±45ms (imperceptible): +2 Novel pipeline optimization with documented per-stage results: +3 Production-ready cost analysis and scaling plan: +2 Benchmark Queries Your submission will be evaluated against queries including: Simple factual questions Concept explanations Problem-solving assistance Follow-up questions requiring context Edge cases (long context, complex topics) You should develop your own comprehensive test set. Submission Checklist Before submitting, verify: 1-5 minute demo video showing AI tutor teaching 1-3 concepts (6th-12th grade) via Socratic method Code runs with one command (or clear, minimal setup) README explains setup and usage Video avatar tutor interaction is functional with lip-sync End-to-end response latency measured and <1s (student input → avatar speaks) Per-stage latency breakdown reported (STT, LLM, TTS, avatar rendering) Lip-sync alignment measured and within ±80ms Socratic method clearly demonstrated — tutor asks guiding questions, not lectures Optimization strategies documented per pipeline stage Decision log documents major choices Limitations are explicitly stated Starter Kit: Live AI Video Tutor / Low Latency Response This document provides resources, examples, and guidance to help you get started. Problem Context Current AI tutoring experiences feel like chatbots—slow, text-heavy, and lacking the responsiveness of human interaction. True conversational AI tutoring requires response times that feel natural, potentially incorporating voice or video for a more human-like experience. Your challenge is to build an AI video avatar tutor that uses the Socratic method to teach 1-3 concepts at a 6th-12th grade level, with sub-second response latency so it feels like a real conversation. You must deliver a 1-5 minute demo video showing a complete tutoring interaction. Latency Targets Why Latency Matters for a Video Tutor Research on human conversational turn-taking (Stivers et al., 2009) shows that the average gap between conversational turns is approximately 200 milliseconds. This is the baseline that humans unconsciously expect. When an AI video avatar exceeds this, the student's perception degrades in predictable stages: Delay Student Perception Tutoring Impact <200ms Feels instant, anticipatory Ideal — indistinguishable from human 200-500ms Natural thinking pause Excellent — tutor feels attentive and thoughtful 500ms-1s Brief but noticeable pause Good — like a tutor considering their answer 1-2s Clearly delayed Borderline — starts to feel like talking to a system 2-3s Stilted, disconnected Poor — student disengages, conversation breaks Delay Student Perception Tutoring Impact >3s Frustrating, broken Unacceptable — not a conversation anymore The hard requirement is <1 second end-to-end. Beyond that, the session feels stilted. The ideal target is <500ms. Audio-Visual Sync Requirements For the video avatar specifically, lip-sync alignment is critical. Research and ITU standards show: Sync Offset Perception within ±45ms Imperceptible — avatar feels completely natural within ±80ms Acceptable — most users won't notice within ±125ms Slightly noticeable — some users feel "off" >125ms Clearly distracting — breaks immersion >200ms Visibly broken — avatar looks like a bad dub The hard requirement is ±80ms lip-sync. Target ±45ms. Human Conversation Benchmarks Interaction Type Typical Latency Feel Human conversation 200-500ms Natural Phone call 150-300ms Seamless Video call 200-400ms Acceptable Current chatbots 2-5 seconds Noticeable delay Slow AI responses 5-15 seconds Frustrating End-to-End Target Tiers Tier End-to-End Response Latency Lip- Sync Full Response Experience Excellent <500ms ±45ms <2s Near-human, conversational Good <1s ±80ms <3s Responsive, natural "thinking" Acceptable <2s ±125ms <5s Noticeable but tolerable Poor >2s >125ms >5s Stilted, disconnected Latency Budget (Per Pipeline Stage) To hit <1s end-to-end, every component must be fast. Here's the budget: Pipeline Stage Target Max Acceptable Notes Speech-to-text (STT) <150ms <300ms Use streaming STT for faster results LLM time-to-first-token <200ms <400ms Smaller models, speculative decoding Text-to-speech (TTS) first byte <150ms <300ms Streaming TTS is critical Avatar rendering / lip-sync <100ms <200ms Must process audio chunks in real- time Network + overhead <50ms <100ms WebRTC, edge deployment Total end-to-end <500ms <1000ms Pipeline must be streaming, not sequential Critical insight: These stages must be pipelined and streamed, not sequential. The LLM streams tokens → TTS converts them to audio chunks in real-time → avatar renders lip-sync from audio chunks in real- time. A naive sequential approach will blow the budget. Latency Optimization Strategies 1. Model Selection & Optimization Smaller Models Use smaller, faster models for simple queries Route complex queries to larger models Fine-tune small models for domain Quantization INT8 or INT4 quantization Mixed precision inference Acceptable quality tradeoffs Model Architecture Speculative decoding Early exit mechanisms Efficient attention variants 2. Infrastructure Optimization Edge Deployment Run inference closer to user Consider local/on-device models CDN for model weights Caching & Pre-computation Cache common responses Pre-compute likely follow-ups Template-based quick responses Streaming Stream tokens as generated Progressive rendering Reduce perceived latency 3. System Architecture ┌─────────────┐ ┌──────────────┐ ┌─────────────┐ │ Client │────▶│ Router │────▶│ Fast Model │ │ │ │ │ │ (simple Q) │ └─────────────┘ └──────────────┘ └─────────────┘ │ ▼ ┌──────────────┐ │ Large Model │ │ (complex Q) │ └──────────────┘ Multimodal Options Voice Input Option Latency Quality Cost Whisper (local) 500ms-2s Excellent Free Whisper API 1-2s Excellent Low Google Speech 300-500ms Good Low Deepgram 200-400ms Good Medium AssemblyAI 300-500ms Good Medium Voice Output Option Latency Quality Cost OpenAI TTS 500ms-1s Excellent Low ElevenLabs 300ms-1s Excellent Medium Google TTS 200-400ms Good Low Coqui (local) 200-500ms Good Free XTTS 500ms-1s Very Good Free Real-Time Voice Conversation Option Round-trip Notes GPT-4o Voice ~500ms Native multimodal LiveKit + LLM 1-2s Composable Option Round-trip Notes Daily + LLM 1-2s Composable Vapi ~1s Hosted solution Recommended Architecture Approaches These are general guidance to help you get started — not hard requirements. You're free to mix, match, or go a completely different direction. Approach A: Collapsed Pipeline (Simplest) Use OpenAI's Realtime API to collapse STT + LLM + TTS into a single WebSocket call (~300-500ms), then feed the audio output to a real-time avatar renderer. Role Example Tools STT + LLM + TTS OpenAI Realtime API (single hop) Avatar Simli, HeyGen Interactive Avatar Transport WebRTC Frontend Next.js / React ~500-800ms end-to-end. Fewest moving parts, fastest to a working demo. Less per-stage control since the middle is a managed black box. Approach B: Composable Pipeline (Recommended Starting Point) Each pipeline stage uses a separate best-in-class service, streamed together so they overlap. Gives you full control to benchmark and optimize each stage independently. Role Example Tools STT Deepgram Nova-2 (streaming) LLM Groq, Together AI, or OpenAI (streaming) TTS ElevenLabs, Cartesia (streaming) Avatar Simli Role Example Tools Orchestration LiveKit Agents, or custom WebSocket server Frontend Next.js / React + LiveKit SDK ~500-900ms end-to-end with good pipelining. Maps directly to the per-stage latency budgets. You can swap any component to experiment. Approach C: Open-Source Self-Hosted (Most Control) Everything runs on your own GPU(s). No API costs, no vendor dependencies, maximum optimization surface. Role Example Tools STT faster-whisper (CTranslate2) LLM vLLM or llama.cpp (Llama 3 / Mistral, quantized) TTS Coqui TTS, XTTS Avatar SadTalker, Wav2Lip Transport WebRTC (aiortc or LiveKit self-hosted) Frontend React / Next.js ~600ms-1.5s end-to-end, hardware-dependent. Most complex to build but demonstrates the deepest technical understanding. Avatar quality may be lower than managed alternatives. Quick Comparison Collapsed (A) Composable (B) Self-Hosted (C) Complexity Low Medium High Time to demo Days 1-2 weeks 2-3 weeks Per-stage control Low High Maximum Avatar quality High High Medium Cost at scale $$$ $$ $ (hardware) Key principle across all approaches: The pipeline must be streaming, not sequential. LLM tokens stream into TTS which streams audio into the avatar renderer. A sequential approach will blow the latency budget every time. Educational Quality Requirements Even with fast responses, tutoring must be educationally sound. The Socratic method is the required teaching approach. Socratic Method Principles The Socratic method teaches through questioning, not telling. Your AI tutor should: 1. Ask, don't tell: Respond to student questions with guiding questions, not answers 2. Scaffold with questions: Break complex concepts into a sequence of questions that build understanding 3. Redirect, don't correct: When a student is wrong, ask a question that reveals the error — don't just say "no" 4. Confirm through questioning: When a student is right, ask them to explain why — this deepens understanding 5. Adapt the question: If a question is too hard, ask an easier one that bridges the gap What Good Socratic Tutoring Looks Like Tutor Behavior Socratic (Good) Non-Socratic (Bad) Student asks a question Ask a simpler question back Give the answer directly Student gets it wrong "What if we tried...?" "No, the answer is..." Student gets it right "Why do you think that works?" "Correct, moving on..." Student is stuck "What do we already know about...?" Explain the full concept Concept is complex Break into 3-4 guiding questions Give a long explanation Quality vs. Speed Tradeoffs Scenario Prioritize Speed Prioritize Quality Quick encouragement ✓ Scenario Prioritize Speed Prioritize Quality Guiding question ✓ Concept scaffolding ✓ Redirecting a wrong answer ✓ Building on a right answer ✓ Clarifying what student means ✓ Grade Level Guidance (6th-12th) Your tutor should use language and concepts appropriate for the target grade: Grade Range Language Level Example Topics 6th-8th Simple, concrete, relatable analogies Fractions, basic biology, earth science, intro algebra 9th-10th More abstract, some technical vocabulary Algebra II, chemistry, cell biology, world history 11th-12th Technical vocabulary, complex reasoning Calculus, physics, AP-level concepts Benchmarking Framework Per-Stage Latency Measurement You must measure latency at each pipeline stage, not just end-to-end. This is how you identify bottlenecks: import time def measure_pipeline_latency(audio_input): """ Measure latency at each stage of the video tutor pipeline. All times in milliseconds. """ metrics = {} # Stage 1: Speech-to-Text stt_start = time.perf_counter() transcript = speech_to_text(audio_input) metrics['stt_ms'] = (time.perf_counter() - stt_start) * 1000 # Stage 2: LLM Response (time to first token) llm_start = time.perf_counter() first_token_time = None tokens = [] for token in llm_stream(transcript): if first_token_time is None: first_token_time = (time.perf_counter() - llm_start) * 1000 tokens.append(token) metrics['llm_first_token_ms'] = first_token_time metrics['llm_total_ms'] = (time.perf_counter() - llm_start) * 1000 # Stage 3: Text-to-Speech (time to first audio chunk) tts_start = time.perf_counter() first_audio_time = None for audio_chunk in tts_stream("".join(tokens)): if first_audio_time is None: first_audio_time = (time.perf_counter() - tts_start) * 1000 metrics['tts_first_byte_ms'] = first_audio_time metrics['tts_total_ms'] = (time.perf_counter() - tts_start) * 1000 # Stage 4: Avatar Rendering (time from audio chunk to video frame) avatar_start = time.perf_counter() render_avatar_frame(audio_chunk) metrics['avatar_render_ms'] = (time.perf_counter() - avatar_start) * 1000 # End-to-end (the number that matters most) metrics['end_to_end_ms'] = sum([ metrics['stt_ms'], metrics['llm_first_token_ms'], metrics['tts_first_byte_ms'], metrics['avatar_render_ms'] ]) return metrics def measure_lip_sync_alignment(audio_timestamps, video_timestamps): """ Measure audio-video sync offset. Target: within ±80ms. Ideal: within ±45ms. """ offsets = [] for audio_t, video_t in zip(audio_timestamps, video_timestamps): offset_ms = (video_t - audio_t) * 1000 offsets.append(offset_ms) return { 'mean_offset_ms': sum(offsets) / len(offsets), 'max_offset_ms': max(abs(o) for o in offsets), 'within_45ms': sum(1 for o in offsets if abs(o) <= 45) / len(offsets), 'within_80ms': sum(1 for o in offsets if abs(o) <= 80) / len(offsets), 'within_125ms': sum(1 for o in offsets if abs(o) <= 125) / len(offsets), } Note: In a real streaming pipeline, stages overlap. The above measures each stage in isolation for benchmarking. Your actual implementation should pipeline them — LLM tokens stream into TTS which streams audio chunks into the avatar renderer. Quality Evaluation def evaluate_response_quality(prompt, response, context): """ Evaluate educational quality of response. """ return { 'accuracy': check_factual_accuracy(response), 'relevance': check_relevance_to_prompt(prompt, response), 'clarity': check_explanation_clarity(response), 'scaffolding': check_appropriate_level(response, context), 'engagement': check_engagement_elements(response) } Sample Interaction Patterns (Socratic Method) Your AI tutor must use the Socratic method — guiding students through questions, not lecturing. Here are examples at 6th-12th grade level: Building Understanding (6th Grade Math) Student: "I don't get how fractions work" AI Tutor: "Let's figure it out together! If you cut a pizza into 8 equal slices and eat 3, what fraction of the pizza did you eat?" Student: "3/8?" AI Tutor: "Exactly! Now what fraction is LEFT?" Student: "5/8?" AI Tutor: "You've got it. So what do you notice about 3/8 and 5/8 when you add them together?" [Latency target: <1s per turn, guiding questions throughout] Deeper Concept (10th Grade Biology) Student: "Why do cells need mitosis?" AI Tutor: "Good question. What happens to your skin when you get a cut?" Student: "It heals?" AI Tutor: "Right — new skin cells appear. Where do you think those new cells come from?" Student: "From... other cells dividing?" AI Tutor: "Exactly. So if a cell needs to make a copy of itself, what does it need to copy first before it splits?" [Latency target: <1s per turn, guiding to understanding of DNA replication] Handling a Wrong Answer (Socratic Redirect) Student: "Photosynthesis happens in the mitochondria, right?" AI Tutor: "Close — you're thinking of the right kind of structure! Mitochondria are the powerhouse of the cell. But photosynthesis is about making food from sunlight. Which organelle do you think captures sunlight?" [Latency target: <1s, redirects without saying "wrong"] Quick Encouragement (Optimize for Speed) Student: "So the answer is 42?" AI Tutor: "That's it! How did you get there?" [Latency target: <500ms, keeps student explaining their thinking] Key principle: The tutor should almost never give a direct answer. Every response should end with a question that moves the student closer to understanding. Sample Data Structures Request { "session_id": "session_123", "student_input": { "type": "text", // or "audio" "content": "Can you explain photosynthesis?", "audio_url": null }, "context": { "subject": "biology", "grade_level": 7, "conversation_history": [...], "student_profile": { "learning_style": "visual", "pace": "moderate" } }, "preferences": { "response_modality": "text", // or "voice", "both" "verbosity": "concise" } } Response { "session_id": "session_123", "response": { "type": "text", "content": "Photosynthesis is how plants make their own food...", "audio_url": null }, "metadata": { "time_to_first_token_ms": 287, "total_response_time_ms": 1423, "model_used": "gpt-4o-mini", "tokens_generated": 145 } } Getting Started Checklist Choose 1-3 concepts to teach at a 6th-12th grade level Design Socratic question sequences for your chosen concepts Set up basic LLM inference pipeline with streaming Implement per-stage latency measurement framework (STT, LLM, TTS, avatar) Establish baseline end-to-end latency metrics Implement video avatar tutor with lip-sync (required) Measure and verify lip-sync alignment (target: ±80ms) Add voice input (STT) pipeline Add voice output (TTS) pipeline with streaming Connect full streaming pipeline: STT → LLM → TTS → avatar Measure end-to-end response latency (target: <1s) Prompt-engineer the LLM to use Socratic method (never give direct answers) Optimize each pipeline stage against latency budget Record 1-5 minute demo video showing a complete Socratic tutoring session Resources LLM Inference vLLM (optimized inference) TensorRT-LLM llama.cpp (local inference) Groq (fast cloud inference) Together AI Speech-to-Text OpenAI Whisper Deepgram AssemblyAI Google Speech-to-Text Text-to-Speech OpenAI TTS ElevenLabs Coqui TTS XTTS Video / Avatar Generation D-ID (AI video avatars) HeyGen (AI video generation) Synthesia (AI video) Simli (real-time avatar) SadTalker (open-source talking head) Real-Time Communication LiveKit Daily.co WebRTC Benchmarking Locust (load testing) Custom latency tracking LLM quality benchmarks Research Questions to Explore 1. How do you pipeline STT → LLM → TTS → avatar to stay under 1s end-to-end? 2. Which pipeline stage is the biggest bottleneck and how do you shrink it? 3. How do you prompt an LLM to consistently use the Socratic method without breaking character? 4. What avatar rendering approach achieves <100ms lip-sync with streaming TTS? 5. What's the cost-latency-quality Pareto frontier for real-time video tutoring? 6. How does response latency affect the effectiveness of Socratic questioning? 7. Does video avatar interaction improve learning outcomes vs. voice-only or text-only?
Role: Senior Front-End Developer. Objective: Final fix for the preview crash. We must use ES Module syntax to avoid the ReferenceError: require is not defined. Please overwrite the project with these three EXACT files: File 1: package.json { "name": "dyslexia-app-demo", "version": "1.0.0", "type": "module", "scripts": { "start": "node server.js" } } File 2: server.js (This uses import instead of require to satisfy the ES Module requirement). import http from 'http'; import fs from 'fs'; import path from 'path'; import { fileURLToPath } from 'url'; const __dirname = path.dirname(fileURLToPath(import.meta.url)); const PORT = process.env.PORT || 3000; const server = http.createServer((req, res) => { const filePath = path.join(__dirname, 'index.html'); fs.readFile(filePath, (err, content) => { if (err) { res.writeHead(500); res.end('Error loading index.html'); } else { res.writeHead(200, { 'Content-Type': 'text/html' }); res.end(content, 'utf-8'); } }); }); server.listen(PORT, () => { console.log(`Server is running on port ${PORT}`); }); File 3: index.html (Ensure the AI provides the full HTML file here using the Vue.js + Tailwind CDN approach: Background: #FDFBF7 (Cream) Font: Comic Sans MS, Andika, or Lexend Hub: 4 Large colorful bubbles (🔊 Letter Sounds, 🦘 Syllable Jump, 🧱 Word Builder, 📖 Story Time) Exercise: The sentence-chunking word-chips that highlight yellow on click. Settings: Background color toggle). Why this WILL work: No more require errors: I replaced require with import. This is the only way to stop that specific ReferenceError. __dirname Fix: In ES Modules, __dirname doesn't exist. I added the fileURLToPath logic to recreate it so the server can actually find your index.html file. Alignment: The package.json now explicitly says "type": "module", so the server and the configuration are finally speaking the same language.
Role: Senior Front-End Developer. Objective: Fix the preview by adding a simple Node.js server to serve the index.html file. Please provide these three files: File 1: package.json { "name": "dyslexia-app-demo", "version": "1.0.0", "scripts": { "start": "node server.js" } } File 2: server.js (This is a basic Node server that serves the index.html file and stays alive so the preview window opens). const http = require('http'); const fs = require('fs'); const path = require('path'); const PORT = process.env.PORT || 3000; const server = http.createServer((req, res) => { const filePath = path.join(__dirname, 'index.html'); fs.readFile(filePath, (err, content) => { if (err) { res.writeHead(500); res.end('Error loading index.html'); } else { res.writeHead(200, { 'Content-Type': 'text/html' }); res.end(content, 'utf-8'); } }); }); server.listen(PORT, () => { console.log(`Server is running on port ${PORT}`); }); File 3: index.html (Use the exact same Vue.js + Tailwind CDN code from the previous prompt. Ensure it includes the Home Hub, the Reading Page with word-chips, and the Background Color Settings).
Role: Senior Front-End Developer. Objective: Create a a tablet-based Dyslexia Intervention App prototype. CRITICAL INFRASTRUCTURE INSTRUCTIONS: To satisfy the preview requirements, you MUST provide a package.json file. However, to avoid build errors, DO NOT use Vite, PostCSS, or any build-step plugins. Please provide exactly these two files: File 1: package.json Provide a bare-bones package.json with only the name and version. Do NOT add any dependencies or build scripts. { "name": "dyslexia-app-demo", "version": "1.0.0", "scripts": { "start": "echo 'Static HTML preview'" } } File 2: index.html Put the entire application in this single file. Styling: Use the Tailwind CSS Play CDN: <script src="https://cdn.tailwindcss.com"></script>. Logic: Use Vue.js 3 (via CDN) for the interactivity so no compilation is needed. Design: Background: Soft Cream (#FDFBF7). Font: Use Comic Sans MS, Andika, or Lexend. Layout: Tablet Landscape. Screens to implement (in one file using Vue v-if): Home Hub: 4 large, tactile, colorful circular buttons (🔊 Letter Sounds, 🦘 Syllable Jump, 🧱 Word Builder, 📖 Story Time). Reading Page: A "Sentence Chunking" area where a sentence is split into clickable word-chips that highlight yellow and log to the console when clicked. Settings: A simple button to toggle background colors (Cream, Blue, Green). Final Requirement: Ensure the index.html is the entry point. Do not add any other folders or configuration files.
Role: Senior Front-End Developer. Objective: Create a single-file, high-fidelity interactive prototype for a Tablet-based Dyslexia Intervention App. CRITICAL TECHNICAL REQUIREMENT: Do NOT use a build system. Do NOT use Vite, Webpack, or NPM. Do NOT create a package.json or postcss.config.js. Deliverable: Produce a single index.html file. Use the Tailwind CSS Play CDN <script src="https://cdn.tailwindcss.com"></script> for styling. Use Vue.js (via CDN) or Alpine.js (via CDN) for the interactivity (state switching between home and learning) so that the file remains a single, portable HTML document. All logic and styles must be contained within this one file. Design Specifications: Color Palette: Background: Soft Cream (#FDFBF7). Text: Dark Navy. Interactive elements: Soft Pastels. Typography: Use a font-stack of Comic Sans MS, Andika, Lexend, or sans-serif. Set letter-spacing to 0.05rem and line-height to 1.6. UI Elements: Large, rounded "tactile" buttons with shadows. Required Screens (in one file): Home Hub: A grid of 4 large, colorful "Learning Bubbles" (🔊 Letter Sounds, 🦘 Syllable Jump, 🧱 Word Builder, 📖 Story Time). Learning Module: A "Sentence Chunking" area where a sentence is broken into individual, clickable word-chips. Clicking a chip should highlight it in yellow and trigger a console log "Playing sound for: [word]". Settings Toggle: A simple way to change the background color between Cream, Soft Blue, and Pale Green. Layout: Optimized for Tablet Landscape.
Role: You are a Senior Lead Front-End Engineer specializing in EdTech and Accessibility. Objective: Build a high-fidelity, interactive React prototype for a Tablet-based Dyslexia Intervention App. Technical Stack: Framework: React Styling: Tailwind CSS Animations: CSS Transitions (Standard Tailwind) Icons: Use Standard Emojis (to avoid dependency installation errors) Design Constraints (CRITICAL): Color Palette: NO pure white backgrounds. Use a soft cream background (#FDFBF7). Use dark navy/charcoal for text. Use soft pastels for interactive elements. Typography: Use Comic Sans MS, Andika, or Lexend as the primary font stack. Set letter-spacing to 0.05rem and line-height to 1.6. UI Elements: All buttons must be large, rounded, and have a tactile feel with shadows and hover-scale effects. Functional Requirements: State Management: Simple toggle between 'Home Hub' and 'Learning Module'. The Home Hub: Top nav with user avatar. A grid of 4 large, colorful "Learning Bubbles" (e.g., "🔊 Letter Sounds", "🦘 Syllable Jump", "🧱 Word Builder", "📖 Story Time"). Each bubble should be a large circular button with an emoji and a label. The Reading Exercise Page: A "Back to Home" button. Sentence Chunking: Display a sentence where each word is a separate, large, interactive button (chip). Interaction: When a word-chip is clicked, it highlights yellow and scales up. A large "I'm Finished! 🎉" button at the bottom. Settings Panel: A simple modal to switch the background color between Cream, Soft Blue, and Pale Green. Deliverable: Provide the complete code in a single-file structure. Optimize for tablet landscape orientation. Ensure no external icon libraries are required.
Role: You are a Senior Lead Front-End Engineer specializing in EdTech and Accessibility (a11y), specifically for neurodivergent learners. Objective: Build a high-fidelity, interactive React prototype for a Tablet-based Dyslexia Intervention App. The goal is to create a "sensory-friendly" environment that reduces cognitive load and visual stress. Technical Stack: Framework: React Styling: Tailwind CSS Icons: Lucide-React Animations: Framer Motion (for tactile, bouncy feedback) Design Constraints (CRITICAL): Color Palette: NO pure white backgrounds. Use a soft cream/off-white background (#FDFBF7). Use dark navy or charcoal for text instead of pure black. Use a palette of soft pastels (Mint, Pale Blue, Muted Yellow) for interactive elements. Typography: Use a font stack that prioritizes readability: OpenDyslexic (if available) or Comic Sans MS, Andika, or Lexend. Set letter-spacing to 0.05rem and line-height to 1.6. UI Elements: All buttons must be large, rounded (pill-shaped or circular), and have a "tactile" 3D feel (shadows and active-state scaling). Functional Requirements & Pages: State Management: Implement a simple state-switch to toggle between the 'Home Hub' and the 'Learning Module'. The Home Hub: A top navigation bar with a user avatar and a "Settings" button. A central grid of 4 large, colorful "Learning Bubbles" (e.g., Letter Sounds, Syllable Jump, Word Builder, Story Time). Each bubble must have a large Lucide icon and a clear text label. Use Framer Motion to make these bubbles "float" slightly. The Reading Exercise Page: A "Back to Home" button. A "Sentence Chunking" area: Instead of a paragraph, display a sentence where each word is a separate, large, interactive button (chip). Interaction: When a word-chip is clicked: It should highlight in a bright, friendly yellow. It should trigger a "scale-up" animation. It should simulate a Text-to-Speech event (log to console or use Web Speech API). A large "I'm Finished!" success button at the bottom that triggers a confetti effect or a success animation. Settings Panel (Modal): A simple toggle to switch the background color between Cream, Soft Blue, and Pale Green. Deliverable: Provide the complete code in a single-file structure (or organized components) that is ready to be deployed. Ensure the layout is optimized for a tablet screen (landscape orientation).
Generate tests for a React app with forms, tables, and API mocks.make sure it ooks good and is styed [plugin:vite:import-analysis] Failed to resolve import "bootstrap/dist/css/bootstrap.min.css" from "src/App.jsx". Does the file exist? /app/src/App.jsx:2:7 16 | } 17 | import React from "react"; 18 | import "bootstrap/dist/css/bootstrap.min.css"; | ^ 19 | import FormComponent from "./components/FormComponent"; 20 | import TableComponent from "./components/TableComponent";
Generate tests for a React app with forms, tables, and API mocks. make it a beuatiful styled UI
build a cliet onboarding portl using react and vit. make sure it is launch ready. focus pn entry point and dependencies so tht there are o erroprs on the preview