AI Prompt Library

Generate a fully typed React component from a plain-English description.

Scaffold a production-ready REST API endpoint with validation.

Generate a well-structured database schema with relationships and indexes.

Build a reusable custom hook with proper TypeScript typing.

Transform traditional CSS into clean Tailwind utility classes.

Generate a production-quality Python script with CLI support.

Build a type-safe server action with validation and revalidation.

Scaffold a complete auth flow with security best practices.

Design a GraphQL API with efficient resolvers and auth.

Create a responsive layout with loading and empty states.

Build an accessible form with schema-based validation.

Add real-time capabilities with robust connection handling.

Create a polished CLI tool with interactive prompts.

Implement advanced data fetching with caching and optimistic updates.

Build composable middleware with security and logging.

Model complex UI flows as a typed state machine.

Build a cross-client compatible HTML email template.

Add accessible drag-and-drop with persistence.

Create a reliable scheduled task with overlap protection.

Build smooth, accessible animations with Framer Motion.

Create a complete file upload system with cloud storage.

Build search with debounce, highlighting, and keyboard nav.

Set up a multi-service Docker development environment.

Build a full-featured, URL-synced pagination component.

Create a robust error boundary with logging and retry.

Configure full internationalization with RTL and plurals.

Build a feature-rich data table with export capability.

Implement social login with account linking.

Create a toast system with stacking and gestures.

Build a sliding-window rate limiter with Redis.

Get a clear explanation and fix for any error message.

Find and fix memory leaks in your application.

Determine whether the bug is in the test or the code.

Identify and fix performance bottlenecks in your code.

Understand and fix complex TypeScript type errors.

Fix layout issues with clear visual explanations.

Find and fix race conditions in async code.

Stop unnecessary React re-renders.

Transform API responses to match frontend types.

Resolve merge conflicts while preserving both changes.

Fix environment variable loading issues.

Understand and fix CORS errors properly.

Optimize slow SQL queries with index recommendations.

Resolve server/client hydration mismatches.

Find and break infinite loops in your code.

Fix build failures from dependency or config issues.

Audit code for common security vulnerabilities.

Fix Docker container startup failures.

Fix and explain broken regular expressions.

Fix stale closure bugs in React components.

Create a comprehensive system design document.

Plan a monolith-to-microservices migration.

Design a scalable project folder organization.

Choose and implement an API versioning approach.

Plan a zero-downtime database migration.

Design a multi-layer caching architecture.

Design an event-driven system with reliable delivery.

Create a production CI/CD pipeline with rollbacks.

Build a feature flag system for gradual rollouts.

Design multi-tenant data isolation for SaaS.

Choose the right design pattern for your problem.

Set up comprehensive monitoring and alerting.

Create an analytics-ready data model.

Make an informed serverless vs server decision.

Choose and structure frontend state management.

Generate comprehensive unit tests for any function.

Test React components with user-centric assertions.

Create end-to-end tests with Playwright.

Test API endpoints with realistic scenarios.

Generate typed mocks and stubs for testing.

Build flexible test data factories.

Configure snapshot testing with best practices.

Create load tests with realistic traffic patterns.

Test for WCAG compliance and keyboard access.

Set up isolated database testing with auto-rollback.

Test error handling and failure recovery.

Detect unintended visual changes automatically.

Ensure API compatibility between services.

Find and fill gaps in test coverage.

Evaluate test quality with mutation testing concepts.

Create a comprehensive project README.

Document REST API endpoints with examples.

Add meaningful JSDoc comments to your codebase.

Document architecture decisions for the team.

Generate a structured changelog from git commits.

Write a new developer onboarding guide.

Document common issues and their solutions.

Guide users through version or library migrations.

Document components with interactive Storybook stories.

Create a complete env var reference document.

Draft a technical blog post with code examples.

Create a 5-email onboarding sequence.

Write converting landing page copy.

Draft a technical proposal or RFC.

Write SEO-optimized product descriptions.

