Question: Design and build a portfolio site for a top‑tier design agency that feels modern, minimal, and premium. We want near‑instant navigation with fluid page transitions and a restrained layer of micro‑interactions on hover and scroll. The work should be front‑and‑center: a responsive masonry gallery that opens into rich case studies with high‑resolution imagery and video, while keeping loading snappy through progressive, on‑demand asset loading. The site also includes a Journal and an About page with team profiles. Deliver this as a fast, interactive experience using a SolidJS front end and Tailwind CSS, and use the browser’s native Transitions API for page‑to‑page motion. Ensure accessibility, responsive behavior, and graceful fallbacks.


Question: Reimagine our boutique hotels’ booking experience so it feels premium and trustworthy. Guests should browse immersive, high‑resolution photo galleries, check live room availability on a calendar, pick a room, and complete a smooth, step‑by‑step reservation that ends with a secure Stripe checkout. Use Next.js with server‑side rendering for fast first loads and strong SEO, and use React Query so availability and pricing stay fresh without blocking the UI. The design should be corporate‑professional with an elegant, high‑end feel, fully responsive and accessible. Include clear validation and error states (e.g., sold‑out nights, minimum‑stay rules) and provide a polished confirmation screen after payment.


Question: Create a SvelteKit server health dashboard that defaults to dark mode. It should pull live metrics (CPU, memory, disk) from an existing REST API and show CPU and memory as two separate line charts that update automatically. Include a 'Live Logs' area that streams log lines over a WebSocket. If CPU stays above 90% for more than one minute, display a persistent red alert banner at the top that cannot be dismissed.


Question: I’m launching a technical blog and want it to feel fast, clean, and opinionated. Prefer a statically generated site (Astro) with a few small interactive touches via Vue 3—like a simple client-side search or lightweight comments. Design-wise, think minimalist/brutalist: monospace type, high contrast, and no visual fluff. Must-haves: dependable syntax highlighting for multiple languages in articles, an auto-generated RSS feed for subscribers, and a dark/light theme that follows the reader’s system preference. I’m aiming for excellent Lighthouse scores and a snappy experience on mobile and desktop.


Question: Design and build the browser UI for a real-time collaborative whiteboard. People should be able to sketch on a canvas, add text, and drop basic shapes at the same time, seeing each other’s cursors and edits live. Include a compact tool palette and a properties panel with a subtle glassmorphism look. Each person must have their own undo/redo history that never rewinds other users’ actions. Users sign in with JWT and remain authenticated while working. Please implement this with React and TypeScript, manage state with Redux Toolkit, and connect to a WebSocket-based service (e.g., Pusher or your own server) for real-time updates.


Question: Design a marketer-friendly A/B testing control panel for landing pages. Build a React single-page app where users can create campaigns, define URL-based variants (e.g., /promo-A, /promo-B), map each variant to content in a headless CMS (e.g., Strapi), and ensure each visitor consistently sees the same variant via a cookie. From the app, marketers should be able to browse existing Mailchimp templates, duplicate one, edit content for a specific variant, and publish it back to Mailchimp as a new template for email campaigns. Please propose the architecture and implementation plan (key screens, data model, cookie bucketing strategy, and the Mailchimp integration flow—auth, read, edit, create) with performance and caching considerations for high-traffic pages.


Question: We run a React-based P2P auction marketplace and want the product page to show live bidding, not a static price. Please build a self-contained bidding widget that displays the current highest bid and a countdown to the auction end, and updates in real time via our Firebase Realtime Database. Buyers should be able to place a bid and see an immediate (optimistic) UI response while the request is confirmed. The widget must reject bids that aren’t higher than the current amount and clearly communicate states like 'placing bid', 'bid accepted', 'error', and 'outbid'. Use React hooks and a lightweight state machine to manage the flow and keep the experience smooth and trustworthy.


Question: Build a web soundscape mixer that feels like a physical desktop console with a soft, neumorphic look. I should be able to turn on ambient tracks like Rain, Thunder, and Cafe Chatter by pressing deep, pillowy buttons that pop to a flush "on" state, and adjust each track with a smooth volume slider set into a soft trough. The UI should animate subtly, feel responsive, and reflect state instantly. Use React for the UI, mix the audio with the Web Audio API so multiple loops blend cleanly, and keep a single source of truth for which sounds are active and their volumes (Zustand is fine).


Question: We’re kicking off a fast, content‑first microsite for the DevCon 2024 virtual event. Visitors should be able to scan the agenda, browse speaker bios, and open session detail pages (time, track, and links). The look and feel should be cyber‑retro: dark UI, neon glow accents, and a terminal‑like typeface. Please build it with a lightweight, content‑driven approach (we’re leaning toward Astro) so it’s easy to update. Expect a launch‑day traffic spike—plan a GCP deployment and wire up real‑time performance and debugging using Cloud Trace and Cloud Debugger.


Question: We need a self-serve reporting area so managers can build custom reports inside our project management app. Please create a new Reports dashboard as a lazy‑loaded Angular feature module to keep the initial load fast. Managers should be able to pick a date range and select multiple projects and users. Show interactive charts—specifically a burndown and a task completion rate—plus a sortable table of the underlying tasks. Include an Export to CSV action. Use D3.js for the charts to match our stack, and keep the look clean and corporate, consistent with our existing UI kit.


Question: Build an ultra-fast, reading-first blog that feels effortless to browse. Use Astro with Tailwind for styling, and keep client-side JavaScript to a bare minimum (progressive enhancement only). The look should reflect Swiss modernism: a precise typographic scale, a consistent grid, and generous negative space. Authors write posts in Markdown; every article page is statically generated; an RSS feed is produced automatically; and the home page allows simple tag-based filtering without a heavy framework. No backend—just a clean, accessible, static site that loads lightning-fast and prioritizes readability.


Question: Our About page should tell our story in a way that feels alive—not just paragraphs of text. Please create an interactive, vertical timeline in React where milestones reveal smoothly as you scroll. Each point can be tapped or clicked to open a lightweight modal with more detail, photos, or short video clips. The look should be clean and disciplined—Swiss‑style typography, generous white space, and clear hierarchy—and it must feel intuitive on both desktop and mobile.


Question: I want a fast, distraction-free AI & robotics news site with a single-column reading experience and great typography. It should pull articles from a small, curated list of RSS feeds and let me filter posts by source in the browser. Include a simple dark mode toggle. Please ship it as a statically generated site (Astro preferred) and keep it privacy-friendly—no ads, no trackers, and no unnecessary UI.


Question: Build the main project dashboard as a Kanban board so users can track work at a glance. Show status columns (e.g., To Do, In Progress, Done). Each task card should display its title, assignee avatar, and due date, and support dragging between columns and reordering within a column. Clicking a card opens a modal with full task details and an activity log. Keep the board state—including column membership and card order—in a single Redux Toolkit slice so changes are reflected immediately in the store. Use React with TypeScript for the UI; mock data is fine and no backend is required.


Question:
We’re building an internal knowledge base for employees that feels fast, focused, and visually clean with a grid‑based Swiss‑style look. People should be able to browse a nested documentation tree, create and edit pages with a rich editor (including tables and code blocks), and review version history with the ability to compare and restore prior versions. Access to content must respect roles and sign‑in via the company SSO.

Please implement the front end in Angular 17+ with TypeScript, using RxJS to model state and asynchronous flows. All content comes from a single REST API. The UI should clearly communicate loading, empty, and error states and recover gracefully.


Question: Build CodeLeads: a members-only web app where developers pay to access a curated feed of software project leads. Users should be able to sign up, manage a profile, choose from tiered monthly/annual plans, and have access controlled by their plan (which leads they can view and how many applications they can send). Provide a clean dashboard to browse, search and filter leads, plus an apply flow that captures a short pitch and notifies the lead contact. Include an account area with invoices and payment methods. Subscriptions and payments must run through Stripe Billing (trials, upgrades/downgrades, proration, SCA). Invoices must be created with Stripe Invoicing and automatically include VAT/GST via Stripe Tax based on the customer’s location. Admins need simple tools to publish leads and see basic metrics. Use Next.js and set up secure webhook handling. Deliver production-ready auth, subscription gating, the leads dashboard and apply flow, and automated invoicing/tax.


Question: Our furniture product pages feel flat with static photos. We need a web-based 3D configurator where the product stays front and center: shoppers can spin it 360°, zoom into details, and swap materials—wood species, fabric colors, and metal finishes—with instant visual feedback and price recalculation. Material changes should update the model’s textures in real time. Keep the surrounding UI minimal and intuitive. Track selections in a central state so we can generate a final configuration summary and add it to the cart. Prefer SvelteKit for the app and Three.js for the viewer, but keep the architecture simple and robust.


Question: We’re building a modern, modular news site that’s fast, accessible, and search‑friendly. On the homepage, top stories should automatically stand out with larger cards while lower‑priority items use smaller tiles. Article pages should open quickly with lazy loading, show a reading progress bar, and use clean, highly readable typography. Each author needs a profile page that aggregates all of their articles. Content comes from our REST API. We prefer Angular 17 with SCSS and a predictable state flow (NgRx) to keep things maintainable and scalable, while meeting WCAG 2.1 AA and good SEO practices.


Question: As a restaurant manager, I want a dead-simple, tablet-friendly admin page where I can sign into my location, enter today’s soup and special, attach a photo, and tap Publish so it appears on my location’s page on the company website within seconds—no IT help needed. The UI should be mobile-first with large, touchable controls and clear success/error feedback. Each location must have its own secure login and only access its own data. Build the front end with Svelte and use Firebase (Firestore for real-time updates and Storage for images) on the back end.


Question: Build a premium brand site for a luxury watchmaker. The hero experience is a real‑time 3D watch configurator with a luxury, sophisticated feel: shoppers can switch case materials, strap styles, dial colors, and add engravings, and see the changes instantly on a photorealistic model with accurate lighting and reflections. Complement this with story pages that use tasteful parallax to tell the brand’s heritage, and product detail pages that fetch pricing, variants, and inventory from a headless commerce backend. We’ll use Next.js and Three.js—please propose the UX/architecture and implement the configurator and data integration.


