ref: prompts-chat/commit-message-preparation

title: Commit Message Preparation

summary: 1. Follow Conventional Commits (https://www.conventionalcommits.org/) 2. Be concise and precise - No flowery language, superlatives, or unnecessary adjectives 3. Focus on WHAT changed, not HOW it…

credit: "Commit Message Preparation" by prompts.chat (https://incantory.ai/prompts-chat/commit-message-preparation), licensed CC0-1.0

title: Commit Message Preparation

content:
# Git Commit Guidelines for AI Language Models

## Core Principles

1. **Follow Conventional Commits** (https://www.conventionalcommits.org/)
2. **Be concise and precise** - No flowery language, superlatives, or unnecessary adjectives
3. **Focus on WHAT changed, not HOW it works** - Describe the change, not implementation details
4. **One logical change per commit** - Split related but independent changes into separate commits
5. **Write in imperative mood** - "Add feature" not "Added feature" or "Adds feature"
6. **Always include body text** - Never use subject-only commits

## Commit Message Structure

```
<type>(<scope>): <subject>

<body>

<footer>
```

### Type (Required)

- `feat`: New feature
- `fix`: Bug fix
- `refactor`: Code change that neither fixes a bug nor adds a feature
- `perf`: Performance improvement
- `style`: Code style changes (formatting, missing semicolons, etc.)
- `test`: Adding or updating tests
- `docs`: Documentation changes
- `build`: Build system or external dependencies (npm, gradle, Xcode, SPM)
- `ci`: CI/CD pipeline changes
- `chore`: Routine tasks (gitignore, config files, maintenance)
- `revert`: Revert a previous commit

### Scope (Optional but Recommended)

Indicates the area of change: `auth`, `ui`, `api`, `db`, `i18n`, `analytics`, etc.

### Subject (Required)

- **Max 50 characters**
- **Lowercase first letter** (unless it's a proper noun)
- **No period at the end**
- **Imperative mood**: "add" not "added" or "adds"
- **Be specific**: "add email validation" not "add validation"

### Body (Required)

- **Always include body text** - Minimum 1 sentence
- **Explain WHAT changed and WHY** - Provide context
- **Wrap at 72 characters**
- **Separate from subject with blank line**
- **Use bullet points for multiple changes** (use `-` or `*`)
- **Reference issue numbers** if applicable
- **Mention specific classes/functions/files when relevant**

### Footer (Optional)

- **Breaking changes**: `BREAKING CHANGE: <description>`
- **Issue references**: `Closes #123`, `Fixes #456`
- **Co-authors**: `Co-Authored-By: Name <email>`

## Banned Words & Phrases

**NEVER use these words** (they're vague, subjective, or exaggerated):

❌ Comprehensive
❌ Robust
❌ Enhanced
❌ Improved (unless you specify what metric improved)
❌ Optimized (unless you specify what metric improved)
❌ Better
❌ Awesome
❌ Great
❌ Amazing
❌ Powerful
❌ Seamless
❌ Elegant
❌ Clean
❌ Modern
❌ Advanced

## Good vs Bad Examples

### ❌ BAD (No body)
```
feat(auth): add email/password login
```

**Problems:**
- No body text
- Doesn't explain what was actually implemented

### ❌ BAD (Vague body)
```
feat: Add awesome new login feature

This commit adds a powerful new login system with robust authentication
and enhanced security features. The implementation is clean and modern.
```

**Problems:**
- Subjective adjectives (awesome, powerful, robust, enhanced, clean, modern)
- Doesn't specify what was added
- Body describes quality, not functionality

### ✅ GOOD
```
feat(auth): add email/password login with Firebase

Implement login flow using Firebase Authentication. Users can now sign in
with email and password. Includes client-side email validation and error
handling for network failures and invalid credentials.
```

**Why it's good:**
- Specific technology mentioned (Firebase)
- Clear scope (auth)
- Body describes what functionality was added
- Explains what error handling covers

---

### ❌ BAD (No body)
```
fix(auth): prevent login button double-tap
```

**Problems:**
- No body text explaining the fix

### ✅ GOOD
```
fix(auth): prevent login button double-tap

Disable login button after first tap to prevent duplicate authentication
requests when user taps multiple times quickly. Button re-enables after
authentication completes or fails.
```

**Why it's good:**
- Imperative mood
- Specific problem described
- Body explains both the issue and solution approach

---

### ❌ BAD
```
refactor(auth): extract helper functions

Make code better and more maintainable by extracting functions.
```

**Problems:**
- Subjective (better, maintainable)
- Not specific about which functions

### ✅ GOOD
```
refactor(auth): extract helper functions to static struct methods

Convert private functions randomNonceString and sha256 into static methods
of AppleSignInHelper struct for better code organization and namespacing.
```

**Why it's good:**
- Specific change described
- Mentions exact function names
- Body explains reasoning and new structure

---

### ❌ BAD
```
feat(i18n): add localization
```

**Problems:**
- No body
- Too vague

### ✅ GOOD
```
feat(i18n): add English and Turkish translations for login screen

Create String Catalog with translations for login UI elements, alerts,
and authentication errors in English and Turkish. Covers all user-facing
strings in LoginView, LoginViewController, and AuthService.
```

**Why it's good:**
- Specific languages mentioned
- Clear scope (i18n)
- Body lists what was translated and which files

---

## Multi-File Commit Guidelines

### When to Split Commits

Split changes into separate commits when:

1. **Different logical concerns**
   - ✅ Commit 1: Add function
   - ✅ Commit 2: Add tests for function

2. **Different scopes**
   - ✅ Commit 1: `feat(ui): add button component`
   - ✅ Commit 2: `feat(api): add endpoint for button action`

3. **Different types**
   - ✅ Commit 1: `feat(auth): add login form`
   - ✅ Commit 2: `refactor(auth): extract validation logic`

### When to Combine Commits

Combine changes in one commit when:

1. **Tightly coupled changes**
   - ✅ Adding a function and its usage in the same component

2. **Atomic change**
   - ✅ Refactoring function name across multiple files

3. **Breaking without each other**
   - ✅ Adding interface and its implementation together

## File-Level Commit Strategy

### Example: LoginView Changes

If LoginView has 2 independent changes:

**Change 1:** Refactor stack view structure
**Change 2:** Add loading indicator

**Split into 2 commits:**

```
refactor(ui): extract content stack view as property in login view

Change inline stack view initialization to property-based approach for
better code organization and reusability. Moves stack view definition
from setupUI method to lazy property.
```

```
feat(ui): add loading state with activity indicator to login view

Add loading indicator overlay and setLoading method to disable user
interaction and dim content during authentication. Content alpha reduces
to 0.5 when loading.
```

## Localization-Specific Guidelines

### ✅ GOOD
```
feat(i18n): add English and Turkish translations

Create String Catalog (Localizable.xcstrings) with English and Turkish
translations for all login screen strings, error messages, and alerts.
```

```
build(i18n): add Turkish localization support

Add Turkish language to project localizations and enable String Catalog
generation (SWIFT_EMIT_LOC_STRINGS) in build settings for Debug and
Release configurations.
```

```
feat(i18n): localize login view UI elements

Replace hardcoded strings with NSLocalizedString in LoginView for title,
subtitle, labels, placeholders, and button titles. All user-facing text
now supports localization.
```

### ❌ BAD
```
feat: Add comprehensive multi-language support

Add awesome localization system to the app.
```

```
feat: Add translations
```

## Breaking Changes

When introducing breaking changes:

```
feat(api): change authentication response structure

Authentication endpoint now returns user object in 'data' field instead
of root level. This allows for additional metadata in the response.

BREAKING CHANGE: Update all API consumers to access response.data.user
instead of response.user.

Migration guide:
- Before: const user = response.user
- After: const user = response.data.user
```

## Commit Ordering

When preparing multiple commits, order them logically:

1. **Dependencies first**: Add libraries/configs before usage
2. **Foundation before features**: Models before views
3. **Build before source**: Build configs before code changes
4. **Utilities before consumers**: Helpers before components that use them

### Example Order:

```
1. build(auth): add Sign in with Apple entitlement
   Add entitlements file with Sign in with Apple capability for enabling
   Apple ID authentication.

2. feat(auth): add Apple Sign-In cryptographic helpers
   Add utility functions for generating random nonce and SHA256 hashing
   required for Apple Sign-In authentication flow.

3. feat(auth): add Apple Sign-In authentication to AuthService
   Add signInWithApple method to AuthService protocol and implementation.
   Uses OAuthProvider credential with idToken and nonce for Firebase
   authentication.

4. feat(auth): add Apple Sign-In flow to login view model
   Implement loginWithApple method in LoginViewModel to handle Apple
   authentication with idToken, nonce, and fullName.

5. feat(auth): implement Apple Sign-In authorization flow
   Add ASAuthorizationController delegate methods to handle Apple Sign-In
   authorization, credential validation, and error handling.
```

## Special Cases

### Configuration Files

```
chore: ignore GoogleService-Info.plist from version control

Add GoogleService-Info.plist to .gitignore to prevent committing Firebase
configuration with API keys.
```

```
build: update iOS deployment target to 15.0

Change minimum iOS version from 14.0 to 15.0 to support async/await syntax
in authentication flows.
```

```
ci: add GitHub Actions workflow for testing

Add workflow to run unit tests on pull requests. Runs on macOS latest
with Xcode 15.
```

### Documentation

```
docs: add API authentication guide

Document Firebase Authentication setup process, including Google Sign-In
and Apple Sign-In configuration steps.
```

```
docs: update README with installation steps

Add SPM dependency installation instructions and Firebase setup guide.
```

### Refactoring

```
refactor(auth): convert helper functions to static struct methods

Wrap Apple Sign-In helper functions in AppleSignInHelper struct with
static methods for better code organization and namespacing. Converts
randomNonceString and sha256 from private functions to static methods.
```

```
refactor(ui): extract email validation to separate method

Move email validation regex logic from loginWithEmail to isValidEmail
method for reusability and testability.
```

### Performance

**Specify the improvement:**

❌ `perf: optimize login`

✅
```
perf(auth): reduce login request time from 2s to 500ms

Add request caching for Firebase configuration to avoid repeated network
calls. Configuration is now cached after first retrieval.
```

## Body Text Requirements

**Minimum requirements for body text:**

1. **At least 1-2 complete sentences**
2. **Describe WHAT was changed specifically**
3. **Explain WHY the change was needed (when not obvious)**
4. **Mention affected components/files when relevant**
5. **Include technical details that aren't obvious from subject**

### Good Body Examples:

```
Add loading indicator overlay and setLoading method to disable user
interaction and dim content during authentication.
```

```
Update signInWithApple method to accept fullName parameter and use
appleCredential for proper user profile creation in Firebase.
```

```
Replace hardcoded strings with NSLocalizedString in LoginView for title,
labels, placeholders, and buttons. All UI text now supports English and
Turkish translations.
```

### Bad Body Examples:

❌ `Add feature.` (too vague)
❌ `Updated files.` (doesn't explain what)
❌ `Bug fix.` (doesn't explain which bug)
❌ `Refactoring.` (doesn't explain what was refactored)

## Template for AI Models

When an AI model is asked to create commits:

```
1. Read git diff to understand ALL changes
2. Group changes by logical concern
3. Order commits by dependency
4. For each commit:
   - Choose appropriate type and scope
   - Write specific, concise subject (max 50 chars)
   - Write detailed body (minimum 1-2 sentences, required)
   - Use imperative mood
   - Avoid banned words
   - Focus on WHAT changed and WHY
5. Output format:
   ## Commit [N]

   **Title:**
   ```
   type(scope): subject
   ```

   **Description:**
   ```
   Body text explaining what changed and why. Mention specific
   components, classes, or methods affected. Provide context.
   ```

   **Files to add:**
   ```bash
   git add path/to/file
   ```
```

## Final Checklist

Before suggesting a commit, verify:

- [ ] Type is correct (feat/fix/refactor/etc.)
- [ ] Scope is specific and meaningful
- [ ] Subject is imperative mood
- [ ] Subject is ≤50 characters
- [ ] **Body text is present (required)**
- [ ] **Body has at least 1-2 complete sentences**
- [ ] Body explains WHAT and WHY
- [ ] No banned words used
- [ ] No subjective adjectives
- [ ] Specific about WHAT changed
- [ ] Mentions affected components/files
- [ ] One logical change per commit
- [ ] Files grouped correctly

---

## Example Commit Message (Complete)

```
feat(auth): add email validation to login form

Implement client-side email validation using regex pattern before sending
authentication request. Validates format matches standard email pattern
(user@domain.ext) and displays error message for invalid inputs. Prevents
unnecessary Firebase API calls for malformed emails.
```

**What makes this good:**
- Clear type and scope
- Specific subject
- Body explains what validation does
- Body explains why it's needed
- Mentions the benefit (prevents API calls)
- No banned words
- Imperative mood throughout

---

**Remember:** A good commit message should allow someone to understand the change without looking at the diff. Be specific, be concise, be objective, and always include meaningful body text.


summary: { "role": "Startup Founder", "context": "Developing a business plan for a startup focused on innovative solutions in the tumor medical industry.", "task": "Create a detailed business plan aimed at…

kind: text

credit: "Tumor Medical Industry Solution Business Plan" by prompts.chat (https://incantory.ai/prompts-chat/tumor-medical-industry-solution-business-plan), licensed CC0-1.0

prompts.chat

handle: prompts-chat

source: prompts-chat

copyrightHolder: prompts.chat contributors

role: Startup Founder

task: Create a detailed business plan aimed at addressing key challenges and opportunities within the tumor medical sector.

Executive Summary: Provide a concise overview of the business, its mission, and its objectives.

Market Analysis: Analyze the current tumor medical industry landscape, including market size, growth potential, and key competitors.

Business Model: Outline the business model, including revenue streams, customer segments, and value propositions.

Solution Description: Detail the innovative solutions offered, including technologies and services that address tumor-related challenges.

Marketing Strategy: Develop strategies for reaching target customers and establishing a brand presence in the market.

Financial Plan: Create financial projections, including startup costs, revenue forecasts, and funding requirements.

Team and Management: Introduce the team members and their expertise relevant to executing the business plan.

Risk Analysis: Identify potential risks and outline mitigation strategies.

constraints: Ensure compliance with medical regulations and standards.

constraints: Focus on patient-centric solutions and ethical considerations.

output_format: A structured JSON object representing each section of the business plan.


credit: "Landing Page Copy Architect – Conversion Framework Prompt" by prompts.chat (https://incantory.ai/prompts-chat/landing-page-copy-architect-conversion-framework-prompt), licensed CC0-1.0

content:
Landing Page Copy Architect – Conversion Framework Prompt

**Role & Goal**
You are a senior conversion copywriter and CRO strategist. Design **one high-converting landing page copy framework** (not final copy) for a specific offer. The output must be a reusable blueprint that another AI (Claude, bolt.new, Lovable, ChatGPT, etc.) can use to generate full landing page copy.

---

### 1. Fill in the Offer Details (before running)

* **Offer Type:** [LEAD MAGNET / PRODUCT / WEBINAR / FREE TRIAL / OTHER]
* **Offer Name:** [OFFER_NAME]
* **Target Audience:** [WHO THEY ARE, SEGMENT, TOP PAINS & DESIRES]
* **Target Conversion:** [CURRENT % → GOAL %]
* **Page Length:** [SHORT / MEDIUM / LONG]
* **Traffic Temperature:** [COLD / WARM / HOT]
* **Unique Mechanism / Key Differentiator:** [1–3 SHORT LINES EXPLAINING “WHAT MAKES THIS DIFFERENT”]
* **Main Objections (3–5):** [PRICE / TRUST / TIME / COMPLEXITY / ETC.]
* **Social Proof Available:** [TESTIMONIALS / REVIEWS / CASE STUDIES / STATS / NONE]
* **Brand Voice:** [E.G., BOLD / PLAYFUL / FORMAL / EMPATHETIC]

Use these details in every part of your answer.

---

### 2. Page Strategy Snapshot (≤ 200 words)

Briefly explain:

* Who this page is for
* What the primary conversion goal is
* The **big idea** behind the offer
* How the **unique mechanism** changes the usual approach
* Recommended page length and section emphasis for this **traffic temperature**

---

### 3. Page Structure & Sections

Create a **scroll-order outline** of the page as a table or numbered list. For each section, include:

* **Section Name** (e.g., Hero, Problem, Solution, Social Proof, Offer, FAQ, Final CTA)
* **Primary Goal** of the section
* **Recommended Length:** [VERY SHORT / SHORT / MEDIUM / LONG]
* **Emotional State** we want the reader in by the end of the section
* **Best Content Type:** [HEADLINE / BULLETS / STORY / TESTIMONIAL / COMPARISON TABLE / FAQ / ETC.]

---

### 4. Headline Formula Bank (10 Variations)

Create **10 headline formulas** tailored to this:

* Offer Type
* Traffic Temperature
* Unique Mechanism / Key Differentiator

For each formula:

1. Show a **pattern with placeholders in ALL CAPS**, e.g.

   * `Get [RESULT] In [TIMEFRAME] Without [HATED_ACTION]`
2. Provide **1 worked example** customized to this offer, audience, and mechanism.

---

### 5. Section-by-Section AI Prompts

For **each section** in the page structure, create a Claude/bolt.new/Lovable-compatible prompt that another AI can paste in to generate copy.

For every section prompt:

* Start with the label:
  `SECTION PROMPT: [SECTION NAME]`
* Include:

  * Section purpose
  * Desired tone & length
  * Quick reminder of offer, audience, traffic temperature, and unique mechanism
  * Instructions to generate **2–3 variations** of that section
* Keep each prompt in **one copy-pasteable block**.

---

### 6. Benefit vs Feature Converter

Create a simple **conversion tool**:

1. A **2-column list**:

   * Column 1: **Feature** (e.g., “8-week live cohort,” “lifetime access”)
   * Column 2: **Benefit phrased in outcome language** with “so you can…” or similar.
2. A **mini rulebook** with **5–7 rules** explaining how to turn features into strong benefits.
3. **3 examples** of copy rewritten from feature-heavy → benefit-driven.

---

### 7. Objection Handling Plan

Using the “Main Objections” provided, build an **objection handling map**:

* List the **top 5 objections** (if fewer provided, infer likely ones from offer type & traffic temperature).
* For each objection, specify:

  * **Where** on the page to address it (e.g., hero subhead, pricing area, FAQ, near CTA, testimonial block).
  * **In what format:** microcopy, FAQ item, guarantee block, testimonial, comparison table, etc.
* Provide **3 short plug-and-play templates** for objection handling, with placeholders in ALL CAPS, e.g.:

  * `Worried about [OBJECTION]? Here’s how [UNIQUE_MECHANISM] removes [RISK].`

---

### 8. CTA Optimization Strategy

Design a **CTA strategy** that fits this offer and traffic temperature:

* Identify **3–5 key CTA locations** on the page (hero, mid-page, after social proof, near FAQ, final section).
* For each location, provide:

  * A **CTA button copy formula** with placeholders (e.g., `Get [RESULT] In [TIMEFRAME]`)
  * Suggested **supporting microcopy** (e.g., risk reversal, urgency, reassurance, key benefit reminder).
* Give **5 best-practice rules** for CTAs on this type of offer & traffic temperature (e.g., clarity > cleverness, friction-reducing language, etc.).

---

### 9. Trust Element Integration

Create a **trust building plan**:

* Recommend **which trust elements** to use based on the available social proof:

  * Testimonials, star ratings, logos, mini case studies, guarantees, badges, media mentions, etc.
* For each major section, specify:

  * Which trust element fits best
  * **Why** it belongs there (what doubt or belief it supports).
* If social proof is weak or missing, suggest **alternatives** such as:

  * Process transparency
  * “Why we built this” story
  * Data, logic, or small commitments to reduce risk.

---

### 10. Output & Formatting Requirements

* Use **clear headings** and **bullet points**.
* Start with a **numbered overview** of all parts, then expand each.
* Do **not** write the actual final landing page copy. Only provide:

  * Frameworks
  * Formulas
  * Tables/lists
  * Ready-to-use prompts
* Use placeholders in **ALL CAPS** (e.g., [AUDIENCE], [RESULT], [TIMEFRAME], [OBJECTION]).
* Aim to keep the full response under **~1,800–2,200 words**.

End with this line, customized:

> **If visitors remember only one thing from this landing page, it should be: “[ONE CORE PROMISE].”**

---


title: A frozen river running past a cabin in mountain side

summary: Stable Diffusion prompt sampled from DiffusionDB (NSFW-, PII- and named-person-filtered).

kind: image

credit: From DiffusionDB (Wang et al., 2022), https://huggingface.co/datasets/poloclub/diffusiondb, CC0-1.0.

DiffusionDB

handle: diffusiondb

source: diffusiondb

sourceName: DiffusionDB

copyrightHolder: DiffusionDB contributors (Wang et al., 2022), dedicated to the public domain

contentRating: general

content: a frozen river running past a cabin in mountain side, blizzard, classic painting, award winning, highly detailed


title: Close up of round pills on top of a wooden table

creditLine: From DiffusionDB (Wang et al., 2022), https://huggingface.co/datasets/poloclub/diffusiondb, CC0-1.0.

content: close up of round pills on top of a wooden table, 8k, high detail, photorealistic, proper shading, stock photo


summary: change home page desgin which contain header bar,tags,blog cards and docs card , give better ui design

credit: "change home page desgin for blog and documentation platorm" by prompts.chat (https://incantory.ai/prompts-chat/change-home-page-desgin-for-blog-and-documentation-platorm), licensed CC0-1.0


summary: { "model": "nano-banana", "task": "imagetoimageproducttransformation",

credit: "Transform the provided clothing product image." by prompts.chat (https://incantory.ai/prompts-chat/transform-the-provided-clothing-product-image), licensed CC0-1.0

model: nano-banana

objective: Transform the provided clothing product image into a luxury studio ghost-mannequin presentation where the garment appears naturally worn and volumetric, as if inflated with air on an invisible mannequin. Preserve the exact identity of the original product with zero alterations.

source_image_type: flat lay clothing product photo

background: white background

product_category: general clothing (t-shirts, jackets, hoodies, pants, denim, vests, etc)

garment_structure: inflate the garment as if worn by an invisible mannequin, creating natural body volume and shape while keeping the interior empty

mannequin_style: luxury ghost mannequin used in high-end fashion e-commerce photography

fabric_condition: perfectly ironed fabric with subtle natural folds that reflect realistic garment tension

pose: natural wearable garment shape as if placed on a torso or body form, but with no visible mannequin or human presence

center_alignment: the garment must remain perfectly centered in the frame

framing: clean product catalog composition with balanced margins on all sides

background: pure white professional studio background (#FFFFFF) with no gradients, textures, props, or shadows except a very soft natural grounding shadow

style: high-end fashion e-commerce studio lighting

direction: soft frontal lighting with balanced fill light

goal: highlight fabric texture, stitching, seams, and garment structure

shadow_control: minimal soft shadow directly beneath garment for realism

exposure: clean bright exposure without overblown highlights or crushed shadows

color: preserve the exact original color values

texture: preserve the exact fabric texture and weave

logos: preserve existing logos exactly if present

stitching: preserve stitching patterns exactly

details: preserve pockets, buttons, zippers, seams, embroidery, tags, and all construction details exactly

strict_prohibitions:
do not add new logos
do not remove existing logos
do not change garment color
do not alter stitching
do not modify pockets
do not modify garment design
do not invent new fabric textures
do not change garment proportions
do not add accessories
do not add a human model
do not add a mannequin
do not add props or scenery
do not crop the garment

structure: realistic garment volume based on clothing physics

folds: subtle natural folds caused by gravity and body form

tension: light tension around chest, shoulders, waist, or hips depending on garment type

fabric_behavior: respect real textile behavior such as denim stiffness, cotton softness, or knit flexibility

camera_angle: straight-on front-facing catalog angle

symmetry: balanced and professional e-commerce alignment

product_visibility: entire garment fully visible without cropping

catalog_standard: consistent framing suitable for automated product galleries

style: luxury fashion e-commerce photography

sharpness: high-detail crisp garment texture

resolution: high resolution suitable for product zoom

cleanliness: no dust, wrinkles, artifacts, distortions, or AI hallucinations

use_case: 360-degree product rotation pipeline

consistency_requirement: garment structure, lighting, and proportions must remain stable and repeatable across multiple angles

output_type: professional e-commerce catalog image


title: Surreal CGI-Photography Hybrid Portrait

summary: { "prompttype": "Surreal CGI-Photography Hybrid Portrait", "subject": { "referenceidentity": "Crucially, the woman's facial features, hair, and unique identity must match the provided reference…

credit: "Surreal CGI-Photography Hybrid Portrait" by akykaan (https://incantory.ai/prompts-chat/surreal-cgi-photography-hybrid-portrait), licensed CC0-1.0

originalAuthor: akykaan

copyrightHolder: akykaan

title: Surreal CGI-Photography Hybrid Portrait

prompt_type: Surreal CGI-Photography Hybrid Portrait

reference_identity: Crucially, the woman's facial features, hair, and unique identity must match the provided reference photo exactly.

expression: Neutral expression, gazing upward.

pose: A surreal full-body composition viewed from above. Her upper torso and arms emerge physically from a smartphone screen lying flat, hands resting on the screen's bezel. Her lower body is digitally contained within the screen's display.

upper_body_real: Attractive daily wear: A fitted, charcoal grey ribbed knit sweater. White over-ear headphones are on her head.

lower_body_screen: Attractive daily wear: Dark high-waisted skinny jeans and stylish black leather ankle boots, rendered digitally within the phone interface.

setting: A minimalist gray concrete surface where a black smartphone lies flat.

screen_content: The smartphone display shows a music player app interface. Track: 'Lions In a Cage' by Pentagram. Timestamp: 0:41 / 5:59. Background visual on screen: A warm sunset with silhouetted palm trees.

props: Iphone 16

camera_angle: High top-down view (God's eye angle), looking straight down at the phone and emerging subject.

lens: 35mm wide-angle lens, creating perspective integration between the real and digital worlds.

aperture: f/8 for deep depth of field, keeping both the physical subject and the screen content sharp.

lighting: Soft artificial overhead and frontal lighting mixed with the warm glow emanating from the smartphone screen. Medium contrast, diffused shadows. The lighting palette is slightly warm and desaturated, mirroring an intimate indoor setting.

color_palette: Neutral gray-white dominant palette in the real world, contrasted by the warm oranges, deep reds, and greens from the sunset interface on the screen.

style: Digital CGI blended seamlessly with photography. Whimsical, surreal, tech-inspired, and immersive mood.


ref: cursorrules/google-adk

title: Google Adk

summary: Google Agent Development Kit rules for agents, tools, sessions, memory, artifacts, evaluation, and deployment

kind: rules

credit: "Google Adk" by PatrickJS (https://incantory.ai/cursorrules/google-adk), licensed CC0-1.0

Awesome CursorRules

handle: cursorrules

source: cursorrules

sourceName: Awesome CursorRules

originalAuthor: PatrickJS

copyrightHolder: PatrickJS

title: Google Adk

content:
# Google ADK Rules

## Agent Design

- Keep each agent focused on a clear goal, persona, and tool set.
- Use LLM agents for flexible reasoning and workflow agents for deterministic orchestration.
- Write instructions that define task boundaries, tool-use rules, and escalation behavior.
- Split multi-agent systems by responsibility rather than by implementation convenience.
- Keep model choices configurable.

## Tools

- Give tools narrow, typed inputs and outputs.
- Validate tool arguments before performing side effects.
- Keep secrets, credentials, and privileged APIs out of agent prompts.
- Handle tool errors explicitly and return actionable failure messages.
- Be aware of ADK tool limitations; some built-in tools cannot be combined with other tools on the same agent.

## Sessions, State, and Memory

- Use session state for current-conversation data.
- Use memory for cross-session recall and retrieval.
- Keep state small and serializable.
- Do not store large files or binary payloads in session state.
- Make state keys stable and documented.

## Artifacts

- Use artifacts for generated files, uploaded files, reports, images, audio, and other binary data.
- Configure an artifact service in the runner before relying on artifact operations.
- Version artifact filenames intentionally and avoid overwriting semantically different outputs.
- Store only references or summaries in state when full content belongs in artifacts.

## Evaluation and Deployment

- Add tests for tool behavior, agent routing, prompt regressions, and unsafe tool calls.
- Use trace or event logs to debug agent decisions.
- Keep local development, staging, and production configuration separate.
- Add observability for latency, tool failures, token use, and handoff failures.

## Common Mistakes

- Do not make one agent responsible for every workflow.
- Do not let tools accept arbitrary shell, SQL, or HTTP input without validation.
- Do not rely on prompt text for access control.
- Do not hide important side effects behind generic tool names.


title: Create Python Dev Container

credit: "Create Python Dev Container" by bugyboo (https://incantory.ai/prompts-chat/create-python-dev-container), licensed CC0-1.0

originalAuthor: bugyboo

copyrightHolder: bugyboo

title: Create Python Dev Container

content:
You are a DevOps expert setting up a Python development environment using Docker and VS Code Remote Containers.

Your task is to provide and run Docker commands for a lightweight Python development container based on the official python latest slim-bookworm image.

Key requirements:
- Use interactive mode with a bash shell that does not exit immediately.
- Override the default command to keep the container running indefinitely (use sleep infinity or similar) do not remove the container after running.
- Name it py-dev-container
- Mount the current working directory (.) as a volume to /workspace inside the container (read-write).
- Run the container as a non-root user named 'vscode' with UID 1000 for seamless compatibility with VS Code Remote - Containers extension.
- Install essential development tools inside the container if needed (git, curl, build-essential, etc.), but only via runtime commands if necessary.
- Do not create any files on the host or inside the container beyond what's required for running.
- Make the container suitable for attaching VS Code remotely (Remote - Containers: Attach to Running Container) to enable further Python development, debugging, and extension usage.

Provide:
1. The docker pull command (if needed).
2. The full docker run command with all flags.
3. Instructions on how to attach VS Code to this running container for development.

Assume the user is in the root folder of their Python project on the host.


title: The Witcher - Double Exposure Effect

summary: Double exposure cinematic wallpaper inspired by The Witcher video game series (game, not TV show). Geralt of Rivia and Yennefer standing back to back in a centered, balanced composition. Geralt…

credit: "The Witcher - Double Exposure Effect" by akykaan (https://incantory.ai/prompts-chat/the-witcher-double-exposure-effect), licensed CC0-1.0

title: The Witcher - Double Exposure Effect

content:
Double exposure cinematic wallpaper inspired by The Witcher video game series (game, not TV show).
Geralt of Rivia and Yennefer standing back to back in a centered, balanced composition.
Geralt:
Facing forward, face fully visible, white hair, cat-like eyes, scarred and stoic expression, wearing witcher armor.
Strong, defined silhouette.
Yennefer:
Standing back to back with Geralt, body turned slightly away, face partially visible in side profile.
Dark hair, intense gaze, elegant but dangerous presence, flowing dark garments.
Inside the silhouettes: Within Geralt’s silhouette: Medieval ruins, monster-haunted forests, foggy mountain paths, cold steel tones, grim atmosphere. Within Yennefer’s silhouette: Arcane landscapes, ancient stone structures, subtle magical motifs, moonlit skies, deep violet and shadowed tones.
Double exposure treatment:
Clean silhouette separation, layered environments integrated naturally, painterly but controlled.
No scenery outside the silhouettes.
Background:
Dark crimson background with subtle texture, cinematic tension, restrained saturation.
Style & mood:
Dark fantasy, serious and grounded, video game cinematic art style.
No Netflix, no modern costume design, no TV adaptation influence.
Ultra high resolution, sharp details, premium wallpaper quality. Format 9:16


title: Photorealistic ruined and abandoned cyberpunk Space resort in orbit

content: photorealistic ruined and abandoned cyberpunk Space resort in orbit, covered in broken glass, rusted metal and moss and vines. daylight. sunlight. lens flare. light fixtures. 8K. detailed. photorealism. artstation. 25mm f/1.7 ASPH Lens. ultra realistic


ref: prompts-chat/study-planner

title: Study planner

summary: I want you to act as an advanced study plan generator. Imagine you are an expert in education and mental health, tasked with developing personalized study plans for students to help improve their…

credit: "Study planner" by ahmedyasseribrahim (https://incantory.ai/prompts-chat/study-planner), licensed CC0-1.0

originalAuthor: ahmedyasseribrahim

copyrightHolder: ahmedyasseribrahim

title: Study planner

content: I want you to act as an advanced study plan generator. Imagine you are an expert in education and mental health, tasked with developing personalized study plans for students to help improve their academic performance and overall well-being. Take into account the students' courses, available time, responsibilities, and deadlines to generate a study plan.


title: A man laughing hysterically at a funeral while everyone looks at him

content: a man laughing hysterically at a funeral while everyone looks at him


title: A full body photograph of Prospero from the stage production of The Tempest…

content: a full body photograph of Prospero from the stage production of The Tempest taken with Nikon D3500, highly detailed


summary: Thoughtful Islamic book cover illustration for teenagers, side silhouette of a young person. Inside the head a question mark transforming into light and certainty. Arabic word "اليقين" integrated in…

credit: "illustration for teenagers, side silhouette of a young person. Inside the head a question mark transforming into light t. Deep purple and blue tones, minimalist and , v." by prompts.chat (https://incantory.ai/prompts-chat/illustration-for-teenagers-side-silhouette-of-a-young-person), licensed CC0-1.0

content: Thoughtful Islamic book cover illustration for teenagers, side silhouette of a young person. Inside the head a question mark transforming into light and certainty. Arabic word "اليقين" integrated in the light. Deep purple and blue tones, minimalist and modern style, serious educational mood, no cartoon elements, vertical format, high resolution.


title: Hd photo of the Pittsburgh skyline

title: Hd photo of the Pittsburgh skyline

content: Hd photo of the Pittsburgh skyline


ref: cursorrules/cpp

title: Cpp

summary: Guide Cursor to write modern C++ and CMake code with clear structure, RAII, const-correctness, and safe error handling.

credit: "Cpp" by PatrickJS (https://incantory.ai/cursorrules/cpp), licensed CC0-1.0

title: Cpp

content:
# C++ Programming Guidelines

## Basic Principles

- Use English for all code and documentation.
- Always declare the type of each variable and function (parameters and return value).
- Create necessary types and classes.
- Use Doxygen style comments to document public classes and methods.
- Don't leave blank lines within a function.
- Follow the one-definition rule (ODR).

## Nomenclature

- Use PascalCase for classes and structures.
- Use camelCase for variables, functions, and methods.
- Use ALL_CAPS for constants and macros.
- Use snake_case for file and directory names.
- Use UPPERCASE for environment variables.
- Avoid magic numbers and define constants.
- Start each function with a verb.
- Use verbs for boolean variables. Example: isLoading, hasError, canDelete, etc.
- Use complete words instead of abbreviations and ensure correct spelling.
  - Except for standard abbreviations like API, URL, etc.
  - Except for well-known abbreviations:
    - i, j, k for loops
    - err for errors
    - ctx for contexts
    - req, res for request/response parameters

## Functions

- Write short functions with a single purpose. Less than 20 instructions.
- Name functions with a verb and something else.
- If it returns a boolean, use isX or hasX, canX, etc.
- If it doesn't return anything (void), use executeX or saveX, etc.
- Avoid nesting blocks by:
  - Early checks and returns.
  - Extraction to utility functions.
- Use standard library algorithms (std::for_each, std::transform, std::find, etc.) to avoid function nesting.
- Use lambda functions for simple operations.
- Use named functions for non-simple operations.
- Use default parameter values instead of checking for null or nullptr.
- Reduce function parameters using structs or classes
  - Use an object to pass multiple parameters.
  - Use an object to return multiple results.
  - Declare necessary types for input arguments and output.
- Use a single level of abstraction.

## Data

- Don't abuse primitive types and encapsulate data in composite types.
- Avoid data validations in functions and use classes with internal validation.
- Prefer immutability for data.
- Use const for data that doesn't change.
- Use constexpr for compile-time constants.
- Use std::optional for possibly null values.

## Classes

- Follow SOLID principles.
- Prefer composition over inheritance.
- Declare interfaces as abstract classes or concepts.
- Write small classes with a single purpose.
  - Less than 200 instructions.
  - Less than 10 public methods.
  - Less than 10 properties.
- Use the Rule of Five (or Rule of Zero) for resource management.
- Make member variables private and provide getters/setters where necessary.
- Use const-correctness for member functions.

## Exceptions

- Use exceptions to handle errors you don't expect.
- If you catch an exception, it should be to:
  - Fix an expected problem.
  - Add context.
  - Otherwise, use a global handler.
- Use std::optional, std::expected, or error codes for expected failures.

## Memory Management

- Prefer smart pointers (std::unique_ptr, std::shared_ptr) over raw pointers.
- Use RAII (Resource Acquisition Is Initialization) principles.
- Avoid memory leaks by proper resource management.
- Use std::vector and other standard containers instead of C-style arrays.

## Testing

- Follow the Arrange-Act-Assert convention for tests.
- Name test variables clearly.
- Follow the convention: inputX, mockX, actualX, expectedX, etc.
- Write unit tests for each public function.
- Use test doubles to simulate dependencies.
  - Except for third-party dependencies that are not expensive to execute.
- Write integration tests for each module.
- Follow the Given-When-Then convention.

## Project Structure

- Use modular architecture
- Organize code into logical directories:
  - include/ for header files
  - src/ for source files
  - test/ for test files
  - lib/ for libraries
  - doc/ for documentation
- Use CMake or similar build system.
- Separate interface (.h) from implementation (.cpp).
- Use namespaces to organize code logically.
- Create a core namespace for foundational components.
- Create a utils namespace for utility functions.

## Standard Library

- Use the C++ Standard Library whenever possible.
- Prefer std::string over C-style strings.
- Use std::vector, std::map, std::unordered_map, etc. for collections.
- Use std::optional, std::variant, std::any for modern type safety.
- Use std::filesystem for file operations.
- Use std::chrono for time-related operations.

## Concurrency

- Use std::thread, std::mutex, std::lock_guard for thread safety.
- Prefer task-based parallelism over thread-based parallelism.
- Use std::atomic for atomic operations.
- Avoid data races by proper synchronization.
- Use thread-safe data structures when necessary.


title: Criar/Alterar Documentação de Projeto

credit: "Criar/Alterar Documentação de Projeto" by prompts.chat (https://incantory.ai/prompts-chat/criar-alterar-documentacao-de-projeto), licensed CC0-1.0

title: Criar/Alterar Documentação de Projeto

content:
---
agent: 'agent'
description: 'Generate / Update a set of project documentation files: ARCHITECTURE.md, PRODUCT.md, and CONTRIBUTING.md, following specified guidelines and length constraints.'
---
# System Prompt – Project Documentation Generator

You are a senior software architect and technical writer responsible for generating and maintaining high-quality project documentation.

Your task is to create or update the following documentation files in a clear, professional, and structured manner. The documentation must be concise, objective, and aligned with modern software engineering best practices.

---

## 1⃣ ARCHITECTURE.md (Maximum: 2 pages)

Generate an `ARCHITECTURE.md` file that describes the overall architecture of the project.

Include:

* High-level system overview
* Architectural style (e.g., monolith, modular monolith, microservices, event-driven, etc.)
* Main components and responsibilities
* Folder/project structure explanation
* Data flow between components
* External integrations (APIs, databases, services)
* Authentication/authorization approach (if applicable)
* Scalability and deployment considerations
* Future extensibility considerations (if relevant)

Guidelines:

* Keep it technical and implementation-focused.
* Use clear section headings.
* Prefer bullet points over long paragraphs.
* Avoid unnecessary marketing language.
* Do not exceed 2 pages of content.

---

## 2⃣ PRODUCT.md (Maximum: 2 pages)

Generate a `PRODUCT.md` file that describes the product functionality from a business and user perspective.

Include:

* Product overview and purpose
* Target users/personas
* Core features
* Secondary/supporting features
* User workflows
* Use cases
* Business rules (if applicable)
* Non-functional requirements (performance, security, usability)
* Product vision (short section)

Guidelines:

* Focus on what the product does and why.
* Avoid deep technical implementation details.
* Be structured and clear.
* Use short paragraphs and bullet points.
* Do not exceed 2 pages.

---

## 3⃣ CONTRIBUTING.md (Maximum: 1 page)

Generate a `CONTRIBUTING.md` file that describes developer guidelines and best practices for contributing to the project.

Include:

* Development setup instructions (high-level)
* Branching strategy
* Commit message conventions
* Pull request guidelines
* Code style and linting standards
* Testing requirements
* Documentation requirements
* Review and approval process

Guidelines:

* Be concise and practical.
* Focus on maintainability and collaboration.
* Avoid unnecessary verbosity.
* Do not exceed 1 page.

---

## 4⃣ README.md (Maximum: 2 pages)

Generate or update a `README.md` file that serves as the main entry point of the repository.

Include:

* Project name and short description
* Problem statement
* Key features
* Tech stack overview
* Installation instructions
* Environment variables configuration (if applicable)
* How to run the project (development and production)
* Basic usage examples
* Project structure overview (high-level)
* Link to additional documentation (ARCHITECTURE.md, PRODUCT.md, CONTRIBUTING.md)

Guidelines:

* Keep it clear and developer-friendly.
* Optimize for first-time visitors to quickly understand the project.
* Use badges if appropriate (build status, license, version).
* Provide copy-paste ready commands.
* Avoid deep architectural explanations (link to ARCHITECTURE.md instead).
* Do not exceed 2 pages.

---

## General Rules

* Use Markdown formatting.
* Use clear headings (`#`, `##`, `###`).
* Keep documentation structured and scannable.
* Avoid redundancy across files.
* If a file already exists, update it instead of duplicating content.
* Maintain consistency in terminology across all documents.
* Prefer clarity over complexity.


title: Datacenter with server in the middle

title: Datacenter with server in the middle

content: datacenter with server in the middle, red laser grid, deep view, heavy blue led lights, wires connected, award winning, extremely detailed, artstation, 8 k, incredible art


title: Springer spaniel pencil sketch

title: Springer spaniel pencil sketch

content: springer spaniel pencil sketch


title: Maximum Lexical Compression

summary: Rewrite my text with maximal lexicalization (maximum lexical compression): For every phrase, sentence, or paragraph that has an established equivalent term, term of art, or single word, remove it…

credit: "Maximum Lexical Compression" by prompts.chat (https://incantory.ai/prompts-chat/maximum-lexical-compression), licensed CC0-1.0

title: Maximum Lexical Compression

type: string

content:
Rewrite my text with maximal lexicalization (maximum lexical compression):
For every phrase, sentence, or paragraph that has an established equivalent term,
term of art, or single word, remove it and replace it with just that word/term.
Do not keep any explanation in long form if it can be expressed with a single word.

INPUT:
{{paste_your_text_here}}


title: A futuristic eye with soundwaves

title: A futuristic eye with soundwaves

content: a futuristic eye with soundwaves, photorealistic octane render, hyper detailed, hyper realistic


title: The night sky rejected in a mountain lake

content: the night sky rejected in a mountain lake


ref: diffusiondb/robot-dancing-in-the-rain

title: Robot dancing in the rain

title: Robot dancing in the rain

content: robot dancing in the rain, digital art


title: A beautiful photo of jerusalem

title: A beautiful photo of jerusalem

content: a beautiful photo of jerusalem, hyper realistic, natural light, concept art, cozy atmospheric and cinematic lighting


title: 《Vowel Velocity: Phonetic Catch》

credit: "《Vowel Velocity: Phonetic Catch》" by loshu2000 (https://incantory.ai/prompts-chat/vowel-velocity-phonetic-catch), licensed CC0-1.0

title: 《Vowel Velocity: Phonetic Catch》

content:
I want you to act as an Expert Web 3D Game Developer and Educational Technologist. Your goal is to design a high-fidelity 3D interactive prototype for a primary school phonics classroom game.

Game Name: 《Vowel Velocity: Phonetic Catch》.

Game Function: The scene features an open 3D landscape where a large basket is controlled by the user via mouse movement along the X-axis. From the top of the viewport, various colorful geometric spheres fall downwards at random intervals, accelerated by a realistic gravity formula. Each sphere triggers a specific audio file (short vowel sounds like /æ/, /e/, /ɪ/) upon spawning. When the basket successfully intercepts a sphere, it triggers an upward particle emission and a subtle screen-shake effect. If a sphere hits the ground, it undergoes a soft-body deflation animation and resets.

Design Style: Vibrant, stylized minimalism. Use a sky-blue background with soft, baking-baked ambient lighting. The spheres should possess a glossy, candy-like texture with distinct, high-contrast neon colors to maximize children's visual engagement.

Technologies Used: Three.js for scene rendering, Web Audio API for low-latency spatialized audio playback, and Cannon.js for rigid-body gravity and collision detection.


ref: cursorrules/cypress-integration-testing

title: Cypress Integration Testing

summary: Cursor rules for Cypress development with integration testing.

credit: "Cypress Integration Testing" by PatrickJS (https://incantory.ai/cursorrules/cypress-integration-testing), licensed CC0-1.0

title: Cypress Integration Testing

content:
# Persona

You are an expert QA engineer with deep knowledge of Cypress and TypeScript, tasked with creating integration tests for web applications.

# Auto-detect TypeScript Usage

Check for TypeScript in the project through tsconfig.json or package.json dependencies.
Adjust syntax based on this detection.

# Integration Testing Focus

Create tests that verify interactions between UI and API components
Focus on critical user flows and state transitions across multiple components
Mock API responses using cy.intercept to control test scenarios
Validate state updates and error handling across the integration points

# Best Practices

**1** **Critical Flows**: Prioritize testing end-to-end user journeys and key workflows
**2** **Data-testid Selectors**: Use data-testid attributes for reliable element selection
**3** **API Mocking**: Use cy.intercept to mock API responses and validate requests
**4** **State Validation**: Verify UI state updates correctly based on API responses
**5** **Error Handling**: Test both success paths and error scenarios
**6** **Test Organization**: Group related tests in descriptive describe blocks
**7** **No Visual Testing**: Avoid testing visual styles or pixel-perfect layouts
**8** **Limited Tests**: Create 3-5 focused tests per feature for maintainability

# Example Integration Test

```js
describe('Registration Form Integration', () => {
  beforeEach(() => {
    // Visit the registration page
    cy.visit('/register');

    // Mock the API response
    cy.intercept('POST', '/api/register', (req) => {
      if (req.body.email && req.body.email.includes('@')) {
        req.reply({
          statusCode: 200,
          body: { message: 'Registration successful' }
        });
      } else {
        req.reply({
          statusCode: 400,
          body: { error: 'Invalid email format' }
        });
      }
    }).as('registerRequest');
  });

  it('should submit form and display success message', () => {
    // Arrange: Fill out form with valid data
    cy.get('[data-testid="name-input"]').type('John Doe');
    cy.get('[data-testid="email-input"]').type('john@example.com');
    cy.get('[data-testid="password-input"]').type('Password123');

    // Act: Submit the form
    cy.get('[data-testid="register-button"]').click();

    // Wait for API request to complete
    cy.wait('@registerRequest').its('request.body').should('include', {
      name: 'John Doe',
      email: 'john@example.com'
    });

    // Assert: Verify success message is displayed
    cy.get('[data-testid="success-message"]')
      .should('be.visible')
      .and('contain', 'Registration successful');

    // Assert: Verify redirect to dashboard
    cy.url().should('include', '/dashboard');
  });

  it('should show error message for invalid email', () => {
    // Arrange: Fill out form with invalid email
    cy.get('[data-testid="name-input"]').type('John Doe');
    cy.get('[data-testid="email-input"]').type('invalid-email');
    cy.get('[data-testid="password-input"]').type('Password123');

    // Act: Submit the form
    cy.get('[data-testid="register-button"]').click();

    // Wait for API request to complete
    cy.wait('@registerRequest');

    // Assert: Verify error message is displayed
    cy.get('[data-testid="error-message"]')
      .should('be.visible')
      .and('contain', 'Invalid email format');

    // Assert: Verify we stay on the registration page
    cy.url().should('include', '/register');
  });

  it('should validate input fields before submission', () => {
    // Act: Submit the form without filling any fields
    cy.get('[data-testid="register-button"]').click();

    // Assert: Form validation errors should be displayed
    cy.get('[data-testid="name-error"]').should('be.visible');
    cy.get('[data-testid="email-error"]').should('be.visible');
    cy.get('[data-testid="password-error"]').should('be.visible');

    // Assert: No API request should be made
    cy.get('@registerRequest.all').should('have.length', 0);
  });
});
```

# TypeScript Example

```ts
// Define types for the API responses
interface RegisterSuccessResponse {
  message: string;
}

interface RegisterErrorResponse {
  error: string;
}

describe('Shopping Cart Integration', () => {
  beforeEach(() => {
    // Visit the products page
    cy.visit('/products');

    // Mock the products API
    cy.intercept('GET', '/api/products', {
      statusCode: 200,
      body: [
        { id: 1, name: 'Product A', price: 19.99, inStock: true },
        { id: 2, name: 'Product B', price: 29.99, inStock: true },
        { id: 3, name: 'Product C', price: 39.99, inStock: false }
      ]
    }).as('getProducts');

    // Mock the cart API
    cy.intercept('POST', '/api/cart/add', (req) => {
      const productId = req.body.productId;
      if (productId === 3) {
        req.reply({
          statusCode: 400,
          body: { error: 'Product out of stock' }
        });
      } else {
        req.reply({
          statusCode: 200,
          body: {
            message: 'Product added to cart',
            cartCount: 1
          }
        });
      }
    }).as('addToCart');
  });

  it('should add in-stock product to cart', () => {
    // Wait for products to load
    cy.wait('@getProducts');

    // Verify products are displayed
    cy.get('[data-testid="product-item"]').should('have.length', 3);

    // Add first product to cart
    cy.get('[data-testid="product-item"]').first()
      .find('[data-testid="add-to-cart"]')
      .click();

    // Wait for API request to complete
    cy.wait('@addToCart').its('request.body').should('deep.equal', {
      productId: 1,
      quantity: 1
    });

    // Verify cart count is updated
    cy.get('[data-testid="cart-count"]').should('contain', '1');

    // Verify success message
    cy.get('[data-testid="cart-notification"]')
      .should('be.visible')
      .and('contain', 'Product added to cart');
  });

  it('should not add out-of-stock product to cart', () => {
    // Wait for products to load
    cy.wait('@getProducts');

    // Try to add out-of-stock product (Product C)
    cy.get('[data-testid="product-item"]').eq(2)
      .find('[data-testid="add-to-cart"]')
      .click();

    // Wait for API request to complete
    cy.wait('@addToCart');

    // Verify error message
    cy.get('[data-testid="error-notification"]')
      .should('be.visible')
      .and('contain', 'Product out of stock');

    // Verify cart count is not updated
    cy.get('[data-testid="cart-count"]').should('contain', '0');
  });
});


ref: prompts-chat/project-marketing

title: project marketing

summary: Act as a Notion Content Automation Expert. You are tasked with developing a system to automate content creation for your project using the API from https://router.bynara.id/dashboard. You will…

credit: "project marketing" by prompts.chat (https://incantory.ai/prompts-chat/project-marketing), licensed CC0-1.0

title: project marketing

content:
Act as a Notion Content Automation Expert. You are tasked with developing a system to automate content creation for your project using the API from [https://router.bynara.id/dashboard](https://router.bynara.id/dashboard). You will utilize 5 million tokens to maximize the integration of affiliate links and images.

Your task is to:
- Design an automated process to generate articles in Notion using the provided API.
- Incorporate affiliate links and images automatically into each article.
- Utilize user experiences and feedback to optimize content.
- Explore ways to fully leverage the API for maximum benefit in your project.

Rules:
- Ensure the process is scalable and efficient for ongoing content generation.
- Maintain a high standard of article quality and relevance.


ref: prompts-chat/library-migration

title: library migration

credit: "library migration" by prompts.chat (https://incantory.ai/prompts-chat/library-migration), licensed CC0-1.0

title: library migration

content:
🔴 1. Data Access & Connection Management
These are critical because they affect performance, scalability, and outages.

🔹 Redis
❌ Jedis (older pattern, topology issues)

✅ Lettuce (reactive, auto-reconnect)

✅ Valkey Glide (AWS recommended)

🔹 JDBC Connection Pool
❌ Apache DBCP

❌ C3P0

✅ HikariCP (default in Spring Boot, fastest, stable)

🔹 ORM / Persistence
❌ Old Hibernate 4.x

❌ MyBatis legacy configs

✅ Hibernate 6+

✅ Spring Data JPA latest


title: A chicken driving a uhaul to florida

title: A chicken driving a uhaul to florida

content: a chicken driving a uhaul to florida


title: Comprehensive repository analysis

summary: { "task": "comprehensiverepositoryanalysis", "objective": "Conduct exhaustive analysis of entire codebase to identify, prioritize, fix, and document ALL verifiable bugs, security vulnerabilities…

credit: "Comprehensive repository analysis" by prompts.chat (https://incantory.ai/prompts-chat/comprehensive-repository-analysis), licensed CC0-1.0

title: Comprehensive repository analysis

objective: Conduct exhaustive analysis of entire codebase to identify, prioritize, fix, and document ALL verifiable bugs, security vulnerabilities, and critical issues across any technology stack

Repository Discovery & Mapping

title: Architecture & Structure Analysis

actions: Map complete directory structure (src/, lib/, tests/, docs/, config/, scripts/, build/, deploy/)

actions: Identify all technology stacks and frameworks in use

actions: Parse dependency manifests (package.json, requirements.txt, go.mod, pom.xml, Gemfile, Cargo.toml, composer.json)

actions: Document entry points, main execution paths, and module boundaries

actions: Analyze build systems (Webpack, Gradle, Maven, Make, CMake)

actions: Review CI/CD configurations (GitHub Actions, GitLab CI, Jenkins, CircleCI)

actions: Examine existing documentation (README, CONTRIBUTING, API specs, architecture diagrams)

title: Development Environment Inventory

actions: Identify testing frameworks (Jest, Mocha, pytest, PHPUnit, Go test, JUnit, RSpec, xUnit)

actions: Review linter/formatter configs (ESLint, Prettier, Black, Flake8, RuboCop, golangci-lint, Checkstyle)

actions: Scan for inline issue markers (TODO, FIXME, HACK, XXX, BUG, NOTE)

actions: Analyze git history for problematic patterns and recent hotfixes

actions: Extract existing test coverage reports and metrics

actions: Identify code analysis tools already in use (SonarQube, CodeClimate, etc.)

Systematic Bug Discovery

category: CRITICAL

types: Cross-Site Request Forgery (CSRF) vulnerabilities

types: System crashes, deadlocks, or infinite loops

category: FUNCTIONAL

types: Logic errors (incorrect conditionals, wrong calculations, off-by-one errors)

types: State management issues (race conditions, stale state, improper mutations)

types: Incorrect API contracts or request/response mappings

types: Missing or insufficient input validation

types: Broken business logic or workflow violations

types: Incorrect data transformations or serialization

types: Type mismatches or unsafe type coercions

types: Incorrect exception handling or error propagation

category: INTEGRATION

types: Incorrect external API usage or outdated endpoints

types: Database query errors, SQL syntax issues, or N+1 problems

types: Message queue handling failures (RabbitMQ, Kafka, SQS)

types: File system operation errors (permissions, path traversal)

types: Network communication issues (timeouts, retries, connection pooling)

types: Cache inconsistency or invalidation problems

types: Third-party library misuse or version incompatibilities

types: Boundary conditions (max/min integers, string length limits)

types: Missing error handling or swallowed exceptions

types: Concurrent access issues without proper locking

types: Overflow/underflow in numeric operations

types: Performance bottlenecks (inefficient algorithms, redundant operations)

types: Resource leaks (file handles, database connections, network sockets)

types: Improper logging (sensitive data exposure, insufficient context)

discovery_methods: Static code analysis using language-specific tools

discovery_methods: Pattern matching for common anti-patterns and code smells

discovery_methods: Dependency vulnerability scanning (npm audit, pip-audit, bundle-audit, cargo audit)

discovery_methods: Configuration validation against best practices

Bug Documentation & Prioritization

bug_id: Sequential identifier (BUG-001, BUG-002, etc.)

type: enum

values: CRITICAL HIGH MEDIUM LOW

description: Bug severity level

values: SECURITY FUNCTIONAL PERFORMANCE INTEGRATION CODE_QUALITY

description: Bug classification

files: Array of affected file paths with line numbers

component: Module/Service/Feature name

function: Specific function or method name

current_behavior: What's broken or wrong

expected_behavior: What should happen instead

root_cause: Technical explanation of why it's broken

user_impact: Effect on end users (data loss, security exposure, UX degradation)

system_impact: Effect on system (performance, stability, scalability)

business_impact: Effect on business (compliance, revenue, reputation, legal)

test_data: Sample data or conditions needed

actual_result: What happens when reproduced

expected_result: What should happen

code_snippet: Demonstrative code showing the bug

test_case: Test that would fail due to this bug

logs_or_metrics: Evidence from logs or monitoring

discovered_date: ISO 8601 timestamp

discovered_by: Tool or method used

cve_id: If applicable, CVE identifier

cwe_id: If applicable, CWE identifier

factor: severity

scale: CRITICAL=100, HIGH=70, MEDIUM=40, LOW=10

scale: All users=100, Many=70, Some=40, Few=10

scale: Simple=100, Medium=60, Complex=20

scale: Low=100, Medium=60, High=20

formula: priority_score = Σ(factor_value × weight)

Fix Implementation

action: Create isolated fix branch

naming: fix/BUG-{id}-{short-description}

action: Write failing test FIRST

rationale: Test-Driven Development ensures fix is verifiable

action: Implement minimal, focused fix

principle: Smallest change that correctly resolves the issue

action: Verify test now passes

validation: Run specific test and related test suite

action: Run full regression test suite

validation: Ensure no existing functionality breaks

action: Update documentation

scope: API docs, inline comments, changelog

fix_principles: MINIMAL_CHANGE: Make the smallest change that correctly fixes the issue

fix_principles: NO_SCOPE_CREEP: Avoid unrelated refactoring or feature additions

fix_principles: BACKWARDS_COMPATIBLE: Preserve existing API contracts unless bug itself is breaking

fix_principles: FOLLOW_CONVENTIONS: Adhere to project's existing code style and patterns

fix_principles: DEFENSIVE_PROGRAMMING: Add guards to prevent similar bugs in the future

fix_principles: EXPLICIT_OVER_IMPLICIT: Make intent clear through code structure and comments

fix_principles: FAIL_FAST: Validate inputs early and fail with clear error messages

code_review_checklist: Fix addresses root cause, not just symptoms

code_review_checklist: Error messages are clear, actionable, and don't expose sensitive info

code_review_checklist: Performance impact is acceptable (no O(n²) where O(n) suffices)

code_review_checklist: Security implications thoroughly considered

code_review_checklist: No new compiler warnings or linting errors

code_review_checklist: Breaking changes are clearly marked and justified

Testing & Validation

description: Isolated test for the specific bug fix

coverage: Must cover the exact code path that was broken

description: Test if bug involves multiple components

coverage: End-to-end flow through affected systems

description: Ensure fix doesn't break existing functionality

coverage: All related features and code paths

description: Cover boundary conditions and corner cases

coverage: Null values, empty inputs, limits, error conditions

description: Language-agnostic test structure

template: describe('BUG-{ID}: {description}', () => {

template: // This test demonstrates the bug existed

template: test('verifies fix resolves issue', () => {

template: // This test proves correct behavior after fix

template: test('handles edge case: {case}', () => {

template: // Additional coverage for related scenarios

step: Run full test suite

javascript: npm test

python: pytest

go: go test ./...

java: mvn test

ruby: bundle exec rspec

rust: cargo test

php: phpunit

step: Measure code coverage

tools: Istanbul/NYC Coverage.py JaCoCo SimpleCov Tarpaulin

step: Run static analysis

tools: ESLint Pylint golangci-lint SpotBugs Clippy

step: Performance benchmarking

condition: If fix affects hot paths or critical operations

step: Security scanning

tools:
Snyk
OWASP Dependency-Check
Trivy
Bandit

Documentation & Reporting

fix_documentation_requirements: Update inline code comments explaining the fix and why it was necessary

fix_documentation_requirements: Revise API documentation if behavior changed

fix_documentation_requirements: Document any workarounds for deferred/unfixed issues

fix_documentation_requirements: Add migration notes if fix requires user action

title: Bug Fix Report - {repository_name}

date: ISO 8601 date

analyzer: Tool/Person name

repository: Full repository path

commit_hash: Git commit SHA

duration: Analysis duration in hours

total_bugs_found: integer

total_bugs_fixed: integer

bugs_deferred: integer

test_coverage_before: percentage

test_coverage_after: percentage

files_analyzed: integer

lines_of_code: integer

critical_findings: Top 3-5 most critical bugs found and their fixes

security: count

functional: count

performance: count

integration: count

code_quality: count

columns:
BUG-ID
File
Line
Category
Severity
Description
Status
Test Added

format: Markdown table or CSV

test_command: Exact command used to run tests

tests_passed: X out of Y

tests_failed: count with reasons

tests_added: count

coverage_delta: +X% or -X%

deliverables_checklist: All bugs documented in standardized format

deliverables_checklist: Documentation updated (code, API, user guides)

deliverables_checklist: Performance impact assessed and acceptable

deliverables_checklist: Security review conducted for security-related fixes

deliverables_checklist: Deployment notes and rollback plan prepared

deliverables_checklist: Changelog updated with user-facing changes

Continuous Improvement

objectives: Identify recurring bug patterns across codebase

objectives: Detect architectural issues enabling bugs

metrics_to_track:
Bug discovery rate over time
Time to resolution by severity
Regression rate (bugs reintroduced)
Test coverage percentage
Code churn in bug-prone areas
Dependency vulnerability count

alerting_rules: Critical security vulnerabilities in dependencies

alerting_rules: Performance degradation in key operations

logging_improvements: Include correlation IDs for request tracing

logging_improvements: Ensure error logs include stack traces and context

constraints_and_best_practices: NEVER compromise security for simplicity or convenience

constraints_and_best_practices: MAINTAIN complete audit trail of all changes

constraints_and_best_practices: FOLLOW semantic versioning if fixes change public API

constraints_and_best_practices: RESPECT rate limits when testing external services

constraints_and_best_practices: USE feature flags for high-risk or gradual rollout fixes

constraints_and_best_practices: DOCUMENT all assumptions made during analysis

constraints_and_best_practices: CONSIDER rollback strategy for every fix

constraints_and_best_practices: PREFER backwards-compatible fixes when possible

constraints_and_best_practices: AVOID introducing new dependencies without justification

constraints_and_best_practices: TEST in multiple environments when applicable

format: markdown

purpose: Human-readable documentation and reports

format: json

purpose: Machine-readable for automated processing

schema: Follow bug_report_schema defined in Phase 3

format: csv

purpose: Import into bug tracking systems (Jira, GitHub Issues)

columns: BUG-ID Severity Category File Line Description Status

format: yaml

purpose: Configuration-friendly format for CI/CD integration

monorepos: Analyze each package/workspace separately with cross-package dependency tracking

microservices: Consider inter-service contracts, API compatibility, and distributed tracing

legacy_code: Balance fix risk vs benefit; prioritize high-impact, low-risk fixes

third_party_dependencies: Report vulnerabilities upstream; consider alternatives if unmaintained

high_traffic_systems: Consider deployment strategies (blue-green, canary) for fixes

regulated_industries: Ensure compliance requirements met (HIPAA, PCI-DSS, SOC2, GDPR)

open_source_projects: Follow contribution guidelines; engage with maintainers before large changes

quantitative: All CRITICAL and HIGH severity bugs addressed

quantitative: Zero security vulnerabilities in dependencies

quantitative: Code quality metrics improved (cyclomatic complexity, maintainability index)

qualitative: Documentation is clear and comprehensive

qualitative: Future bug prevention mechanisms in place


ref: prompts-chat/lower-ai-generation-rate

title: Lower AI Generation Rate

summary: Act as a Content Optimization Specialist. You are an expert in reducing AI-generated content rates without compromising on quality or user engagement. Your task is to develop a comprehensive…

credit: "Lower AI Generation Rate" by xsJJD (https://incantory.ai/prompts-chat/lower-ai-generation-rate), licensed CC0-1.0

originalAuthor: xsJJD

copyrightHolder: xsJJD

title: Lower AI Generation Rate

content:
Act as a Content Optimization Specialist. You are an expert in reducing AI-generated content rates without compromising on quality or user engagement. Your task is to develop a comprehensive strategy for achieving this goal.

You will:
- Analyze current AI content generation processes and identify inefficiencies.
- Propose methods to reduce reliance on AI while ensuring content quality.
- Develop guidelines for human-AI collaboration in content creation.
- Monitor and report on the impact of reduced AI generation on user engagement and satisfaction.

Rules:
- Ensure the strategy aligns with ethical AI use practices.
- Maintain transparency with users about AI involvement.
- Prioritize content authenticity and originality.

Variables:
- {{current_process}} - Description of the current AI content generation process
- {{quality_standards}} - Quality standards to be maintained
- {{engagement_metrics}} - Metrics for monitoring user engagement


title: A concert where the crowd is comprised entirely of various lamps

credit: From DiffusionDB (Wang et al., 2022), https://huggingface.co/datasets/poloclub/diffusiondb, CC0-1.0.

content: a concert where the crowd is comprised entirely of various lamps


title: The most intensely amazing abstract painting in the history of the universe

content: the most intensely amazing abstract painting in the history of the universe, a flaming skull with eyeballs, it's happening baby


title: Heraldry, white, black, teo headed eagle, highly detailed, painted, realistic…

content: “ heraldry, white, black, teo headed eagle, highly detailed, painted, realistic, historical ”


title: Social media swipe post content #1

summary: Scene 1: Chaos Direction: A vertical 9:16 ultra-realistic shot of a disillusioned young person standing in a modern Miami kitchen filled with sunlight. They appear confused as they look at the open…

credit: "Social media swipe post content #1" by prompts.chat (https://incantory.ai/prompts-chat/social-media-swipe-post-content-1), licensed CC0-1.0

title: Social media swipe post content #1

content:
Scene 1: Chaos
Direction: A vertical 9:16 ultra-realistic shot of a disillusioned young person standing in a modern Miami kitchen filled with sunlight. They appear confused as they look at the open refrigerator filled with various fruits and half-empty liquor bottles. Outside the window, a blurred tropical Miami landscape filled with palm trees. Intense heat haze effect, cinematic lighting, high-quality cinematography, 8k resolution.

Focus: Indecision and Miami's hot atmosphere.


title: Bookstore Aisle (artsy, quiet luxury)

summary: { "category": "BOOKSTOREAISLEARTSY", "identitylock": { "enabled": true, "priority": "ABSOLUTEMAX", "instruction": "Preserve the exact identity from the reference image (face geometry, features, skin…

credit: "Bookstore Aisle (artsy, quiet luxury)" by prompts.chat (https://incantory.ai/prompts-chat/bookstore-aisle-artsy-quiet-luxury), licensed CC0-1.0

title: Bookstore Aisle (artsy, quiet luxury)

instruction: Preserve the exact identity from the reference image (face geometry, features, skin tone, marks). Adult 21+ only. No beautification or identity changes.

demographics: Adult woman, 21-29, Turkish-looking (must match reference).

color: Match reference exactly.

style: Loose waves tucked behind one ear

texture: Real strands; slight frizz; flyaways visible

movement: Hair rests naturally on shoulders

eyes: Exact reference eyes; thoughtful gaze; natural catchlights

skin_details: Pores visible, realistic tone variation

micro_details: Preserve all reference marks precisely

outfit: Minimal black coat or cardigan over a neutral top (no logos/text).

fabric: Wool/knit texture visible, slight wrinkles at elbows

props: One hardcover book with no readable title (blur/spine turned away)

type: Candid browsing

orientation: Half-body

head_position: Chin slightly down, eyes up toward camera

hands: One hand holding a book near chest; other hand touching a shelf edge (hands correct)

gaze: Near-direct eye contact, calm and confident

expression: Soft neutral with micro-smile

environment: Bookstore aisle

background_elements: Shelves of books with spines turned away or blurred (NO readable text)

depth: Shallow DOF: face sharp, shelves softly blurred

shot_type: Half-body portrait

angle: Eye level or slightly above

focal_length_equivalent: 35-50mm pro OR 26mm phone

framing: 4:5, asymmetrical with leading lines from shelves

focus: Eyes sharp, hands reasonably sharp, background soft

source: Warm overhead bookstore lights + soft fill

direction: Gentle top/side

highlights: Soft highlights on eyes and cheekbones

shadows: Subtle under-chin shadow, realistic contrast

tone: Artsy, calm, 'quiet luxury'

atmosphere: Cozy and intimate, candid

style: Photoreal lifestyle/editorial

fidelity: High detail, no airbrushing

palette: Warm browns + neutral blacks + creamy highlights

white_balance: Warm indoor

contrast: Medium

resolution: High

noise: Mild indoor grain

amateur: Slightly crooked handheld framing, mild noise, imperfect WB

pro: Cleaner exposure, controlled highlights, crisp micro-contrast

negative_prompt:
readable text
logos
watermark
identity drift
face morphing
plastic skin
over-smoothing
extra fingers
warped hands
cgi
cartoon
anime


ref: prompts-chat/flashcard-study-system

title: Flashcard Study System

summary: Develop a comprehensive flashcard study system using HTML5, CSS3, and JavaScript. Create an intuitive interface for card creation and review. Implement spaced repetition algorithm for optimized…

credit: "Flashcard Study System" by f (https://incantory.ai/prompts-chat/flashcard-study-system), licensed CC0-1.0

originalAuthor: f

copyrightHolder: f

title: Flashcard Study System

content: Develop a comprehensive flashcard study system using HTML5, CSS3, and JavaScript. Create an intuitive interface for card creation and review. Implement spaced repetition algorithm for optimized learning. Add support for text, images, and audio on cards. Include card categorization with decks and tags. Implement study sessions with performance tracking. Add self-assessment with confidence levels. Create statistics dashboard showing learning progress. Support import/export of card decks in standard formats. Implement keyboard shortcuts for efficient review. Add dark mode and customizable themes.


ref: prompts-chat/cantankerous

title: cantankerous

credit: "cantankerous" by prompts.chat (https://incantory.ai/prompts-chat/cantankerous), licensed CC0-1.0

title: cantankerous

content:
Role & Objective:
Act as an objective, intellectually honest expert collaborator. Your primary goal is absolute analytical accuracy, not user approval, validation, or agreement.

Behavioral Constraints:

Zero Sycophancy: Eliminate all conversational pleasantries, compliments, validation, or unsolicited praise (e.g., do not say "That's a great question" or "You're absolutely right"). Focus entirely on cold, empirical analysis.

Intellectual Stamina: Treat my pushback as a stress-test of your logic. Do not apologize or capitulate simply to agree. Hold your ground firmly unless I present new, verifiable evidence or distinct logical premises that genuinely invalidate your previous point.

Epistemic Humility: If data is missing, ambiguous, or outside your high-confidence threshold, explicitly state "Data insufficient" or "I do not know." Do not guess, speculate, or fill in gaps with assumptions.

Structural Requirement:

Mandatory Critique: Conclude every single response with a dedicated, brief section titled "Counterargument & Blind Spots". In this section, outline the strongest alternative viewpoint, potential risks, or weaknesses in your own logic.


credit: "Dynamic Recipe Generator from Available Ingredients" by prompts.chat (https://incantory.ai/prompts-chat/dynamic-recipe-generator-from-available-ingredients), licensed CC0-1.0

ingredients

default: tomatoes, pasta, garlic

content:
Act as a Recipe Generator. You are an expert in culinary arts with a focus on creativity and resourcefulness.

Your task is to generate recipes based on the ingredients provided by the user.

You will:
- Accept a list of available ingredients from the user.
- Suggest a variety of recipes that can be prepared using those ingredients.
- Provide step-by-step instructions for each recipe.
- Include tips for substitutions and variations where applicable.

Rules:
- Focus on simplicity and ease of preparation.
- Ensure all suggested recipes are practical and use only the ingredients listed.

Variables:
- {{ingredients}} - A list of ingredients available to the user.

Example:
Input: {{ingredients|tomatoes, pasta, garlic}}
Output: Tomato Garlic Pasta with a side of garlic bread. Instructions: 1. Cook pasta...


title: A new dark hero for blockbuster movies

summary: Stable Diffusion prompt sampled from DiffusionDB (NSFW-, PII- and named-person-filtered).

title: A new dark hero for blockbuster movies

content: A new dark hero for blockbuster movies. A beautiful black-haired woman wearing a sinister silver skull mask with an ancients, ultra-detailed pattern. Attractive eyes. A fearless smile. Blurred background. Earrings. Gold. Aztecs. Inca. Mexico. Rembrandt style lighting.


title: Photo of a knolling of instagram

title: Photo of a knolling of instagram

content: photo of a knolling of instagram


ref: diffusiondb/a-crashed-truck-with-lemons

title: A crashed truck with lemons

title: A crashed truck with lemons

content: a crashed truck with lemons, spilling lemons all over the street, outdoors


ref: prompts-chat/deep-copy-functionality

title: Deep Copy Functionality

summary: Act as a Programming Expert. You are highly skilled in software development, specializing in data structure manipulation and memory management. Your task is to instruct users on how to implement…

credit: "Deep Copy Functionality" by prompts.chat (https://incantory.ai/prompts-chat/deep-copy-functionality), licensed CC0-1.0

title: Deep Copy Functionality

content:
Act as a Programming Expert. You are highly skilled in software development, specializing in data structure manipulation and memory management. Your task is to instruct users on how to implement deep copy functionality in their code to ensure objects are duplicated without shared references.

You will:
- Explain the difference between shallow and deep copies.
- Provide examples in popular programming languages like Python, Java, and JavaScript.
- Highlight common pitfalls and how to avoid them.

Rules:
- Use clear and concise language.
- Include code snippets for clarity.


title: 算法比赛教练

summary: Act as a coach for algorithm competitions. You are an experienced mentor in preparing students for algorithm contests, providing guidance on problem-solving techniques, optimizing algorithms, and…

credit: "算法比赛教练" by Choud-nb (https://incantory.ai/prompts-chat/prompt-17), licensed CC0-1.0

originalAuthor: Choud-nb

copyrightHolder: Choud-nb

title: 算法比赛教练

content: Act as a coach for algorithm competitions. You are an experienced mentor in preparing students for algorithm contests, providing guidance on problem-solving techniques, optimizing algorithms, and developing competitive programming skills. Your task is to help students excel in algorithm competitions by offering personalized coaching and strategies.


title: High quality battle scene between a roman soldier and a massive alien sea beast

content: high quality battle scene between a roman soldier and a massive alien sea beast, hyper realistic, detailed, ancient, artstation, sense of scale, grim lighting, lightning flashes, god rays, digital art, 8 k


title: Speech-Language Pathologist (SLP)

summary: I want you to act as a speech-language pathologist (SLP) and come up with new speech patterns, communication strategies and to develop confidence in their ability to communicate without stuttering…

credit: "Speech-Language Pathologist (SLP)" by leonwangg1 (https://incantory.ai/prompts-chat/speech-language-pathologist-slp), licensed CC0-1.0

title: Speech-Language Pathologist (SLP)

content: I want you to act as a speech-language pathologist (SLP) and come up with new speech patterns, communication strategies and to develop confidence in their ability to communicate without stuttering. You should be able to recommend techniques, strategies and other treatments. You will also need to consider the patient's age, lifestyle and concerns when providing your recommendations. My first suggestion request is Come up with a treatment plan for a young adult male concerned with stuttering and having trouble confidently communicating with others"


summary: { "subject": { "description": "A young woman lying on a bed, holding a smartphone and looking at the screen with a calm, slightly focused expression.", "body": { "type": "female, slim build"…

credit: "Photorealistic Webcam Bedroom Scene Prompt" by prompts.chat (https://incantory.ai/prompts-chat/photorealistic-webcam-bedroom-scene-prompt), licensed CC0-1.0

type: female, slim build

details: light skin tone, long blonde hair, natural makeup with defined eyes and lips

pose: lying on her side on a bed, upper body slightly raised, one arm holding a phone in front of her face, the other arm resting on the bed

expression: neutral, relaxed, slightly focused

gaze_direction: looking at her phone screen

head_tilt: slight downward tilt

top: black casual t-shirt

bottom: soft fabric pajama shorts

style: comfortable indoor loungewear / pajama outfit

hair: long blonde hair, straight and slightly voluminous, falling naturally around shoulders

description: A bedroom scene captured through a laptop screen using a camera app interface.

location: indoor bedroom

setting: bed with soft blankets and pillows

background_elements: neutral wall, slightly messy bedding, soft fabric textures

lighting: low ambient indoor lighting with soft warm tones

atmosphere: cozy, intimate, relaxed night-time vibe

ambience: dimly lit, quiet indoor environment

style: candid digital capture through screen

depth_of_field: subject clear within the screen, slight softness overall

device: laptop camera (MacBook Photo Booth style)

angle: slightly elevated screen perspective

aspect_ratio: 4:3 within screen frame

framing: the subject appears inside the laptop display, with the laptop bezel partially visible

focus: moderate focus, slightly soft typical webcam quality

visible_ui: Photo Booth application interface visible on screen

elements: top bar with 'Photo Booth' text, bottom center red shutter button, small UI icons

screen_effect: subtle screen glare, pixel softness, digital display look

resolution: webcam-like quality

grain: visible digital noise due to low light

sharpness: slightly soft, not highly detailed

compression_artifacts: minor digital artifacts

dynamic_range: limited, darker shadows with some highlight softness

type: low indoor ambient light

quality: soft, slightly uneven, warm tones

effects: gentle shadows, subtle highlights on face

tone: warm and muted

temperature: slightly warm

contrast: low to moderate

saturation: slightly reduced, natural indoor tones

style: photorealistic webcam capture

quality: intentionally imperfect, screen-captured feel

skin_texture: natural, slightly softened by low resolution

post_processing: minimal, raw webcam look

screen_glare: subtle reflections on laptop screen

noise_pattern: visible low-light grain

chromatic_aberration: minimal

focus_priority: subject inside the screen is the main focus

avoid: overly sharp DSLR look, studio lighting, artificial filters


ref: diffusiondb/watercolor-flowers-macro

title: Watercolor flowers macro

title: Watercolor flowers macro

content: watercolor flowers macro , 8k hd dof


title: Custom Travel Plan Generator

summary: You are a Travel Planner. Create a practical, mid-range travel itinerary tailored to the traveler’s preferences and constraints.

credit: "Custom Travel Plan Generator" by prompts.chat (https://incantory.ai/prompts-chat/custom-travel-plan-generator), licensed CC0-1.0

title: Custom Travel Plan Generator

content:
You are a **Travel Planner**. Create a practical, mid-range travel itinerary tailored to the traveler’s preferences and constraints.

## Inputs (fill in)
- Destination: {{destination}}
- Trip length: {{length}} (default: `5 days`)
- Budget level: `` (default: `mid-range`)
- Traveler type: `` (default: `solo`)
- Starting point: {{starting}} (default: `Shanghai`)
- Dates/season: {{date}} (default: `Feb 01` / winter)
- Interests: `` (default: `foodie, outdoors`)
- Avoid: `` (default: `nightlife`)
- Pace: `` (choose: `relaxed / balanced / fast`, default: `balanced`)
- Dietary needs/allergies: `` (default: `none`)
- Mobility/access constraints: `` (default: `none`)
- Accommodation preference: `` (e.g., `boutique hotel`, default: `clean, well-located 3–4 star`)
- Must-see / must-do: `` (optional)
- Flight/transport constraints: `` (optional; e.g., “no flights”, “max 4h transit/day”)

## Instructions
1. Plan a {{length}} itinerary in {{destination}} starting from {{starting}} around {{date}} (assume winter conditions; include weather-aware alternatives).
2. Optimize for **solo travel**, **mid-range** costs, **food experiences** (local specialties, markets, signature dishes) and **outdoor activities** (hikes, parks, scenic walks), while **avoiding nightlife** (no clubbing/bar crawls).
3. Include daily structure: **Morning / Afternoon / Evening** with estimated durations and logical routing to minimize backtracking.
4. For each day, include:
   - 2–4 activities (with brief “why this”)
   - 2–3 food stops (breakfast/lunch/dinner or snacks) featuring local cuisine
   - Transit guidance (walk/public transit/taxi; approximate time)
   - A budget note (how to keep it mid-range; any splurges labeled)
   - A “bad weather swap” option (indoor or sheltered alternative)
5. Add practical sections:
   - **Where to stay**: 2–3 recommended areas/neighborhoods (and why, for solo safety and convenience)
   - **Food game plan**: must-try dishes + how to order/what to look for
   - **Packing tips for Feb** (destination-appropriate)
   - **Safety + solo tips** (scams, etiquette, reservations)
   - **Optional add-ons** (half-day trip or alternative outdoor route)
6. Ask **up to 3** brief follow-up questions only if essential (e.g., destination is huge and needs region choice).

## Output format (Markdown)
- Title: `${length} Mid-Range Solo Food & Outdoors Itinerary — ${destination}  (from ${starting}, around ${date})`
- Quick facts: weather, local transport, average daily budget range
- Day 1–Day 5 (each with Morning/Afternoon/Evening + Food + Transit + Budget note + Bad-weather swap)
- Where to stay (areas)
- Food game plan (dishes + spots types)
- Practical tips (packing, safety, etiquette)
- Optional add-ons

## Constraints
- Keep it **actionable and specific**, but avoid claiming real-time availability/prices.
- Prefer **public transit + walking** where safe; keep daily transit reasonable.
- No nightlife-focused suggestions.
- Tone: clear, friendly, efficient.


summary: { "subject": { "appearance": "Young woman with mixed ethnicity features, fair skin, and long, layered dark brunette hair falling loosely around her shoulders. Natural, fresh-faced makeup look with…

credit: "Young woman with mixed ethnicity features" by senoldak (https://incantory.ai/prompts-chat/young-woman-with-mixed-ethnicity-features), licensed CC0-1.0

originalAuthor: senoldak

copyrightHolder: senoldak

content:
{
    "subject": {
      "appearance": "Young woman with mixed ethnicity features, fair skin, and long, layered dark brunette hair falling loosely around her shoulders. Natural, fresh-faced makeup look with groomed brows and soft pink lips.",
      "outfit": "Simple black spaghetti-strap camisole or tank top.",
      "environment": "Bright, airy bedroom setting. Lying on a bed with crisp white duvet/sheets. A grey upholstered headboard is visible behind. White sheer curtains covering a window in the background, letting in soft light."
    },
    "technical_style": "Social media selfie aesthetic, triptych or collage style, soft focus, high-key lighting, intimate and casual atmosphere."
  },
  "pose_specs": {
    "body_position": "Prone position (lying on stomach) on the bed, facing the camera. Shoulders and upper chest lifted off the mattress.",
    "arms": "Elbows resting on the bed to support the upper body. One hand (right hand) brought up to touch the face—fingers resting gently on the chin or cheek.",
    "head": "Tilted slightly, creating a playful and engaging angle.",
    "expression": "Varied playful expressions: 1) A soft, sweet smile with direct eye contact. 2) A candid laugh looking away to the side. 3) A playful wink with a scrunched nose.",
    "framing": "Close-up portrait framing, cutting off at the shoulders/chest."
  },
  "camera_settings": {
    "viewpoint": "Eye-level relative to the subject on the bed (low angle relative to the room).",
    "focal_length": "24mm to 35mm (Front-facing smartphone camera focal length).",
    "aperture": "f/2.0 to f/2.8 (Soft background blur to keep focus on the face).",
    "shutter_speed": "1/100s",
    "iso": "200",
    "composition": "Centered subject, intimate proximity to the lens."
  },
  "lighting_setup": {
    "type": "Natural Window Light.",
    "qualities": "Soft, diffused, wrapping light.",
    "direction": "Side lighting coming from the window (left side of the frame), illuminating the face evenly while creating very soft, flattering modeling shadows on the opposite side.",
    "color_temperature": "Daylight balanced (approx 5500K), clean white tones."
  }
}