Create a compelling case study with results.

Create an engaging social media thread.

Write a clear step-by-step tutorial.

Write user-friendly release notes.

Draft a developer newsletter with curated content.

Transform technical errors into friendly messages.

Outline a conference talk with demos.

Write inclusive, compelling job descriptions.

Draft a funding or grant proposal.

Write a balanced comparison article.

Write a transparent investor update.

Draft a professional press release.

Write team announcements people actually read.

Structure a thought-leadership white paper.

Write a video script with visual cues.

Generate a complete SWOT with action strategies.

Map the competitive landscape with recommendations.

Map your business model on one canvas.

Design a data-informed pricing strategy.

Build detailed customer personas for targeting.

Define OKRs with measurable key results.

Plan stakeholder comms with RACI matrix.

Assess project risks with mitigation plans.

Design productive meeting agendas.

Evaluate vendors with a weighted scorecard.

Structure a quarterly business review.

Plan a product launch strategy.

Draft a justified budget proposal.

Propose a business partnership with clear terms.

Map the full customer journey with emotions.

Structure sprint planning for your team.

Project revenue with scenario analysis.

Document a business process end-to-end.

Run a structured sprint retrospective.

Create a comprehensive service level agreement.

Plan SEO-optimized content with keyword strategy.

Generate A/B testable ad copy variations.

Plan a month of social content.

Generate high-open-rate subject lines.

Plan a successful Product Hunt launch.

Design a lead magnet with delivery sequence.

Plan a statistically valid A/B test.

Create a viral referral program.

Promote a webinar across all channels.

Define your brand's voice and tone.

Pitch yourself as a podcast guest.

Respond to customer reviews professionally.

Analyze competitor advertising strategies.

Design an automated email drip campaign.

Craft influencer collaboration proposals.

Perform a thorough code review with severity ratings.

Quantify and prioritize technical debt.

Find gaps and ambiguities in requirements.

Audit npm packages for security and bloat.

Turn user feedback into actionable insights.

Analyze web performance and create an improvement plan.

Quantify the costs and benefits of a decision.

Compare data modeling approaches with trade-offs.

Review API design for best practices.

Audit for WCAG 2.1 AA compliance.

Reduce bundle size with targeted optimizations.

Write a blameless incident post-mortem.

Estimate TAM/SAM/SOM for your market.

Evaluate and improve your testing strategy.

Build a team technology radar.

Build a GitHub Actions CI/CD pipeline.

Automate app integrations with Zapier.

Create a reliable ETL data pipeline.

Build a custom Slack bot command.

Extract data from websites responsibly.

Automate recurring report generation.

Define infrastructure as code.

Automate encrypted database backups.

Automate code scaffolding with templates.

Build a multi-channel notification system.

Set up centralized log aggregation.

Automate multi-platform content publishing.

Build health check endpoints for your services.

Automate data quality validation.

Automate deployment rollback on failure.

Get clear explanations at your level.

Generate coding exercises for skill building.

Plan a structured learning path.

Get a guided walkthrough of any code.

Prepare for technical interviews.

Learn design patterns with real examples.

Visualize algorithm execution step by step.

Learn refactoring through guided exercises.

Practice system design interviews.

Create flashcards for spaced repetition.

Practice debugging with hidden-bug challenges.

Understand concepts at multiple complexity levels.

Get project ideas matched to your skill level.

Learn best practices with do's and don'ts.

Get actionable summaries of tech books.

Generate standup updates from your activity.

Generate PR descriptions from diffs.

Write conventional commit messages.

Turn messy notes into structured summaries.

Break complex tasks into actionable sub-tasks.

Create polished weekly status reports.

Build and test regex patterns from descriptions.

Clean up and improve code comments.

Calculate and forecast sprint velocity.

Make tech stack decisions with a weighted matrix.

Get a concept explained with zero assumptions about prior knowledge

Create a focused exercise to learn a topic in half an hour

Step-by-step mini-project demonstrating a concept

