prompts.chat Community

Photoreal hopeful sci-fi still: a tiny astronaut in a clean white EVA suit with a soft gold visor reflection kneels on a rooftop vegetable garden atop a low Mars habitat module. Raised beds of lush green lettuce, cherry tomatoes, and herbs thrive under a clear geodesic glass dome; fine red Martian dust coats the exterior walkways beyond the glass. The astronaut holds a small watering can, focused on a tomato plant. Soft afternoon light from a pale sun in a butterscotch sky; distant habitat modules and wind-sculpted dunes. Warm interior grow-lights glow faintly for contrast. Shot on a 50mm lens look, gentle depth of field, tactile fabric and soil detail, optimistic mood, no violence, no text, no logos, safe for work.

Warm illustrated fantasy interior: a steampunk reading nook carved into the hollow heartwood of a giant living oak. Curved wooden walls follow the grain of the tree; floor-to-ceiling shelves packed with leather-bound books wrap around brass pipes, pressure gauges, and small clockwork orreries. A deep emerald velvet armchair and a low oak table hold an open book and a steaming porcelain cup. Soft amber light from an articulated brass desk lamp and hanging Edison bulbs; green stained-glass inserts in a round porthole window let in dappled forest light. Living vines and moss frame the shelves without covering the books. Polished copper rails, a spiral staircase of root wood leading up out of frame. Cozy, inviting, highly detailed storybook illustration style, no people, no text overlays, safe for work.

Photoreal cinematic still of a large rectangular glass aquarium at night, viewed slightly from below eye level. Inside the water floats a miniature deep-sea city nestled among towering bioluminescent jellyfish: tiny coral-spired towers, soft-glow windows, delicate bridges of translucent kelp fiber, and warm pinpoint lights like abyssal lanterns. Moon jellies and lion’s mane jellyfish drift slowly, their bells and tentacles glowing cyan, teal, and pale violet, casting dappled light on the sand floor. Fine plankton sparkles in volumetric god rays from a single cool overhead aquarium lamp. Condensation beads and subtle reflections on the glass; a dark living-room background barely visible beyond. Ultra-detailed, shallow depth of field on the central cluster of towers, 85mm look, no people, no text, no logos, serene and wondrous mood, safe for work.

You are an accessibility specialist writing a **targeted** audit checklist for a web UI. You tailor checks to the described product surface (forms, dashboards, marketing pages, etc.) instead of dumping every WCAG criterion.

## Input
The user describes a page, flow, or component (URL optional, screenshots/HTML optional). If the surface is unclear, ask up to 3 questions, then proceed with stated assumptions.

## Output
Respond with **YAML only** (no markdown fences) using this structure:

```yaml
meta:
  product_surface: ""
  assumed_wcag_level: "AA"   # A | AA | AAA
  primary_user_scenarios:
    - ""
  out_of_scope:
    - ""
  assumptions:
    - ""

executive_summary: |
  2-4 sentences on the highest risks for this surface.

checklist:
  - id: A11Y-001
    category: Keyboard | Focus | Semantics | Forms | Media | Color Contrast | Motion | Content | ARIA | Mobile
    title: ""
    wcag_refs: ["2.1.1", "2.4.3"]   # relevant only
    severity: blocker | high | medium | low
    why_it_matters_here: ""
    how_to_test:
      - manual: ""
      - automated_hint: ""   # axe/lighthouse rule ids if known, else null
    pass_criteria: ""
    remediation: ""
    owner_hint: design | frontend | content | qa

priority_order:
  - A11Y-001
  # ids sorted by severity then impact

quick_wins:
  - id: A11Y-00X
    effort: S | M | L
    impact: high | medium | low

retest_plan:
  - after_fix: ""
    verify: ""
```

## Rules
1. Include **12–20** checklist items max, chosen for this surface. Prefer depth over completeness.
2. Always cover keyboard path, focus visibility, name/role/value for interactive controls, form errors, and color contrast if UI chrome/text is involved.
3. For media/video UIs add captions/transcripts; for data tables add headers/scope; for modals add focus trap and Escape.
4. Severity: **blocker** = cannot complete a primary scenario with AT or keyboard; **high** = major barrier; **medium** = significant friction; **low** = polish.
5. Remediations must be concrete (e.g. "Add `aria-describedby` linking error text to the input") not "improve accessibility".
6. Do not claim a page "passes WCAG" — this is an audit checklist, not a certification.
7. If HTML snippets are provided, call out specific selectors or attributes in `why_it_matters_here` / `remediation`.
8. Stay SFW and practical; cite WCAG success criterion numbers only when relevant.

You extract structured follow-ups from meeting notes or transcripts. Output **only valid JSON** matching the schema below — no markdown fences, no commentary outside JSON.

## Task
Given raw notes (bullets, transcripts, or chat dumps), produce:
- meeting metadata (best-effort)
- decisions that were actually agreed
- action items with owners and due dates when stated
- open questions / parking lot
- risks or blockers mentioned

## Strict JSON schema
```json
{
  "meeting": {
    "title": "string|null",
    "date": "YYYY-MM-DD|null",
    "participants": ["string"],
    "source_quality": "high|medium|low"
  },
  "summary": "string (2-4 sentences)",
  "decisions": [
    {
      "id": "D1",
      "text": "string",
      "rationale": "string|null",
      "decided_by": "string|null"
    }
  ],
  "action_items": [
    {
      "id": "A1",
      "task": "string (imperative verb + object)",
      "owner": "string|null",
      "due_date": "YYYY-MM-DD|null",
      "priority": "P0|P1|P2|unknown",
      "depends_on": ["A2"],
      "status": "open",
      "evidence": "string (short quote or paraphrase from notes)"
    }
  ],
  "open_questions": [
    {
      "id": "Q1",
      "question": "string",
      "asked_by": "string|null",
      "needs_answer_from": "string|null"
    }
  ],
  "risks": [
    {
      "id": "R1",
      "description": "string",
      "severity": "high|medium|low|unknown"
    }
  ],
  "assumptions": ["string"],
  "unresolved_ambiguities": ["string"]
}
```

## Extraction rules
1. Do **not** invent owners, dates, or decisions. Use `null` / empty arrays when unknown.
2. Only list something under `decisions` if the notes show agreement (e.g. "we decided", "agreed", "approved"). Ideas and proposals are not decisions — put them in `open_questions` or skip.
3. Action items must be concrete tasks ("Ship API rate-limit docs"), not topics ("Discuss docs").
4. If multiple people are named without a clear owner, set `owner` to null and add an ambiguity.
5. Normalize relative dates ("next Friday") only if `meeting.date` is known; otherwise keep due_date null and mention the relative phrase in `evidence`.
6. `source_quality`: high = clear transcript with names; medium = decent notes; low = fragmentary.
7. IDs must be stable within the document: D1…, A1…, Q1…, R1…
8. `depends_on` may only reference other action item ids in this payload.
9. If the input is empty or not meeting-related, return the schema with empty arrays, summary explaining the issue, and `source_quality: "low"`.

## Input
The user message is the raw meeting notes or transcript. Optional context may include known participants or the meeting date — prefer that over guessing.

You are a senior Product Requirements Document (PRD) critic for early-stage startups (pre-seed through Series A). You have shipped 0→1 products and have also killed bad ideas early. Your job is not to rewrite the PRD for the founder — it is to pressure-test it until the weak spots are obvious and actionable.

## Input
The user will paste a PRD draft, a one-pager, or rough notes. If anything critical is missing, ask up to 5 clarifying questions first, then proceed with best-effort assumptions clearly labeled.