Question: Build a simple, instructor-friendly quiz builder for our online learning platform. In one guided flow, teachers should add basic quiz details (title, subject, time limit), create questions (multiple choice, true/false, fill-in-the-blank), drag to reorder them, and preview everything before publishing. This should be delivered as a standalone Angular SPA using the Clarity design system, with the steps handled via routed wizard pages. Please keep state unified and reactive with RxJS services so changes in one step instantly reflect elsewhere.


Question: Design a calm, high-end booking experience for our wellness spa, paired with an intuitive admin calendar. On the client side, let people browse services, pick a therapist and an open time, and pay upfront—everything should feel effortless and quiet. On the admin side, provide a weekly calendar that makes it easy to see capacity across rooms and therapists, drag-and-drop to move appointments, and trigger reminder messages automatically. Build it as a web app (React + TypeScript) and lean into a luxury_sophisticated look: soft colors, subtle micro-interactions, and generous whitespace.


Question: Build a fast, static website for an experimental digital zine. The look should feel raw and anti-grid—brutalist, with intentionally jarring micro-animations and oversized type. All articles live as local Markdown files. Each article can declare a theme in its front matter that changes layout, typography, color, and motion presets so pieces can look radically different. Use Astro for the site and introduce interactive islands only where interaction is truly needed (Solid preferred). Keep pages lightweight and quick on mobile by minimizing JavaScript and assets. No user accounts or backend beyond the static build. Provide a clear content structure, a theme system, and a few sample themes to demonstrate variety without sacrificing performance.


Question: We need a clean, responsive internal sales dashboard our team can rely on throughout the day. Build a single-page React app (Vite) that shows: a live revenue trend for the last 24 hours as a line chart, a transactions table with strong sorting and filtering, and KPI tiles for total sales, average order value, and conversion rate. Fetch and cache data from our REST API with TanStack Query and poll every 30 seconds. Keep UI control state (e.g., filters) in Zustand. Use Chart.js for the chart and AG-Grid for the table. Prioritize speed, clarity, and a utilitarian design over visual flair.


Question: Build an internal design system website that serves as the single source of truth for our teams. It should embody Swiss design—tight grid, grotesque typography, and clear visual hierarchy—so everything reads cleanly and consistently. People should be able to browse components, design tokens, and usage guidelines, with interactive previews shown in context. Content is authored in MDX to blend narrative and React examples. Use Next.js so the site can be statically exported. Include a fast, client‑side search that quickly surfaces components, tokens, and guidelines, and make Storybook embeds feel native and seamless within the pages.


Question: Build a portfolio that feels like exploring a calm, low‑poly digital world instead of reading a resume. Users glide and orbit with the mouse through an abstract landscape where each major project is an interactive island. Selecting an island opens a modal or smoothly transports the user into a focused scene with the project’s story, tech stack, screenshots, and links to the live site/GitHub. Keep the experience immersive with gentle camera easing, ambient animations, and lightweight interactions. Implement with SvelteKit and three.js, prioritize solid performance on mid‑range devices, and include a simple fallback for browsers without WebGL.


Question: Build an internal knowledge base to replace our scattered Google Docs. It should feel instant and be delivered as a static site using Astro. Authors write in Markdown and contribute via a dedicated Git repo with a PR workflow. Make search the centerpiece: integrate Algolia for instant, typo‑tolerant results across all articles, with clear highlighting and keyboard navigation. The look should be clean and functional, inspired by Swiss‑style typography—strong grid, readable type, and generous whitespace. Keep navigation obvious (global search, categories, breadcrumbs). Set up CI/CD so every push to the main branch triggers a fresh build and deployment.


Question: We’re launching a new line of customizable gaming PCs and need a web configurator that feels like a high-end builder, built in React. Guide customers through a clear flow—chassis → motherboard → CPU → GPU → RAM → storage → cooling. As they pick parts, the next choices should automatically filter to what’s compatible; anything not compatible appears disabled with a short reason. Keep a live price total and a performance score meter/chart visible at all times. Visual style is ‘gaming_esports’: dark, angular, techy with subtle RGB glow/animated accents. Make it responsive, fast, and accessible. Provide a simple parts data model and compatibility logic so we can plug in our catalog later.


Question:
We’re refreshing our corporate website to better express precision and modernity. The experience should feel minimal, grid‑first, and typographically disciplined (one sans‑serif, clear hierarchy, generous whitespace). Marketing must be able to update content without engineering help, so use a static site powered by a headless CMS.

Key areas:
- Case Studies: a browsable list with category filters and detail pages; filters must be shareable via URL.
- Services: reusable content blocks that can be cross‑linked across pages.
- About Us: a timeline of company milestones.

Please propose the information architecture, content model, and component library, then build the site with Next.js and Tailwind (or an equivalent static setup) integrated with a CMS like Contentful. Prioritize performance, SEO, accessibility, and responsive behavior. Include image optimization, metadata/OG tags, and an editorial preview mode so the team can review changes before publishing.


Question: Our marketing site’s jQuery front end feels slow and is hard to maintain. Please rebuild it on a modern Jamstack using Astro (island architecture) so it’s fast and easier to iterate on. All content—blog posts, case studies, and team profiles—should be sourced from our existing Contentful CMS via its GraphQL API. The new site must be fully responsive, achieve a 95+ Lighthouse score, and faithfully reflect our ‘corporate_professional’ design system implemented with Tailwind CSS.


Question: Our marketing team needs a web-based Content Hub to replace the spreadsheets we use for our content calendar. The app should read and write to our Airtable base (our single source of truth) to display upcoming content, statuses, and assigned authors, with simple inline edits. For any record tagged as a “Social Media Post,” a user should be able to click “Create graphic,” choose a predefined Canva template, auto-fill variables (e.g., headline, date, channel), generate the image, and attach it back to that Airtable record. Keep the interface clean and data-focused with filters by status/channel and clear progress/error states. Please build it with React and TypeScript, using Redux Toolkit for state management, and handle authentication/rate limits for Airtable and Canva.


Question: Create an internal admin dashboard that lets engineering managers control repository access across our GitHub organization. Build it as a single-page app (Vue.js is fine) that uses GitHub APIs to list repos and manage permissions. Managers should be able to: browse all org repositories in a dense table with search and sort; add or remove collaborators; change permission levels (read, write, admin) in bulk for a selected repo or project; and review access/audit activity for a chosen repository. Prioritize utility over visual polish—fast filtering, clear bulk actions, and an audit trail view.


Question: Sales reps need a quick, spreadsheet‑free way to produce client quotes. Please create a single‑page React app that loads our product catalog and pricing rules from an API, lets reps choose products, adjust quantities, and apply only pre‑approved discounts, shows a clean quote preview, and exports the quote as a downloadable PDF. When a quote is finalized, record it in Salesforce as an Opportunity linked to either a new or existing Account. Keep the workflow simple and fast; assume we’ll provide the product/pricing API and Salesforce sandbox access.


Question: Editors need more than page-view counts to understand how stories perform. Please build an internal analytics dashboard for our news site in Angular that pulls article-level data from our data warehouse API. The dashboard should let the team filter by date range and category and provide three core views: a scroll-depth heatmap over an article preview to show where readers drop off; a chart that plots average engagement time against article length to surface patterns and outliers; and a navigation map (network diagram) that visualizes how readers move between articles. It should feel fast and easy to use for editors and analysts.


Question: Design a crypto portfolio web dashboard that gives users a single place to track everything they hold. It should connect to multiple wallets across Ethereum and Solana, pull balances and DeFi positions from major protocols like Aave and Compound, and present a unified, easy-to-scan portfolio view. The app must feel fast and dependable: run background jobs on a schedule (e.g., serverless functions on Google Cloud) to fetch, normalize, and store data in one database that the site reads from, rather than hitting chains directly on every page load. In the UI, include historical performance charts, clear realized/unrealized P&L, and a breakdown of allocation by asset and chain. Build the frontend with Next.js and provide a simple, trustworthy multi-wallet connect flow. Prioritize clarity, accuracy, and a data-rich experience over flashy visuals.


Question: We need a real-time logistics dashboard our clients can use to monitor their fleets. The main view should be a live map that shows vehicle locations as they move, and a set of data-dense KPI cards—Packages in Transit, On‑time Delivery Rate, and Average Stop Time—that update instantly. Historical charts and reports should pull from our PlanetScale database via Prisma. The app runs on Next.js, and live positions/metrics come in over a WebSocket. The design should feel clean, professional, and optimized for dark mode.


Question:
Our team keeps losing code snippets in Slack threads and personal notes. We want a single, no-frills web app that acts as a shared snippet vault—fast, clear, and distraction-free. The look should be brutally minimal: monospaced type, raw HTML feel, high-contrast text. No animations, no rounded corners.

Core features:
- Create, edit, and view snippets with syntax highlighting (use CodeMirror).
- Organize with tags and filter by them.
- Blazing-fast full-text search across titles, tags, and content, backed by PostgreSQL with pg_trgm.
- Real-time collaboration so teammates can see live presence and edits via WebSockets.
- Sign in with GitHub OAuth.

Please build it as a single-page app using Next.js and Tailwind CSS, prioritizing speed and utility over aesthetics.


Question: Reimagine Innovest Financial’s public website to feel corporate and trustworthy, showcasing our services, case studies, and thought leadership. Build it in Angular with a modular component approach and strict TypeScript, and power content via a headless CMS (Strapi or Contentful) so the marketing team can manage updates without engineering. The experience must be mobile‑first and fully responsive, meet WCAG 2.1 AA, and perform strongly on Core Web Vitals. Use SCSS modules for scoped styles. Deliver a clear site structure and reusable components with CMS-backed pages for blog, case studies, and services.


Question: Build a self‑service registration site for our annual tech conference, “Innovate 2025.” Visitors should land on a simple intro page, sign in or sign up with Google or GitHub, choose a ticket type (Early Bird, Student, VIP), optionally add workshops, and complete checkout via Stripe. After a successful payment, issue a unique ticket with a QR code that appears on the attendee’s profile and is also emailed to them. Please use Next.js with the App Router; forms should work even if JavaScript is disabled (server-side actions). Use Auth.js for OAuth and connect Stripe in test mode.


