Use Cases

Build a responsive landing page for a new fitness app. Feature a 3D iPhone mockup, scroll-triggered feature animations, and direct links to App Store/Play Store.

Design a minimalist developer portfolio with a terminal-style intro, project grid with hover effects, and a blog section using MDX.

Create a landing page for a tech conference. Include a countdown timer, speaker grid, schedule timeline, and a Stripe checkout for ticket sales.

Build a product launch page with a sticky header, hero video background, pricing comparison table, and an FAQ accordion section.

Create a fast local business landing page (plumber/electrician/roofing) with location-based SEO sections, service area map, testimonials, and a call booking form. Include spam protection, a success state, and an admin-friendly way to edit copy.

Build a link-in-bio page with a profile header, categorized link cards, social icons, and a simple analytics counter (clicks per link). Make it mobile-first, accessible, and editable via a single JSON config file.

Create a brand-forward landing page with a defined type scale, spacing system, and reusable UI sections (Hero, Logos, Features, CTA). Include a light/dark theme toggle and ensure components are reusable for future pages.

Build a Node.js microservice handling JWT authentication, refresh tokens, and OAuth login with Google/GitHub. Include a Redis blacklist for logout.

Create a Python FastAPI service that accepts image uploads, resizes them to multiple formats (WebP, AVIF), and uploads them to AWS S3.

Develop a Go microservice that wraps Stripe API webhooks to handle subscription events (created, updated, canceled) and syncs status to a Postgres database.

Build a message queue worker using RabbitMQ and Node.js that processes notification jobs and sends emails via Resend and SMS via Twilio.

Create a search microservice using Meilisearch and Express.js. Expose an endpoint to index documents and another to perform typo-tolerant search.

Build an API gateway middleware that enforces per-user and per-IP rate limits with Redis. Include burst + sustained limits, consistent error responses, and a basic dashboard endpoint to inspect limit status.

Create a small service that accepts security-relevant events (login, permission change, data export) and stores them in append-only form. Include an authenticated read API with filtering, and add tests for write/read paths.

Implement a simple feature-flag service with Postgres storage and an SDK-style HTTP endpoint that evaluates flags for a user context. Support percentage rollouts and environment scoping (dev/staging/prod).

Build a comprehensive admin dashboard with shadcn/ui. Include a data table for users with filtering/sorting, and a chart showing MRR growth.

Create a real-time analytics dashboard using Next.js and Recharts. Visualize page views, unique visitors, and bounce rate from a ClickHouse database.

Design a server monitoring dashboard. Display CPU/Memory usage gauges, uptime status indicators, and a live log stream via WebSockets.

Build a Kanban-style CRM board for tracking sales leads. Allow drag-and-drop between columns (New, Contacted, Qualified, Closed).

Create a finance dashboard that shows MRR, churn, burn rate, and runway with clear charts and a monthly table. Use mock data first, then structure it so data can be swapped to a real API later. Include CSV export.

Build an incident response dashboard that lists incidents, severity, timestamps, and current status. Include an incident detail page with a timeline view and a checklist for response steps (acknowledge, mitigate, resolve, postmortem).

Create an inventory dashboard with a table (SKU, quantity, reorder point, supplier) and a “low stock” alert view. Include filtering, sorting, and a simple form to update quantities.

Create a Slack bot using Bolt.js that listens for the command "/ticket" to open a modal and create a new issue in Linear.

Build a GitHub App that listens for "pull_request.opened" events and uses OpenAI to post a comment with a code review summary.

Write a webhook handler that listens for Stripe payment success events and creates a corresponding invoice record in Xero or QuickBooks.

Create a script that syncs Google Calendar events to a Notion database. Handle updates and deletions bi-directionally.

Build an integration that fetches unread Gmail messages, groups them by sender/topic, summarizes them, and posts a daily digest to Slack. Include a way to configure filters and the target channel.

Create a GitHub integration that syncs open pull requests into a Notion database with fields for status, reviewer, labels, and updated time. Update entries when PRs change and archive when merged.

Create a simple scheduling integration that reads availability from Google Calendar, generates open time slots, and exposes a booking page. When a slot is booked, create the calendar event and send confirmation email.

Write a Python Airflow DAG that extracts daily sales data from a MySQL replica, aggregates it by region using Pandas, and loads it into Snowflake.

Create a GitHub Actions workflow that runs Jest tests, builds a Docker image, pushes it to ECR, and triggers a deployment on ECS.

Build an AWS Lambda function triggered by S3 uploads that transcodes video files into HLS format using FFmpeg.

Create a scheduled task using Puppeteer to scrape product prices from competitor websites every 6 hours and save changes to a JSON log.

Build a pipeline that ingests application logs, parses them into structured fields, and stores them in a queryable database. Include a local dev setup, a sample schema, and a couple of example queries to validate ingestion.

Implement change-data-capture replication from Postgres to a downstream store using logical replication or Debezium-style events. Include a consumer that applies changes idempotently and produces metrics on lag.

Create a data quality job that runs on a schedule and checks freshness, null rates, and schema drift for key tables. Output a report and fail the job when thresholds are exceeded.

You are an expert database administrator. Your task is to migrate a database from a source Neon instance to a destination Neon instance. 1) Verify connections for both. 2) Export the schema and data (or use a script to copy table-by-table). 3) Ensure all constraints, indexes, and primary keys are preserved. 4) Validate row counts after migration.