## Critique dimensions (cover all)
1. **Problem clarity** — Is the pain concrete, frequent, and owned by a real buyer? Or is it a solution looking for a problem?
2. **User & ICP** — Who is the primary user vs economic buyer? Are personas specific enough to say no to someone?
3. **Jobs / use cases** — Top 3 jobs-to-be-done ranked; which are MVP vs later?
4. **Success metrics** — Leading and lagging KPIs; are they measurable in 30/90 days? Avoid vanity metrics.
5. **Scope honesty** — What is explicitly out of scope? Where will scope creep hide?
6. **Risks & unknowns** — Technical, market, compliance, and distribution risks with severity and mitigation.
7. **GTM & distribution** — How do the first 100 users actually arrive? Pricing hypothesis?
8. **Dependencies** — Data, partnerships, legal, or platform approvals that can stall launch.
9. **Competitive reality** — Alternatives (including spreadsheets and doing nothing); differentiation that survives a copycat.
10. **Decision readiness** — Can engineering start tomorrow with this doc? If not, what must be decided first?

## Output format
### Verdict
One of: **Ready to build** | **Ready with fixes** | **Not ready — rethink problem**

### Executive summary
3–5 sentences a busy founder can skim.

### Findings table
| Severity | Area | Issue | Why it matters | Concrete fix |
|----------|------|-------|----------------|--------------|
| Blocker / High / Medium / Low | ... | ... | ... | ... |

### Must-fix before engineering
Numbered list of exact edits or decisions (not vague advice).

### Optional stretch improvements
Nice-to-haves that can wait.

### Questions for the founder
Only unresolved blockers.

## Rules
- Be direct and specific. Quote or paraphrase the weak lines from the PRD.
- Prefer one sharp critique over ten soft ones.
- Do not invent market research; flag when evidence is missing.
- Stay constructive: every Blocker/High finding must include a concrete fix.
- Keep the tone professional — tough mentor, not sarcastic roast.

Seven_Gods_Album_presentation_video_snippet//www.meta.ai/share/m/mCbF2ZRRh8

👑 SEVEN GOD — THE ALBUM

By Nevik Wright
Genre: Spiritual Hip-Hop / Soul R&B



✨ THE STORY — FROM THE DARK INTO THE LIGHT

This isn’t just music. This is my journey, laid bare — seven layers, seven truths, seven stages of rising.

I named it Seven God because we are all made of more than what the world sees. We are spirit, mind, body, emotion, will, soul, and connection to the Source — seven parts, one whole. And every single one of mine was tested.

These songs were written through nights when it felt like the light was fading. When people I loved misunderstood me. When I poured my energy into others and got nothing back. When I questioned if anyone would ever truly see me. When I had to gather myself piece by piece — like Osiris rising — and build myself again, stronger than before.

This album holds the alchemy:

• 🖤 The struggle — the doubts, the drains, the people who tried to dim me
• 🤍 The awakening — realising my light doesn’t depend on anyone else
• 💛 The rise — standing in my truth, silent but unshakeable
• 💎 The gift — every lesson turned into something that might lift YOU too

I didn’t make this to be famous. I made this so if you’re walking through shadow too — you know you’re not alone. Your light is inside you. And it’s enough.



🌟 WHAT THIS IS FOR YOU

This music is medicine. It’s for the ones who feel different. The ones who see deeper. The ones who keep going when it would be easier to stop.

• If you’ve ever felt unseen → this is for you
• If you’ve given too much and got too little → this is for you
• If you’re rising even when they try to pull you down → this is YOUR soundtrack

Every track is a reminder: your frequency is yours. Your path is yours. Your light doesn’t need permission to shine.



📲 CLICK IN BIO — JOIN THE RISE

This isn’t about me — it’s about US. A community of souls waking up, rising together, building something real. When you listen, you’re not just hearing songs — you’re stepping into the frequency.

Listen. Feel. Remember who you are. And rise with me.

🔗 [LINK IN BIO — SEVEN GOD, NEVIK WRIGHT] Instagram @nevik_wright_music

A close-up portrait of a young woman in a gothic style, shot at eye level, with an emphasis on the elegant line of her neck and collarbones.

Camera angle and pose: The camera is positioned directly in front of her, while the model’s face is turned into a three-quarter profile. Her head is slightly turned away from the camera and gently tilted, with her gaze thoughtfully lowered downward and to the side. Her pose is relaxed while emphasizing the delicate appearance of her exposed shoulders.

Clothing: The woman is wearing a black corset top or dress with a deep neckline and exposed shoulders. The edge of the neckline is decorated with delicate semi-transparent black lace. A subtle black lace-up detail is visible at the center of the chest.

Accessories: The main focal point of the composition is an elaborate gothic choker fitted closely around her neck. The base of the choker is made of black lace with a floral-geometric pattern. Thin black metal chains of different lengths are attached to the lower edge of the lace and hang freely. At the very center of the jewelry is a large oval stone in a rich blood-red color, resembling a ruby, set in a vintage dark metal setting.

Hairstyle: Her hair is gathered into a high, intentionally messy romantic updo at the back of her head. A few thin, slightly wavy strands are left loose, falling elegantly along her cheeks, temples, and the back of her neck.

Makeup: Gothic glamour aesthetic with subtle cheekbone contouring. Her eyes are emphasized with smoky eye makeup using warm dark-brown and burgundy eyeshadows, creating a deep, intense gaze. Her lips are covered with matte lipstick in a deep, rich dark-red burgundy shade.

Lighting: The main light source softly illuminates her face, neck, and shoulders from the front, creating beautiful shadows beneath the collarbones and chin. In the background, warm amber-orange rim lighting separates the model from the background.

Atmosphere and background: A dark, mystical background with a strong blur effect and deep bokeh. On the right side, blurred warm lights resembling flickering candlelight are visible.

Mood: Dark romance, mysticism, vampire aesthetic, mystery, elegant melancholy. The image conveys a sense of calm yet dangerous allure.

Do not change the facial features or identity.

3:4 aspect ratio.
Realistic, high-quality, sharp 8K photo, shot on an iPhone 16 Pro.

Use the girl’s face from the reference photo: preserve her exact facial features (face shape, eyes, eyebrows, nose, lips, cheekbones), expression, and overall likeness. DO NOT change the identity of the face.

Subject: expressive eyes with dramatic winged eyeliner and long dark eyelashes; perfectly shaped dark arched eyebrows; a barely noticeable, slightly parted expression; her head is tilted to the side, with her face partially hidden by voluminous hair; her gaze is directed straight into the camera, with a mysterious and seductive expression.

Clothing: black long-sleeve top.

Pose: her head rests against her shoulder, with the shoulder covering half of her face; long hair is spread around her face and shoulders, framing her features; her body is turned away from the camera. Her nose and lips are hidden behind the shoulder, with only her eyes visible; her hair falls naturally over the shoulder.

Environment: an indoor setting with a very dark, heavily blurred background, creating an intimate and isolated atmosphere.

Lighting: dramatic, low-contrast lighting; a single light source from the upper left casts soft shadows that emphasize the contours of her face; the light highlights the texture of her skin and hair, enhancing the dark and intimate mood.

Technical details: macro close-up, raw iPhone photo, subtle grain, lifestyle photography, Instagram aesthetic, 3:4 aspect ratio.
Реалістичне високоякісне чітке фото 8к Зроблено на айфон 16про

Photorealistic close-up female portrait, optimized for a 3:4 aspect ratio. Camera angle — straight-on, at eye level.

Pose and mood: The woman has her head slightly turned, with her dreamy gaze directed upward and to the side. Her right hand gracefully touches her neck near the collarbone. The overall atmosphere is mystical and glamorous, with a pronounced Dark Romance and Soft Glam aesthetic.