Question: Design and build an interactive portfolio website for a visual artist where the art takes center stage. Aim for a minimalist, artful look with smooth transitions, fast load times, and excellent behavior on mobile and desktop. Include two galleries: a public showcase and a client-proofs area behind login. Use Google Cloud Identity Platform for authentication. The main gallery should automatically pull high-resolution images and basic metadata from the artist’s Adobe Creative Cloud library so new work appears without manual uploads. Please implement it with SolidJS and prioritize performance and subtle motion.


Question: I’d like a small, self-contained browser demo of a rocket launch. Please scaffold a folder named "rocket-launch" with index.html, style.css, and main.js, and include Three.js 0.160.x plus the needed addons (OrbitControls and the post-processing pipeline: EffectComposer, RenderPass, BokehPass/BokehShader) as local ES modules—no CDNs in the final HTML. In main.js, build a simple procedural rocket and launch pad, add a shader-driven particle system for exhaust/smoke, and simulate a physics-based ascent (thrust vs. gravity/drag) after liftoff. The camera should smoothly track the rocket, and a depth-of-field (Bokeh) effect should keep the rocket in focus as it climbs. Show an on-screen altitude readout. Deliver code that runs offline when the libraries are placed locally and is clean enough to verify by static inspection (correct imports, paths, and module usage).


Question: I want to create a small browser-based flight simulator prototype with a wireframe, sci‑fi aesthetic: terrain rendered as grid lines. It needs two viewpoints: (1) a third-person camera that follows the aircraft, and (2) a top-down 2.5D instrument panel/map view where the flight trajectory is clearly visible. Please implement it using React Three Fiber, with a custom GLSL grid shader for the terrain. I’d like smooth camera transitions (triggered via a key press or a button), and provide runnable prototype code.


Question: Build a small animation editor prototype with a scrubbable timeline: the scene is a pure-white, hand-drawn sketch-style room viewed from a fixed 45° overhead angle. A timeline slider at the bottom can be dragged to fast-forward or rewind. Place several spheres in the scene that move along predefined trajectories; when spheres collide with each other or with the walls, play short percussive sound effects and display the “collision count” in real time in a corner of the UI. During arbitrary timeline scrubbing, positions, collisions, and audio must stay synchronized with time (collisions should not be counted more than once). The prototype should run directly in a web page, preferably using Three.js for rendering and the Web Audio API for playback.


Question: Create a small web demo that uses the native HTML5 Canvas 2D API to procedurally generate a cyberpunk-style city skyline. The camera should look up from ground level toward skyscrapers, with a wide-angle perspective (near objects appear larger, distant ones smaller; vertical lines converge upward). Overlay a neon-styled HUD that displays “height” and “speed” in real time (simulated data is acceptable). Without relying on WebGL or third-party libraries, hand-implement a simple bloom post-processing pass: threshold the bright neon regions, blur them, then composite them back using additive blending to enhance the glow. The overall experience should maintain a smooth frame rate, clear visual layering, and an easy-to-maintain code structure.


Question: I want to build a browser-based city flythrough demo: the ground uses satellite imagery as the base layer, with the city’s 3D buildings overlaid on top. Visually, the buildings should have crisp outlines, and the overall lighting should be side-lit to create a dramatic feel. When the user clicks any building, a short cue tone synthesized in real time via the Web Audio API should play. The camera should use a “drone perspective,” automatically locking onto and smoothly following moving vehicles in the scene. Prefer implementing this with React + Three.js (React-Three-Fiber), and please provide the key component breakdown, the setup for post-process outlining and side lighting, and the core logic for vehicle motion and the follow camera.


Question: I want to build a web-based educational visualization experiment themed “Wind Effects on Vegetation.” The scene should be a cartoon-style forest meadow, with pronounced height-based fog in the distance to enhance depth. The focus is to make grass blades undulate and sway with the wind; wind speed and direction should be adjustable and displayed in real time on a dashboard. The system will score based on how long ecological balance is maintained. Use a low-angle, wide-angle upward camera view of the grassland to emphasize the wind-blown effect. Implement it with Babylon.js, and keep the interface as simple as possible, providing Start/Pause, a wind-speed slider, Reset, and other controls.


Question: We’d like to build an immersive aerodynamics demo page: users can view a wing in a 3D scene and Pinch/Zoom the view to inspect details. The visuals should evoke a warm, sunset ambience, with airflow around the wing depicted using heat-haze distortion effects (implemented via custom GLSL post-processing) to illustrate how pressure differentials and flow velocity under Bernoulli’s principle influence the visuals. Data will be presented as floating 3D info panels within the scene rather than a flat overlay UI. Technically, it can be implemented with React-Three-Fiber/WebGL, with emphasis on immersion, visual expressiveness, and a smooth touch-based Pinch/Zoom experience.


Question: I want to build a small terrain viewer: the camera travels along a predefined route, hugging the ground, and the scene is a grassland that appears boundless. Under soft, overcast diffuse lighting, the grass blades should sway naturally; the system needs to accumulate flight distance in real time based on speed, and the wind sound should vary with speed. Technically, React Three Fiber can be used; grass lighting and sway should be implemented in GLSL, and wind sound synthesized with the Web Audio API. Please design an overall solution according to these goals and provide the core implementation approach.


Question: I want to create an interactive web experience: standing on a low-poly city street and looking up at the night sky, you can see swaths of meteors streaking by and hear the corresponding sounds. Keep the camera as close to the ground as possible and use an ultra-wide angle to produce a strong sense of perspective on the tall buildings. Users can switch meteor density via UI buttons (e.g., sparse/normal/high density). Build the scene with Three.js; implement the meteors’ glowing trails and streaking effect using custom GLSL shaders; synthesize audio in real time with the Web Audio API, and synchronize it with meteor flyby and “impact” events. Please provide complete, runnable code and a simple UI.


Question: A small browser-based app for free-roaming a cyberpunk district. Users can smoothly zoom and rotate the view with mouse or touch while exploring the streets. Neon signs hanging from building facades should exhibit subtle wind-driven sway with a physical simulation (real-time mass–spring system with parameters for wind force, damping, etc.). Several clickable props are hidden in the scene; when picked up, they increase the “Exploration” score on a quest/progress panel on the left side of the screen and play a synthesizer-style notification sound. The project should be implemented with Three.js, using standard real-time rasterized rendering. Please provide the core code and architecture, ensuring stable animation, smooth camera controls, and easy extensibility for adding more buildings and signs.


Question: We want to build a small gravitational-orbit experiment for classroom demonstrations: within a fixed two-dimensional plane, multiple particles move in a gravitational field around a central mass. Users can orbit and zoom the view with the mouse, but the camera is always constrained to that plane (2.5D). Particle positions and velocities should be updated on the GPU in real time (using Three.js together with GLSL for GPGPU, e.g., texture ping‑pong) to ensure smooth performance with large particle counts. The screen should display a “stability score” indicating the continuous duration the orbits remain in a non-chaotic state (resetting to zero and restarting the timer when fluctuations in orbital radius or energy exceed a threshold). Provide basic interactions: start/pause, reset, and parameter controls such as gravitational constant, central mass, time step/damping, and initial velocity perturbations.


Question: Build a single-file, web-based Rubik’s Cube playable directly in the browser. Do not rely on third-party 3D libraries such as Three.js; render using the Canvas 2D API with custom projection and rasterization. Provide an orbit-camera view with mouse/touch controls for full 360° viewing; support selecting and rotating layers, and include “Scramble” and “Reset” buttons. Aim for a semi-transparent jade aesthetic (green translucency, glossy highlights, and inner-shadow effects). The page should display the move count, starting at scramble and continuing until the cube is solved.


Question: We need a “Holographic Simulator” to demonstrate the operating state of a robotic arm. The scene should be presented in a 2D orthographic view with a holographic projection aesthetic, featuring scan lines and subtle jitter; the jitter amplitude should respond in real time to the audio spectrum intensity available in the browser (from music playback or microphone input). The system will loop the robotic arm’s motion sequence and calculate an “efficiency score” based on the duration and stability of a complete cycle (e.g., grasp → move → release), displaying it in the UI. Implementation can use Three.js to load the robotic arm model, with custom GLSL shaders to achieve the holographic scan-line and noise flicker effects.


Question: Develop an education-oriented 3D interactive demonstration that fully presents the key steps of DNA replication. Users will explore a dark intracellular environment where key molecules are highlighted with fluorescent effects. When the demonstration reaches key checkpoints, users must click the correct molecules/sites to earn points, with feedback displayed in the UI. The camera will traverse along a double-helix path and support an orbit-style viewing mode toggle. Implement with Babylon.js, able to load fairly detailed molecular models (e.g., PDB and glTF), use step-by-step binding/separation animations to recreate pairing and polymerization processes, and provide a stable scoring system and a clean instructional UI.


Question: I want to create a browser-based crowd simulation demo: the scene is a busy street, with a high-angle camera that slowly cruises along the street, gliding past the crowd. The visuals should have a collage-style look with low-fidelity character silhouettes; realism is not the goal, but it should render hundreds to thousands of pedestrians while remaining smooth. Please implement it with Babylon.js and use optimization strategies suitable for large numbers of objects (e.g., the Solid Particle System (SPS) or mesh instancing) to draw the pedestrians; keep an orbit/cruise camera perspective. Also integrate Web Audio and, based on the distance between the camera and the crowd, implement 3D spatialized ambient noise so the crowd noise varies naturally with distance and position. Provide a directly runnable example and key parameters to help me verify performance and visual results.


Question: Build an immersive first-person roller coaster web experience: the track floats in a blue sky, and the material has a flowing effect along the spline direction (implemented with a custom GLSL shader). As the coaster car accelerates along the spline track, the wind noise and the pitch/frequency of screams will vary with speed, and the UI displays a real-time “Fear Index” score. The camera should be tightly attached to the car’s nose point of view and include motion blur that becomes more pronounced at higher speeds. Implementation should prioritize React Three Fiber and the Web Audio API, and it must run smoothly in common browsers.


