# 100+ AI Prompts for Developers

*A curated collection of ready-to-use prompt templates for coding, debugging, architecture, and productivity.*

**Works with**: ChatGPT, Claude, Gemini, Copilot, and any AI assistant

**How to use**: Replace `{placeholders}` with your specific values, then paste into your AI tool.

---

## Table of Contents

1. [Code Generation (20 prompts)](#1-code-generation)
2. [Debugging (15 prompts)](#2-debugging)
3. [Architecture (15 prompts)](#3-architecture)
4. [DevOps (10 prompts)](#4-devops)
5. [Code Review (15 prompts)](#5-code-review)
6. [Productivity (10 prompts)](#6-productivity)
7. [Learning (15 prompts)](#7-learning)

---

## 1. Code Generation

### CG-01: REST API Endpoint
```
Create a {language} REST API endpoint for {resource} that supports {operations: CRUD/list/search}. Include input validation, error handling, and {database} integration. Follow {framework} conventions and include proper HTTP status codes.
```

### CG-02: React Component
```
Build a React {component_type: form/table/modal/dashboard} component for {purpose}. Include: TypeScript types, loading and error states, responsive design using {CSS_framework}, accessibility attributes, and unit test suggestions. Use functional components with hooks.
```

### CG-03: Database Schema
```
Design a {database_type} schema for a {app_description}. Include tables/collections, fields with types, relationships (one-to-many, many-to-many), indexes for common queries, and migration scripts. Consider data growth and query performance.
```

### CG-04: CLI Tool
```
Create a {language} CLI tool that {functionality}. Include: argument parsing, help text, input validation, error messages with suggestions, progress indicators, and colored output. Make it installable via {package_manager}.
```

### CG-05: Authentication System
```
Implement user authentication in {language/framework} with: signup, login, logout, password reset, email verification, and session management. Use {JWT/sessions/OAuth}, include rate limiting, and follow security best practices (bcrypt hashing, CSRF protection, secure cookies).
```

### CG-06: Data Processing Pipeline
```
Build a {language} data pipeline that {ingestion_description}. Include: data validation, transformation steps, error handling, logging, retry logic, and output to {destination}. Make it configurable via a YAML/JSON config file.
```

### CG-07: API Integration Wrapper
```
Create a {language} SDK/wrapper for the {service_name} API. Include: all endpoint methods, authentication handling, rate limit awareness, pagination support, error classes, type definitions, and usage examples. Add retry logic with exponential backoff.
```

### CG-08: Unit Test Suite
```
Generate comprehensive unit tests for this {language} code using {testing_framework}. Include: tests for happy paths, edge cases, error handling, boundary values, and mock dependencies. Aim for 90%+ coverage.

Code:
{paste_code_here}
```

### CG-09: Regex Pattern
```
Create a regex pattern for {matching_requirement}. Explain how it works step by step. Include: test cases that match, test cases that should NOT match, and a {language} code snippet using this regex with proper escaping.
```

### CG-10: CRUD Operations
```
Implement full CRUD operations for a {resource} model in {language/framework}. Include: model definition, validation rules, controller/service layer, repository pattern, and API routes/endpoints. Add filtering, sorting, and pagination for the list endpoint.
```

### CG-11: WebSocket Handler
```
Create a {language} WebSocket server and client for {use_case}. Include: connection management, heartbeat/ping-pong, room/channel support, message serialization, reconnection logic on the client, and graceful shutdown on the server.
```

### CG-12: Email Template Generator
```
Create an HTML email template for {email_type: welcome/reset/newsletter/receipt}. Must be responsive, work in Gmail/Outlook/Apple Mail, use inline CSS, include a text version, and have a clean dark-mode fallback. Brand colors: {colors}.
```

### CG-13: Payment Integration
```
Integrate {payment_provider: Stripe/PayPal/Razorpay} into a {language/framework} app. Include: checkout flow, webhook handler, subscription management, receipt generation, refund handling, and proper error states. Use their latest API version.
```

### CG-14: Search Implementation
```
Implement search functionality in {language/framework} for {data_type}. Support: full-text search, filtering by {fields}, sorting by relevance/date, faceted navigation, autocomplete/suggestions, and pagination. Use {search_tech: Elasticsearch/Postgres_FTS/Algolia/Meilisearch}.
```

### CG-15: Caching Layer
```
Implement a caching strategy for {language/framework} using {cache_tech: Redis/Memcached/in-memory}. Include: cache keys naming convention, TTL policies, cache invalidation on data changes, cache-aside pattern, cache warming, and fallback when cache is unavailable.
```

### CG-16: File Upload Handler
```
Create a {language} file upload system that handles {file_types}. Include: file validation (type, size limit), virus scanning placeholder, unique filename generation, storage to {storage: local/S3/GCS}, progress tracking, resumable uploads, and cleanup of temp files.
```

### CG-17: Notification System
```
Build a notification system in {language} supporting {channels: email/push/SMS/in-app}. Include: notification preferences per user, template management, queue-based sending, delivery tracking, retry failed notifications, and a notification preferences API.
```

### CG-18: GraphQL API
```
Design a GraphQL API for {domain}. Include: schema definition with types, queries, mutations, and subscriptions. Add DataLoader for N+1 prevention, pagination (cursor-based), authentication directives, and error handling. Use {framework: Apollo/Relay/Yoga}.
```

### CG-19: State Machine
```
Implement a state machine for {entity} with states: {list_states}. Include: valid transitions, guard conditions, entry/exit actions, side effects on transition, event logging, and a visual representation of the state diagram in Mermaid syntax.
```

### CG-20: API Rate Limiter
```
Implement an API rate limiter in {language} using the {algorithm: token_bucket/sliding_window/fixed_window} strategy. Include: per-user and per-IP limits, configurable thresholds, proper HTTP headers (X-RateLimit-*), 429 response handling, and Redis-backed distributed counting.
```

---

## 2. Debugging

### DB-01: Error Diagnosis
```
I'm getting this error in {language/framework}:

Error: {paste_full_error}

Code context:
{paste_code_here}

What I expected: {expected_behavior}
What actually happens: {actual_behavior}

Analyze the error, explain the root cause, and provide a fix.
```

### DB-02: Performance Analysis
```
Analyze this {language} code for performance bottlenecks. Focus on: time complexity, memory usage, database queries (N+1 issues), unnecessary computations, and I/O operations. Provide specific optimizations with before/after code comparisons and expected performance improvement.

Code:
{paste_code_here}
```

### DB-03: Memory Leak Detection
```
This {language} application has a memory leak. It starts at {initial_memory} and grows to {peak_memory} over {time_period}. Review the code for: unclosed resources, event listener accumulation, growing caches, circular references, and retained closures. Provide a fix for each issue found.

Code:
{paste_code_here}
```

### DB-04: Race Condition Fix
```
This concurrent {language} code has a race condition that causes {symptom}. Analyze the code for thread safety issues, identify the race condition, explain the execution interleaving that causes it, and provide a fix using {mutex/lock/atomic/queue_pattern}.

Code:
{paste_code_here}
```

### DB-05: Database Query Optimization
```
This {database} query is slow ({execution_time}) on a table with {row_count} rows:

```sql
{paste_query_here}
```

Analyze the query execution plan, suggest indexes, rewrite for performance, and estimate the improvement. Include the CREATE INDEX statements needed.
```

### DB-06: Network Request Debugging
```
This {language} HTTP request to {endpoint} is failing with {error_or_status_code}. The request details are:

Method: {method}
Headers: {headers}
Body: {body}

The API documentation says {expected_behavior}. Help me identify the issue and fix the request.
```

### DB-07: CSS Layout Debug
```
This HTML/CSS has a layout issue where {describe_problem}. The expected behavior is {expected_layout}. Check for: box model issues, flex/grid misconfigurations, overflow problems, z-index stacking, responsive breakpoints, and browser-specific bugs.

HTML:
{paste_html}

CSS:
{paste_css}
```

### DB-08: Build Error Resolution
```
My {language/framework} project fails to build with this error:

{paste_build_error}

Build tool: {webpack/vite/esbuild/rollup}
{language} version: {version}
Dependencies: {package_manager} {lock_file_version}

I recently {what_changed}. Help me resolve this build error.
```

### DB-09: Type Error Investigation
```
I'm getting a type error in {language_with_types}:

Error: {type_error_message}

Code:
{paste_code_here}

Trace the types through the code, identify where the type mismatch occurs, explain why, and provide a type-safe fix.
```

### DB-10: API Response Mismatch
```
My {language} code sends a request to {api_endpoint} but the response doesn't match what I expect.

Expected response format:
{expected_json}

Actual response:
{actual_json_or_error}

Code making the request:
{paste_code_here}

Help me understand the discrepancy and fix the code.
```

### DB-11: Concurrency Deadlock
```
This {language} application occasionally freezes/hangs. I suspect a deadlock between these operations:
{describe_operations}

Code:
{paste_code_here}

Identify potential deadlock scenarios, draw the resource dependency graph, and provide a fix that eliminates the deadlock while maintaining correctness.
```

### DB-12: Frontend Hydration Error
```
I'm getting a hydration mismatch error in {framework: React/Next.js/Nuxt}:

Error: {error_message}

Component:
{paste_component_code}

This happens when {condition}. Explain the SSR vs client rendering difference causing this and provide a fix.
```

### DB-13: Intermittent Test Failure
```
This test passes locally but fails in CI (or fails intermittently):

Test:
{paste_test_code}

Error when it fails:
{error_message}

The test {what_it_tests}. Check for: timing issues, test order dependencies, shared state, environment differences, and flaky async patterns. Provide a reliable fix.
```

### DB-14: Authentication/Authorization Bug
```
Users report that {auth_issue: can't login/unexpected logout/can't access/permission_denied} in my {language/framework} app. My auth setup uses {auth_method: JWT/session/OAuth} with {library}.

Auth configuration:
{paste_config}

Middleware:
{paste_middleware}

Trace the auth flow step by step, identify where it fails, and provide a fix.
```

### DB-15: Log Analysis Request
```
Analyze these {language/framework} logs and identify the root cause of the issue:

{paste_logs}

For each error/warning, explain: what happened, why it happened, severity level, and recommended fix. Identify any patterns or cascading failures.
```

---

## 3. Architecture

### AR-01: System Design from Scratch
```
Design a {type_of_system: social media/e-commerce/streaming/chat} that handles {scale: DAU/concurrent_users/requests_per_second}. Provide:
1. High-level architecture diagram description
2. Database schema (entities and relationships)
3. API design (key endpoints)
4. Technology stack with rationale
5. Scaling strategy (horizontal/vertical)
6. Caching strategy
7. Failure handling and redundancy
```

### AR-02: Microservices Decomposition
```
I have a monolithic {language} application that handles {business_domains}. Decompose it into microservices. For each service define: responsibilities, data ownership, API contract, communication pattern (sync/async), and dependencies. Include an API gateway design and service discovery approach.
```

### AR-03: Database Design
```
Design the database for {application_description}. Requirements:
- {requirement_1}
- {requirement_2}
- {requirement_3}

Provide: entity-relationship diagram description, table schemas with fields and types, indexes for common queries, denormalization opportunities for read performance, migration strategy from empty state, and estimated storage at {projected_scale}.
```

### AR-04: API Design
```
Design a RESTful API for {domain}. Include: resource naming, endpoint list with methods, request/response schemas (JSON), pagination strategy, filtering and sorting, error response format, versioning approach, rate limiting, and authentication method. Provide OpenAPI/Swagger snippet for the key endpoints.
```

### AR-05: Event-Driven Architecture
```
Design an event-driven architecture for {use_case}. Define: event types and schemas, event bus/message broker choice with rationale, producer and consumer services, event sourcing vs notification events, ordering guarantees, dead letter queue handling, and idempotency strategy for consumers.
```

### AR-06: Caching Architecture
```
Design a multi-layer caching strategy for {application_description}. Cover: browser caching (headers), CDN caching, application-level cache (Redis/Memcached), database query cache, and cache invalidation strategies. Include cache hit ratio targets, TTL policies, and a cache warming plan.
```

### AR-07: Real-time System Design
```
Design a real-time {feature: chat/collaboration/notifications/live_updates} system using {technology: WebSocket/SSE/Socket.io}. Include: connection management, message delivery guarantees, presence system, scaling across multiple servers (pub/sub), reconnection handling, and fallback for restricted networks.
```

### AR-08: Authentication Architecture
```
Design the authentication and authorization system for {application_description}. Include: user registration flow, login with {methods: email/password/OAuth/2FA/SAML}, session vs token management, role-based access control (RBAC) model, API key management for third-party access, and security considerations (brute force, session fixation, CSRF).
```

### AR-09: Data Pipeline Architecture
```
Design a data pipeline that {pipeline_purpose}. Include: data sources, ingestion layer, transformation steps, storage (data lake/warehouse), orchestration tool choice, monitoring and alerting, data quality checks, error handling and retry logic, and estimated throughput at peak.
```

### AR-10: Mobile Backend Architecture
```
Design a backend for a {mobile_app_type} mobile app. Include: API layer (REST/GraphQL), push notification service, offline data sync strategy, image/file upload handling, authentication flow, analytics event tracking, and versioning strategy for backward compatibility with older app versions.
```

### AR-11: CI/CD Pipeline Design
```
Design a CI/CD pipeline for a {language/framework} application. Include: branch strategy ({gitflow/trunk/github_flow}), build steps, test stages (unit/integration/e2e), code quality gates, artifact management, deployment strategies (blue-green/canary/rolling), rollback procedure, and environment promotion (dev → staging → prod).
```

### AR-12: Search Architecture
```
Design a search system for {content_type} with {document_count} documents. Include: indexing strategy, search engine choice (Elasticsearch/Meilisearch/Typesense), relevance tuning approach, autocomplete implementation, faceted search/filters, synonym handling, and index update strategy for real-time content.
```

### AR-13: Multi-tenant Architecture
```
Design a multi-tenant SaaS architecture for {application_description}. Include: tenant isolation strategy (database/schema/row level), tenant provisioning flow, per-tenant configuration, data migration approach, billing integration, and scaling strategy as tenant count grows.
```

### AR-14: Payment System Architecture
```
Design a payment processing system for {business_type}. Include: payment flow (checkout → authorization → capture), integration with {provider: Stripe/Braintree}, webhook handling, idempotency for duplicate prevention, refund/reversal flow, reconciliation process, and PCI compliance considerations.
```

### AR-15: Monitoring & Observability
```
Design the observability stack for a {infrastructure_description}. Include: metrics collection and storage, log aggregation, distributed tracing setup, alerting rules with severity levels, dashboard design for key business/technical metrics, SLO/SLI definitions, and incident response runbook template.
```

---

## 4. DevOps

### DO-01: Dockerfile
```
Create an optimized Dockerfile for a {language/framework} application. Requirements:
- Multi-stage build for minimal image size
- Non-root user for security
- Health check
- Proper .dockerignore
- Layer caching optimization
- Alpine or distroless base
- Environment variable configuration
- Signal handling for graceful shutdown

Provide the Dockerfile, .dockerignore, and build/run commands.
```

### DO-02: Docker Compose Stack
```
Create a Docker Compose configuration for a full-stack app with: {frontend}, {backend}, {database}, and {cache}. Include: health checks for all services, volume mounts for data persistence, environment variables with defaults, networking (internal vs exposed), restart policies, and resource limits. Add comments explaining each section.
```

### DO-03: CI/CD Pipeline
```
Create a {platform: GitHub Actions/GitLab CI/CircleCI} pipeline for a {language/framework} project. Stages: lint, test, build, deploy. Include: caching for dependencies, parallel test execution, deployment to {target: AWS/Vercel/GCP/Render}, Slack/email notification on failure, and manual approval gate for production.
```

### DO-04: Kubernetes Manifests
```
Create Kubernetes manifests for deploying a {language/framework} application. Include: Deployment (with rolling update strategy), Service, Ingress with TLS, ConfigMap, Secrets template, HorizontalPodAutoscaler, and PodDisruptionBudget. Add resource requests/limits and readiness/liveness probes.
```

### DO-05: Infrastructure as Code
```
Write {tool: Terraform/Pulumi/CloudFormation} code to provision: {resources: VPC/subnets/compute/database/CDN}. Include: variable definitions, output values, state management considerations, environment separation (dev/prod), and tagging strategy. Follow the principle of least privilege for IAM.
```

### DO-06: Monitoring Setup
```
Set up monitoring for a {language/framework} application using {tool: Prometheus/Grafana/Datadog/New Relic}. Include: key metrics to track (RED method — Rate, Errors, Duration), custom business metrics, alert rules with thresholds, dashboard JSON/definitions, and log correlation setup.
```

### DO-07: Database Migration Strategy
```
Design a database migration strategy for {database} in a {deployment_environment}. Include: migration tool setup ({tool: Flyway/Liquibase/Prisma/Knex}), backward-compatible migration approach, rollback procedure, zero-downtime migration for schema changes, data migration for large tables, and CI validation of migrations.
```

### DO-08: SSL/TLS Setup
```
Configure HTTPS for {domain} using {tool: Let's Encrypt/Certbot/cloud_provider}. Include: certificate provisioning, auto-renewal setup, HTTP-to-HTTPS redirect, HSTS headers, TLS configuration (ciphersuites, protocols), and certificate monitoring/alerting before expiry.
```

### DO-09: Backup & Recovery Plan
```
Create a backup and recovery plan for {infrastructure_description}. Include: backup frequency and retention policy, backup storage locations (on-site + off-site), database backup method (logical/physical), file/storage backup, disaster recovery procedure, RPO/RTO targets, and regular restore testing schedule.
```

### DO-10: Log Management
```
Set up centralized logging for {infrastructure_description} using {tool: ELK/Loki/Datadog/CloudWatch}. Include: log shipping agent configuration, structured logging format (JSON), log levels and when to use each, log retention policies, log-based alerts, and a correlation ID strategy for request tracing.
```

---

## 5. Code Review

### CR-01: Security Audit
```
Perform a security-focused code review on this {language} code. Check for: SQL injection, XSS, CSRF, authentication bypass, authorization flaws, insecure data handling, exposed secrets/tokens, path traversal, and OWASP Top 10 vulnerabilities. Rate each finding as Critical/High/Medium/Low with a recommended fix.

Code:
{paste_code_here}
```

### CR-02: Performance Review
```
Review this {language} code for performance issues. Analyze: algorithm complexity, unnecessary computations, memory allocations, database query efficiency, network call patterns, caching opportunities, and lazy loading possibilities. For each issue, provide the estimated impact and an optimized alternative.

Code:
{paste_code_here}
```

### CR-03: Clean Code Review
```
Review this {language} code for readability and maintainability. Check: naming conventions, function size (single responsibility), code duplication (DRY), proper error handling, meaningful comments (not obvious ones), consistent style, and adherence to {language} idioms/best practices. Provide refactored suggestions.

Code:
{paste_code_here}
```

### CR-04: API Design Review
```
Review this API implementation for {language/framework}. Check: RESTful conventions, proper HTTP methods and status codes, consistent error response format, pagination implementation, rate limiting, input validation, API versioning, and documentation completeness. Suggest improvements with code examples.

Code:
{paste_code_here}
```

### CR-05: Database Code Review
```
Review this {language} database-related code for: SQL injection vulnerabilities, N+1 query patterns, missing indexes, transaction handling, connection pooling, query performance, proper use of ORM/query builder, and data migration safety. Provide optimized alternatives.

Code:
{paste_code_here}
```

### CR-06: Frontend Review
```
Review this {framework} component for: accessibility (WCAG compliance), performance (unnecessary re-renders, bundle size), responsive design, error boundaries, loading states, proper event handling, memory leaks (cleanup in useEffect), and SEO considerations. Provide improved code.

Code:
{paste_component_here}
```

### CR-07: Test Review
```
Review these tests for: coverage completeness (happy path, edge cases, errors), test isolation (no shared state), proper assertions (specific, not too broad), test naming clarity, test independence (order doesn't matter), mocking correctness, and missing test scenarios. Suggest additional tests to write.

Code:
{paste_tests_here}
```

### CR-08: Error Handling Review
```
Review this {language} code for error handling completeness. Check: are all possible error paths handled? Are errors properly propagated? Is there a global error handler? Are errors logged with context? Are user-facing error messages appropriate? Are resources cleaned up in error cases (finally blocks)?

Code:
{paste_code_here}
```

### CR-09: Dependency Review
```
Analyze this {language} project's dependencies for: outdated packages with known vulnerabilities, unnecessary dependencies, better alternatives, dependency tree bloat, license compatibility issues, and supply chain risk. Provide specific upgrade/downgrade recommendations.

{package_file_contents}
```

### CR-10: Concurrency Review
```
Review this {language} code for thread safety and concurrency issues. Check for: race conditions, deadlocks, shared mutable state, proper synchronization, atomic operations, thread-safe data structures, and potential issues under high load. Provide fixes with explanations.

Code:
{paste_code_here}
```

### CR-11: Architecture Review
```
Review the architecture of this {language/framework} module for: separation of concerns, dependency injection, single responsibility, proper abstraction levels, coupling between modules, testability, and adherence to {pattern: MVC/Clean Architecture/Hexagonal}. Suggest structural improvements.

Code structure:
{describe_or_paste}
```

### CR-12: Logging Review
```
Review this {language} code for logging best practices. Check: appropriate log levels, structured logging, sensitive data redaction, log message clarity, correlation IDs, context enrichment, performance impact of logging, and proper logging in error paths. Provide improved logging code.

Code:
{paste_code_here}
```

### CR-13: Configuration Review
```
Review this {language/framework} configuration approach for: environment variable handling, secrets management, config validation, default values, config documentation, environment-specific overrides, and runtime config updates. Ensure no secrets are hardcoded.

Configuration files:
{paste_config_files}
```

### CR-14: API Contract Review
```
Review this API contract between {service_a} and {service_b}. Check for: backward compatibility, versioning strategy, field naming consistency, required vs optional fields, pagination approach, error response format, timeout and retry expectations, and idempotency guarantees.

Contract/API definitions:
{paste_api_spec}
```

### CR-15: Migration Review
```
Review this database migration for: backward compatibility (can it run while app is serving traffic?), rollback safety, data integrity (are constraints in place?), performance impact on large tables, locking concerns, and data loss risk. Provide a safer alternative if issues are found.

Migration:
{paste_migration_code}
```

---

## 6. Productivity

### PR-01: README Generator
```
Generate a comprehensive README.md for a {language/framework} project called "{project_name}" that {project_description}. Include: badges, description, features list, installation instructions, usage examples, API reference, configuration options, contributing guidelines, license, and a table of contents. Use clear, professional language.
```

### PR-02: Documentation Writer
```
Write API documentation for this {language} endpoint/method. Include: description, parameters table (name, type, required, default, description), request example (cURL and {language}), response example (success and error), status codes, rate limits, and common gotchas. Use a clean, scannable format.

Code:
{paste_code_here}
```

### PR-03: Git Commit Messages
```
Given these staged changes, generate 3 conventional commit message options:

Changes:
{git_diff_or_description}

Format: type(scope): description. Types: feat, fix, docs, style, refactor, perf, test, chore. Keep the subject under 72 characters.
```

### PR-04: Changelog Generator
```
Generate a changelog entry from these commits since version {previous_version}. Group by: Breaking Changes, New Features, Bug Fixes, Improvements, and Dependencies. Include upgrade notes for breaking changes. Follow Keep a Changelog format.

Commits:
{paste_git_log}
```

### PR-05: Code Comments
```
Add meaningful comments to this {language} code. Focus on: WHY the code does something (not WHAT it does), algorithm explanations, business rule references, gotchas and edge cases, TODOs for future improvements, and JSDoc/docstring format for public APIs. Do NOT add obvious comments.

Code:
{paste_code_here}
```

### PR-06: TypeScript Types from JSON
```
Generate TypeScript types/interfaces from this JSON response. Include: proper types (not `any`), optional fields, enums where appropriate, JSDoc comments for each field, and a namespace or module structure if complex.

JSON:
{paste_json_here}
```

### PR-07: Regular Expression Explainer
```
Explain this regular expression step by step, as if teaching a {level: beginner/intermediate} developer:

Regex: {paste_regex}

Also provide: visual breakdown, test strings that match, test strings that don't match, and a simplified alternative if one exists.
```

### PR-08: Code Refactoring Plan
```
Analyze this {language} code and create a step-by-step refactoring plan. For each step: describe the change, explain the motivation, estimate the risk level (low/medium/high), and note any dependencies between steps. Order from lowest risk to highest.

Code:
{paste_code_here}
```

### PR-09: Environment Setup Script
```
Create a setup script ({shell/powershell/makefile}) for a {language/framework} development environment. Include: dependency installation, environment variable template creation, database setup, seed data, build steps, development server start, and useful aliases/shortcuts. Make it idempotent (safe to run multiple times).
```

### PR-10: Meeting Notes to Action Items
```
Convert these meeting notes into structured action items. For each action: assign an owner (if mentioned), set a priority (urgent/high/medium/low), note any dependencies, and suggest a deadline. Also list key decisions made and open questions.

Meeting notes:
{paste_notes}
```

---

## 7. Learning

### LE-01: Concept Explainer
```
Explain {concept} in {language/framework} as if I'm a {level: beginner/junior/mid} developer. Include:
1. Simple one-line definition
2. Why it matters (real-world motivation)
3. Step-by-step example with annotated code
4. Common mistakes to avoid (3-5)
5. Practice exercises (3, increasing difficulty)
6. "Next level" — where to go from here
```

### LE-02: Technology Comparison
```
Compare {technology_a} vs {technology_b} for {use_case}. Include:
- When to use each (decision matrix)
- Performance comparison
- Ecosystem and community
- Learning curve
- Migration difficulty between them
- My recommendation for {my_situation} and why
Present as a balanced analysis, not a fan piece.
```

### LE-03: Learning Roadmap
```
Create a {duration: 2-week/1-month/3-month} learning roadmap for {technology/topic} aimed at a developer who knows {prerequisites}. Break into weekly milestones with: concepts to learn, hands-on projects, resources (free preferred), and checkpoint assessments. Focus on practical skills over theory.
```

### LE-04: Code Walkthrough
```
Walk through this code line by line and explain what it does. For each section: explain the purpose, note any non-obvious patterns, identify the design pattern being used (if any), and point out things a {level} developer might miss. End with a high-level summary of the overall approach.

Code:
{paste_code_here}
```

### LE-05: Algorithm Explanation
```
Explain the {algorithm_name} algorithm. Include:
1. Problem it solves
2. Intuition (analogy from real life)
3. Step-by-step walkthrough with a small example
4. Code implementation in {language}
5. Time and space complexity analysis
6. When to use it vs alternatives
7. Common variations and follow-up problems
```

### LE-06: Design Pattern Tutorial
```
Teach the {pattern_name} design pattern with a practical example in {language}. Include:
1. What problem it solves
2. UML-like structure description
3. Real-world analogy
4. Full working code example (not abstract)
5. When NOT to use it
6. Related patterns
7. A mini-project to practice
```

### LE-07: Error Message Translator
```
Explain this {language/framework} error message in plain English:

{error_message}

Include:
1. What the error means (jargon-free)
2. The most common cause
3. How to debug it step by step
4. The fix (with code example)
5. How to prevent it in the future
```

### LE-08: Framework Deep Dive
```
Do a deep dive into {feature} in {framework}. Cover:
1. How it works internally (high level)
2. Common use cases with code examples
3. Edge cases and gotchas
4. Performance implications
5. Best practices
6. Comparison with the alternative approach
7. Advanced techniques
```

### LE-09: Code Review as Learning
```
This code was written by a junior developer. Review it not just for bugs, but as a teaching opportunity. For each suggestion: explain WHY the change matters, link to a principle or best practice, and rate importance (must-fix vs nice-to-have). Be constructive and educational.

Code:
{paste_code_here}
```

### LE-10: Architecture Decision Record
```
Write an Architecture Decision Record (ADR) for choosing {technology/approach} for {problem}. Include:
1. Context (what is the issue?)
2. Decision (what are we doing?)
3. Alternatives considered
4. Rationale (why this choice?)
5. Consequences (pros and cons)
6. Reversibility plan

Use the ADR template format that's easy to revisit later.
```

### LE-11: Terminal/Git Command Guide
```
Create a practical guide for {tool: git/docker/kubernetes/{CLI_tool}} focused on {developer_level} developers. Include: the 20 most useful commands, what each does, common flag combinations, real-world examples, and a "danger zone" section of commands to be careful with. Format as a cheat sheet.
```

### LE-12: Code to Diagram
```
Analyze this code and generate a Mermaid diagram showing the architecture/flow. Include: module dependencies, class hierarchy, data flow, or state transitions (whichever is most appropriate). Add annotations to explain key relationships.

Code:
{paste_code_here}
```

### LE-13: Performance Optimization Guide
```
Create a performance optimization guide for {technology/framework}. Include: profiling tools and how to use them, the most common performance bottlenecks in {technology}, optimization techniques ordered by impact, how to measure improvement, and when to stop optimizing (the 80/20 rule).
```

### LE-14: Security Best Practices
```
List the top 10 security best practices for {language/framework} web applications. For each practice: explain the vulnerability it prevents, show a vulnerable code example, show the secure code example, and rate how common the vulnerability is in production. Include a pre-launch security checklist.
```

### LE-15: Testing Strategy Guide
```
Design a testing strategy for a {language/framework} {project_type} project. Cover:
1. Test pyramid (unit/integration/e2e ratio)
2. Testing framework setup
3. What to test and what NOT to test
4. Mocking strategy
5. Test data management
6. CI integration
7. Coverage targets (and what they really mean)
8. Practical examples for each test type
```

---

## How to Get the Most from These Prompts

1. **Be specific** — Replace ALL placeholders with real values
2. **Provide context** — Paste relevant code, error messages, or data
3. **Iterate** — If the first response isn't perfect, ask follow-up questions
4. **Combine** — Chain multiple prompts (e.g., generate code → review it → optimize)
5. **Save winners** — Keep prompts that work well and customize them further

---

*Built by [BigPicture AI](https://github.com/biggykidid-source) — Check out [DevUtils](https://biggykidid-source.github.io/devtools/) for free developer tools.*