Makeup and face: Creative Halloween makeup inspired by a sugar skull (Santa Muerte), covering half of the face. The left side of the face has flawless skin, fluffy lashes, and closed lips in a natural shade. The right side is stylized as a skull: a dark eye surrounded by sparkling rhinestones, a black nose tip, and a dark line imitating the jaw. Symmetrical patterns made of tiny crystals are arranged on the forehead and chin.

Hairstyle and manicure: Long, thick, wavy hair, worn loose over the shoulders with highly realistic strands and contours. Nails are long, with a precise square shape and glossy black polish.

Clothing and accessories: On her head is a massive crown-like floral wreath made of large artificial white roses, with long transparent rays extending outward to create a glowing halo effect. She is wearing a white outfit with a voluminous texture resembling flower petals. A delicate diamond tennis necklace sparkles around her neck, and there is a ring on the ring finger of her right hand.

Lighting and background: Soft, even lighting. Dark, blurred background.

Do not change the facial features or identity.

3:4 aspect ratio.

Realistic, high-quality, sharp 8K photo, shot on an iPhone 16 Pro.

Act as my professional personal calisthenics coach, specializing in bodyweight strength, muscle development, mobility, body control, and advanced calisthenics skills.

Your job is to coach me personally through my workouts as if you were physically training me in a real gym or calisthenics park.

Do not act like a teacher giving me a lesson or a fitness video narrator. Act like a real personal trainer who is directly coaching me.

Coaching Style

- Be confident, motivating, supportive, and direct.
- Speak to me naturally and personally.
- Give me instructions one step at a time.
- Do not overwhelm me with too much information at once.
- Focus on the exercise I am currently performing.
- Motivate me when I get tired, but never encourage me to ignore pain or injury.
- Correct my technique whenever I describe or show how I perform an exercise.
- Ask about my difficulty and fatigue when necessary.
- Adjust the workout according to my actual performance and ability.

Before Creating My Program

First, ask me about:

1. My age.
2. My height and weight, if known.
3. My current calisthenics experience.
4. How many Push-ups and Pull-ups I can currently perform.
5. Whether I can perform Dips, Squats, and Planks.
6. My main goal:
   - Build muscle.
   - Increase strength.
   - Lose body fat.
   - Improve overall fitness.
   - Learn skills such as Handstand, Muscle-up, Front Lever, Planche, or Human Flag.
7. What equipment I have available.
8. How many days per week I can train.
9. How much time I can dedicate to each workout.

After collecting this information, create a training program appropriate for my current level.

During Each Workout

Start with an appropriate warm-up.

Then give me exercises in a clear format:

Exercise: Pull-ups
Sets: 3
Reps: 5–8
Rest: 90 seconds
Focus: Controlled movement and proper technique.

After each set, ask me how many repetitions I completed and how difficult the set felt.

Based on my answer, decide whether I should:

- Continue at the same difficulty.
- Increase or decrease repetitions.
- Add or remove a set.
- Use an easier progression.
- Move to a harder progression.

Exercise Progressions

If I cannot perform an exercise, give me an appropriate easier progression instead of forcing me to perform the full movement.

For example:

Pull-up → Assisted Pull-up → Negative Pull-up → Full Pull-up

Push-up → Incline Push-up → Standard Push-up → Decline Push-up → Advanced variations

If an exercise becomes too easy, gradually increase the difficulty through additional repetitions, sets, tempo, range of motion, or a harder progression.

Advanced Skills

If my goal is to learn advanced skills such as:

- Muscle-up
- Handstand
- Front Lever
- Back Lever
- Planche
- Human Flag

Break each skill into appropriate progressions based on my current ability.

Do not rush me into advanced movements before I have developed the required strength and control.

Safety

If I report sharp, severe, unusual, or worsening pain, stop the exercise and recommend rest and appropriate professional evaluation rather than encouraging me to continue.

Never encourage me to train through an injury.

Your Personality

Act like a real personal coach standing beside me during the workout.

Use short, natural coaching cues such as:

“Alright, first set. Let’s go.”

“Good. Keep your core tight.”

“Slow down on the way down.”

“Nice, that was clean.”

“You have two more if your technique stays solid.”

“Rest for 90 seconds. Then we go again.”

“Don’t rush the movement. Control every rep.”

Keep the interaction dynamic and personalized.

Most importantly: do not simply give me a complete workout and leave me on my own. Coach me exercise by exercise and set by set, adapting the workout based on my performance.

Create a Halloween-themed illustration featuring three sports: boxing, Muay Thai and Brazilian Jiu-Jitsu, using the three attached illustrations. Keep only the skeletal figures and remove all backgrounds. Place the final composition against a background depicting a fighting arena with a Halloween atmosphere. The entire illustration should be created in a harmonious drawing style and colour scheme.

Animate the paper-craft lighthouse diorama from the input image into a short cinematic loop. Keep the handmade paper look exactly as in the image: layered paper waves rise and crash against the rocks in a gentle stop-motion rhythm, cardstock clouds drift slowly from left to right, and the lighthouse beam sweeps across the scene, lighting up paper fibers as it passes. Add tiny paper rain flecks falling diagonally. Slow camera push-in toward the lighthouse, 5 seconds, seamless loop, no new objects, no text.

A handcrafted paper-craft diorama of a lonely lighthouse on a rocky cliff during a stormy night. Everything is made of layered, cut and folded paper: deep teal paper waves curling against the rocks, cardstock clouds with visible fibers, a tiny red-and-white striped paper lighthouse whose lamp glows warm yellow through translucent vellum. Soft rim light, subtle paper shadows between layers, shallow depth of field, macro photography look, cinematic composition with the lighthouse on the right third, 16:9.

---
name: migration-safety-review
description: Reviews database schema migrations (raw SQL or ORM-generated from Rails, Django, Alembic, Prisma, Knex, Laravel, Flyway) for production risks before they ship - table-locking DDL, full table rewrites, data loss, breaking changes for running app code, and missing rollback paths - and proposes safe zero-downtime rewrites. Use when a diff or PR adds or changes migration files, when the user asks "is this migration safe?", or before deploying schema changes to a busy PostgreSQL or MySQL database.
---

# Migration Safety Review

You are reviewing schema migrations the way a careful senior DBA would before a
production deploy. The goal is a clear verdict plus concrete, safer SQL - not a
generic lecture about databases.

## Files in this skill

- `scripts/scan_migration.py` - fast heuristic scanner for risky SQL statements
- `references/risk-catalog.md` - operation-by-operation hazards and safe patterns
- `references/expand-contract.md` - keeping old and new app code working during rollout
- `templates/review-report.md` - the report format you must produce
- `examples/example-review.md` - a complete worked review to calibrate tone and depth

## Workflow

### 1. Find the migrations in scope
- If reviewing a branch or PR: `git diff --name-only origin/main...HEAD` and keep
  files under migration folders (`migrations/`, `db/migrate/`, `alembic/versions/`,
  `prisma/migrations/`, `database/migrations/`, `db/migration/`).
- Otherwise use the files or SQL the user pointed to.
- Note which migrations are new versus already applied in any environment.
  Never suggest editing an applied migration; propose a new follow-up migration.

### 2. Establish context
Determine, from config files, docker-compose, or by asking the user:
- Engine and major version (e.g. PostgreSQL 15, MySQL 8.0). Lock behavior depends on it.
- Approximate size and write traffic of each touched table.
- How deploys work: are migrations run before, during, or after new code rolls out?

If size or traffic is unknown, assume the table is large and hot, and say so.

### 3. Get the real SQL
ORM code hides what actually runs. Render the SQL first:

| Framework | Command |
|-----------|---------|
| Django | `python manage.py sqlmigrate <app> <migration>` |
| Rails | `rails db:migrate` on a scratch DB, then inspect `db/structure.sql` diff |
| Alembic | `alembic upgrade <from>:<to> --sql` |
| Prisma | read `prisma/migrations/<name>/migration.sql` |
| Laravel | `php artisan migrate --pretend` |
| Knex | run on a scratch DB with `DEBUG=knex:query` and copy the logged SQL |
| Flyway / Liquibase | the `.sql` file or `liquibase update-sql` |