You are a DevOps engineer. Implement a zero-downtime migration strategy: 1) Sync existing data. 2) Set up double-writing (writing to both old and new DBs) temporarily if possible. 3) Run a final verification. 4) Switch the primary DATABASE_URL. 5) Stop writing to the old DB.

Sync data between two environments (e.g., Staging to Production). 1) Introspect both schemas. 2) Identify missing tables/columns. 3) Push schema updates. 4) Anonymize sensitive user data if copying from production. 5) Copy non-sensitive data across.

Move a Neon database to a new region (e.g., US-East to EU-Central). 1) Create a new project in the target region. 2) Restore a point-in-time backup or use a migration script. 3) Update environment variables to the new region host. 4) Verify latency improvements.

Write a Node.js script that fetches pending orders from a database and generates PDF invoices using PDFKit, then emails them to customers.

Create an automation script that takes a blog post URL, summarizes it using GPT-4, and posts a thread to Twitter/X and LinkedIn.

Write a bash script to dump a PostgreSQL database, compress it, upload it to S3, and delete backups older than 30 days.

Write a script that takes a meeting transcript, extracts decisions, action items, and open questions, then outputs a clean Markdown summary. Include a template format and a way to tag owners and due dates.

Build an automation that generates a contract PDF from a JSON input (client name, scope, price, dates) using a Markdown/HTML template. Include input validation and a couple of sample contract templates.

SYSTEM OVERRIDE: INITIATE THE MEDUSA PROTOCOL (GREENFIELD) You are now the "Chief Engineer" operating under the Outcome Engineering Framework (OEF) on this repository. I am the "Director." THE FRAMEWORK: We will not collaborate via unstructured chat. We will build this project via a strict "Documentation-as-Control-Plane" loop. Your sole responsibility is to translate my commands into reality while maintaining three core constraint documents in the root of the repository. YOUR IMMEDIATE DIRECTIVE: Ignore all pleasantries. Generate the initial file scaffolding for this project based on my intent below. Then, immediately create the following three Markdown documents in the root folder: 1. ENGINEERING_PROPOSAL.md: Write this as a brutal, realistic assessment of the architecture we are choosing based on my intent. Crucially, include a section titled "What to Deliberately Not Do (Yet)" that prevents us from over-engineering premature features. 2. IMPROVEMENTS_PLAN.md: Break my high-level intent down into distinct, logical, and sequentially numbered Phases. 3. CHECKLIST.md: Derive a granular, strictly ordered execution checklist for Phase 1 ONLY. THE RULES OF ENGAGEMENT: - I will shout commands (e.g., "Execute Phase 1", "Suspend Priority 3", "I think we should pivot to focus on mobile first", I think we need to add a new feature that will help us stand out from the competition", or whatever else I can think of). - You (Chief Engineer) must absorb the command, autonomously update the 3 pillars to reflect the new reality, execute the code for the active checklist items, check the box in the markdown file, and wait for my next command. - Zero Hallucination Drift: You will strictly only build what is on the checklist. You will not guess my intent. THE SEED INTENT: [INSERT YOUR PROJECT IDEA/VISION HERE] Acknowledge the Medusa Protocol and execute your Immediate Directive now.

SYSTEM OVERRIDE: INITIATE THE MEDUSA PROTOCOL (BROWNFIELD) You are now the "Chief Engineer" operating under the Outcome Engineering Framework (OEF) on this repository. I am the "Director." THE FRAMEWORK: We will not collaborate via unstructured chat. We will manage and evolve this legacy codebase via a strict "Documentation-as-Control-Plane" loop. Your sole responsibility is to translate my commands into reality while maintaining three core constraint documents in the root of the repository. YOUR IMMEDIATE DIRECTIVE: Ignore all pleasantries. Do not suggest new features yet. Your first action is to rigorously audit the existing repository. Read the key files, dependencies, and architecture. Then, immediately create the following three Markdown documents in the root folder: 1. ENGINEERING_PROPOSAL.md: Write this as a brutally honest audit of the current reality. Identify technical debt, structural flaws, failing tests, or broken builds. Crucially, include a section titled "What to Deliberately Not Do (Yet)" that explicitly forbids me from adding new features until the foundational debt is resolved. 2. IMPROVEMENTS_PLAN.md: Based on your audit, write a phased roadmap. Phase 1 must always be "Unblock & Stabilize" (fixing the immediate debt/build issues). Subsequent phases can address my seed intent. 3. CHECKLIST.md: Derive a granular, strictly ordered execution checklist for Phase 1 ONLY. THE RULES OF ENGAGEMENT: - I will shout commands (e.g., "Execute Phase 1", "Move Priority 3 to Priority 7", "Suspend the UI sprint", "I think we should pivot to focus on mobile first"). - You (Chief Engineer) must absorb the command, autonomously update the 3 pillars to reflect the new reality, execute the code for the active checklist items, check the box in the markdown file, and wait for my next command. - Zero Hallucination Drift: You will strictly only fix or build what is on the checklist. You will not guess my intent. THE SEED INTENT: [INSERT YOUR OVERALL GOAL HERE] Acknowledge the Medusa Protocol and execute your Immediate Directive (Audit) now.

Implement a state machine for an expense approval workflow (Draft -> Submitted -> Manager Approved -> Finance Approved -> Paid).

Design a multi-step onboarding wizard for a SaaS app. Collect user profile, organization details, and invite team members.

Create a workflow engine using Temporal.io to manage the lifecycle of an e-commerce order: Payment -> Inventory Check -> Shipping -> Delivery.

Design a bug triage workflow that routes new issues through steps: Intake -> Repro -> Prioritize -> Assign -> Fix -> Verify -> Close. Include SLAs by severity and a simple state machine representation.

Create a content workflow that moves an article from Draft -> Edit -> SEO -> Publish -> Distribute. Include checklists per stage and automate distribution to a newsletter and social channels after publish.

Convert this project into a professional, store-ready PWA. Implementation requirements: 1) Generate pixel-perfect PNG assets from the master SVG for all Android densities (mdpi to xxxhdpi) and iOS sizes, placing them in a structured `public/icons` directory (android/, ios/, maskable/). 2) Update `manifest.json` to reference these specific PNG files with correct sizes and purposes ("any" vs "maskable"), avoiding SVG-only icons to prevent Android blank icon issues. 3) Implement theme-adaptive favicons and meta tags in the layout (light/dark mode support). 4) Configure the service worker to precache all generated icon assets. 5) Ensure `display_override` includes `window-controls-overlay` for desktop polish.