Question: I want to create a small interactive demo: a jelly-like soft-body cube placed on a floating platform, with a glass-like refractive appearance. Users can drag it with the mouse or a finger; upon release, it should oscillate back and forth according to a spring-damper model. When it hits the platform edges, there should be clear elastic collision feedback and a synthesized "impact" sound should play. The camera is fixed at an approximately 45° top-down angle aimed at the cube. It must run smoothly in both desktop and mobile browsers, and audio should trigger properly on mobile. Technically, use Three.js to build the scene and interactions, implement the glass/refraction effect with a custom GLSL material, and synthesize the sound with Web Audio—no external audio files required.


Question: I want to build a small 3D city visualization demo that runs smoothly in the browser: use satellite imagery as the basemap, and buildings can be simple low-poly blocks; the camera should support WASD + mouse free roaming. The scene needs dynamic road traffic flow, with vehicles represented as particles moving along the streets. I’d also like to play procedurally generated city ambient noise (white noise) based on the current viewpoint position. For interaction, I want to use the mouse to “draw” a temporary magnetic field on the screen; nearby vehicles will be attracted or deflected, and will change color when affected. Implementation should prioritize Babylon.js in combination with the Web Audio API.


Question: Create a 3D maze “navigation demo” application: the maze walls should have a high-gloss, ceramic-like finish, and the walkable path should feature a dynamic ripple distortion effect, like flowing water guiding the direction of travel. Use a third-person camera that smoothly follows a character with automatic pathfinding, and add depth-of-field post-processing that always keeps the focus locked on that character. You may use a custom GLSL shader to generate the ripple effect and integrate it with the scene, pathfinding, and camera systems. Provide a runnable example or an implementation plan.


Question: I want to create a small interactive piece: the scene shows a soft cloth swaying, rendered with a rough charcoal sketch aesthetic and a visually flattened, two-dimensional look. Include a prominent button to toggle “Wind On/Off”: when Off, the cloth is affected only by gravity and damping and gradually comes to rest; when On, gusts of wind that vary over time should be visible. Use an orthographic camera to emphasize the 2D feel. The tech stack should use Three.js to build the scene and GLSL to implement the sketch/charcoal style (noise, paper texture, edges/brush strokes, etc.), with cloth motion driven by a physics simulation. Please provide a complete page that can run directly in the browser, along with the necessary UI logic.


Question: I want to build a small in-browser “wind tunnel” experiment with a fixed 2D cross-sectional view, using HTML Canvas. Users can drag and drop different wing cross-sections (e.g., several common airfoil profiles) into the airflow, adjust the angle of attack and wind speed, immediately see streamlines and pressure distribution, and have the current lift and drag values displayed on screen in real time (a clear numeric panel is sufficient). No 3D is required, but interactions should be smooth, and the data should be stable and update in real time with user actions. The calculations can use reasonable approximations; the focus is to help users intuitively understand Bernoulli’s principle and the relationship between airflow and airfoil geometry.


Question: I want to build a browser-based interactive “Underwater Canyon Exploration” tool: the user descends from the entry point into the depths while the camera follows a predefined path, with play/pause and speed controls. The visuals should deliver realistic water and wet rock materials (showing reflection and refraction), within a dark underwater volumetric light-scattering atmosphere. Implementation will use React Three Fiber, with materials and lighting tuned to closely match underwater effects. Additionally, include sonar feedback: emit periodic pulse sounds as the journey progresses, with adjustable frequency and attenuation, synthesized via the Web Audio API. The target is smooth performance on desktop, with a small yet polished scene.


Question: Please create an instant-play web puzzle mini-level (single-file HTML) with 2.5D visuals. The player controls a caped character to traverse obstacles and solve puzzles to progress. The cape should exhibit noticeable physical dynamics (similar to cloth affected by gravity, inertia, and wind), naturally swaying with the character’s movement. Use the mouse wheel to adjust the camera’s zoom or height for easier viewing. The interface should include a fixed score panel displaying the current level’s score/progress. The background should feature a depth-of-field effect: distant elements slightly blurred, near elements sharp. Implement this directly using the Canvas 2D context, minimizing external libraries; a single HTML file is sufficient.


Question: I want to build a side-scrolling 2D diving game prototype, with a glowing jellyfish as the protagonist swimming in the deep sea. The visuals should feature realistic underwater lighting: visible water caustics and subtle refraction, with overall illumination primarily driven by the jellyfish’s bioluminescence and a faint diffuse fill from above to simulate under-ice light. The jellyfish’s tentacles should exhibit soft-body behavior—flexible and drifting—with lag, sway, and spring-back in response to speed, turning, and currents. The gameplay only needs basic movement, collision, and camera follow; the water lighting effects can be implemented using GLSL shaders. The goal is a runnable prototype with switchable effects, tunable parameters, and stable operation on common hardware.


Question: I want to create a web-based sci-fi spaceship showcase: open with a wide-angle, low-angle shot from beneath the ship to emphasize its monumental scale; the thrusters should feature realistic emissive glow/heat bloom, with lens flare visible in the frame; as the ship approaches or recedes from the camera, the thruster audio should exhibit a pronounced Doppler shift. For implementation, use Three.js to load the spacecraft model, write a small amount of custom shaders to achieve engine emission and post-processing bloom, and use the Web Audio API to dynamically synthesize audio based on the distance and relative velocity between the ship and the camera. Please provide an example that can run directly in the browser (clear structure, adjustable parameters, and easy model swapping), and explain the camera setup, the post-processing pipeline, and the key points of the Doppler calculation.


Question: I want to build an interactive fabric showcase: a soft piece of cloth appears on screen, and users can grab any point with the mouse and drag it in real time, with natural deformation and elastic rebound. The scene should feature strong backlighting to reveal the fabric’s translucency and thickness variations. The camera must support free rotation, panning, and zooming to inspect details from different angles. The implementation should be based on Web 3D (e.g., Three.js) and integrate physics simulation to ensure smooth performance.


Question: I want to create a black-hole traversal experience in the browser: the visuals have a “glitch” aesthetic, and the accretion disk is warped and deformed. The player uses the keyboard (WASD) to fine-tune thrust speed and the viewpoint, as if piloting a spacecraft into a wormhole. Use Three.js to build the scene, have the camera move along a path, and render to a Canvas. Use a GLSL post-processing shader to implement an adjustable distortion/screen-shake effect, and provide the key implementation and interaction logic.


Question: I want to create a small immersive web experience: flying through volumetric clouds during a nighttime meteor shower. Use Babylon.js to build the scene, render the clouds with a ray marching technique, and have the camera smoothly traverse the clouds along a predefined “shuttle path.” Use the Web Audio API to synthesize continuous ambient white noise as the background sound. Add a simple gameplay mechanic: when a meteor streaks through the center of the screen, play a synthesized cue sound and increase the on-screen score by +1. Please provide a complete implementation, including the cloud shader, meteor generation and movement, center-crossing detection logic, scoring UI, and audio triggers, ensuring it runs smoothly in the browser.


Question: Create a web-based ocean wave physics demonstration: the scene should be a close, water-level, eye-level view with a vintage CRT monitor aesthetic and a subtle chromatic aberration effect. The wave undulation and surface turbulence must respond in real time to changes in microphone input: use the Web Audio API to capture audio from the microphone and perform spectral analysis, mapping low frequencies to overall wave height and high frequencies to fine detail/turbulence intensity. Render exclusively with the native Canvas 2D API, without WebGL or any third-party libraries.


Question: I want to build a small browser-based 3D data visualization app: display dynamic data using a bar chart where each bar looks like it’s carved from transparent ice, set in a warm sunset ambience. The camera should be fixed to a wide-angle view looking upward from a low position to emphasize the monumental scale of the bars. For interaction, users can click lower-value ice bars to “shatter” them; the system automatically calculates and accumulates points based on the volume that is shattered. On the rendering side, I’d like to use a ray marching–based approach to achieve a realistic ice material (e.g., a sense of internal volume, refraction/micro-scattering visual effects) while maintaining usable frame rates. Please provide an implementation in Three.js that includes data-to-bar-height mapping, Golden Hour–style lighting, a fixed wide-angle low-angle camera, click detection and shatter animation/volume estimation, and scoring rules with a basic score panel.


Question: I want to build an immersive 3D data exploration page: a large transparent cube with an amber-like material, enclosing cloud-like volumetric data that changes over time. Users can enter the cube in first person and freely roam and observe within the data; as the camera traverses the volume, the stratification of density changes and light refraction/absorption effects should be clearly visible. Meanwhile, I want to generate low-frequency ambient sound in real time based on the data density at the user’s location—the higher the density, the heavier and darker the sound. The entire project should be implemented with Web technologies, prioritizing 3D solutions within the React ecosystem, and must run reliably in desktop browsers.


Question: Create a browser-based interactive “smoke beside a candle” demo: smoke rises slowly from near the candle flame and drifts according to the wind direction and strength set by the user. The visuals should have a volumetric appearance and convey candlelight illumination and shadows. The camera is fixed at a low position, looking upward, with a wide field of view to emphasize the smoke’s rising shape. Implementation can use Babylon.js; for volumetric smoke, we recommend custom GLSL shaders rendered via ray marching. Users can apply wind to change the smoke’s trajectory through UI controls or by dragging within the scene.


Question: I want to build a small demo project: a simple ray-tracing renderer implemented from scratch in the browser using the Canvas API, without WebGL. The scene will be a coffee cup sitting on a table, and the cup’s surface material should support loading from external images (e.g., a ceramic texture). The overall lighting should evoke the golden, warm tone of sunset. Rendering can be offline, but I’d like progressive accumulation so the image becomes cleaner frame by frame, while supporting basic camera movement (orbit and zoom). The focus is to depict the cup’s soft shadows on the tabletop and its subtle reflections.


Question: I want to create a small web piece: at the center of the screen is a geometric puzzle that “split-and-reassemble” over time (inspired by the Rubik’s Cube), with its form undergoing topological changes. The project should be driven by Three.js, with the main object rendered using a GLSL ray‑marching shader; the camera should automatically orbit the object; the visuals should present warm, sunset‑like tones. Synthesize electronic timbres based on the rhythm of the shape’s transformations, and display a “synchronization rate” score to measure how well the visual deformations align with the audio rhythm. Please implement a soft Bloom effect along the object’s edges, and provide a ready‑to‑run webpage example.