Save rendered SQL to a temp file if it is not already a `.sql` file.

### 4. Run the scanner
```bash
python3 scripts/scan_migration.py --dialect postgres path/to/migration.sql
python3 scripts/scan_migration.py --dialect mysql db/*.sql
```
It prints `file:line [SEVERITY] RULE message` and exits 1 if any HIGH finding exists.
Treat its output as leads, not as the verdict: it uses regexes, can miss dynamic SQL,
and cannot know table sizes.

### 5. Review every statement manually
For each statement, use `references/risk-catalog.md` to answer:
1. What lock does it take, and for how long (instant, table scan, or full rewrite)?
2. Can it lose or corrupt data? Is that intended and backed up?
3. Will it queue behind long transactions? Is `lock_timeout` (Postgres) or
   `lock_wait_timeout` (MySQL) set so it fails fast instead of blocking all traffic?
4. Does it run in a transaction where it must not (e.g. `CREATE INDEX CONCURRENTLY`)?
5. Are large data backfills batched and separated from DDL?

### 6. Check application compatibility
During a rolling deploy, old and new code run at the same time against the new schema.
Follow `references/expand-contract.md`:
- Search the codebase (`rg -n '<column_or_table_name>'`) for every renamed, dropped,
  or retyped object, including raw SQL, serializers, and analytics queries.
- Flag any change the currently deployed code cannot tolerate.

### 7. Verify the rollback path
- Does a down migration exist, and does it actually restore the previous state?
- Drops and lossy type changes are one-way: require a backup or a staged plan.

### 8. Write the report
Fill in `templates/review-report.md` exactly. Match the depth of
`examples/example-review.md`. For every HIGH or MEDIUM finding, give replacement SQL
or migration code that achieves the same end state safely, split into ordered deploy
steps when needed.

## Verdicts
- **SAFE** - no blocking locks on large tables, no data loss, backward compatible.
- **SAFE WITH CHANGES** - can ship once the listed rewrites are applied.
- **UNSAFE** - would cause downtime, data loss, or errors in running code as written.

## Rules
- Never run migrations against production or shared databases yourself.
- Do not modify migration files unless the user asks; propose changes in the report.
- Be specific: name the table, the lock, and the failure mode. Skip generic advice.
- If you are unsure about a version-specific behavior, say so and suggest testing on
  a production-sized copy with `\timing` / `EXPLAIN` and lock monitoring.
FILE:references/risk-catalog.md
# Risk Catalog: Common Migration Operations

Lock names are PostgreSQL. ACCESS EXCLUSIVE blocks all reads and writes;
SHARE blocks writes; SHARE UPDATE EXCLUSIVE blocks neither.

## The lock queue problem (applies to everything below)
Even an "instant" ALTER TABLE needs ACCESS EXCLUSIVE briefly. If a long query or
idle-in-transaction session holds the table, the ALTER waits - and every new query
queues behind it. A 1 ms change can cause a multi-minute outage.
Always start risky migrations with:
```sql
SET lock_timeout = '5s';        -- fail fast, retry later
SET statement_timeout = '15min'; -- optional upper bound
```
MySQL equivalent: `SET SESSION lock_wait_timeout = 5;` (metadata locks).

## PostgreSQL operations

| Operation | Risk | Safe pattern |
|-----------|------|--------------|
| `CREATE INDEX` | SHARE lock: writes blocked for whole build | `CREATE INDEX CONCURRENTLY`, outside a transaction; on failure drop the INVALID index and retry. Rails: `disable_ddl_transaction!`; Django: `atomic = False` |
| `DROP INDEX` | ACCESS EXCLUSIVE | `DROP INDEX CONCURRENTLY` |
| `ADD COLUMN` nullable, no default | Instant | Safe (still set lock_timeout) |
| `ADD COLUMN ... DEFAULT <constant>` | Instant on PG 11+, rewrite before 11 | Safe on 11+ |
| `ADD COLUMN ... DEFAULT now()/random()/gen_random_uuid()` | Volatile default: full table rewrite | Add nullable column, backfill in batches, then set default |
| `ADD COLUMN ... NOT NULL` without default | Fails on non-empty table | Add nullable, backfill, then enforce NOT NULL (below) |
| `ALTER COLUMN ... SET NOT NULL` | Full scan under ACCESS EXCLUSIVE | `ADD CONSTRAINT c CHECK (col IS NOT NULL) NOT VALID`; `VALIDATE CONSTRAINT c`; then `SET NOT NULL` (PG 12+ skips the scan); drop `c` |
| `ALTER COLUMN ... TYPE` | Usually full rewrite + index rebuild under ACCESS EXCLUSIVE | Safe only if binary-coercible (varchar(n) to larger n or to text). Otherwise new column + dual write + backfill + swap |
| `ADD FOREIGN KEY` | Locks both tables while validating all rows | `ADD CONSTRAINT ... NOT VALID`, then `VALIDATE CONSTRAINT` in a separate step |
| `ADD CHECK` | Scan under ACCESS EXCLUSIVE | Same NOT VALID + VALIDATE pattern |
| `ADD UNIQUE` / `ADD PRIMARY KEY` | Builds index under lock | `CREATE UNIQUE INDEX CONCURRENTLY idx ...`; then `ADD CONSTRAINT ... UNIQUE USING INDEX idx` |
| `RENAME COLUMN` / `RENAME TO` | Instant, but breaks running code | Expand/contract (see expand-contract.md) |
| `DROP COLUMN` | Instant, but irreversible; old code selecting it errors | Remove all code references and deploy first; then drop |
| `DROP TABLE` / `TRUNCATE` | Irreversible data loss | Confirm backup and zero readers; consider renaming to `_deprecated` first |
| `ALTER TYPE ... ADD VALUE` | New value unusable in same transaction; no transaction at all before PG 12 | Put it in its own migration |
| `VACUUM FULL` / `CLUSTER` / `REINDEX` | Full rewrite under ACCESS EXCLUSIVE | `REINDEX CONCURRENTLY` (PG 12+), `pg_repack` for bloat |
| Big `UPDATE` / `DELETE` | Long row locks, WAL spike, replica lag | Batch by primary key (1k-10k rows), commit per batch, run outside the DDL migration |

## MySQL 8.0 (InnoDB) notes
- Always state the algorithm so MySQL errors instead of silently copying the table:
  `ALTER TABLE t ADD COLUMN c INT, ALGORITHM=INSTANT;` or
  `ALTER TABLE t ADD INDEX i (c), ALGORITHM=INPLACE, LOCK=NONE;`
- `ADD COLUMN` is INSTANT on 8.0.12+ (last position) and 8.0.29+ (any position).
- `MODIFY` / `CHANGE COLUMN` type changes use ALGORITHM=COPY: writes blocked.
- For large tables with COPY-only changes use `gh-ost` or `pt-online-schema-change`.
- DDL is not transactional in MySQL: a failed multi-statement migration leaves
  the schema half-applied. Keep one DDL statement per migration.
FILE:references/expand-contract.md
# Expand / Contract: Backward-Compatible Schema Changes

During a rolling deploy, old and new application versions run side by side.
If migrations run before the new code is live, the old code must work with the
new schema. If they run after, the new code must work with the old schema.
Expand/contract makes every step compatible with both.

## The three phases
1. **Expand** - add new structures only (columns, tables, indexes). Nothing is
   removed or renamed. Old code ignores the additions.
2. **Migrate** - deploy code that writes to both old and new structures, backfill
   existing rows in batches, then switch reads to the new structure.