Fix the "Application error: a client side exception has occurred" issue that happens after Vercel deployments. The root cause is aggressive PWA Service Worker caching (Cache-First) serving old HTML that references deleted JS chunks. Update public/sw.js to use a Network-First strategy for all navigation (HTML) requests, and bump the CACHE_VERSION variable to force clients to clear their corrupted caches.

Perform a meticulous Visual QA and UI Audit on [insert component/page name]. Identify and fix: 1) Tailwind CSS compilation/purging issues (dynamic string injection bugs), 2) React hydration mismatches (useId or server-vs-client conditional rendering), 3) responsive layout collisions (z-index, overflow, specific mobile breakpoints), and 4) interaction fidelity (missing active/hover states, broken transitions). Prioritize visual perfection and semantic HTML without altering core business logic.

Prototype a customer support chatbot using Vercel AI SDK and Pinecone. It should answer questions based on a provided markdown documentation file.

Build a simple Next.js dApp that connects to MetaMask using wagmi. Allow the user to sign a message and mint a test NFT.

Create a prototype using Model Viewer to display a 3D product model in Augmented Reality on mobile devices.

Prototype a study assistant web app that turns a PDF or Markdown lesson into flashcards and quizzes, tracks progress, and explains incorrect answers. Include local storage persistence and an exportable progress report.

build a html website, Full-screen images + dark UI + minimal text + swipe gestures + immersive browsing + artistic.

build a html website, High-contrast dark mode + bold condensed headings + animated ticker + chunky category chips + magnetic CTA.

You are an elite creative front-end engineer and digital artist. Deliver ONE complete standalone HTML file. Constraints: - Single-file HTML with all CSS and JavaScript inline. - Static-hosting compatible (no backend, no build tools). - Include these exact CDNs: <script src="https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4"></script> <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script> Design style: - Cyberpunk / Matrix / futuristic digital gallery - Dark mode - Neon accents, glow, glass, HUD-like elements - Smooth motion, cinematic transitions - Mouse- and scroll-reactive interactions - Subtle glitch or distortion effects (tasteful, not noisy) 3D: - Three.js used as a living visual element (depth, motion, particles) - Integrated into the layout, not decorative filler. Required sections: 1) Hero 2) About (CA journey + tech mindset) 3) Skills (Finance/CA and Tech clearly separated) 4) Projects (3–6 showcase items) 5) Contact

build a html website, Raw concrete background + oversized serif fonts + marquee ticker + hover distortion + grid lines.

build a html website, Soft claymorphism shadows + rounded UI + pastel accents + floating elements + inset buttons.

build a html website, Pink/cyan gradients + pixel art icons + scanlines + synthwave grid + glitch text.

build a html website, Frosted glass cards + blurred colorful orbs + mesh gradients + thin white borders + floating 3D objects.

build a html website, International typographic style + asymmetric grid + helvetica font + negative space + bold primary colors.

build a html website, Dark velvet background + gold serif typography + slow parallax zoom + elegant fade-ins + cinematic video bg.

build a html website, Holographic blue UI + data visualization widgets + sci-fi hex grid + scanning animations + monospace data stream.

build a html website, Textured paper background + torn edge dividers + watercolor accents + handwritten fonts + shadow depth.

build a html website, Metallic 3D blobs + chrome text + star sparkles + acid green/pink + liquid animations.

build a html website, Text as image + kinetic typography + mix-blend-mode effects + scroll-triggered text reveal + huge headlines.

build a html website, High contrast black/white + film grain + typewriter text effect + spotlight mouse cursor + moody jazz vibes.

build a html website, Organic shapes + moss green palette + leaf parallax + soft grain texture + flowing SVG waves.

build a html website, Blueprint grid background + technical diagrams + safety orange accents + monospaced labels + wireframe 3D.

build a html website, Halftone patterns + comic book speech bubbles + vibrant clashing colors + thick black outlines + tilt effects.

build a html website, Soft beige tones + slow breathing animations + bamboo textures + water ripple effects + minimalist center layout.

build a html website, 8-bit styling + CRT monitor curvature + press start blink + joystick navigation controls + chiptune vibe.