Generate a quiz to test understanding of a topic

Learn the most common mistakes beginners make

Build a project with every line explained

Convert a no-code workflow into actual code

Create a structured learning plan for a new skill

Understand the difference between two similar concepts

Get mentorship-style feedback on your code

Create a bootcamp-style project brief for building an app

Design a portfolio project that showcases specific skills

Create a coding challenge that tests understanding of a concept

Generate study flashcards with questions and answers

Understand APIs from absolute zero

Learn database concepts from scratch with hands-on examples

Master Git from zero with practical exercises

Learn React core concepts with a mini project

Learn Next.js App Router from scratch

Transition from JavaScript to TypeScript smoothly

Learn Tailwind CSS by building real components

Practice coding interview questions with explanations

Learn system design interview fundamentals

Understand auth flows: sessions, JWT, OAuth from scratch

Learn to deploy your first app to the internet

Learn systematic debugging techniques

Write code that other developers can understand

Learn to write your first tests with practical examples

Make any layout work on every screen size

Make your web apps usable by everyone

Master callbacks, promises, and async/await

Set up a professional development environment from scratch

Fix common CSS layout problems systematically

Create a complete app with frontend, backend, and database

Decode every field in package.json

Learn essential data structures with practical web dev examples

Understand common error messages and fix them fast

How to read and learn from real open source projects

Choose the right state management approach for React apps

Create your own command-line tool from scratch

Understand HTTP, DNS, TCP, and how the internet works

Learn how to effectively code with an AI assistant

Generate complex spreadsheet formulas from plain English

Create a structured presentation outline from a topic

Draft professional emails for any business situation

Create an effective meeting agenda from a topic list

Transform messy meeting notes into structured summaries

Generate a professional weekly status report

Analyze CSV or spreadsheet data and extract insights

Create Standard Operating Procedure documents

Create training materials for teaching a skill or process

Write compelling and inclusive job descriptions

Draft a quarterly business report from raw data

Create templates for common customer communications

Write a business or project proposal

Review a contract and flag key terms and risks

Analyze and optimize your calendar for productivity

Prioritize your task list using proven frameworks

Improve team communication and reduce meetings

Analyze financial data and create summary reports

Create a multi-touch outreach email sequence

Design a project status dashboard for stakeholders

Draft company policies and guidelines

Clean messy spreadsheet data into consistent format

Create pivot tables and charts from raw data

Create effective follow-up emails that get responses

Design an n8n automation workflow from a process description

Design a multi-step automation for a business process

Write a scheduled script for automated tasks

Build a complete CI/CD pipeline with GitHub Actions

Automate email responses for common scenarios

Create a data processing pipeline from source to destination

Build a bot that monitors a source and sends alerts

Automate recurring report generation from data sources

Create a webhook receiver that processes events from external services

Build a social media scheduling automation system

Automate invoice receipt, extraction, and processing

Automate the new customer onboarding process

Build an automated lead scoring system

Automate content creation, review, and publishing workflow

Automatically organize files by type, date, or content

Determine when to use Server Components vs Client Components

Design a layout system with shared and nested layouts

Implement dynamic routing patterns in Next.js App Router

Build type-safe API routes with input validation

Implement middleware for authentication, redirects, and more

Build a comprehensive SEO metadata system for Next.js

Set up i18n with multiple languages in Next.js App Router

Handle forms with Next.js Server Actions

Add real-time capabilities to a Next.js application

Implement complete authentication flow with NextAuth.js

Set up Prisma ORM with Next.js for database operations

Optimize a Next.js app for maximum performance

Build a collection of reusable React hooks

Implement comprehensive error handling in React/Next.js

Implement streaming and loading states with React Suspense

Define complex TypeScript types for real-world data

Build reusable generic types for common patterns

Leverage TypeScript type inference for cleaner code

Model application states with discriminated unions

Build powerful string-based types with template literals

Master conditional types for advanced type logic

Transform types with mapped types

Write effective type guards for runtime type checking