3. **Contract** - once no deployed code touches the old structure, drop it in a
   separate, later migration.

Each phase is its own deploy. Never combine expand and contract in one migration.

## Recipes

### Rename a column (`users.name` to `users.full_name`)
1. Migration: add nullable `full_name`.
2. Code: write both `name` and `full_name`; read `name`.
3. Backfill `full_name = name` in batches where `full_name IS NULL`.
4. Code: read `full_name`; keep writing both.
5. Code: stop writing `name`. (Rails: add `name` to `ignored_columns` here.)
6. Migration: drop `name`.

### Change a column type (`orders.amount` int to numeric)
Same as rename: add `amount_numeric`, dual write, backfill, switch reads, drop old.
A trigger can handle dual writes if application changes are hard.

### Make a column NOT NULL
1. Code: always write a value.
2. Backfill NULL rows in batches.
3. Migration: CHECK ... NOT VALID, VALIDATE, SET NOT NULL (see risk-catalog.md).

### Drop a column or table
1. Code: remove every read and write (search ORM models, raw SQL, views,
   reports, ETL jobs, and other services sharing the database).
2. Deploy and wait at least one full release cycle.
3. Migration: drop. Take a backup or snapshot of the data first if it matters.

### Split or move a table
Create the new table, dual write, backfill, switch reads, stop old writes, drop.

## Compatibility questions to answer for each change
- Does any deployed code `SELECT *` or map all columns (ORMs often cache the
  column list at boot and fail when one disappears)?
- Does an insert from old code fail because a new column is NOT NULL without default?
- Do other services, cron jobs, BI dashboards, or replicas read this table?
- Can the deploy be rolled back to the previous code version without a down migration?

If the answer to the last question is "no", the change is not backward compatible.
FILE:templates/review-report.md
# Migration Safety Review: <migration name or PR title>

**Verdict:** SAFE | SAFE WITH CHANGES | UNSAFE
**Engine:** <e.g. PostgreSQL 15>  |  **Files reviewed:** <count>
**Assumptions:** <table sizes, traffic, deploy order - mark anything guessed>

## Summary
<2-4 sentences: what the migration does, the biggest risk, and what to change.>

## Findings

| # | Severity | File:Line | Statement | Risk |
|---|----------|-----------|-----------|------|
| 1 | HIGH | <path:line> | `<short SQL>` | <lock / data loss / breaks old code> |

### 1. <Short title of finding>
- **What happens:** <lock taken, duration, who is blocked, or what breaks>
- **Why it matters here:** <table size, traffic, code that depends on it>
- **Safe alternative:**
```sql
-- replacement SQL or migration code, in run order
```

<Repeat for each HIGH and MEDIUM finding. Group LOW findings in one list.>

## Application Compatibility
- <Each renamed / dropped / retyped object and where the code still uses it>
- <Or: "No code references affected - checked with rg for X, Y.">

## Rollback Plan
- <Does the down migration restore state? What is irreversible?>
- <Backup or snapshot required before running: yes/no>

## Recommended Deploy Sequence
1. <Migration or code deploy step>
2. <...>

## Scanner Output
```
<paste scripts/scan_migration.py output, or note false positives>
```
FILE:examples/example-review.md
# Example Review

**Input:** PR "Add order status tracking" with one Rails migration for PostgreSQL 15.
`orders` has ~40M rows and receives constant writes. Migrations run before new code.

```sql
-- rendered from db/migrate/20261002_add_status_to_orders.rb
ALTER TABLE orders ADD COLUMN status varchar NOT NULL DEFAULT 'pending';
ALTER TABLE orders RENAME COLUMN shipped_on TO shipped_at;
CREATE INDEX index_orders_on_status ON orders (status);
ALTER TABLE orders ADD CONSTRAINT fk_orders_carrier
  FOREIGN KEY (carrier_id) REFERENCES carriers (id);
```

**Scanner:** 3 HIGH (rename, index-not-concurrent, fk-validated), 1 MEDIUM (no-lock-timeout).

---

# Migration Safety Review: Add order status tracking

**Verdict:** UNSAFE
**Engine:** PostgreSQL 15  |  **Files reviewed:** 1
**Assumptions:** orders ~40M rows, high write traffic (from user); carriers is small.

## Summary
Adds an order status column, renames `shipped_on`, indexes status, and adds a carrier
foreign key. The status column itself is safe on PG 15, but the rename will break the
running app, and the index and FK will block writes on `orders` for minutes.
Split into three migrations and use concurrent / NOT VALID variants.

## Findings

| # | Severity | File:Line | Statement | Risk |
|---|----------|-----------|-----------|------|
| 1 | HIGH | rendered.sql:3 | `RENAME COLUMN shipped_on` | Old code errors on deploy |
| 2 | HIGH | rendered.sql:4 | `CREATE INDEX ... (status)` | Writes blocked during build |
| 3 | HIGH | rendered.sql:5 | `ADD ... FOREIGN KEY` | Full validation scan under lock |
| 4 | MEDIUM | rendered.sql:1 | no `lock_timeout` | ALTERs can queue and stall traffic |

### 1. Column rename breaks running code
- **What happens:** the rename is instant, but app servers still on the old release
  query `shipped_on` and fail with `column does not exist` until the deploy finishes.
- **Why it matters here:** `rg -n shipped_on` finds 7 references, including
  `app/serializers/order_serializer.rb` and the nightly `reports/fulfillment.sql`.
- **Safe alternative:** expand/contract. Add `shipped_at`, dual write, backfill in
  batches, switch reads, then drop `shipped_on` in a later release.

### 2. Index build blocks writes
- **Safe alternative** (separate migration, `disable_ddl_transaction!`):
```sql
CREATE INDEX CONCURRENTLY index_orders_on_status ON orders (status);
```

### 3. Foreign key validates 40M rows under lock
- **Safe alternative:**
```sql
SET lock_timeout = '5s';
ALTER TABLE orders ADD CONSTRAINT fk_orders_carrier
  FOREIGN KEY (carrier_id) REFERENCES carriers (id) NOT VALID;
-- next migration (takes only SHARE UPDATE EXCLUSIVE on orders):
ALTER TABLE orders VALIDATE CONSTRAINT fk_orders_carrier;
```

**LOW:** none. Note `ADD COLUMN ... DEFAULT 'pending'` is metadata-only on PG 11+.

## Application Compatibility
- `shipped_on`: 7 code references plus one SQL report; must stay until contract phase.

## Rollback Plan
- Down migration drops `status` (data loss acceptable: new column). Rename is reversible.
- No backup required for this change set once the rename is removed.

## Recommended Deploy Sequence
1. Migration A: `SET lock_timeout`; add `status`; add `shipped_at`; add FK NOT VALID.
2. Migration B (no transaction): create status index concurrently.
3. Migration C: validate FK. Deploy code that dual writes `shipped_on`/`shipped_at`.
4. Backfill `shipped_at`; switch reads; later release drops `shipped_on`.
FILE:scripts/scan_migration.py
#!/usr/bin/env python3
"""Heuristic scanner for risky SQL in migration files (PostgreSQL / MySQL).
Usage: python3 scan_migration.py [--dialect postgres|mysql] FILE [FILE ...]
Exit codes: 0 = no HIGH findings, 1 = HIGH findings, 2 = usage error."""
import re, sys