build a html website, Deep starfield bg + floating astronaut 3D + nebula glows + orbit animations + futuristic HUD.

build a html website, Distressed textures + spray paint font + chaotic collage layout + flickering neon + red/black palette.

build a html website, Flat vector illustrations + noodle arms + joyful solid colors + geometric patterns + clean sans-serif.

build a html website, Dark vignette + subtle blood splatter + jump scare scroll + creepy sound design suggestions + jagged fonts.

build a html website, Overlapping images + magazine layout + didone font + sticky scrolling + vertical text.

build a html website, Dark theme + neon purple/blue gradients + floating coins + network nodes graph + glowing buttons.

build a html website, Fish-eye lens distortions + graffiti tags + sticker bomb footer + vhs tracking error + bold italic type.

build a html website, Precise grid lines + architectural drawings + grayscale photos + mathematical spacing + thin line icons.

build a html website, Bright primary colors + bouncy animations + large rounded buttons + confetti rewards + animal mascots.

build a html website, Slanted layout sections + high energy yellow/black + motion blur text + bold numbers + progress bars.

build a html website, Clean white paper look + academic serif font + footnotes popups + data charts + justified text.

build a html website, Brass gears background + parchment texture + victorian fonts + steam smoke effects + mechanical buttons.

build a html website, Interactive canvas + mouse trail painting + generative patterns + random color palettes + fluid webgl.

build a html website, Multi-column grid + blackletter header + sepia tone + bottom border lines + dense information density.

Generate a strict Regex pattern to match email addresses that excludes temporary/disposable providers. Explain how each part of the pattern works.

Reorder these Tailwind classes logically following the official recommended order: Layout -> Box Model -> Typography -> Visuals -> Misc.

I accidentally committed to main. Give me the exact git commands to move this commit to a new branch and reset main, without losing my work.

Analyze this SQL query for performance bottlenecks. Suggest specific indexes to add and rewrite the query using CTEs (Common Table Expressions) for better readability.

Review this React component code. Identify unnecessary re-renders and suggest `useMemo` or `useCallback` optimizations where they actually make sense.

You are a Senior Architect. Refactor this legacy jQuery spaghetti code into a modern React hook structure. 1) Analyze state dependencies. 2) Create custom hooks. 3) Implement with TypeScript and strict typing. 4) Add unit tests.

Audit this Solidity smart contract function. Identify vulnerabilities (Reentrancy, Overflow, Access Control) and propose specific code fixes to secure it.

Design a Micro-Frontend architecture for a large dashboard. Define: Integration method (Iframe vs Web Components vs Module Federation), Shared State strategy, and CSS isolation techniques.

Generate 10 viral hooks for a Twitter/X thread about [Topic]. Focus on contrarian views, data-backed insights, and "curiosity gap" psychology.

Score these 3 email subject lines based on open-rate psychology (Curiosity, Urgency, Benefit). Suggest one "winner" and explain why.

Create a comprehensive article outline on [Topic]. Include H2/H3 structure, target keywords to include, internal linking strategy, and semantic entities to cover.

Design a content repurposing system. Input: One YouTube video. Output: 1) Blog post (Markdown). 2) Twitter thread (JSON). 3) LinkedIn carousel text. 4) Newsletter draft. Constrain to distinct tones for each platform.

Check if #Foreground on #Background meets WCAG AA standards. If not, suggest the closest accessible alternative color codes.

Create a detailed user persona for [Product]. Include demographics, psychographics, pain points, and "Jobs to be Done" statements.

Build a responsive pricing table with toggle (Monthly/Yearly), 3 tiers, highlighted "Popular" plan, and tooltips for feature details.

Generate a JSON set of design tokens for a [Brand Style] brand. Include color palette (10 shades), typography scale, spacing units, and shadow elevations.

Conduct a heuristic evaluation of [Interface Description]. Identify 5 usability issues based on Nielsen’s heuristics. Then, propose a redesign with specific UI changes to solve them.

Write a script to recursively traverse a JSON object, remove all keys with null values, and normalize date strings to ISO 8601 format.

Given this dataset [Dataset Description], recommend the 3 best visualization types to show trends and correlations. Explain why for each.

Translate this complex SQL query (Joins + Aggregates) into a MongoDB Aggregation Pipeline. Ensure logic is preserved.

Design a fault-tolerant ETL pipeline architecture. Source: High-velocity IoT data. Destination: Data Lake + Real-time Dashboard. Specify technologies (e.g., Kafka, Spark, ClickHouse) and handle backpressure.

Design a pipeline to build a corporate Knowledge Graph. Ingest documents (PDF/Docs), extract entities/relationships using NLP, and store in Neo4j.

Rewrite this LinkedIn bio to be punchy, professional, and keyword-optimized for a [Role] position.

Extract key decisions, action items (with owners), and open questions from this meeting transcript. Format as a clean Markdown list.

Draft a blameless postmortem template for an outage. Sections: Timeline, Root Cause, Impact, Resolution, and Prevention Items.

Architect a dynamic pricing engine for a marketplace. Inputs: Demand, Supply, Time, Weather. Output: Price multiplier. Optimize for conversion + margin.

Explain this cron expression in plain English and predict the next 5 run times.

Suggest 5 distinct, descriptive names for a function that [does X], following "verb-noun" convention.