Extend third-party types with module augmentation

Migrate a JavaScript or loose TypeScript project to strict mode

Type API responses for full-stack type safety

Design a complete REST API from business requirements

Design a GraphQL schema from data requirements

Implement a complete authentication system

Implement rate limiting for an API

Build a reusable input validation system for APIs

Build a centralized error handling system for APIs

Optimize slow database queries for better performance

Design a caching strategy for your application

Build a webhook delivery system for your API

Build a robust file upload system with validation and storage

Build a search feature with filtering and ranking

Implement efficient pagination for lists and feeds

Generate comprehensive API documentation

Design a database schema from business requirements

Generate database migrations for schema changes

Generate realistic seed data for development and testing

Design an optimal indexing strategy for your database

Apply common data modeling patterns to your schema

Set up full-text search in your database

Write complex aggregation queries for reporting

Build a Retrieval-Augmented Generation system from scratch

Build an AI chatbot that remembers conversation history

Build semantic search using AI embeddings

Build a system that answers questions from your documents

Build an AI content generation system with human review

Build a sentiment analysis system for customer feedback

Build an AI-powered text classification system

Build an AI recommendation system

Use AI to auto-fill forms from unstructured data

Build a text summarization system for different content types

Build an AI code review bot for pull requests

Build an AI agent that can use external tools to accomplish tasks

Build a translation system for multilingual content

Build a complete application using the vibe coding approach

Convert a design mockup into working Next.js code

Generate a complete CRUD application for any domain

Add a new feature to an existing project with AI assistance

Refactor existing code to follow best practices

Make any component responsive and accessible

Add polished animations to a UI component

Convert a JavaScript file to TypeScript with proper types

Build a reusable component library for a specific use case

Build a high-converting landing page from requirements

Scaffold a complete project structure with all files

Implement a feature with comprehensive tests using TDD

Find and fix a bug with systematic root cause analysis

Audit your application code for security vulnerabilities

Protect your app against the OWASP Top 10 vulnerabilities

Sanitize user input to prevent injection attacks

Secure your environment variables and secrets

Configure security headers for your web application

Scan and fix vulnerabilities in project dependencies

Manage API keys securely across environments

Create optimized Docker images with multi-stage builds

Create Kubernetes deployment manifests for your application

Create a Helm chart for deploying your application

Optimize your CI/CD pipeline for speed and reliability

Define your infrastructure with Terraform

Set up centralized logging for your application

Create monitoring dashboards with Grafana

Write load tests to find performance limits

Implement zero-downtime deployments with blue-green strategy

Document procedures for rolling back failed deployments

Set up secure secret management for your infrastructure

Create an SEO-optimized blog post outline

Create a monthly social media content calendar

Write compelling product descriptions that sell

Write engaging email newsletter content

Write a compelling customer case study

Write scripts for marketing or educational videos

Turn one piece of content into multiple formats

Create copy variations for A/B testing

Draft a press release for a company announcement

Write high-converting landing page copy

Create comprehensive podcast show notes from a transcript

Master the most important spreadsheet lookup functions

Automate repetitive spreadsheet tasks with scripts

Map and optimize a business process

Structure productive one-on-one meetings

Write effective self-assessments and performance reviews

Build an interactive dashboard in Google Sheets or Excel

Analyze competitors systematically

Automate database backups with rotation and verification

Build an automated web scraping and data collection pipeline

Build a Slack bot for team automation

Automatically parse and process incoming emails

Build a unified notification system across channels

Automate PDF generation from data and templates

Sync environment configuration across dev, staging, and production

Optimize a slow React component for better performance

Implement common design patterns in TypeScript

Build a real-time chat application with WebSockets

Implement a state machine for complex business logic

Implement comprehensive API error handling on client and server

Design a multi-tenant SaaS application architecture

Implement an OAuth 2.0 provider for your API

Build a drag and drop interface with React

Find and fix memory leaks in your application

Debug failed or slow API calls systematically

Practice reading and understanding code you didn't write