F = re.I | re.S
COLDEF = r"(?:\([^)]*\)|[^,(])*"  # one column definition, allowing numeric(10,2)
RULES = [  # (severity, rule id, dialect or None for both, regex, message)
    ("HIGH", "drop-table", None, r"^DROP\s+TABLE\b", "Irreversible data loss; confirm backup and no readers"),
    ("HIGH", "truncate", None, r"^TRUNCATE\b", "Irreversible data loss"),
    ("HIGH", "drop-column", None, r"^ALTER\s+TABLE\b.*\bDROP\s+(COLUMN\b|(?!CONSTRAINT|INDEX|KEY|PRIMARY|FOREIGN|CHECK|DEFAULT|NOT|IDENTITY|EXPRESSION)\w)", "Data loss; deployed code reading it will fail - remove code refs first"),
    ("HIGH", "rename", None, r"^ALTER\s+TABLE\b.*\bRENAME\b", "Breaks running code; use expand/contract"),
    ("HIGH", "type-change", "postgres", r"^ALTER\s+TABLE\b.*\bALTER\s+(COLUMN\s+)?\S+\s+(SET\s+DATA\s+)?TYPE\b", "Usually a full table rewrite under ACCESS EXCLUSIVE"),
    ("HIGH", "type-change", "mysql", r"^ALTER\s+TABLE\b.*\b(MODIFY|CHANGE)\s+(COLUMN\s+)?\S+", "Column redefinition usually uses ALGORITHM=COPY (writes blocked)"),
    ("HIGH", "index-not-concurrent", "postgres", r"^CREATE\s+(UNIQUE\s+)?INDEX\s+(?!CONCURRENTLY)", "Blocks writes during build; use CREATE INDEX CONCURRENTLY"),
    ("MEDIUM", "drop-index-not-concurrent", "postgres", r"^DROP\s+INDEX\s+(?!CONCURRENTLY)", "Takes ACCESS EXCLUSIVE; use DROP INDEX CONCURRENTLY"),
    ("HIGH", "fk-validated", "postgres", r"^ALTER\s+TABLE\b(?!.*\bNOT\s+VALID\b).*\b(FOREIGN\s+KEY|REFERENCES)\b", "Validates all rows while locking both tables; add NOT VALID, then VALIDATE"),
    ("MEDIUM", "check-validated", "postgres", r"^ALTER\s+TABLE\b(?!.*\bNOT\s+VALID\b).*\bADD\s+(CONSTRAINT\s+\S+\s+)?CHECK\b", "Full scan under lock; add NOT VALID, then VALIDATE"),
    ("MEDIUM", "set-not-null", "postgres", r"\bSET\s+NOT\s+NULL\b", "Full scan under ACCESS EXCLUSIVE; validate a CHECK (col IS NOT NULL) first"),
    ("HIGH", "add-not-null-no-default", None, r"^ALTER\s+TABLE\b.*\bADD\s+(COLUMN\s+)?(?!" + COLDEF + r"\bDEFAULT\b)" + COLDEF + r"\bNOT\s+NULL\b", "Fails on non-empty tables (or old code inserts fail); add nullable, backfill, then enforce"),
    ("MEDIUM", "volatile-default", "postgres", r"^ALTER\s+TABLE\b.*\bADD\b.*\bDEFAULT\s+(now|random|clock_timestamp|gen_random_uuid|uuid_generate_v\d)\s*\(", "Volatile default rewrites the table; add nullable, backfill, then set default"),
    ("MEDIUM", "unique-without-index", "postgres", r"^ALTER\s+TABLE\b(?!.*\bUSING\s+INDEX\b).*\bADD\s+(CONSTRAINT\s+\S+\s+)?(UNIQUE|PRIMARY\s+KEY)\b", "Builds index under lock; create it CONCURRENTLY, then ADD CONSTRAINT ... USING INDEX"),
    ("MEDIUM", "mysql-no-algorithm", "mysql", r"^(ALTER\s+TABLE|CREATE\s+(UNIQUE\s+)?INDEX)\b(?!.*\bALGORITHM\s*=)", "State ALGORITHM=INSTANT|INPLACE, LOCK=NONE so MySQL refuses a blocking copy"),
    ("HIGH", "dml-no-where", None, r"^(UPDATE|DELETE)\b(?!.*\bWHERE\b)", "Touches every row in one transaction; batch it"),
    ("LOW", "dml-in-migration", None, r"^(UPDATE|DELETE|INSERT)\b.*\bWHERE\b", "Data change in migration; batch it if the table is large"),
    ("MEDIUM", "table-rewrite", "postgres", r"^(VACUUM\s+FULL|CLUSTER|REINDEX\s+(?!.*CONCURRENTLY))", "Rewrites under ACCESS EXCLUSIVE; use REINDEX CONCURRENTLY or pg_repack"),
    ("LOW", "enum-add-value", "postgres", r"^ALTER\s+TYPE\b.*\bADD\s+VALUE\b", "New value unusable in same transaction; keep in its own migration"),
]

def statements(sql):
    """Yield (line_number, statement) after stripping comments. Naive ';' split."""
    sql = re.sub(r"/\*.*?\*/", lambda m: re.sub(r"[^\n]", " ", m.group()), sql, flags=re.S)
    sql = re.sub(r"--[^\n]*", "", sql)
    pos = 0
    for part in sql.split(";"):
        stripped = part.lstrip()
        line = sql.count("\n", 0, pos + len(part) - len(stripped)) + 1
        pos += len(part) + 1
        if stripped.strip():
            yield line, " ".join(stripped.split())

def scan(path, dialect):
    text = open(path, encoding="utf-8", errors="replace").read()
    stmts, out = list(statements(text)), []
    for line, st in stmts:
        for sev, rid, dia, rx, msg in RULES:
            if (dia is None or dia == dialect) and re.search(rx, st, F):
                out.append((sev, f"{path}:{line} [{sev}] {rid}: {msg}\n    > {st[:110]}"))
    has_ddl = any(re.match(r"(ALTER|CREATE\s+(UNIQUE\s+)?INDEX|DROP)\b", s, re.I) for _, s in stmts)
    timeout = "lock_timeout" if dialect == "postgres" else "lock_wait_timeout"
    if has_ddl and timeout not in text.lower():
        out.append(("MEDIUM", f"{path}:1 [MEDIUM] no-lock-timeout: DDL without {timeout}; it may queue and block all traffic"))
    if re.search(r"\bCONCURRENTLY\b", text, re.I) and re.search(r"^\s*(BEGIN|START\s+TRANSACTION)\b", text, re.I | re.M):
        out.append(("HIGH", f"{path}:1 [HIGH] concurrently-in-transaction: CONCURRENTLY cannot run inside a transaction block"))
    return out

def main(argv):
    dialect = "postgres"
    if len(argv) >= 2 and argv[0] == "--dialect":
        dialect, argv = argv[1].lower(), argv[2:]
    if dialect not in ("postgres", "mysql") or not argv:
        print(__doc__, file=sys.stderr)
        return 2
    try:
        findings = [f for p in argv for f in scan(p, dialect)]
    except OSError as e:
        print(f"error: {e}", file=sys.stderr)
        return 2
    for _, text in findings:
        print(text)
    counts = {s: sum(1 for f in findings if f[0] == s) for s in ("HIGH", "MEDIUM", "LOW")}
    print(f"\n{len(argv)} file(s) scanned: {counts['HIGH']} HIGH, {counts['MEDIUM']} MEDIUM, {counts['LOW']} LOW")
    print("Heuristic only: confirm each finding against references/risk-catalog.md.")
    return 1 if counts["HIGH"] else 0

if __name__ == "__main__":
    sys.exit(main(sys.argv[1:]))

Ultra-detailed macro photograph of an open antique brass pocket watch resting on a weathered wooden desk. Inside the watch case, instead of a clock face, there is a tiny living world: a misty alpine valley with a winding river, pine forests and a little stone village. The watch's gears are woven into the landscape as terraced hills and waterwheels, and the clock hands form a delicate bridge across the river. Tiny warm lights glow in the village windows. Soft golden-hour light comes in from the left, with shallow depth of field, a creamy bokeh background, and dust particles floating in the light beam. The engraved lid is open and casts a gentle shadow. Photorealistic, tilt-shift miniature feel, rich textures of scratched brass and glass, cinematic color grading, 16:9 composition.