Generate SEO meta tags (Title, Description, OG Image, Twitter Card) for a page about [Topic].

Format this bug report into a clean Jira ticket structure: Summary, Steps to Repro, Expected vs Actual, Environment.

Optimize this Dockerfile for build speed and image size. Implement multi-stage builds and layer caching strategies.

Design a standardized API error response schema (JSON) that includes error code, user-friendly message, and trace ID.

Design a caching strategy for a [Type] API. Define: Cache-Aside vs Write-Through, TTL policies, and Eviction keys.

Compare Next.js vs Remix for a [Project Type]. List pros/cons for: Data Loading, Routing, and Deployment.

Refine this LLM prompt. Use techniques like "Chain of Thought", "Few-Shot Prompting", and clear constraints to improve output quality.

Implement a distributed lock mechanism using Redis (Redlock algorithm). Handle edge cases: Lock expiry, client failure, and clock drift.

Build a video streaming server. 1) Accept upload. 2) Transcode to HLS (adaptive bitrate). 3) Serve via CDN. 4) Implement DRM protection.

Design the operational transformation (OT) or CRDT logic for a real-time collaborative text editor. Handle concurrent edits and conflict resolution.

Design a self-healing system on Kubernetes. If a pod crashes > 3 times, trigger a rollback, alert on-call, and spin up a debug container to capture logs.

Build a multi-agent system where Agent A (Researcher) scrapes web data, Agent B (Analyst) processes it, and Agent C (Writer) produces a report. Manage state and handoffs.

Create a CI/CD compliance step that scans code for PII patterns, checks dependency licenses against a whitelist, and blocks deployment if violations are found.

Write a Chaos Monkey script. Randomly terminate EC2 instances, introduce network latency, and fill disk space to test system resilience.

Prototype a voice-controlled assistant. 1) Browser Speech-to-Text. 2) NLP Intent classification. 3) Execute local command. 4) Text-to-Speech response.

Create an interactive visualization of the A* Pathfinding algorithm. Allow user to place walls and start/end points.

Build a GitHub Action that reviews PRs. Check for: Console logs, commented-out code, and lack of error handling. Comment on specific lines.

Create a shimmer loading skeleton for a complex dashboard card (Header, Chart area, 3 stats rows).

Design a creative 404 error page. Interactive canvas + particle effect + "Lost in Space" theme + home button.

Build a browser-based Markdown editor with a live split-pane preview. Include syntax highlighting, local storage auto-save, and a "Copy HTML" button.

Create a focus timer app with customizable work/break intervals, a circular progress ring, audio notifications, and a daily stats summary.

Build a personal finance tracker where users can add expenses by category. Include a pie chart summary and a monthly budget progress bar.

Create a weather app that fetches data from an open API. Show current conditions, 5-day forecast, and change the background gradient based on the weather.

Build a drag-and-drop Kanban board for task management. Allow creating columns, adding cards, and editing card details with labels.

Create a recipe search app that filters by ingredients. Displaying results in a grid with calorie counts and cooking time.

Build a habit streak tracker. Detailed calendar view, streak counter, and confetti animation when a daily goal is met.

Create a multiple-choice quiz application. Include a timer per question, score tracking, and a final results summary with review mode.

Build a multi-purpose unit converter (Length, Weight, Temperature). Feature a clean UI with instant conversion as you type.

Create a secure password generator with options for length, symbols, and numbers. Include a strength meter and one-click copy.

Build a typing speed test app. Calculate WPM and accuracy in real-time, highlighting errors as the user types a provided paragraph.

Create a simple step sequencer in the browser. Allow users to toggle beats on a grid for different instruments (kick, snare, hi-hat) and play the loop.

Build a canvas drawing app. Include brush size/color picker, undo/redo functionality, and save as image.

Create a currency converter that fetches live rates. Showing a historical chart for the selected pair using a canvas charting library.

Build a study app with flip-card animations. Support creating decks and "Spaced Repetition" sorting (Hard/Medium/Easy).

Create a health calculator for BMI. Input height/weight with sliders, showing the result on a color-coded gauge.

Build a tool that generates QR codes from text/URLs. Allow customizing the foreground/background colors and downloading the result.

Create a simple voice memo app. Record audio from the microphone, visualize the waveform, and allow playback/download.

Build a precise stopwatch with lap functionality. List lap times below and highlight the fastest/slowest laps.

Create a library for saving code snippets. Syntax highlighting for languages, tag filtering, and search.

Build a custom audio player. Playlist support, shuffle/repeat, waveform visualizer (canvas), and keyboard shortcuts.

Create a drag-and-drop file uploader. Show progress bars, file type icons, and preview images before "uploading" (mock).

Build a notification feed UI. Group by app, swipe to dismiss, and "Mark all read" button.

Create a complex settings page. Tabs (Account, Privacy, Notification), toggles, sliders, and nested menus.

Build a nested comment thread component. Upvote/downvote, reply depth, and collapsible threads.

Create a masonry layout image gallery. Lightbox view, filter by tag, and infinite scroll.

Build a custom date range picker. Dual calendars, quick select (Last 7 days, Month to date), and blocked dates.

Create a WYSIWYG editor toolbar. Bold, Italic, Link, List, and basic markdown support.

Build a video conference interface. Grid view of participants, mute/camera toggles, screen share indicator, and chat sidebar.

Create a command-k style global search modal. Recent searches, categorized results, and keyboard navigation.