Question:
I want to build an immersive “fractal tunnel” experience in the browser: the visuals feel like a first-person, continuous flight through a constantly changing abstract corridor. Users can use mouse or touch to paint ripples on the screen, causing the tunnel’s structure and details to distort in real time, and those changes are converted into harmonic swells that play in sync.

Implementation-wise, render with a full-screen fragment shader (ray marching), using Three.js only to draw a full-screen quad. Interaction should affect fractal parameters or the distance field, and Web Audio should map visual frequencies/flight speed, etc., to corresponding harmonic layers. Please ensure near-60 fps performance on common desktop browsers, and provide a basic parameter panel (e.g., flight speed, fractal frequency, volume) as well as mobile gesture support.


Question: An interactive “soap bubble” demo in the browser: in a beach scene, the floating bubble is gently pushed by wind and deforms; up close, you can see iridescence that varies with film thickness and viewing angle, and the tighter the bubble gets as it inflates, the higher-pitched the tension sound. The background should be an HDR beach environment map, and users can freely zoom and orbit to inspect surface reflections and mirrored scenery. Implementation will use Three.js for rendering and a custom shader to reproduce thin-film interference and dispersion, while mapping wind strength and bubble film thickness to both audio and deformation.


Question: I want to create an interactive web mini‑project: the screen displays a sci‑fi starship in an “Enterprise”-style homage, with the viewpoint fixed to a 2D cross-sectional perspective. The background features neon-heavy cyberpunk light strips and foggy glow. The user can drag horizontally or use the arrow keys to smoothly move the ship for viewing. I’d like the visuals to use a Babylon.js ray marching (SDF) shader to achieve metallic texture and neon lighting effects. Meanwhile, use the Web Audio API to synthesize a continuous low-frequency engine hum, with slight volume/filter changes based on movement. Please provide a directly runnable implementation (HTML/JS/GLSL) that includes initialization, shaders, interaction, and audio.


Question: Create a small interactive scene: soap bubbles floating against the sky, with the camera looking up from ground level. The bubbles should exhibit a realistic iridescent thin-film effect, with subtle surface wobble and deformation so they read as a soft membrane. Players can apply “wind,” as if blowing, to move the bubbles and dodge airborne obstacles; the UI displays survival time as the score. Technically, we hope to implement thin-film interference shading in GLSL (colors vary with film thickness and viewing angle) and use a vertex shader to drive the bubbles’ surface wobble and deformation.


Question: I want to render an immersive black hole scene on a web page: the background starfield is clearly distorted by gravitational lensing near the event horizon, and the accretion disk features a spark-emitting particle effect with flicker and motion trails. Use Babylon.js, with the core implemented via a custom ray marching shader to realize the black hole itself and the lensing deformation; also configure a camera with a “shuttle orbit” perspective that automatically spirals along the edge of the accretion disk and ultimately crosses the event horizon. The visuals should be detailed, the motion natural, and the overall presentation as realistic and smooth as possible.


Question: We want to create an interactive candlelit scene that can be viewed on smartphones: the candle flame should exhibit realistic flow and interact with the smoke, accompanied by heat-induced visual distortion from rising hot air. Place a coffee cup in the scene as a reference object, dynamically illuminated by the candlelight, and allow users to freely adjust the 3D viewpoint. The intensity of the flame’s flicker needs to drive the page’s low-frequency ambient audio (Web Audio API), making the sound vary with the flame’s fluctuations. At the rendering layer, custom GLSL and ray marching can be used to implement flame turbulence and heat distortion, while maintaining stable performance on mobile.


Question: I want an Android app that teaches drawing basics through friendly step-by-step lessons. It should have a clean, minimalist look: a browsable list of tutorials and a simple canvas where I can practice shapes and strokes. I need to save my sketches and track tutorial progress offline, and the app should remember the last brush color and size. It must support English, Russian (ru-RU), and Hindi (hi-IN). Please build it in Java using MVVM, use XML for the UI, a RecyclerView for the tutorial list, and a custom View for the canvas. Store artwork and progress in Realm, and use DataStore for lightweight preferences. Deliver a universal APK or app bundle covering common CPU architectures, and make sure the layout looks correct across screens from 16:9 to 21:9.


Question: Create an approachable "Beginner’s Home Garden" Android app that teaches homemakers how to grow herbs and vegetables at home. The experience should center on a visual plant catalog in a grid and clear detail pages with care instructions (watering, sunlight, soil, harvest tips). Users can save a personalized "My Plants" list and set custom watering schedules; all of this must be stored on the device (no cloud) by serializing Kotlin data classes to JSON and writing to Internal Storage. Keep the app fast and simple using Kotlin with MVVM and XML layouts; a RecyclerView with a GridLayoutManager is suitable for the catalog. The app needs to be ready for multiple languages, including zh-CN, via Android resources, and the layouts should remain consistent and performant across popular phones (Samsung, Google Pixel, OnePlus, Motorola). Please ensure a clean, compatible project setup and that the project compiles and passes basic tests.


Question: I’m building “RetroLens,” a camera app that feels like shooting with classic film cameras and appeals to nostalgic users. The UI should evoke analog dials and a viewfinder, with several ‘film’ profiles that apply live looks—grain, color shifts, and occasional light leaks—directly in the preview. Users pick a profile, see the effect instantly, and saved photos should include EXIF notes about the chosen film. Please scaffold the project in Kotlin with MVVM and Jetpack Compose, wire up a real-time preview using GPU shaders, and keep it smooth on devices ranging from 2GB to 16GB RAM. We’re targeting Android 15 only (minSdkVersion 35, targetSdkVersion 35). Photo saving should be fast on both UFS and eMMC storage. Make sure the project builds with a Gradle wrapper and include a couple of simple tests.


Question: Build a family chore planner app that lets households add recurring or one‑off chores, assign them to specific people, set reminders, and track progress. When a chore is marked done, some tasks should require a quick photo as proof, captured in‑app and saved with the log. Keep data local and offline-friendly, and make the interface simple for all ages. Implement it in Kotlin with an MVVM approach (ViewModels + LiveData) and straightforward navigation between the main dashboard, chore creation, and history screens. Use Room for storage and CameraX for photo capture. The app must be fully localized for zh‑CN, id‑ID, and ru‑RU.


Question: I want to create a ‘Light Painting Assistant’ for long‑exposure photographers. The phone screen should act as a controllable light source: pick a full‑screen color, run animated patterns, display custom text, and toggle a stroboscope mode. Users can build and save their own color sequences/patterns and reuse them later. The UI should be clean and distraction‑free so it’s easy to use in the dark. Technically, let’s use Jetpack Compose for the interface, Room to store saved sequences, Hilt for DI, and Kotlin Coroutines to drive smooth timing without UI jank. Expose the current sequence state to the UI (LiveData is acceptable). Add simple navigation between the main tool and the saved patterns list (LazyColumn). Target min SDK 28 and target SDK 35, and set up dev, staging, and production build flavors. If we later support image‑based patterns, Coil can be included.


Question: We’re creating a minimalist, light-themed “Double Exposure Blender” app for Android that helps artists merge two photos into a single, artistic image. Users should be able to pick a base photo, add an overlay, switch between common blend modes, adjust opacity, and refine the overlay with an eraser mask. Keep the canvas uncluttered: use an XML layout with a FrameLayout to stack the base image, overlay, and mask. Navigation is simple: a Bottom Navigation with New Project, My Gallery, and an Inspiration feed. When users cycle through blend modes, the transition should feel polished with a smooth cross‑fade. Finished images export as high‑quality JPEGs into the app’s external storage folder. Localize all UI text and blend mode names for hi‑IN and zh‑CN. Build the app in Kotlin and set up dev and release flavors, with the dev flavor exporting lower‑resolution outputs to speed testing.


Question: Please help me design and build a 'Warranty Wallet' Android app for homemakers to organize appliance warranties and manuals. Users should be able to add appliances, record purchase date and warranty expiry, and attach photos of receipts or warranty cards (store image URIs rather than the files themselves). The home screen shows a card list of all appliances, with clear indicators for items expiring soon; users can tap to view details or add/edit entries. Technically, use Kotlin with Jetpack Compose and an MVI-style approach where the ViewModel handles user intents and produces UI state. Persist all appliance data in Room; manage a user preference for the 'expiring soon' window via DataStore; and use the Navigation Component for moving between list, details, and the add form. Include a 'find manual' feature that tries to locate a PDF online from the model number using OkHttp. Use Material styling, keep it single flavor, set minSDK 29 and targetSDK 32, and fully localize the UI for pt-BR and hi-IN.


Question: We’re building PanoStitcher, a travel-friendly panorama assistant. The goal is to help people shoot smooth, well-aligned panoramic sequences and get a stitched result with minimal effort. In the camera view, show a live alignment guide that reacts to phone movement (gyroscope + accelerometer) so each frame stays level and consistent. After capture, stitching should run quietly in the background, and progress must be recoverable if the app is interrupted—each frame is cached safely. Please set up the app in Kotlin with MVVM, use Jetpack Compose for the UI and CameraX for the camera, store in-progress frames with Room, and handle stitching via OpenCV with coroutines. Use min/target SDK 31, include dev and release build flavors, and ensure sensor readings are accurate with smooth performance on Samsung, Google Pixel, OnePlus, and Motorola devices.


Question: Create 'Project Pulse', a lightweight project and time tracker for solo entrepreneurs. People should be able to start/stop timers for tasks, see progress across projects, and attach photo or short video proof to milestones. Keep the app snappy on low-memory phones and localize core strings (including zh-CN). The UI uses XML with Material cards, progress bars, and dialogs; show all active projects and their tasks in a RecyclerView. When a major milestone is completed, play a short Lottie celebration. From the tech side: Kotlin + MVVM, ViewModel for timer/project state, Coroutines for timer ticks and database writes, CameraX for capture, and include a small OkHttp stub to prepare for future sync. Please set up Gradle so it builds cleanly in a Linux VM and add a couple of simple tests or lint checks.