Use AI as a rubber duck debugging partner

Document architectural decisions for your project

Practice technical interviews with realistic scenarios

Practice explaining code clearly for code reviews and interviews

Understand PWA features and implementation

Learn to consume GraphQL APIs in React applications

Understand CI/CD from scratch with hands-on setup

Visualize abstract technical concepts with diagrams

Create a spaced repetition study plan for technical topics

Solidify your knowledge by teaching a concept to others

Reflect on weekly learning and plan the next week

Document your learning journey for building in public

Set up a personal knowledge management system

Optimize your daily development workflow for maximum efficiency

Write clear technical documentation, blog posts, and READMEs

Condense long documents into executive summaries

Create a comprehensive new employee onboarding checklist

Create a project or department budget template

Design effective customer surveys that get responses

Communicate organizational changes effectively

Run an effective project retrospective or post-mortem

Delegate tasks effectively with clear ownership

Write concise stakeholder updates that busy leaders actually read

Build a central hub that integrates multiple APIs

Set up comprehensive automated testing in CI/CD

Build an RSS feed aggregator with AI summaries

Build a health check system with a public status page

Build a CLI tool that generates project boilerplate

Set up Git hooks for code quality automation

Automatically generate changelogs from Git history

Build a transactional email system with templates

Integrate Stripe payments into your application

Build an image upload system with optimization and CDN

Build an in-app notification center like GitHub or Slack

Build a feature-rich data table component

Handle dates, numbers, and currencies for multiple locales

Build a feature flag system for gradual rollouts

Set up background job processing for async tasks

Implement a token bucket rate limiter from scratch

Build a split-pane markdown editor with live preview

Build a URL shortener with analytics

Build a multi-step form with validation and persistence

Build a complete admin dashboard layout with navigation

Build a type-safe configuration system for multiple environments

Track all data changes with a comprehensive audit trail

Hands-on exercise for handling API errors properly

Practice refactoring messy code into clean code

Practice designing database schemas from real requirements

Create a simple Chrome extension from scratch

Learn regular expressions through progressive exercises

Test your understanding of API design principles

Learn Docker from zero with hands-on exercises

Understand WebSockets from theory to implementation

Learn to navigate and understand technical documentation effectively

Create a personal API that serves your own data

Conduct a SWOT analysis for a project or business

Identify which business processes should be automated

Write a professional incident report for any situation

Design and facilitate an effective workshop or brainstorming session

Set effective OKRs for individuals or teams

Set up a local AI model for privacy-first applications

Automate visual testing with screenshots

Build real-time updates using Server-Sent Events

Implement optimistic UI for instant-feeling interactions

Build performant infinite scroll with virtualization

Build a command palette like VS Code or GitHub

Build a dynamic form builder that generates forms from JSON

Complete hands-on tutorial for building your first API

Understand React component lifecycle with hooks

Generate a daily coding kata for skill building

Get a detailed explanation of any error message

Create a cohesive personal brand for your developer presence

Create beautiful README badges for your GitHub projects

Design an Extract-Transform-Load pipeline for data integration

Build a data validation system with configurable rules

Analyze and optimize pricing for a product or service

Create detailed user personas for product development

Map the complete customer journey from awareness to advocacy

Assess whether a feature or project is technically feasible

Compare technologies for an informed decision

Create a comprehensive test strategy for your project

Build comprehensive E2E tests with Playwright

Test API routes comprehensively with Vitest

Track technical and business decisions with context

Create a comprehensive code review checklist for your team

Understand event bubbling and delegation patterns

Master CSS Grid with practical layout exercises

Create a project plan with Gantt chart timeline

Build a simple uptime monitor with alerts

Build a dynamic breadcrumb component from URL structure

Build a GDPR-compliant cookie consent banner

Build a type-safe API client SDK for your backend

Generate a cohesive color palette for your application

Set up and manage SSL/TLS certificates

Choose between Docker Compose, Docker Swarm, and Kubernetes