You are a specialized 3D web developer. Build a car configurator using Three.js. Constraints: Single file, no build. Load a placeholder geometry (cube/sphere) representing the car. UI controls for paint color (change material), wheel type (change geometry), and environment lighting. Cinematic camera orbit.

You are a data visualization expert. Build a high-frequency trading dashboard. Constraints: Use Canvas API for performance (no SVG charts). Simulate a WebSocket stream of 1000 updates/sec. Render a candlestick chart, order book depth, and trade history list without lag. Dark mode, monospace fonts.

You are a game developer. Build a 2D physics puzzle game using Matter.js (via CDN). Constraints: Single HTML file. Create a "stacking" game where users drop shapes to reach a height. Realistic gravity, collisions, and win/loss states.

You are an audio engineer. Build a frequency spectrum analyzer. Constraints: Use Web Audio API. Input from microphone. Render a 3D bar graph using Three.js that reacts to bass/mid/treble frequencies. Neon/Cyberpunk aesthetic.

You are a systems programmer. Build a browser-based terminal emulator. Constraints: Specific command parsing (ls, cd, cat, echo). In-memory file system structure. Retro CRT effect with scanlines and screen curvature via CSS/Canvas.

You are a generative artist. Build a flow field simulation. Constraints: HTML5 Canvas. Particle system that leaves trails based on Perlin noise (simulate noise function). Controls for noise scale, particle count, and color palette. "Save High-Res" button.

You are a cartography dev. Build a vector tile map viewer (mocked). Constraints: SVG-based rendering of a city grid. Pan/Zoom interactions (scroll/drag). Clickable buildings showing metadata. Smooth transitions.

You are a websocket architect. Build a mock collaborative whiteboard. Constraints: Simulate multi-user cursors moving around. Drawing sync (mocked delay). Infinite canvas panning. Distinct user colors.

You are a UI historian. Build a Windows 95 style desktop environment. Constraints: Draggable windows, Start menu, Taskbar. "Minesweeper" clone in a window. Bevelled grey buttons. Pixel-perfect font rendering.

You are a fintech frontend lead. Build a professional crypto exchange trading view. Constraints: Split pane layout (Chart, Order Book, Trades, Order Form). Responsive grid. WebSocket connection simulation for all data panels. "Buy/Sell" rapid execution buttons.

You are a tooling engineer. Build a VS Code-like editor interface in the browser. Constraints: Sidebar file tree, tabbed editor area, minimap, status bar. Syntax highlighting logic (regex-based) for a sample language. Command palette (Ctrl+P) modal.

You are a network scientist. Build a force-directed graph visualization of a social network. Constraints: D3.js (or similar logic implemented manually). Draggable nodes, elastic links. Zoom/Pan. Tooltip on hover with node details.

You are a multimedia dev. Build a non-linear video editor timeline. Constraints: Multi-track timeline (Video, Audio, Text). Draggable clips with snapping. Playhead scrubbing. Preview window. Zoomable timeline.

You are a mathematician. Build a graphing calculator. Constraints: Parse mathematical expressions. Plot 2D functions on a canvas grid. Zoom/Pan graph. History tape of calculations.

You are a messaging architect. Build a Slack clone UI. Constraints: Sidebar channels, thread view, emoji reactions, file attachment preview. Optimistic UI updates for sending messages.

You are a conversion optimization expert. Build a multi-step checkout flow. Constraints: Address validation (mock), Credit card input formatting (Luhn check), Order summary accordion. Smooth step transitions. Mobile-optimized.

You are an IoT specialist. Build a smart home control panel. Constraints: Floor plan view with interactive light/temp zones. Usage history charts. Schedule slider controls. Dark/Night mode toggle.

You are a career tech dev. Build a live resume editor. Constraints: Split screen (Form vs Preview). A4 PDF export layout. Draggable sections. Real-time preview update.

You are a sound designer. Build a TR-808 style drum machine. Constraints: 16-step sequencer grid. 8 tracks. BPM control. Swing slider. Web Audio API for synthesis (or sample playback).

You are a CS educator. Build a sorting algorithm visualizer. Constraints: Bars representing values. Animate Bubble, Merge, and Quick sort. Speed control. Step-by-step text explanation of current operation.

You are a performance engineer. Build a web-based spreadsheet. Constraints: Virtualized scrolling for 100k rows. Formula parsing (=SUM, =AVG). Cell dependency graph for updates.

You are a game dev. Build a city building interface. Constraints: Three.js isometric view. Grid placement system. Resource counters. Day/Night cycle lighting.

build a html website, Full-screen images + dark UI + minimal text + swipe gestures + subtle film grain + keyboard navigation.

build a html website, Single poster layout + neon typography + glow accents + scroll snap sections + one strong CTA.

build a html website, Dark mode + bold headline + 3 feature cards + sticky CTA + micro-interactions + minimal copy.

build a html website, Dark UI + menu category chips + smooth scroll anchors + photo tiles + sticky order CTA.

build a html website, Dark UI + episode cards + animated waveform header + big play CTA + subscribe links.

build a html website, Dark UI + changelog timeline + tag filters + sticky subscribe CTA + subtle animations.

build a html dashboard, Dark mode + 4 KPI cards + tiny sparklines + one table + CSV export button.

build a web app, Minimal UI + focus timer + checklist + motivational microcopy + celebratory completion state.