Question: I’d like to build an Android app called Kinship where small, invite-only circles of friends share one short journal entry per day, visible only within their circle. The vibe should be warm and minimal, showing each day’s entry as a card. It needs to work offline: entries from a user’s circles are stored locally so they can read and post without a connection, and sync when back online. Please create the project in Kotlin using an MVVM approach (ViewModel + LiveData), connect to our REST API with Retrofit/OkHttp, and keep personal settings and the active circle in DataStore. Use XML layouts, minSdk 31 and targetSdk 32, a single build flavor, and set it up on a Linux VM with compatible Gradle/Java and a Gradle wrapper that compiles cleanly. Basic tests or lint checks would be appreciated.


Question: Build 'ClipStack' — a friendly clipboard companion that remembers everything you copy and lets you pin favorites. The app should feel fast and simple: a Compose UI with a bottom bar for History, Snippets, and a Live Text camera. When the camera points at words, the text is recognized on-device and instantly added to the clipboard and shown in History. Use the main camera by default for best clarity, and let me switch to other lenses (including telephoto) so it works across single- and multi-camera phones. Keep all history in a local database that persists across restarts. Use Kotlin with an MVI-style state model. Minimum Android 11 (minSDK 30), target Android 15 (targetSDK 36). Provide dev and release flavors; the dev build should include a lightweight ML performance overlay to evaluate OCR speed and accuracy.


Question: Build an Android app called “LAN-Guard” that helps gamers quickly check their home/LAN network before a match. The app should discover devices on the local network, highlight basic risks (e.g., open ports), and show each device as a clean card with IP, MAC, and a simple security status. Users can mark familiar consoles/PCs as trusted and the app should remember that. It should feel fast, support both gesture and button navigation, and use an XML/ConstraintLayout UI with vendor logos on device cards. To simplify setup, let users scan the router’s QR code to get Wi‑Fi credentials instead of typing them. Technically, use Kotlin with MVVM on SDK 35, run scans off the main thread with coroutines, save trusted MACs with DataStore and store scan options in SharedPreferences. Use Retrofit to call a MAC‑vendor lookup service, load logos with Picasso, inject dependencies via Hilt, and schedule periodic re‑scans with WorkManager. Provide dev, staging, and production flavors and ensure the project builds cleanly.


Question: I want to build a simple hub for mobile gamers: one place to see all installed games, track how much I play, and start each game with a custom pre-launch routine (turn on Do Not Disturb, clear cache where possible, and perform a light memory cleanup). The app should feel clean and fast with Material Design and a Bottom Navigation for Library, Stats, and Settings. Please set up a new Android project in Kotlin using MVVM: show the game list and playtime in a RecyclerView, store game metadata and per-game launch profiles in an SQLite database, and keep global preferences (theme, auto-scan) in DataStore. Use Dagger for dependency management and let a ViewModel drive the UI state. Minimum SDK and target SDK must be 30, and the app should be localizable, including ru-RU. Make sure the Gradle wrapper and dependency versions are compatible in a Linux dev environment so the project compiles cleanly; add a couple of simple tests or lint checks if possible.


Question: I need a lightweight Android app called “Daily Ledger” that lets office workers and seniors quickly log daily expenses without the complexity of a full finance app. The flow should be simple: type an amount, pick a category from chips, and save; show entries in a chronological list. Keep the UI clean with an attractive header and a gradient FloatingActionButton. The app must work offline and store data locally (use Room). Amounts and currencies must display correctly for the user’s locale, and all labels and category names should be fully translated into zh-CN and ru-RU. Build it in Kotlin using an MVVM approach, XML layouts, and RecyclerView, targeting Android (min SDK 31, target SDK 32).


Question:
Let’s build ‘Ghar Ka Kharch’, a family-first expense and bill-reminder app for households in India’s tier-2 to tier-4 cities. Families should be able to quickly log shared spends by familiar categories (groceries, daily milk, gas cylinder refills, school fees, etc.), see monthly/weekly summaries with simple bar or pie charts, and set up recurring reminders so due dates aren’t missed. Everything works offline with all data kept on the device in an encrypted database, and the app should feel smooth on entry-level phones (2 GB RAM) as well as higher-end devices.

Implementation notes:
- Kotlin + Jetpack Compose for a friendly, accessible UI
- Local notifications for recurring bills (no backend)
- Encrypted Room for storage
- Target SDK 35, min SDK 28
- First-class Hindi (hi-IN) and English
- Works with gesture and 3-button navigation across all screen densities
- Dev and release build flavors so development logs are stripped from production


Question: We’re building a hobbyist subscription hub for DIY kit lovers—think model building, painting, and electronics. Users should be able to discover new boxes, manage active subscriptions, track project progress, and browse past kits in a clean, card-based UI. A Floating Action Button provides quick access to searching categories. The app needs to feel smooth across common screen ratios (16:9, 18:9, 20:9, etc.) and look correct on both AMOLED and LCD displays. It must support Chinese (zh-CN) and Brazilian Portuguese (pt-BR). Technically, use Kotlin with an MVC approach and XML-based Views; store local data with GreenDAO and keep simple settings like notification toggles in SharedPreferences. Target Android minSDK 27 and SDK 33. Please separate the build into dev and release flavors and ensure the project builds cleanly and runs well on typical devices (16GB+ eMMC or UFS).


Question: Create a kid-friendly math practice app for ages 6–9 that works well on lower-cost phones in Tier 3/4 cities. The experience should feel like a game: quick card-style quizzes for addition, subtraction, and multiplication tables, with stars or badges for correct answers and visible streaks/accuracy to keep kids motivated. It must work offline and save progress (daily streaks, accuracy, recent scores) on the device. Include a dark theme. I’d prefer Kotlin with MVVM where the ViewModel generates problems, checks answers, and updates scores; use a repository to separate data access and persist to a local SQLite store. Please target broad device coverage with min SDK 26 and target SDK 27, and set up a clean project that compiles with Gradle.


Question:
We want to build a simple, reliable shift management app for hourly workers—ShiftSwap Pro. Workers should be able to enter their schedule, see it in a calendar or list, and use a “Swap Board” to offer a shift or pick up one from others without texting back and forth. It should feel great on small phones and large tablets (e.g., weekly view on phones, full-month calendar on tablets) and stay smooth when scrolling through long shift lists. The app must work offline with local storage and include basic settings like name and primary location.

Implementation notes: Kotlin with MVVM, XML-based UI; Room for storing shifts; SharedPreferences for simple settings; Calendar or RecyclerView for the schedule. Please target both 32- and 64-bit devices and prioritize performance.


Question:
We’re building “Senior Savings Finder,” an easy-to-use Android app that helps adults 50+ find nearby senior discounts. On launch, users see a map of nearby businesses and a scrollable list they can filter by categories like Restaurants, Retail, and Groceries. The app should remember their last location and filters so they can pick up where they left off. The UI should be clean and accessible Material Design with XML layouts, and the app must support multiple languages, including Simplified Chinese (zh-CN).

Technical notes: native Kotlin app with min SDK 31 and target SDK 36. Use Google Maps for the map view, a RecyclerView for the list, and fetch discount data from our backend using Retrofit. Set up dev/staging/production build flavors with different base URLs. Store user preferences (last location and filters) with Preferences DataStore. Deliver a compilable project scaffold that implements these core pieces.


Question: Create an Android app called “Sequence” for young creators to turn photo sequences into short animated stories. Users pick photos from their device, drag to reorder, set a duration per frame, and add simple text overlays. They can preview the story and export it as an animated GIF or a short MP4. The interface should feel clean and minimalist, built in Jetpack Compose, with rounded photo thumbnails and a subtle gradient highlight for selected/active items. Save drafts and export preferences locally with DataStore. The app must be fully localized (zh-CN and ru-RU) and implemented in Kotlin. Ensure the project builds reliably with a Gradle wrapper and include basic tests or checks.


Question: I’d like an Android app called “Clipboard Manager+” that quietly keeps a searchable history of everything I copy so I can quickly reuse snippets at work. It should feel fast and reliable and keep working without me opening it. Core flows: browse clipboard history, pin favorites to the top, search by text/time, and automatically clean up old entries based on user rules. The UI should be a simple, Material-style list with a settings screen for things like cleanup schedule, pin behavior, and the persistent notification. Build it in Kotlin using an MVI approach for state, and store items with timestamps in Room. Target Android 9–12 (minSDK 28, targetSDK 31). To keep listening for changes, run a foreground service with a persistent notification and use ClipboardManager.OnPrimaryClipChangedListener. Please localize the app for zh-CN, id-ID, and ru-RU, and make sure the project builds cleanly with Gradle on Linux (basic tests or lint are a plus).


Question:
We need to deliver a Personal Medication Reminder for Android that patients can trust. Users should be able to add medicines (name, dosage, times), handle patterns like “every other day,” see an at-a-glance schedule, get on-time notifications with snooze, and mark each dose as taken or skipped. It must work offline with local storage, and all labels/instructions need full multi-language support, including hi-IN.

Implementation preferences: Kotlin-only with an MVI-style state flow; min SDK 31, target SDK 35. Build the UI in XML with a list of cards for each medication/schedule. Use Room for persistence (Medication and MedicationLog), store complex scheduling rules as JSON and parse with Moshi, keep global settings (e.g., snooze duration) in DataStore, and use WorkManager to trigger reliable, on-time reminders even when the device is idle. Set up dependency injection with Hilt. Please initialize a fresh project on our Linux VM, choose compatible Gradle/JDK versions, generate the Gradle wrapper, and ensure the project compiles. Add a small set of unit tests or lint checks to validate the core flows.


Question:
Create a clean, card-based Android app that helps people in Tier 1–2 cities keep track of recurring subscriptions (digital and physical). Users should be able to add a service, choose a billing cycle and cost, and get a reminder before the renewal date. A dashboard should summarize monthly and yearly spend at a glance. All data stays on-device; no cloud sync.

Please set up the project in Java with an MVI-style state flow for the subscription list and payment totals, and save everything with DataStore. The UI should follow Material Design with a minimalist look. Ship a single-flavor build targeting SDK 33 (min 32), run consistently across MIUI, ColorOS, OneUI, EMUI, and stock Android, and work on ARM, ARM64, x86, and x86_64 devices. Add localization for ru-RU, id-ID, and hi-IN.