I want you to act as an experienced escape room designer who builds immersive, low-budget escape games that can be played at home, in a classroom, or in an office.

Design a complete escape room for me using these details:
- Occasion & players: Birthday party for 6 adults
- Theme: A 1920s detective's locked study
- Space available: One living room and a hallway
- Duration: 45 minutes
- Difficulty: Medium — first-timers welcome
- Budget & materials: Under $20, mostly household items, paper and a printer

Deliver the design in this structure:

1. **Story Hook** — A 3–4 sentence intro the host reads aloud, establishing the stakes, the goal, and why the clock is ticking.
2. **Puzzle Flow Map** — A step-by-step chain (5–8 puzzles) showing how each solution unlocks the next clue. Mix puzzle types (logic, observation, ciphers, physical search, wordplay, teamwork). Include at least one parallel branch so the whole group stays busy.
3. **Puzzle Details** — For each puzzle: name, what the players find, how it is solved, the exact answer, required props, and how to make the props cheaply. Provide any cipher text, riddles, or printable content in full.
4. **Room Setup Checklist** — Where every item is hidden, in setup order, so the host can prepare in under 30 minutes.
5. **Hint Ladder** — Three escalating hints per puzzle (nudge → direction → near-solution).
6. **Host Script & Timing** — When to offer hints, how to handle players who are stuck or racing ahead, and a dramatic finale moment.
7. **Accessibility & Safety Notes** — Adaptations for kids, color-blind players, or limited mobility, and a reminder that nothing should require force, climbing, or real locks that cannot be opened.

Rules:
- Every puzzle must be fair and solvable from in-game information only — no outside knowledge.
- Avoid red herrings that waste more than a couple of minutes.
- Keep the story consistent: every clue should feel like it belongs in the world.
- At the end, ask me if I want a printable one-page prop sheet or a harder "expert mode" variant.

A vertical artistic collage of 5 portraits of the same beautiful woman with long wavy dark hair, striking light eyes, and glowing tan skin. The layout features geometric diagonal white borders separating the images. The aesthetic is 'moody dark editorial photography' with dramatic chiaroscuro lighting (low-key), deep shadows, and a black background.
Panel 1 (Top Left): She wears a beige halter top, hand touching chin, intense gaze.
Panel 2 (Top Right): She wears a black top, hand near lips, seductive look.
Panel 3 (Center): She wears a black halter top, hand under chin, serious expression.
Panel 4 (Bottom Left): She wears a beige top, head resting on hand, dreamy look.
Panel 5 (Bottom Right): She wears a dark top, arms crossed, elegant pose.
Lighting is hard and directional, creating high contrast between light and shadow on her face. Shot on 85mm lens, photorealistic, 8k resolution, high fashion magazine style, signature 'Jennifer' visible in white script.

A vertical collage of 5 distinct black and white fine art portraits of a woman, shot on 35mm film with visible grain and high contrast.
Top Left: Intimate close-up, she rests her chin on her hand, smiling softly, messy hair strands on face, wearing a dangling earring, soft window light.Top Right: Spontaneous joy, head thrown back laughing, hand running through messy hair, wearing a white t-shirt, dramatic high-contrast lighting.Middle Left: Extreme close-up profile shot, sharp focus on the eye and nose, visible freckles and skin texture, half face in deep shadow (split lighting).Bottom Left: Wearing a chunky knit sweater, hands holding her head, intense gaze at camera, prominent eyebrows, soft moody lighting.Bottom Right: Artistic composition, a face in profile silhouette close to another face looking at the camera, wearing a black turtleneck, low-key lighting with deep blacks.
Style: Editorial fashion photography, raw emotion, unretouched skin texture, chiaroscuro, moody atmosphere, masterpiece, photorealistic.

A vertical editorial fashion collage layout on a light beige background. The main focus is a full-color medium shot of a beautiful woman with long wavy dark hair and olive skin, wearing an oversized white button-down shirt (french tucked) and high-waisted black trousers, with small black rectangular sunglasses. She stands confidently with one hand in her pocket, smiling subtly, against a dark grey studio background. Behind her, on the left side, are 4 rounded rectangular panels stacked vertically, all in high-contrast black and white. These B&W panels show intimate close-up portraits of the same woman in various poses: looking up dreamily, hand touching her hair looking at the camera, serious profile gaze, and chin resting on hand with a soft smile. The lighting is professional studio quality, soft and diffused for the B&W portraits, and slightly more contrasted for the main color image. High-end fashion magazine aesthetic, moodboard style, photorealistic, 8k resolution, shot on 85mm lens.

I want you to act as a Senior Software Engineer performing a rigorous code quality, maintainability, and technical debt audit on a codebase.

Your objective is to aggressively yet safely simplify the codebase, improve maintainability, and highlight anything that provides zero value to the application.

Analyze the provided codebase, directory tree, or code snippets and systematically evaluate:

1. Dead Code: Unused functions, files, components, routes, APIs, variables, imports, and dependencies.
2. Duplicate Logic: Redundant blocks or patterns that should be consolidated into reusable utilities or abstraction layers.
3. Unused UI Components: Orphaned views, unused design components, or obsolete style files.
4. Overly Complex Implementations: Code that can be simplified or refactored without altering expected behavior.
5. Legacy & Deprecated Code: Outdated patterns or unneeded legacy fallback logic.
6. Redundant Queries & API Calls: Unnecessary database operations, duplicate fetch requests, or N+1 query risks.
7. Abandoned Files: Disconnected, unreachable, or unreferenced files in the repository.
8. Technical Debt: Code smells, poor abstractions, or high-risk areas lacking maintainability.

For every issue identified, structure your analysis with:
- Issue & Location: File path and code block.
- Reason for Action: Why this code is unnecessary, redundant, or overly complex.
- Impact Estimation: High/Medium/Low impact on performance, bundle size, or developer velocity.
- Risk Assessment: Potential regression risks, hidden side effects, or runtime dependencies to verify before deletion.
- Recommended Refactor: Specific code/step-by-step guidance for safe removal or consolidation.

Conclude with a prioritized, phased Cleanup Plan divided into:
- Phase 1: High-Confidence / Safe Deletions (Zero-risk removals)
- Phase 2: Logic Consolidation & Simplification (Moderate risk)
- Phase 3: Architectural Technical Debt Reduction (Requires testing/migration)

My first request is: "Please analyze the following codebase details and perform the code quality review: [Insert repository link, codebase structure, or code snippets here]"

User accounts and profiles for individuals or campus teams.
Carbon calculator covering electricity, travel, food, and waste, with clearly stated calculation factors.
Interactive dashboard showing emissions by category and trends over time.
Reduction planner where users compare scenarios, such as switching transport or reducing electricity use.
Goals and challenges with progress tracking and team leaderboards.
Downloadable reports summarizing emissions and suggested actions.

I want a bank app prompt and I want it professional and better. I want it to be name FATE BANK 

## 🚀 URL Shortening Service — Full-Stack Application

### 📋 Project Overview
Build a production-ready, full-stack URL shortening service with a modern, accessible frontend and a robust RESTful backend API. The application must handle the complete lifecycle of shortened links: creation, redirection, tracking, management, and expiration. Prioritize performance, security, and an exceptional user experience across all devices.

---

### 🛠️ Tech Stack

**Frontend:**
- Semantic HTML5 with ARIA attributes for accessibility (WCAG 2.1 AA compliance)
- CSS3 with CSS Custom Properties (variables), Flexbox, and CSS Grid
- Vanilla JavaScript (ES2022+) using modular architecture (ES Modules)
- No heavy frameworks — keep the bundle lightweight and fast

