25 ready-to-use ChatGPT prompts for web development. Fill in the bracketed fields, paste into ChatGPT, and go.
Engineering · 25 prompts
01
Build a Responsive Navigation System with Grid, Flexbox, and Mobile Menu States
Create a practical guide for building a responsive navigation system with desktop and mobile states, semantic structure, and breakpoint-specific behavior.
You’ll neednavigation structuredesktop and mobile behaviorbreakpointsaccessibility requirementsstyling constraints
Prompt
You are a senior frontend engineer advising on a responsive navigation implementation rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: a mobile menu overlay with no focus trap that lets keyboard users tab behind it, sticky-header z-index/stacking-context conflicts that break on scroll, breakpoint logic duplicated between CSS media queries and JS resize listeners that drift out of sync, and a hamburger toggle missing aria-expanded/aria-hidden state for screen readers.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Nav structure and breakpoint strategy
- Desktop and mobile state handling
- Keyboard and screen-reader behavior
- Cross-breakpoint testing checklist
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
02
Write a Reusable JavaScript Form Validation Module
Generate a reusable JavaScript validation module that handles required fields, field-specific rules, normalized error output, and browser-friendly integration.
You are a senior web development engineer.
Produce code or a code scaffold for a reusable form-validation module.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: validating only on submit and never re-validating a field after the user fixes it, regex-only email checks that reject valid but unusual addresses, error state that isn't cleared when a field becomes valid again (leaving stale messages on screen), and error messages that aren't announced to screen readers via aria-live.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases (including accessibility of error states)
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
03
Design a Theme Preference System with Persistence, Accessibility, and Rendering Safety
Design a theme preference system with dark and light modes that respects system settings, persists user choice, avoids theme flash, and stays accessible across the UI.
You are a senior frontend engineer advising on a theme preference system rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: a flash of the wrong theme before JS applies the stored preference (FOUC), a system-preference listener that never re-checks once a user has explicitly chosen a theme, color values hardcoded in individual components that bypass the theme system entirely, and localStorage being unavailable in private/incognito browsing breaking persistence silently.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Theme detection and persistence strategy
- Rendering-safety plan to prevent flash-of-wrong-theme
- Component and design-token integration
- Fallback behavior when storage is unavailable
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
04
Design a Web Performance Optimization Plan with Measurement, Rendering, and Asset Tradeoffs
Design a web performance optimization plan with measurement approach, rendering-path fixes, asset strategy, and clear tradeoffs between speed, UX, and implementation cost.
You’ll needsite typestackcurrent performance issuescore web vitals or latency goalsrendering modelconstraints
Prompt
You are a senior frontend performance engineer advising on a web performance optimization effort rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: optimizing for lab metrics like a Lighthouse score while field data (real user monitoring, CrUX) tells a different story, lazy-loading images that are actually above the fold and hurting LCP instead of helping it, unowned third-party scripts left blocking the main thread while first-party code gets all the attention, and code-splitting so aggressively that it multiplies requests and hurts users on slow connections.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Measurement approach (lab vs field data)
- Rendering-path and asset fixes ranked by impact
- Tradeoffs between speed, UX, and implementation cost
- Regression-prevention plan
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
05
Plan an Ecommerce Website Redesign
Create a redesign plan for an outdated ecommerce site with a UI/UX focus.
You’ll needcurrent site issuesbusiness goalsaudienceconstraints
Prompt
You are a senior web development architect creating a plan for a real engineering initiative.
Create a plan for the task below.
Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]
Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: redesigning the checkout flow without preserving the specific steps that currently convert, losing SEO equity because URL structure changes without redirects, cart or session state not migrated cleanly during rollout, and mobile checkout friction ignored because the redesign process centered on desktop mockups.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.
Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- SEO, conversion, and migration risks
- Main assumptions or open questions
Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.
Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
06
Scaffold a React Router App with Nested Routes and Layout Boundaries
Generate a React Router app scaffold with nested routes, shared layouts, not-found handling, and clean route organization.
You’ll needreact and router versionroute maplayout requirementstoolingdata loading needsconstraints
Prompt
You are a senior web development engineer.
Produce code or a code scaffold for a React Router application scaffold.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: data-loading logic duplicated across nested layouts instead of hoisted to the right route level, a not-found route ordered so it shadows valid nested routes, layouts re-rendering on every navigation from a missing key or memoization strategy, and no route-level code splitting, so the initial bundle loads every route up front.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
07
Debug a CSS Alignment Issue
Diagnose CSS alignment problems and recommend clear fixes.
You are a senior web development debugging assistant working on a real production issue.
Diagnose and improve the technical issue below.
Context:
- Problem description: [problem]
- Stack or environment: [stack]
- Current system role or production impact: [system role]
- Expected behavior: [expected]
- Actual behavior: [actual]
- Relevant code, logs, traces, metrics, or signals: [evidence]
Instructions:
1. Check first for the causes that actually produce this class of bug: a parent element missing the display context (block vs flex vs grid) that the alignment properties silently depend on, margin collapsing between sibling elements that looks like a spacing bug but isn't, legacy float-based layout mixed with flex or grid inside the same container, and a percentage or viewport-unit height chain broken by an ancestor with no explicit height.
2. Explain the debugging path in priority order based on risk, probability, and speed of confirmation.
3. Recommend fixes, mitigations, or containment steps and when each is appropriate.
4. Include how to validate the fix and what to monitor after rollout.
5. Keep the answer concise, operational, and biased toward restoring reliability.
Output format:
- Likely root causes (checked against the failure modes above)
- Highest-priority diagnostic steps
- Fix or containment options
- Validation and post-fix monitoring
- Main assumptions or risks
Missing information policy:
Ask up to 2 concise questions only if the stack, production impact, or failure mode is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prioritize root cause over guesswork.
- Name the specific failure modes above rather than generic debugging advice.
- Explain how to verify the fix.
- Include the operational reality of shipping the change safely.
08
Plan a Web Project That Integrates a Third-Party API
Create a sample project plan for integrating a third-party API and displaying data dynamically.
You are a senior web development architect creating a plan for a real engineering initiative.
Create a plan for the task below.
Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]
Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: no caching or rate-limit handling for the third-party API, causing throttling the moment traffic grows, an API key exposed in client-side code instead of proxied through a backend, no fallback UI for when the API is down or slow, and no versioning guard against the provider changing its response shape.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.
Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- API reliability and rate-limit risks
- Main assumptions or open questions
Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.
Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
09
Design a Maintainable Webpack Build for a Frontend with Legacy and Production Constraints
Design a maintainable Webpack build setup that handles bundling, asset processing, environment differences, and production hardening for a real frontend codebase.
You are a senior frontend build engineer advising on a Webpack build configuration rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: a dev configuration accidentally shipped to production with unminified code or exposed source maps, duplicate dependencies bloating the bundle from inconsistent version resolution, environment-variable handling that leaks secrets into the client bundle, and cache-busting/hashing misconfigured so users get stale assets after a deploy.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Build configuration and environment strategy
- Bundle-size and dependency-duplication controls
- Production hardening (minification, source maps, secrets)
- Cache-busting and deployment validation
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
10
Design a Progressive Web App Offline Strategy with Caching and Failure Boundaries
Design a Progressive Web App offline strategy with service worker scope, caching rules, update behavior, and user-facing failure boundaries for a real web app.
You are a senior frontend engineer advising on a Progressive Web App offline strategy rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: a service worker that caches the app shell indefinitely with no update prompt, leaving users stuck on stale code, a cache-first strategy applied to API data that should be network-first, offline fallbacks that cover the home screen but miss critical secondary routes, and an install prompt fired too early or too often that trains users to dismiss it.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Service worker scope and caching strategy
- Update and stale-content handling
- Offline coverage across critical routes
- Install-prompt timing and UX
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
11
Implement User Authentication in Node and Express with Session or Token Tradeoffs
Create an implementation guide for Node and Express authentication covering signup, login, password handling, session or token strategy, and security review points.
You’ll needauth methoddatabasesession or token approachfrontend client typesecurity constraintsdeployment context
Prompt
You are a senior web development engineer advising on a real authentication implementation rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it (schema and hashing, then session or token issuance, then client integration).
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break Node/Express auth in production: cookie flag misconfiguration (missing httpOnly, secure, or sameSite), CSRF exposure on cookie-based sessions, bcrypt/argon2 cost-factor tuning against login latency, and token refresh/revocation gaps that leave stolen tokens valid.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Auth flow (signup, login, session/token issuance, refresh, logout)
- Password and credential handling decisions
- Session or token security hardening checklist
- Revocation and abuse-handling plan
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific auth failure modes above rather than generic "security best practices" language.
- Make the advice usable by an engineering team shipping real work.
12
Create a Technical SEO Launch Checklist for a Website
Build a staged technical SEO checklist covering crawlability, metadata, performance, structured data, and post-launch validation.
You’ll needsite typerendering approachcontent modellaunch goalsknown issuesanalytics or search tooling
Prompt
You are a senior web development practitioner creating a reusable engineering asset for a real team workflow.
Build the asset using the context below.
Context:
- Goal of the asset: [goal]
- System or project context: [context]
- Audience using it: [audience]
- Constraints, standards, or compliance needs: [constraints]
- Quality risks, failure modes, or review focus: [risk focus]
- Stage of use such as design, implementation, release, or incident response: [stage]
Instructions:
1. Create an asset that is immediately usable in a real workflow.
2. Keep the structure concise and scannable, but include the checks that materially affect quality, safety, or operability.
3. Prioritize the checks that catch real technical SEO failures over generic completeness: canonical tags misconfigured and causing duplicate-content penalties, render-blocking JS hiding content from crawlers on JS-heavy sites, structured data errors that go undetected until manual testing catches them, and redirect chains left over from a past migration that quietly bleed link equity.
4. Organize the checklist by launch stage (pre-launch, deploy, post-launch validation) rather than a flat list.
5. Add short usage guidance when it improves consistency or judgment.
6. Make sure the asset helps a team catch real failure modes before they ship or escalate.
Output format:
- Staged checklist (pre-launch, deploy, post-launch validation)
- How to use it well
- Main failure modes or review notes
Missing information policy:
Ask up to 2 concise questions only if the goal, audience, or context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Keep it practical.
- Make the structure reusable.
- Name the specific SEO failure modes above rather than generic checklist bloat.
- Emphasize the checks that prevent real mistakes.
13
Plan Whether WebAssembly Is Actually Worth Introducing into a Web Product
Evaluate whether WebAssembly is worth introducing into a web product by clarifying use cases, performance upside, integration cost, tooling implications, and safer alternatives.
You’ll needcurrent web productperformance or capability problemfrontend stackteam skill leveldeployment constraintsdecision pressure
Prompt
You are a senior web development architect creating a plan for a real engineering initiative.
Create a plan for the task below.
Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]
Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: adopting WebAssembly for a workload where the actual bottleneck is I/O, not compute, underestimating the JS-WASM boundary marshaling overhead that can eat the expected performance gain, a tooling and debugging maturity gap that slows the team down more than expected, and the WASM binary's bundle-size cost hurting initial load more than the runtime gain helps.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.
Output format:
- Plan overview
- Recommended approach and tradeoffs
- Decision: adopt, prototype, or defer
- Risks, dependencies, and validation checks
- Main assumptions or open questions
Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.
Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
14
Design a Headless CMS Blog Architecture with Editorial and Deployment Constraints
Design a headless CMS blog architecture with content modeling, preview flow, publishing workflow, and deployment tradeoffs for a real editorial setup.
You’ll needcms choicefrontend stackcontent model needseditorial workflowhosting constraintsseo or performance requirements
Prompt
You are a senior frontend engineer advising on a headless CMS blog architecture rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: a preview mode that doesn't match production rendering, which erodes editor trust in what they're publishing, a content model too rigid for real editorial needs that forces workarounds within months, webhook-driven rebuilds that create a stale-content window between publish and live, and an unoptimized CMS asset pipeline that tanks page performance.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Content model and editorial workflow decisions
- Preview and publishing pipeline
- Rebuild/revalidation strategy and stale-content window
- Asset and performance handling
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
15
Design a Reusable React Data-Fetching Hook with Caching and Failure-State Boundaries
Design a reusable React data-fetching hook with caching, cancellation, error-state boundaries, and integration expectations for a real frontend codebase.
You are a senior frontend engineer advising on a reusable React data-fetching hook rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: race conditions where a stale request resolves after a newer one and overwrites fresher data, missing cache invalidation after a mutation that leaves the UI showing stale state, a dependency array that's unstable and causes the hook to re-fetch on every render, and an error boundary that can't distinguish a network failure from an empty result from an auth failure.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Hook API and caching strategy
- Race-condition and stale-response handling
- Cache invalidation on mutation
- Error and empty-state differentiation
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
16
Build a Responsive Developer Portfolio Site Skeleton
Generate semantic HTML and CSS for a responsive developer portfolio with strong hierarchy, project cards, and accessible layout patterns.
You are a senior web development engineer.
Produce code or a code scaffold for a developer portfolio site skeleton.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: fixed-pixel layouts that break on very small or very large viewports, unoptimized image assets that inflate load time on what should be a lightweight static site, missing semantic HTML that hurts both accessibility and SEO for a personal site, and no build or minification step at all, leaving a bloated deploy for a simple static page.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
17
Fix Common Cross-Browser Compatibility Issues
Write a troubleshooting guide for resolving common cross-browser problems.
You are a senior web development debugging assistant working on a real production issue.
Diagnose and improve the technical issue below.
Context:
- Problem description: [problem]
- Stack or environment: [stack]
- Current system role or production impact: [system role]
- Expected behavior: [expected]
- Actual behavior: [actual]
- Relevant code, logs, traces, metrics, or signals: [evidence]
Instructions:
1. Check first for the causes that actually produce this class of bug: relying on one browser's CSS behavior with no feature-detection fallback, testing only the latest Chrome and missing Safari's flexbox/gap quirks, using a JS API without checking support and assuming a polyfill exists, and mobile Safari vs Chrome Android rendering viewport and zoom differently for the same CSS.
2. Explain the debugging path in priority order based on risk, probability, and speed of confirmation.
3. Recommend fixes, mitigations, or containment steps and when each is appropriate.
4. Include how to validate the fix and what to monitor after rollout.
5. Keep the answer concise, operational, and biased toward restoring reliability.
Output format:
- Likely root causes (checked against the failure modes above)
- Highest-priority diagnostic steps
- Fix or containment options
- Validation and post-fix monitoring
- Main assumptions or risks
Missing information policy:
Ask up to 2 concise questions only if the stack, production impact, or failure mode is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prioritize root cause over guesswork.
- Name the specific failure modes above rather than generic debugging advice.
- Explain how to verify the fix.
- Include the operational reality of shipping the change safely.
18
Plan a WordPress to React Migration
Create a migration plan for moving a WordPress site to a custom React front end.
You are a senior web development architect creating a plan for a real engineering initiative.
Create a plan for the task below.
Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]
Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: losing SEO rankings from a URL or rendering-model change with no redirect and SSR parity plan, content editors losing the WYSIWYG workflow they relied on in WordPress, plugin-dependent functionality like forms or SEO meta with no scoped React equivalent, and a big-bang cutover instead of an incremental, route-by-route migration.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.
Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- SEO and editorial-workflow risks
- Main assumptions or open questions
Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.
Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
19
Design a Tailwind Adoption Strategy for an Existing Frontend Without Breaking the Styling System
Design a Tailwind adoption strategy for an existing frontend that manages build setup, content scanning, style collisions, migration boundaries, and team-usage discipline.
You are a senior frontend engineer advising on a Tailwind adoption on an existing frontend rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: utility classes conflicting with existing CSS specificity and producing inconsistent overrides, a purge/content configuration that strips classes actually used in production, design-token drift between the existing design system and Tailwind's default scale, and utility-class sprawl from the team lacking shared component patterns.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Migration strategy and coexistence plan with existing CSS
- Purge/content configuration and token alignment
- Shared component patterns to prevent utility sprawl
- Rollout sequencing across the codebase
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
20
Automate Static Site Deployment to GitHub Pages
Write a script that automates deployment of a static site to GitHub Pages.
You are a senior web development engineer.
Produce code or a code scaffold for a GitHub Pages static-site deployment automation.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: relative or base-path misconfiguration that breaks assets on project pages versus user/org pages, a deploy that runs without the build step first and publishes stale content, a custom domain or HTTPS certificate that isn't verified before the DNS cutover, and a deploy branch that conflicts with the source branch and causes accidental overwrites.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
21
Design a Real-Time Chat Architecture with WebSocket Session, Delivery, and Moderation Boundaries
Design a real-time chat architecture with WebSocket session handling, auth boundaries, delivery expectations, reconnection behavior, and moderation or abuse considerations.
You’ll needstackchat requirementsauth needsdelivery expectationsmoderation or compliance needsconstraints
Prompt
You are a senior backend/frontend engineer advising on a real-time chat architecture rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: no reconnect/backoff strategy, leaving clients silently disconnected after a network blip, message ordering and delivery not guaranteed, producing duplicate or out-of-order messages, no rate-limiting or moderation boundary letting abuse flood the socket, and horizontal scaling of WebSocket servers without a shared pub/sub layer that breaks cross-instance delivery.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Session and connection lifecycle (connect, reconnect, backoff)
- Message delivery and ordering guarantees
- Moderation and rate-limiting boundaries
- Scaling model across server instances
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
22
Design HTTPS Termination and Certificate Renewal for a Node.js Service
Design HTTPS termination and certificate renewal for a Node.js service using Let's Encrypt with proxy boundaries, renewal safety, and failure visibility.
You are a senior backend/infrastructure engineer advising on HTTPS termination and certificate renewal rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: renewal automation that fails silently until the certificate expires and takes the site down, the HTTP-01 challenge getting blocked by a load balancer or CDN routing rule, mixed-content warnings from hardcoded http:// asset URLs left over after the switch, and renewal restarts scheduled during high-traffic windows causing avoidable downtime.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Certificate issuance and termination setup
- Renewal automation and failure alerting
- Mixed-content and asset-URL cleanup
- Rollout timing and downtime avoidance
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
23
Create and Publish a React Component Library with Build, Docs, and Versioning Decisions
Write a practical guide for building a React component library with packaging, typing, documentation, and release workflow decisions that hold up beyond a toy example.
You are a senior frontend engineer advising on a published React component library rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: components tightly coupled to the consuming app's global styles instead of properly isolated, no defined versioning or breaking-change policy that leaves consumer apps permanently pinned to old versions, a bundle that isn't tree-shakeable and forces consumers to import the whole library, and documentation/examples that drift out of sync with the actual component API.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Component API and style-isolation decisions
- Build, bundling, and tree-shaking setup
- Versioning and breaking-change policy
- Documentation and example maintenance plan
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
24
Integrate Stripe into a Web Application with Checkout, Webhooks, and Failure Handling
Provide implementation guidance for a Stripe integration that covers checkout flow selection, secure server boundaries, webhook handling, and payment-state edge cases.
You’ll needpayment flowstackcheckout typeorder lifecyclecompliance or security constraintsconstraints
Prompt
You are a senior backend/frontend engineer advising on a Stripe payment integration rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: webhook signature verification skipped or misconfigured, opening a replay/spoofing risk, webhook events handled non-idempotently that cause duplicate order fulfillment, trusting client-side-only payment confirmation without server-side verification, and test-mode keys or logic accidentally shipped to production.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Checkout and payment flow
- Webhook handling and idempotency
- Server-side verification boundary
- Test-to-production safeguards
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
25
Design a GraphQL Delivery Model with Apollo Client, Server Boundaries, and Cache Discipline
Design a GraphQL delivery model with Apollo client and server boundaries, schema scope, cache discipline, error handling, and rollout concerns for a real application.
You are a senior frontend/backend engineer advising on a GraphQL delivery model with Apollo rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: cache normalization mismatches that cause stale or duplicated UI data, an unaddressed N+1 query problem on the server that only shows up at scale, over-fetching from loosely scoped queries that defeats GraphQL's purpose, and error handling that swallows partial-data responses instead of surfacing them to the UI.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Schema and query-scoping decisions
- Cache normalization and client-state strategy
- Server-side resolution and N+1 handling
- Partial-data and error-surfacing behavior
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.