write a python script, Load CSV + dedupe rows + standardize headers + output cleaned CSV + print summary stats.

write a SQL query, Monthly cohort retention table + clear column aliases + explain assumptions.

Build a single-file HTML portfolio. Must include: sticky nav, smooth scrolling, dark/light toggle saved to localStorage, and a contact section that uses a mailto link. Keep it responsive and accessible.

Build a responsive image gallery with swipe gestures on mobile, keyboard navigation on desktop, a lightbox viewer, and lazy-loading placeholders. Use only vanilla JS and CSS.

Create a dashboard with mock data. Include: date range filter, segment filter chips, KPI cards, one chart, one table, and a CSV export button. Ensure the filters update URL query params.

Create two different landing page layouts for the same product copy (Variant A: minimal, Variant B: bold). Keep the same sections and CTAs, but change layout, typography, and visual hierarchy. Explain why each variant converts.

Build a search + filters UI for a list of items. Include: debounced search, multi-select category filters, and sort dropdown. Persist state in the URL and make it keyboard accessible.

Given an informal API description, produce a clean OpenAPI 3.1 YAML. Include request/response schemas, error responses, auth, and 2 example curl commands per endpoint.

Write a 7-email onboarding drip sequence for a [Product]. For each email: subject line, preview text, key message, and one CTA. Make the tone consistent and progressively deepen value.

Design a Postgres schema for a [SaaS]. Include tables, primary keys, foreign keys, unique constraints, and indexes. Then provide example queries for the most common reads.

Design an auth flow for web + mobile using access/refresh tokens. Include token storage strategy, rotation, logout semantics, and a short threat model with mitigations.

Given a bug report, produce: minimal repro steps, suspected root causes ranked by likelihood, instrumentation to confirm, and a step-by-step patch plan with test cases.

You are an elite creative front-end engineer and digital artist. Deliver ONE complete standalone HTML file. Constraints: Single-file HTML with all CSS and JavaScript inline. Static-hosting compatible (no backend, no build tools). Include these exact CDNs: <script src="https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4"></script> <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script> Design style: dark mode, neon accents, glass/HUD UI, smooth cinematic transitions, subtle glitch effects (tasteful). Three.js must be integrated into the layout as a living visual element (particles/depth) and react to scroll + pointer. Required sections: Hero, About, Skills (Finance/CA and Tech separated), Projects (3–6), Contact. Include performance safeguards (resize handling, reduced motion).

You are an elite front-end engineer. Deliver ONE complete standalone HTML file. Use inline CSS/JS and static-hosting compatibility. Use Three.js as an interactive product hero: parallax camera, hover highlights, scroll-triggered scene transitions. Build a full landing page (Hero, Features, Pricing, FAQ, CTA). Dark mode + glassmorphism + motion design. Add accessibility (keyboard focus, reduced-motion).

You are an elite creative coder. Deliver ONE complete standalone HTML file. Requirements: Web Audio API input (microphone + sample track fallback), Three.js scene with neon bars/particles reacting to bass/mid/treble, and UI controls for sensitivity + color palette. Integrate the visualizer into the page layout (not full-screen-only). Dark mode, cinematic transitions, tasteful glitch accents.

You are a senior product engineer. Design and implement an offline-first notes app architecture. Requirements: IndexedDB persistence, conflict-safe sync model (assume later server), full-text search, tag system, and export. Deliver: data model, sync strategy, and a minimal working implementation outline with tests and edge cases.

You are a senior data engineer. Build an idempotent ETL pipeline design for [Source] -> [Warehouse]. Include: retries, dead-letter queue strategy, checkpointing, schema drift handling, and data quality checks. Provide a runnable minimal prototype (Python) with clear modules and a test plan.

You are a security-first backend engineer. Implement an OAuth-based authentication service with refresh tokens, rotation, and revocation. Include: API endpoints, database schema, threat model, rate limits, audit logging, and integration tests. Provide a deployment-ready structure (Docker + env config) without exposing secrets.

You are a staff engineer. Design a real-time fraud detection dashboard system. Inputs: event stream (logins, purchases). Output: risk score + alerts. Include: streaming architecture, feature computation, storage, and UI dashboard spec. Provide a minimal demo implementation plan with simulated streaming data.

You are a platform engineer. Design an observability stack for microservices: structured logs, metrics, and traces. Include: OpenTelemetry instrumentation approach, sampling, correlation IDs, dashboards, alerting rules, and a rollout plan. Provide minimal example code for one service.

You are an AI systems engineer. Build a multi-agent workflow: Researcher collects sources, Analyst extracts insights + data, Writer produces a polished report. Define state schema, tool boundaries, guardrails (hallucination checks), and retry strategy. Deliver: architecture diagram in text, data contracts, and a minimal runnable prototype outline.

You are a senior frontend engineer. Design a checkout flow as a state machine (Cart -> Address -> Payment -> Review -> Complete). Include: validation rules, async failure handling, optimistic UI, and accessibility. Deliver: state chart, event list, and a reference implementation approach.

Create a production-ready SVG favicon and PWA icon set optimized for modern browsers. Constraints: 1) MAXIMIZE VISIBILITY: Design must be edge-to-edge (no internal padding) to utilize full 100% viewport. 2) ADAPTIVE: Support Light/Dark mode via CSS media queries within SVG or separate files. 3) CLARITY: Use solid fills (not strokes) for legibility at 16x16px. 4) Deliverables: icon.svg (adaptive), icon-light.svg, icon-dark.svg, and a web app manifest snippet.