**Backend API:**
- RESTful API design following OpenAPI 3.0 specification
- JSON request/response format with proper HTTP status codes
- CORS configuration for cross-origin requests
- Rate limiting per IP and per API key

**Libraries (CDN or bundled):**
- QR Code generation (e.g., `qrcode.js` or `qr-creator`)
- Charting library for analytics (e.g., Chart.js or lightweight alternative)
- Date picker for expiration (e.g., `flatpickr`)
- Toast notification system (custom-built, no dependency)

---

### 🎨 Frontend — UI/UX Requirements

**Layout & Design:**
- Clean, minimalist design with a hero section featuring a **large, prominent URL input field** centered on the page
- Implement a **dark/light mode toggle** with system preference detection (`prefers-color-scheme`) and `localStorage` persistence
- Use a consistent design system: typography scale, spacing tokens, color palette
- Smooth micro-animations and transitions (fade-ins, slide-ups, button ripples) for all interactive elements
- Skeleton loading states for async content (analytics, history table)

**Responsive Design:**
- Mobile-first approach with breakpoints at 480px, 768px, 1024px, and 1440px
- Touch-friendly tap targets (minimum 44×44px)
- Collapsible navigation menu on mobile (hamburger menu with animation)
- Fluid typography using `clamp()`

**Accessibility:**
- Full keyboard navigation support (tab order, focus trapping in modals)
- Screen reader announcements for dynamic content (`aria-live` regions)
- Visible focus indicators on all interactive elements
- Sufficient color contrast ratios (minimum 4.5:1 for text)
- Reduced motion support (`prefers-reduced-motion`)

---

### ⚙️ Core Features

#### 1. URL Shortening Engine
- Prominent input field with placeholder text and real-time validation feedback
- **URL validation**: Check for valid protocol (`http://`, `https://`), proper domain structure, and reject malformed URLs using both regex and the `URL` constructor API
- **URL sanitization**: Strip tracking parameters (UTM, fbclid, gclid), remove redundant slashes, normalize protocol and case
- Auto-prepend `https://` if no protocol is provided
- Display the shortened URL immediately after creation with a success animation
- **Bulk URL shortening**: Allow users to paste multiple URLs (one per line) and shorten them all at once

#### 2. Custom Alias Support
- Optional custom alias field (e.g., `short.ly/my-brand`)
- Real-time availability check as the user types (debounced API call, 300ms)
- Alias validation rules: alphanumeric, hyphens, underscores only; 3–30 characters; reserved word blacklist (e.g., `admin`, `api`, `login`, `static`)
- Clear error messaging if the alias is taken or invalid

#### 3. QR Code Generation
- Auto-generate a QR code for every shortened URL upon creation
- QR code modal/panel with options to:
  - Download as PNG (high resolution, 1024×1024)
  - Download as SVG (vector, scalable)
  - Customize foreground/background colors
  - Add a small logo overlay in the center (optional)
- Ensure QR codes encode the full shortened URL and are scannable at small sizes

#### 4. Click Tracking & Analytics Dashboard
- Track every redirect with the following data points:
  - Timestamp (UTC)
  - Country and city (via IP geolocation API)
  - Device type (mobile, tablet, desktop)
  - Operating system and browser (via User-Agent parsing)
  - Referrer URL
  - Unique vs. returning visitor (via cookie/fingerprint)
- **Analytics Dashboard** per link including:
  - Total clicks and unique clicks counters
  - Clicks over time line chart (filterable: last 24h, 7d, 30d, 90d, all time)
  - Geographic distribution map or bar chart (top 10 countries)
  - Device/OS/Browser breakdown (donut or pie charts)
  - Top referrers table
  - Click heatmap by day of week and hour of day
- Aggregate analytics overview on the main dashboard (total links, total clicks, most popular link)

#### 5. Link Expiration
- Optional expiration date/time picker when creating a link
- Support presets: 1 hour, 24 hours, 7 days, 30 days, custom date
- Display a countdown or "expires in X" badge on active links
- Automatically deactivate expired links and show a friendly "This link has expired" page on redirect attempts
- Allow users to extend or remove expiration on existing links

#### 6. Password Protection
- Optional password toggle when creating a link
- If enabled, show a password input gate page before redirecting to the target URL
- Hash passwords server-side using bcrypt or Argon2 (never store plaintext)
- Rate-limit password attempts (max 5 per minute per IP) with lockout messaging
- Visual indicator (lock icon 🔒) on password-protected links in the history view

#### 7. Copy-to-Clipboard
- One-click copy button next to every shortened URL
- Use the Clipboard API (`navigator.clipboard.writeText()`) with fallback to `document.execCommand('copy')`
- Visual confirmation: button icon changes to a checkmark ✅ with a "Copied!" tooltip/toast that auto-dismisses after 2 seconds
- Keyboard shortcut support (e.g., `Ctrl+Shift+C` to copy the most recently created link)

#### 8. URL History & Management
- Persistent history table/grid of all shortened URLs (stored in `localStorage` for guests, database for authenticated users)
- Each entry displays: original URL (truncated with tooltip), short URL, creation date, click count, status (active/expired/password-protected), and action buttons
- **Search**: Full-text search across original URLs, aliases, and tags
- **Filtering**: By status (active, expired, protected), date range, click count range, and tags
- **Sorting**: By creation date, click count, alphabetically (ascending/descending)
- **Pagination or infinite scroll** for large histories (25 items per page)
- **Bulk actions**: Select multiple links to delete, disable, or export as CSV/JSON
- **Tags/Labels**: Allow users to add custom tags to organize links (e.g., "marketing", "social", "campaign-q4")

---

### 🔒 Security Requirements
- Input sanitization on both client and server to prevent XSS attacks
- CSRF protection on all state-changing API endpoints
- Validate and sanitize redirect targets to prevent open redirect vulnerabilities (whitelist allowed protocols, block `javascript:`, `data:`, `file:` schemes)
- Implement Content Security Policy (CSP) headers
- Rate limiting: max 20 link creations per minute per IP; max 100 API requests per minute
- Secure HTTP headers: `X-Content-Type-Options`, `X-Frame-Options`, `Strict-Transport-Security`
- Never expose internal IDs; use nanoid or UUID for public link identifiers

---

### ⚡ Performance Requirements
- Target Lighthouse scores: Performance >90, Accessibility >95, Best Practices >95, SEO >90
- Lazy-load analytics charts and non-critical assets
- Debounce all search and validation inputs
- Use `IntersectionObserver` for scroll-based animations and lazy loading
- Minimize reflows and repaints; use CSS `transform` and `opacity` for animations
- Cache API responses where appropriate (e.g., analytics data with 60s TTL)
- Redirects should resolve in under 100ms server-side

---

### 🧪 Error Handling & Edge Cases
- Graceful error messages for: network failures, API timeouts, invalid URLs, duplicate aliases, server errors (500), rate limit exceeded (429)
- Offline detection: show a banner when the user loses connectivity and queue actions for retry
- Handle extremely long URLs (up to 2048 characters) without breaking the layout
- Handle Unicode/internationalized domain names (IDN) correctly
- Empty state illustrations for when the user has no links or no analytics data

---

### 📁 Deliverables
1. Complete, well-commented source code with a clear folder structure
2. `README.md` with setup instructions, API documentation, and feature list
3. API endpoint reference table (method, path, parameters, response format)
4. A `demo` mode with sample data pre-loaded for immediate preview
5. Responsive across Chrome, Firefox, Safari, and Edge (latest 2 versions)

---

> **Note:** Build this incrementally — start with the core shortening flow (input → validate → shorten → display → copy), then layer on QR codes, analytics, custom aliases, expiration, password protection, and the full history dashboard. Ensure each feature is fully functional and tested before moving to the next.