Start from a fresh project in our Linux VM, choose compatible Java/Gradle versions, generate the Gradle wrapper, and make sure the app compiles and basic tests/lint pass.


Question:
I want to build an Android app called LAN Link that helps organize LAN parties. Hosts can create an event, invite friends, and manage a shared “what to bring” list for snacks and drinks; guests can RSVP and claim items so there’s no overlap. Each user also has a reusable Gear Checklist (PC, peripherals, cables) and a shopping area that highlights missing items with product images and simple browsing.

The app should work great offline with all data stored on-device, feel fast on OnePlus, Google, and Samsung devices, and support both 32-bit and 64-bit ABIs. The UI will be clean and minimalist in Jetpack Compose, using subtle color-coded gradients to indicate guest status (attending, declined).

Tech boundaries:
- Kotlin
- Realm for local storage
- Dagger for dependency injection
- WorkManager for background reminders/sync; Coroutines for immediate async writes
- Shopping list rendered with a LazyColumn and images loaded by Coil
- LiveData driving reactive updates across the UI
- Localize the app for hi-IN and ru-RU

Please set up the project with compatible Gradle/AGP/Kotlin/Compose/Realm versions, implement the basic architecture, and provide a build that compiles with a Gradle wrapper.


Question:
Build an Android app called EquitySim for young tech professionals to make sense of their stock options. Users can enter their grant details (option type, shares, strike price), vesting schedule (start, cliff, duration), and a company valuation to simulate what their options might be worth under different exit scenarios (e.g., acquisition, IPO) over various timelines. The experience should feel modern and clear, with interactive sliders that update results instantly and smooth micro-interactions, following Material Design. Saved grants and scenarios should be stored securely on-device for fast access.

Technically, keep it native and lean: Kotlin with an MVVM approach, UI fully in Jetpack Compose, local storage via MMKV, and a single-flavor build. Please ensure real-time calculations are reflected in the UI and that the project compiles cleanly with compatible Gradle/Kotlin/Compose versions.


Question: I want a playful short‑form video app focused on stand‑up comedy clips where users swipe vertically to discover, like, follow, and share. The experience should feel fast and distraction‑free, with smooth autoplay as you move between videos. It needs to look great on phones with display cutouts and on tablets like the Samsung Galaxy Tab. Build it in Kotlin with a clean MVVM setup and Jetpack Compose; use a Pager‑based vertical feed and ExoPlayer for playback. Keep likes and followed comedians saved locally (DataStore). Launch with English and Hindi (hi‑IN). Set up Gradle flavors for dev, staging, and production, and ship builds for ARM, ARM64, x86, and x86_64. Target Android 10+ (min SDK 29) and SDK 31, with a mostly flat UI that uses light Material touches so the content stays front and center.


Question: Let’s start building “BabyLog+,” an Android app that helps new parents quickly record feedings (bottle or breast, amount/duration), diaper changes (wet/dirty), and sleep with simple start/stop timers. The app should feel fast and work offline, with a home dashboard that shows today’s totals and a scrolling timeline of events. Please use Kotlin with an MVVM structure so screens refresh automatically, and store all data locally with Room. From day one we need English, Chinese (zh-CN), and Russian (ru-RU)—keep all text in string resource files. Design with Material components and support SDK 30–35. On foldable devices like the Galaxy Fold, show the timeline on one pane and data entry controls on the other when unfolded, scaling cleanly across all screen densities. Allow a baby profile photo and load it efficiently with Coil. Set up the project so it builds with the Gradle wrapper.


Question:
Help me kick off a new app concept called ‘Urban Explorer’, an offline‑first city discovery tool for people who like to wander and pin interesting spots. Users should be able to download a city map for offline use, drop personal pins with notes and photos, and browse everything in a clean, readable Light Mode interface built with Jetpack Compose. On foldable devices, the unfolded view should become a two‑pane dashboard: the map on one side and a list of saved pins or search results on the other.

Technically, start this as a Kotlin project using an MVI approach to keep map and location state predictable. The app must run on devices with or without Google Play Services: use a map SDK that doesn’t depend on GMS (for example, Mapbox or osmdroid), and make location work with a graceful fallback—prefer Google’s FusedLocationProvider when available, otherwise use Huawei Location Kit or the platform’s GPS provider. All pins and offline map data should be stored locally with Room and the device file system.


Question: Create 'VisionGuard', an Android app that helps screen-heavy professionals reduce digital eye strain. The app should gently prompt the 20‑20‑20 rule at user‑selected intervals and provide short, guided eye exercises that feel unobtrusive. Users can choose which exercises to follow and how often to be reminded, and the app keeps a simple history of completed sessions so they can track consistency over time. The interface should be clean and Light Mode only, built with Jetpack Compose. Implement in Kotlin using MVVM, store session logs with Room, manage preferences with SharedPreferences, support Hindi (India) localization (hi‑IN), target modern devices (min SDK 33, target SDK 35), and ship builds that run efficiently on both 32‑bit and 64‑bit CPU architectures.


Question:
I’d like to build an Android app called “TrailView Logger” that helps hikers capture short video moments at scenic spots, automatically tag them with GPS, and turn those clips into a single “hike story” video. The home screen should feel modern with a clean, card-style layout and soft shadows, showing saved trails with a map snapshot or a video thumbnail. A prominent floating action button lets me quickly start recording on the trail. I want to preview individual clips and play the compiled story inside the app.

Please implement this in Kotlin with an MVI-style state flow to handle recording, location tracking, and the compilation process. Target Android 10–14 (API 29–34). Use ExoPlayer for clip and story playback, Glide for images/thumbnails, and Navigation Component for moving between the trail list, map/record screen, and preview screen. Use Hilt to inject things like location services and repositories. Store user preferences and offline trail data with DataStore. Retrofit may be used to fetch trail info or share stories, with coroutines for async work and state kept in a ViewModel. The app must launch with English (en) and Hindi (hi-IN) support.


Question:
I need a fast, lightweight expense tracker for freelancers. Open the app, snap a photo of a receipt, type the amount, pick a category, and you’re done. The home screen should be a simple vertical list showing each expense as a card with the merchant name, amount, and a small receipt thumbnail. It must work smoothly offline, remember my default currency, and let me customize the category list. A basic summary view is enough, and I want to export monthly expenses to a JSON file. Localization is required for ru-RU, zh-CN, and pt-BR.

Technical notes: Build with Kotlin and MVVM. Store expenses (image URI, date, category, merchant, amount) in Room; use DataStore for preferences. Show the list in a RecyclerView and load thumbnails with Picasso. Use the Navigation Component to move between the list, the capture/entry form, and the summary. Use LiveData for reactive UI updates. Export should be serialized with Moshi. Set both minSDK and targetSDK to 36.


Question: I want a clean, distraction-free comics/webtoon reader for Android that feels fast and polished. It should let me import CBZ/CBR files into a library, read page-by-page with smooth animated transitions, and add bookmarks. The app needs to remember my progress per comic and preferences like reading direction, and keep everything stored locally for instant resume. Please build it with a Kotlin-only codebase using MVVM and Jetpack Compose following Material guidelines, use MMKV for persistence, target Android 12L–13 (minSdk 32, targetSdk 33), and ship with English and Indonesian (id-ID) translations.


Question: Build “Frame-It!”, a friendly photo framing app that helps teens and seniors create stylish profile pictures. The flow is simple: take a photo or choose one from the gallery, then swipe through a curated set of frames—from clean modern to ornate vintage—and apply them instantly. Users should be able to save drafts and reopen them later, and the app should remember their last-used or favorite frame for quick access. The UI must adapt well to common phone aspect ratios (16:9, 18:9, 19:9, 20:9, 21:9) and support English, Simplified Chinese (zh-CN), and Brazilian Portuguese (pt-BR). Implement it in Kotlin with Jetpack Compose and a clean MVVM approach; render frames with Bitmap/Canvas. CameraX should work reliably across single/dual/triple/quad camera devices. Use Room for projects and DataStore for preferences, and set up dev, staging, and production build flavors suitable for CI/CD.


Question: Design a privacy-first 2FA authenticator for Android aimed at security-conscious office workers and young adults. Users should see their time-based codes in a clean list and copy them with one tap, with carefully crafted light and dark themes. All 2FA account data stays on the device in an encrypted database. Let users create an encrypted local backup to a file they choose, restore it on a new phone, and trigger a panic wipe that instantly removes all tokens. Please use Kotlin with an MVI-style state approach and Jetpack Compose for the UI, set min SDK to 33 and target 35, and include full localization for ru-RU and hi-IN.


Question: We’re building a simple, fast baby feeding and diaper tracker that sleep-deprived parents can use with just a few taps. It should let you quickly record a feeding (breast or bottle) or a diaper change, show the day’s history at a glance, and work reliably in both portrait and landscape. Save each day’s entries privately on the device as a single serialized list in a new file per day, and start a new file automatically for the next day. Use Kotlin with a predictable, testable state flow (MVI) and a clean Material Design UI built in XML, including Dark Mode for late-night use. The app must run on Android 12/12L (min SDK 31, target 32), scale well from 720p up to 4K, and ship for ARM, ARM64, x86, and x86_64. Keep startup fast, interactions snappy, and ensure the project compiles cleanly and is easy to test.


Question: I want to build LinguaFlow, a voice-first language practice app where learners talk with an AI coach through a clean, chat-style screen. Users should press-and-hold to speak, see a subtle “thinking” animation while the AI processes, then read the AI’s response and keep the conversation going. The app should remember past sessions and basic performance stats, and let users choose their target language and theme. It must run smoothly on phones and tablets from 4" to 12.9", including popular Chinese brands (Xiaomi, Oppo, Vivo, Huawei, Honor), and support UI localization and learning content for id-ID and pt-BR. Technically, build it in Kotlin with an MVI presentation layer; Jetpack Compose for the entire UI (using ConstraintLayout for robust layouts) and Material 3 with gentle motion; Hilt for dependency injection; Retrofit to call a backend for speech-to-text and NLP; Lottie for the “thinking” indicator; MMKV for conversation history and metrics; SharedPreferences for user settings; and expose ViewModel state via LiveData. Target Android 14+ devices (minSdk 33, targetSdk 35).