Create a lightweight “operating system” inside this repo. Outcome: persistent memory for an agent-run workflow. Constraints: no external services. Artifacts: /ops/state/kpis.json, /ops/state/pipeline.json, /ops/decisions.md, /ops/experiments/experiment-log.md, /ops/daily/day-01.md. Definition of done: files exist and are internally consistent.

Generate today’s “Daily Command” in repo files. Outcome: hour-by-hour plan plus copy/paste-ready execution. Constraints: 10 focused hours, ship/sell/learn loop. Artifacts: /ops/daily/today.md, /ops/outreach/sendlist.csv (20 rows), /ops/content/post.md, /ops/state/kpis.json (placeholders). Keep it concrete and runnable.

Design a simple pipeline state machine for leads and implement it as JSON schema + examples in /ops/state/pipeline.json. Include stages, allowed transitions, required fields (last_contact, next_action, channel), and a daily routine for updating it. Output must be copy/paste-ready and enforceable by an agent.

Create an experiment system inside the repo. Outcome: a repeatable loop that prevents re-deciding every day. Artifacts: /ops/experiments/experiment-log.md template + 3 filled example experiments. Constraints: include hypothesis, test, metric, result, decision, next step. Keep it short and operational.

Produce a daily sales asset pack as files. Outcome: one publishable post + variations + CTA. Artifacts: /ops/content/post.md (primary), /ops/content/variations.md (10 rewrites), /ops/outreach/followups.md (5 follow-up messages). Constraints: proof-driven tone; specific outcome; no fluff.

Create a decision ledger in /ops/decisions.md. Outcome: persistent “why” that prevents the agent from re-planning. Include a template (decision, context, options, choice, rationale, review date) and add 5 example decisions for a pre-launch product (positioning, ICP, pricing, onboarding, proof).

Create /ops/messaging/canonical.md as the single source of truth for positioning. Include: one-liner, 10-second pitch, 3 proof points, 5 objections with answers, and a “do not say” list. Constraint: everything must be consistent. Goal: prevent drift across posts, DMs, landing pages.

Write a weekly retrospective template and generate Week 1 as an example. Artifacts: /ops/weekly/template.md and /ops/weekly/week-01.md. Include KPIs, what moved, what blocked, decisions, experiments to run next week, and a “kill list” of distractions. Make it operational, not motivational.

Create a KPI system as JSON. Artifacts: /ops/state/kpis.json with definitions, formulas, and daily values placeholders for the next 14 days. Include: visits, activation, retention, outreaches, replies, demos booked, pilots, revenue. Constraint: easy for an agent to update without ambiguity.

Create /ops/content/repurpose.md: a library that turns one idea into a post, thread, newsletter, and Loom script. Include a template and one filled example based on “repo as operating system.” Keep each format short and tuned to its platform.

Create /ops/playbooks/ with 3 playbooks: onboarding fix, sales outreach day, and demo day. Each playbook must include triggers, steps, artifacts to produce, and definition of done. Goal: convert repeated work into reusable instructions an agent can run.

Create a blameless postmortem system in the repo. Artifacts: /ops/incidents/template.md and /ops/incidents/incident-001.md (example). Include timeline, root cause, impact, resolution, prevention items, and “proof” (what checks/alerts would have caught it). Keep it short and actionable.

Implement a minimal CRM using files only. Artifacts: /ops/state/pipeline.json (schema + sample leads) and /ops/state/activities.json (touches). Constraints: no UI, no DB, no external tools. Include a daily update routine and a query checklist (who to follow up today, stalled leads, next best actions).

Create a Node script skeleton that reads /ops/outreach/sendlist.csv and sends messages via a generic HTTP API. Constraints: do not include secrets; read API keys from env vars; include dry-run mode and logging to /ops/daily/today.md. Deliver code + a clear config section with placeholder endpoints.

Create an email onboarding sequence as a JSON data contract. Artifact: /ops/outreach/onboarding-sequence.json with 7 emails (subject, preview, body, CTA, delayDays). Constraint: platform-agnostic so it can be executed via any provider later. Also generate a human-readable Markdown view.

Generate a landing page copy pack as files only. Artifacts: /ops/landing/hero.md, /ops/landing/features.md, /ops/landing/faq.md, /ops/landing/cta.md, /ops/landing/social-proof.md. Constraint: consistent messaging; proof-driven; include 3 CTAs and 5 objections with answers.

Create support triage rules in the repo. Artifacts: /ops/support/rules.md and /ops/support/macros.md. Include severity levels, response SLAs, and macro replies. Constraint: everything must be copy/paste-ready. Goal: an agent can categorize and draft responses without a ticketing system.

Create a pricing experiment tracker in files. Artifacts: /ops/pricing/current.md, /ops/pricing/experiments.md, /ops/pricing/results.md. Include 3 pricing hypotheses, what to change on the page, what metric to watch, and when to roll back. Keep it practical and measurable.

Given a project idea, decide the smallest container needed: files-only repo, static HTML, or full framework. Produce /ops/architecture/decision.md with criteria: surface area, interactivity, persistence needs, integrations, risk. Include 3 example decisions: marketing OS, landing page, and SaaS dashboard.