AI Prompts Library

Isometric illustration (1024x1024) of [SCENE - e.g., a developer’s desk / a server room / a startup office].

Style: flat-color isometric, 30-degree projection, clean linework.
Palette: limited to 5 colors maximum, [PRIMARY COLOR] dominant.
Elements: [LIST OBJECTS - laptop, monitor, plant, coffee, keyboard, etc.] each rendered at consistent scale.
Lighting: subtle drop shadows, no gradients.
Background: solid pastel color, no clutter.
Mood: friendly, professional, modern tech.

No text in the illustration. Designed for use as a marketing-page hero or section divider.

Generate a set of 6 line-art icons in a single image (1024x1024 grid, 3x2).

Icons: [ICON 1], [ICON 2], [ICON 3], [ICON 4], [ICON 5], [ICON 6].
Style: single-weight stroke, 2px, rounded line caps, no fill.
Color: solid #1f2937 strokes on white background.
Size: each icon centered in its grid cell with 20px padding.
Design: minimalist, contemporary, web-app friendly.

Export as SVG for clean vector use.

Icons should share visual language and feel like one set.

Editorial portrait of [SUBJECT DESCRIPTION] for a [PUBLICATION TYPE - Forbes / The New Yorker / Wired] feature.

Lighting: dramatic single-source key light from upper left, deep shadows on opposite side.
Lens: 85mm f/2 portrait lens, sharp focus on eyes, subtle bokeh background.
Composition: tight headshot, eye-level, slight asymmetry.
Mood: contemplative, intelligent, gravitas.
Background: out-of-focus dark backdrop, possibly with hint of environment context.
Grading: cinematic color grade, slight film grain.
Aspect ratio: 4:5 vertical for editorial layout.

Ethnically neutral / [SPECIFY IF NEEDED]. No retouching beyond natural skin texture.

Storyboard frame (1920x1080) for shot #[N] of a [PROJECT TYPE - ad / explainer / film].

Scene description: [WHAT IS HAPPENING].
Framing: [WIDE / MEDIUM / CLOSE-UP / EXTREME CLOSE-UP].
Camera angle: [EYE LEVEL / LOW / HIGH / DUTCH].
Key subject: [SUBJECT].
Lighting: [DAY / NIGHT / GOLDEN HOUR / NEON / NATURAL].
Mood: [TONE].
Motion notes (text overlay, top-left): "[CAMERA MOVE - pan, dolly, static]".
Dialogue / VO (text overlay, bottom): "[LINE]".

Sketch style: clean black-and-white pencil drawing, simple line work.
Not a final render - clearly a storyboard.

You are working in the codebase at [PATH]. Your task is to implement [FEATURE].

Follow this protocol:
1. First, READ the relevant files to understand the existing patterns (controllers, models, views).
2. Plan the change in 3-5 bullets. Don't implement yet.
3. Once I confirm the plan, implement step by step.
4. After implementation, run [TEST COMMAND] and report results.
5. Do NOT modify files outside the listed scope without asking.

Scope: only files in [DIRECTORY].
Constraints: keep the existing coding style. Don't add new dependencies.
Deliverable: working feature + brief PR description.

Start by reading and reporting back what you found. Don't change anything yet.

There's a bug in [PROJECT/COMPONENT]. The symptom is: [DESCRIBE SYMPTOM].

Do not fix it yet. First, INVESTIGATE:
1. Read the relevant files. List file paths and line numbers you suspect.
2. Form 3 hypotheses about the root cause, ranked by likelihood.
3. For each hypothesis, describe how you'd verify it (a test, a log, a manual check).
4. Recommend the cheapest verification path to start with.

Report back with the investigation summary. I'll tell you which hypothesis to verify first. Then we fix.

I want to refactor [DESCRIPTION OF REFACTOR - e.g., extract auth logic into its own service].

Before touching any code, produce a refactor plan:
1. List the files that will be modified, created, or deleted.
2. Show the new architecture in a one-paragraph summary.
3. Identify the riskiest steps and how to mitigate them.
4. Propose a safe ordering: which step lands first, second, etc., so the codebase stays green at every step.
5. List tests to add or update.

No code yet. Plan only. I'll review and then we execute one step at a time.

For the file at [PATH], generate a comprehensive test suite.

Framework: [JEST / PYTEST / RSPEC / etc.].
Coverage targets:
- Happy path for every public function
- Edge cases: empty inputs, null, max values, unicode, very large inputs
- Error paths: invalid input, exceptions, timeouts
- Integration with [DEPENDENCY] (mock if needed)

For each test, include a one-line comment explaining WHY this test exists (what regression it would catch).
Use descriptive `test("...")` names - not generic ones.

After writing, run the suite and confirm all pass. Report any code changes needed for testability.

Generate a database migration for [DATABASE - Postgres / MySQL / SQLite].

Goal: [DESCRIBE - add column, rename table, add index, etc.].
Framework: [Prisma / Knex / Rails / Alembic / raw SQL].

Requirements:
1. The migration must be safe to run on a table with millions of rows in production. No table-level locks if avoidable.
2. Include both UP and DOWN migrations.
3. Defaults handled correctly - if adding a NOT NULL column, propose a backfill strategy.
4. Add appropriate indexes.
5. Name the migration descriptively with a timestamp prefix.

Return the migration file content and a one-paragraph runbook explaining how to apply it safely in production.

Generate a REST API endpoint with the following spec:

Method: [GET / POST / PUT / DELETE]
Path: [/api/...]
Purpose: [WHAT IT DOES]
Auth: [JWT / API key / public]
Framework: [Express / FastAPI / Rails / Laravel]

Deliverables:
1. Route handler with input validation
2. OpenAPI/Swagger spec for this endpoint
3. TypeScript / Pydantic types for request and response
4. Two unit tests (happy path + invalid input)
5. cURL example for manual testing

Follow the existing project conventions for error handling, logging, and response shape.

Profile this code for performance issues:

[PASTE CODE]

1. Identify the top 3 performance bottlenecks. For each, explain WHY it's slow (Big-O, IO blocking, repeated allocations, etc.).
2. Propose a specific optimization for each.
3. Estimate the speedup (rough order of magnitude).
4. Identify the lowest-hanging fruit - the optimization with best ROI (largest speedup per line of code change).
5. Provide the optimized code only for the top recommendation. Don't refactor everything at once.

If the code is already efficient, say so honestly.

Draft an incident postmortem for the following:

Incident: [BRIEF DESCRIPTION]
Date/Time: [WHEN]
Duration: [HOW LONG]
Impact: [WHO/WHAT WAS AFFECTED]
Detection: [HOW DID YOU FIND OUT]
Resolution: [WHAT FIXED IT]
Root cause: [WHAT BROKE]

Write a blameless postmortem covering:
1. Summary (3 sentences)
2. Timeline (UTC, key events)
3. Root cause analysis (5 whys, with concrete causal chain - not generic phrases like "human error")
4. What went well during response
5. What went poorly
6. Action items (specific, owned, dated)

Maintain a blameless tone - focus on systems and processes, not individuals.