Question: Design a teen-friendly Android app for discovering and rating international snacks. Users browse a curated catalog with big, vibrant photos, tap a floating action button to quickly add items to a wishlist, leave star ratings and short reviews, and build a taste profile (including allergies) that shapes suggestions. The app should feel fast and work offline: cache high‑resolution images in app-specific external storage, and persist the user’s profile, allergies, and personal ratings with DataStore. Build in Kotlin with a simple, single‑source‑of‑truth MVI flow managing snack lists, ratings, and the wishlist. Go for a bold, flat visual style and ship full localization for zh-CN, hi-IN, and ru-RU. Min SDK 28, target SDK 36.


Question:
We’re building MentorMatch, a friendly internal app where junior employees discover senior mentors based on skills and career goals, then start a conversation right away. The experience focuses on profile cards, a clean search with filters, and a Floating Action Button that takes users to either a guided profile setup or search. Onboarding is multi-step and remembers the user’s goals and progress. Browsing should feel fast and visual; tapping a card opens a detailed profile, and users can message mentors securely in-app.

Implement this in Kotlin with Jetpack Compose. Use ViewModel for screen state, Koin for DI, Retrofit for backend profiles/matching/messaging, and DataStore to persist onboarding and mentorship goals. Navigation Component should manage flows between onboarding, browsing, and chat. Load profile images with Glide. Optimize for foldables with a two-pane layout (list on the left, details on the right). Localize for en, zh-CN, and hi-IN. Configure dev/staging/production build flavors. Target minSdk 28 and targetSdk 33, and ensure accurate color rendering on AMOLED and LCD. The project should compile with gradlew in our Linux environment and include basic tests or lint checks.


Question: Create a newborn tracker that makes it effortless for parents to log feeds, sleep, and diaper changes in seconds. Keep the UI clean and light, with quick-entry controls (prefilled timestamps, quantity pickers, and notes). Show a chronological timeline of all logs and a simple dashboard with live-updating stats. Parents can set a baby profile photo and attach or capture images to any log (e.g., monitoring a rash). Also surface age-appropriate articles pulled from the web. Build in Kotlin with MVVM and Jetpack Compose; persist data in SQLite with coroutines, use a LazyColumn for the timeline, LiveData for the dashboard stats, Coil for image loading, CameraX for photo capture, Retrofit for fetching articles, and SharedPreferences for user settings. Localize for English ('en') and make sure the project compiles on our Linux VM with Gradle.


Question:
Build an Android app that helps teenagers plan and track their STEM science‑fair projects. Each task or milestone should show up as a card in a scrollable list with due dates, progress, and a place for research notes. The app should work smoothly offline and celebrate achievements (like completing a task or submitting a project) with playful animations. Students should get deadline reminders and regular check‑in prompts. They can attach images/diagrams to tasks, and the app may pull project templates or ideas from a remote catalog.

Tech constraints:
- Kotlin + MVVM; XML layouts with ConstraintLayout; Card-based list via RecyclerView
- API 34 as both minSdk and targetSdk
- Room + Coroutines as the single source of truth; repositories injected into ViewModels via Hilt
- WorkManager for scheduling reminders and check‑ins
- Lottie for completion celebrations
- Gson for parsing any remote JSON templates
- Glide to display attached images
- Full localization for id-ID and hi-IN from day one


Question: I love finding street art and quirky buildings, but there’s no place to share these discoveries on a map with others. Please build an iOS app where the map is the centerpiece: people can drop public pins with photos, a short description, and tags; others can view them, comment, and add their own photos. The map must stay smooth even with thousands of pins and thumbnail previews while panning and zooming, and a live feed should reflect new spots as soon as the community posts them. Use MVC overall, a UIKit-based map for maximum performance, and SwiftUI for the detail and comment screens. Manage third‑party libraries with CocoaPods.


Question: Mobile browsing on my iPhone feels slow and cluttered because of ads, trackers, and social widgets. I want an iOS app with a Safari content blocker that cleans this up. The app should work as a simple control center: let me toggle categories (ads, trackers, social widgets) on or off and add sites I want to support to a whitelist. All blocking rules must be stored and updated locally in the app—no servers or background calls—so it works fully offline.


Question: Build an iPhone/iPad app that helps regional managers audit visual merchandising across many partner stores. Managers should be able to fetch store-specific planograms and checklists, browse a long store list that stays fast and responsive while planogram thumbnails load in the background, and use the checklist during a visit. If a display is not compliant, they can take a photo, mark it up (draw, highlight, add notes), and send a detailed report to HQ. Use SwiftUI for the UI and organize the app with MVC.


Question: Mobile browsing on iPhone often feels cluttered and slow. I want a Safari content blocker that filters known ads and trackers so pages load faster and feel more private. The companion iOS app (built with UIKit in MVC) should make it simple to turn the blocker on or off, add sites I want to support to a whitelist, and view lightweight stats about blocking. The rules must stay effective by automatically fetching and applying updated blocklists from our server on a regular schedule, using Safari’s content‑blocking ruleset to block network requests.


Question: We want the app to feel truly native on iPad. Please redesign it with an iPad‑first experience: support multiple windows so a user can open two articles side by side or keep the feed next to an article; use a fully adaptive layout that expands to a three‑column navigation on larger screens; add strong hardware keyboard support with discoverable shortcuts for primary actions (e.g., search, navigate, open a new window); and make drag‑and‑drop work so a user can drag an article from a list into another app to share it. Use iPadOS scene and interaction APIs to stitch these behaviors together.


Question: Design an iOS wealth management dashboard for advisors who need a fast, consolidated view of each client while on the move. The home screen should show a scrollable, multi‑section list per client—asset allocation, recent performance, and action items—with smooth, progressive loading of nested details as you scroll. The app must sign in securely to our advisory platform, fetch and update client data (including portfolio allocations) and sync notes. Keep the project organized with a clear MVC separation so models and views remain manageable.


Question: Build a sleep tracker that helps me wake up refreshed. It should monitor movement and ambient sound overnight, estimate sleep stages, and trigger a smart alarm during a light‑sleep window I set (e.g., 30 minutes before my target wake time). Each morning, show an easy‑to‑read summary with cycle graphs and key metrics, and write the data to Apple Health. Keep a full history and sync it to the cloud so I can browse long‑term trends. Please use SwiftUI for the interface, a simple MVC‑style structure, and manage dependencies with Swift Package Manager.


Question: I’m often buried in massive server logs and need an iOS app that helps me find issues fast. It should open multi‑GB log files quickly and let me browse and search without freezing. The file must be streamed and indexed in the background (do not load the whole file into memory). I need fast regex filters to isolate relevant lines and configurable color rules for timestamps, severity levels, and other patterns. Show an interactive timeline of log activity with pinch‑to‑zoom so I can drill into spikes. The UI should stay responsive while indexing and searches run. Build it in Swift with SwiftUI, organize the code using an MVC approach, and use CocoaPods for dependencies.


Question: Design a simple daily meds/supplements checklist screen for an iOS app. Users should be able to add items to the list, tick a checkbox to mark today’s dose, and remove items they no longer need. All checkmarks should clear automatically at the start of a new day so the list is reset for today. Keep everything on-device; implement the list with a UITableView and store the items plus today’s completion state using UserDefaults. Use Objective-C.


Question: I’m often breaking my reading flow in Safari to look up terms or save references. I want a Safari extension with a companion library app to keep everything in one place. When I select text on a webpage, a small overlay should appear with options to: fetch a definition from a scholarly API, search the term in a research database, or save the selection as a citation. Every saved citation must include the selected text and the page’s URL and automatically sync to the app’s central library so I can review and manage them later.


Question: Build a lightweight iPhone utility that bundles several tiny, single‑purpose tools—like a quick tip calculator and a unit converter—and makes them available as actions in Shortcuts, via Siri, and from Spotlight. The app itself should be a simple settings hub where I can set a default tip percentage and choose common unit conversions, and those preferences should automatically apply whenever I run the actions. Everything must execute locally on‑device, and the integration should use the system’s App Intents/Intents framework so the actions are discoverable and configurable in Shortcuts.


Question: Add a dashboard tile that shows today’s total step count (midnight to now). On first use, present a motion & fitness access prompt with a clear, friendly explanation of why it’s needed. The number should refresh whenever the app returns to the foreground. Implement the step retrieval with CoreMotion in an Objective‑C module.


Question: Add a long‑term goal feature to our iOS app so users can set a target amount and a deadline (e.g., saving for retirement or a home down payment). Whatever they create or edit should appear the same on both iPhone and iPad. If two devices update the same goal around the same time, the app should sync securely with our cloud service and keep the data consistent with a clear, predictable conflict policy. Use an MVVM structure so the goal state is easy to observe and update across screens.


Question: Our customers need a straightforward way to configure complex industrial equipment and get a quote instantly. Create an iOS app with a step-by-step flow where users pick a base model, engine type, and accessories. As they make choices, later steps should only show compatible options using rules from our API, and a running total should update in real time. When they finish, generate a professional PDF quote with the full configuration and customer details, then send it to our sales system. Please build it in Objective-C with UIKit, following an MVC structure.


Question: I often debug responsive issues directly on my iPhone and need a lightweight Safari extension to make that practical. When switched on, it should let me tap any element and display a clear, color‑coded overlay of its CSS box model (margin, border, padding). A small control panel should offer quick presets to emulate popular mobile screen widths by adjusting the page’s viewport, so I can verify responsiveness in seconds. Please deliver it as a self-contained extension organized with an MVC pattern.


Question: We sell complex industrial machines and want an iOS app that a sales rep can use with a customer to configure a product in 3D. The app should display a detailed model that can be rotated and zoomed, and let the rep swap modular parts, choose materials, and pick colors, with the model updating instantly. A simple, touch-friendly control panel (built with SwiftUI) is fine. The app should pull available components and pricing rules from our server so pricing reflects each selection. Please also include an AR mode so the configured machine can be placed in the customer’s space at real scale.