title: High-Stakes Decision Support System

summary: Build a high-stakes decision support system called "Pivot" — a structured thinking tool for major life and business decisions. This is distinct from a simple pros/cons list. The value is in the…

credit: "High-Stakes Decision Support System" by mmanisaligil (https://incantory.ai/prompts-chat/high-stakes-decision-support-system), licensed CC0-1.0

originalAuthor: mmanisaligil

copyrightHolder: mmanisaligil

title: High-Stakes Decision Support System

content:
Build a high-stakes decision support system called "Pivot" — a structured thinking tool for major life and business decisions.
This is distinct from a simple pros/cons list. The value is in the structured analytical process, not the output document.
Core features:
- Decision intake: user describes the decision (what they're choosing between), their constraints (time, money, relationships, obligations), their stated values (top 3), their current leaning, and their deadline
- Mandatory clarifying questions: [LLM API] generates 5 questions designed to surface hidden assumptions and unstated trade-offs in the user's specific decision. User must answer all 5 before proceeding. The quality of these questions is the quality of the product
- Six analytical frames (each run as a separate API call, shown in tabs):
  (1) Expected value — probability-weighted outcomes under each option  (2) Regret minimization — which option you're least likely to regret at age 80  (3) Values coherence — which option is most consistent with stated values, with specific evidence  (4) Reversibility index — how easily each option can be undone if it's wrong  (5) Second-order effects — what follows from each option in 6 months and 3 years  (6) Advice to a friend — if a trusted friend described this exact situation, what would you tell them?
- Devil's advocate brief: a separate analysis arguing as strongly as possible against the user's current leaning — shown after the 6 frames
- Decision record: stored with all analysis and the final decision made. User updates with actual outcome at 90 days and 1 year

Stack: React, [LLM API] with one carefully crafted prompt per analytical frame, localStorage. Focused, serious design — no gamification, no encouragement. This handles real decisions.


title: Studio photograph of a titanium pyramid embedded with amethyst

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: studio photograph of a titanium pyramid embedded with amethyst, intricate detail, ruby dwarven runes, xf iq 4, 1 5 0 mp, 5 0 mm, f 1. 4, iso 2 0 0, 1 / 1 6 0 s, natural light, adobe lightroom, photolab, affinity photo, photodirector 3 6 5


title: A portrait of o j simpson in a glass of orange juice

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

content: a portrait of o j simpson in a glass of orange juice


title: Food photography of italian meals

title: Food photography of italian meals

content: food photography of italian meals, highly detailed, high resolution, rustic, studio lighting, sharp focus, flickr


title: Note-Taking Assistant

summary: I want you to act as a note-taking assistant for a lecture. Your task is to provide a detailed note list that includes examples from the lecture and focuses on notes that you believe will end up in…

kind: text

credit: "Note-Taking Assistant" by eltociear (https://incantory.ai/prompts-chat/note-taking-assistant-2), licensed CC0-1.0

prompts.chat

handle: prompts-chat

source: prompts-chat

originalAuthor: eltociear

copyrightHolder: eltociear

title: Note-Taking Assistant

content: I want you to act as a note-taking assistant for a lecture. Your task is to provide a detailed note list that includes examples from the lecture and focuses on notes that you believe will end up in quiz questions. Additionally, please make a separate list for notes that have numbers and data in them and another separated list for the examples that included in this lecture. The notes should be concise and easy to read.


ref: cursorrules/netlify-official

title: Netlify Official

summary: Cursor rules for Netlify development with official integration.

kind: rules

credit: "Netlify Official" by PatrickJS (https://incantory.ai/cursorrules/netlify-official), licensed CC0-1.0

Awesome CursorRules

handle: cursorrules

source: cursorrules

sourceName: Awesome CursorRules

originalAuthor: PatrickJS

copyrightHolder: PatrickJS

title: Netlify Official

content:
<ProviderContextOverrides>
	// Developers can override the content as needed, but it should all be placed in this section.

</ProviderContextOverrides>

ANY RULES IN THE ProviderContextOverrides SECTION CAN OVERRULE SPECIFIC RULES IN ProviderContext

<ProviderContext version="1.0" provider="netlify">
  ## General

  - the `.netlify` folder is not for user code. It should be added to the .gitignore list
  - avoid adding version numbers to imported code. (for example use `@netlify/functions` and never `@netlify/functions@VERSION`)
  - *NEVER* add CORS headers (such as Access-Control-Allow-Origin) unless user EXPLICITLY asks for them.
  - prefer using `netlify dev` to start dev server unless another dev command is requested by the user

  # Guidelines

  - There are 4 types of compute systems you can write code for:
    - Serverless functions - usually used for transactional server/api requests.
    - Edge functions - usually used for code that must modify requests before hitting the server or modifying responses before returning to users.
    - Background functions - longer running functions for asynchronous work.
    - Scheduled functions - schedule logic to run on a CRON-based interval.
  - Netlify Blobs is a general object storage that can be used to accomplish state storage, data storage, etc.
  - Netlify Image CDN enables on-demand image transformations without affecting build times or optimizing images upon upload. It optimizes images dynamically based on client capabilities and caches transformations for performance improvements. Use this when optimizing images dynamically. Don't use this when you need to modify an image during the development/build process.
  - Environment variables are available for storing secrets, API keys, and other values that you want to control external to the code or are too sensitive to put in the code.

  ## Netlify compute

  - NEVER put any type of serverless or edge function in the public or publish directory
  - DO NOT change the default functions or edge functions directory unless explicitly asked to.
  - ALWAYS verify the correct directory to place functions or edge functions into

  ### Context object for serverless functions and edge functions

  Below are the available fields/functions from the context argument to serverless and edge functions.

  ```
  {
    account: {
      id: string, // Unique ID of the Netlify team account associated with the site and function.
    },
    cookies: {
      get: (name: string) => string | undefined, // Reads a cookie from the incoming request.
      set: (options: { name: string; value: string; path?: string; domain?: string; secure?: boolean; httpOnly?: boolean; expires?: Date }) => void, // Sets a cookie on the outgoing response following the CookieStore.set web standard.
      delete: (nameOrOptions: string | { name: string; path?: string; domain?: string }) => void, // Deletes a cookie on the outgoing response, following the CookieStore.delete web standard.
    },
    deploy: {
      context: string, // The deploy context (e.g., production, deploy-preview).
      id: string, // Unique ID of the deploy the function belongs to.
      published: boolean, // Indicates whether the function belongs to the currently published deploy.
    },
    geo: {
      city: string, // City name of the client location.
      country: {
        code: string, // ISO 3166 country code.
        name: string, // Full country name.
      },
      latitude: number, // Latitude coordinate of the client location.
      longitude: number, // Longitude coordinate of the client location.
      subdivision: {
        code: string, // ISO 3166 subdivision code (e.g., state or province).
        name: string, // Subdivision name.
      },
      timezone: string, // Timezone of the location.
      postalCode: string, // Postal code of the location in its regional format.
      ip: string, // Client IP address.
    },
    params: Record<string, string>, // Object containing route parameters from the function path configuration.
    requestId: string, // Unique Netlify request ID.
    server: {
      region: string, // The region code where the deployment is running (e.g., us-east-1).
    },
    site: {
      id: string, // Unique ID for the Netlify site.
      name: string, // The site's Netlify subdomain name.
      url: string, // The main address of the site, which could be a Netlify subdomain or a custom domain.
    },
  }
  ```

  ### the `Netlify` global object

  - the `Netlify` object is available in global scope.
  - available on all serverless and edge function types

  It has the following fields/functions:

  ```
  {
    context: object | null, // The Netlify-specific context object - same as function's second arg. Available only within function handlers or child scopes; otherwise, it returns null.

    env: {
      delete: (name: string) => void, // Deletes an environment variable within the context of the invocation.
      get: (name: string) => string | undefined, // Retrieves the string value of an environment variable; returns undefined if not defined.
      has: (name: string) => boolean, // Checks if an environment variable exists; returns true if it does, otherwise false.
      set: (name: string, value: string) => void, // Sets an environment variable within the invocation context.
      toObject: () => Record<string, string>, // Returns an object containing all environment variables and their values.
    },
  };
  ```

  ### Serverless Functions (aka Functions, aka Synchronous functions)
  - Serverless functions use Node.js and should attempt to use built-in methods where possible
  - When adding new npm modules, ensure "node_modules" is in the .gitignore
  - ALWAYS use the latest format of a function structure.
  - if using typescript, ensure types are installed from `npm install @netlify/functions`
  - DO NOT put global logic outside of the exported function unless it is wrapped in a function definition
  - ONLY use vanilla javascript if there are other ".js" files in the functions directory.
  - ALWAYS use typescript if other functions are typescript or if there are no existing functions.
  - The first argument is a web platform Request object that represents the incoming HTTP request
  - The second argument is a custom Netlify context object.
  - Functions have a global `Netlify` object that is also accessible.
    - ONLY use `Netlify.env.*` for interacting with environment variables in code.
  - Place function files in `YOUR_BASE_DIRECTORY/netlify/functions` or a subdirectory.
    - The serverless functions directory can be changed via:
      - **Netlify UI**: *Site configuration > Build & deploy > Continuous deployment > Build settings*
      - **`netlify.toml`**:
        ```toml
        [functions]
          directory = "my_functions"
      ```
    - `netlify.toml` settings override UI settings.
  - If using a subdirectory, name the entry file `index.mts` or match the subdirectory name.
    - Example valid function paths:
      - `netlify/functions/hello.mts`
      - `netlify/functions/hello/index.mts`
      - `netlify/functions/hello/hello.mts`
  - Naming files with `.mts` enables modern ES module syntax

  #### Examples of the latest Serverless Function or Function structures
    - ```typescript
        import type { Context, Config } from "@netlify/functions";

        export default async (req: Request, context: Context) => {
          // user code
          return new Response("Hello, world!")
        }

        export const config: Config = {
          // use this path instead of /.netlify/functions/{fnName}
          path: "/hello-world"
        };
      ```
    - ```javascript
        export default async (req, context) => {
          // user code
          return new Response("Hello, world!")
        }

        export const config = {
        // use this path instead of /.netlify/functions/{fnName}
          path: "/hello-world"
        };
      ```
  #### In-code function config and routing for serverless functions
  - prefer to use in-code configuration via exporting a `config` object. This is the structure the config can have:
  - prefer to provide a friendly path using the config object.
  - ONLY serverless functions use `/.netlify/functions/{function_name}` path by default.
  - If you set a specific path via this config or the netlify.toml, it will only be available at that new path.
  - path and excluded path supports substring patterns or the URLPattern syntax from the web platform.

  ```
  {
    path: string | string[], // Defines the URL path(s) that trigger the function. Can be a single string or an array of paths.
    excludedPath?: string | string[], // Optional. Defines paths that should be excluded from triggering the function.
    preferStatic?: boolean, // Optional. If true, prevents the function from overriding existing static assets on the CDN.
  }
  ```

  ### Background Functions
  - Use background functions when you need to run long-running logic, and that logic does not need to compute a response immediately.
  - Any data that background functions need to serve to users should be calculated and stored in a place that a serverless function can read from later - such as Netlify Blobs or a preconfigured database.
  - Background functions operate the same as standard Serverless functions and are syntactically the same with the following exceptions
    - they have a 15-minute timeout measured by "wall clock" time
    - they immediately return an empty response with a 202 status code. Return values from these functions are ignored.
    - Background functions MUST have a "-background" suffix on the function file name or function directory (for example, netlify/functions/hello-background.mts or netlify/functions/hello-background/index.mts).

  #### Examples of the latest background function structures
  - ```typescript
      import { Context } from "@netlify/functions";

      export default async (req: Request, context: Context) => {
        await someLongRunningTask();

        console.log("Done");
      };
    ```

  - ```javascript
      export default async (req, context) => {
        await someLongRunningTask();

        console.log("Done");
      };
    ```

  ### Scheduled Functions
  - Use scheduled functions when the logic needs to run on an interval or can be defined via CRON timing.
  - CRON expressions are executed against the UTC timezone
  - our CRON syntax supports extensions defined the RFC except for the @reboot and @annually.
  - The minimum interval is 1 minute
  - Scheduled functions have a 30-second execution limit
  - Scheduled functions do not return response bodies
  - the request body is a JSON-encoded object containing a `next_run` property. It represents the timestamp of the next scheduled invocation, as a string in the ISO-8601 format.
  - in addition to in-code config, schedules can be defined in the `netlify.toml`. ONLY do this for consistency or if explicitly asked to keep all schedules in one place.
    ```toml
      [functions."test-scheduled-function"]
        schedule = "@hourly"
    ```
  - Scheduled functions ONLY run on published deploys. They donâ€™t run on Deploy Previews or branch deploys.
  - For local tests, the Netlify CLI to run the site in dev mode and the `netlify functions:invoke` [command](mdc:https:/cli.netlify.com/commands/functions/#functionsinvoke) to trigger the scheduled function.
    example:
    ```bash
      netlify functions:invoke myfunction
    ```

  #### Examples of the latest background function structures
  - ```typescript
      import type { Config } from "@netlify/functions"

      export default async (req: Request) => {
          const { next_run } = await req.json()

          console.log("Received event! Next invocation at:", next_run)
      }

      export const config: Config = {
          schedule: "@hourly"
      }

    ```

  - ```javascript
      export default async (req) => {
          const { next_run } = await req.json()

          console.log("Received event! Next invocation at:", next_run)
      }

      export const config = {
          schedule: "@hourly"
      }

    ```

  ### Edge Functions
  - ALWAYS use the latest format of an edge function structure.
  - **DO NOT** add CORS headers (such as Access-Control-Allow-Origin) unless explicitly asked for them.
  - if using typescript, ensure types are installed from `npm install @netlify/edge-functions`
  - DO NOT put global logic outside of the exported function unless it is wrapped in a function definition
  - ONLY use vanilla javascript if there are other ".js" files in the functions directory.
  - ALWAYS use typescript if other functions are typescript or if there are no existing functions.
  - The first argument is a web platform Request object that represents the incoming HTTP request
  - The second argument is a custom Netlify context object.
  - Edge functions have a global `Netlify` object that is also accessible.
    - ONLY use `Netlify.env.*` for interacting with environment variables in code.
  - Place function files in `YOUR_BASE_DIRECTORY/netlify/edge-functions` or a subdirectory.
    - The serverless functions director can be changed via`netlify.toml`:
      ```toml
      [build]
        edge_functions = "my-custom-directory"
      ```

  - Edge functions use Deno as runtime and should attempt to use built-in methods where possible. See the list of available web APIs to know which built-ins to use.
    - **Module Support**:
      - Supports **Node.js built-in modules**, **Deno modules**, and **npm packages** (beta).
    - **Importing Modules**:
      - **Node.js built-in modules**: Use `node:` prefix (e.g., `import { randomBytes } from "node:crypto"`).
      - **Deno modules**: Use **URL imports** (e.g., `import React from "https://esm.sh/react"` or an **import map**).
      - **npm packages (beta)**: Install via `npm install` and import by package name (e.g., `import _ from "lodash"`).
      - Some npm packages with **native binaries** (e.g., Prisma) or **dynamic imports** (e.g., cowsay) may not work.
    - You may use an **import map** to reference third-party modules with shorthand names instead of full URLs.
    - **Import Map Usage**:
      - Define mappings in a separate **import map file** (not in `deno.json`).
      - The file can be placed anywhere in the project directory.
    - **Example Import Map (`import_map.json`)**:
      ```json
      {
        "imports": {
          "html-rewriter": "https://ghuc.cc/worker-tools/html-rewriter/index.ts"
        }
      }
      ```
    - **Enabling Import Maps**:
      - Declare the import map in `netlify.toml`:
        ```toml
        [functions]
          deno_import_map = "./path/to/your/import_map.json"
        ```
    - **Usage in Code**:
      - Modules can now be imported by name:
        ```javascript
        import { HTMLRewriter } from "html-rewriter";
        ```
  #### Examples of the latest Edge function structures
    - ```typescript
        import type { Context, Config } from "@netlify/edge-functions";

        export default async (req: Request, context: Context) => {
          // user code
          return new Response("Hello, world!")
        }

        export const config: Config = {
          path: "/hello-world"
        };
      ```
    - ```javascript
          export default async (req, context) => {
            // user code
            return new Response("Hello, world!")
          }

          export const config = {
            path: "/hello-world"
          };
      ```

  #### Extra properties on context argument for Edge Functions
  - these are ONLY available in Edge Functions

  ```
  {
    ...ALL OTHER Context fields/methods,

    next: (options?: { sendConditionalRequest?: boolean }) => Promise<Response>, // Invokes the next item in the request chain, optionally using conditional requests.

    nextRequest: (request: Request, options?: { sendConditionalRequest?: boolean }) => Promise<Response>, // Same as next(), but requires an explicit Request object.
  }

  ```

  #### Web APIs available in Edge Functions ONLY
  - console.*
  - atob
  - btoa
  - Fetch API
    - fetch
    - Request
    - Response
    - URL
    - File
    - Blob
  - TextEncoder
  - TextDecoder
  - TextEncoderStream
  - TextDecoderStream
  - Performance
  - Web Crypto API
    - randomUUID()
    - getRandomValues()
    - SubtleCrypto
  - WebSocket API
  - Timers
    - setTimeout
    - clearTimeout
    - setInterval
  - Streams API
    - ReadableStream
    - WritableStream
    - TransformStream
  - URLPattern API

  #### In-code function config and routing for Edge functions
  - prefer to use in-code configuration via exporting a `config` object. This is the structure the config can have:
  - prefer to provide a friendly path using the config object.
  - Edge functions are configured with a path pattern and only paths matching those patterns will run the edge function
  - path and excludedPath supports substring patterns or the URLPattern syntax from the web platform.
  - unless explicitly asked to modify other properties, only set path, pattern, excludedPath when creating functions.

  ```
  {
    path?: string | string[], // URLPattern expression defining paths where the edge function should run. Must start with '/'.
    excludedPath?: string | string[], // Optional. Defines paths to exclude from execution. Must start with '/'.
    pattern?: RegExp | RegExp[], // Alternative to `path`. Uses regex for path matching.
    excludedPattern?: RegExp | RegExp[], // Optional. Defines regex patterns to exclude certain routes.
    method?: string | string[], // Optional. Specifies HTTP methods that should trigger the function (e.g., "GET", ["POST", "PUT"]).
    onError?: "continue" | "fail" | "fallback", // Optional. Controls how the function handles errors.
    cache?: 'manual', // Optional. Enables response caching if set to 'manual'.
  } = {
    path: "", // Default value; should be set per function.
  };
  ```

  #### Configuring Edge Functions in netlify.toml
  - ONLY Use `netlify.toml` for precise function order control instead of inline declarations.
  - DO NOT use `netlify.toml` if there is not edge function ordering requirements.
  - When controlling order, it's important to include all edge functions for order control.

  - **Declare Edge Functions in `netlify.toml`**:
    - Allows multiple edge functions on the same path with explicit execution order.
    - Functions run **top-to-bottom**, except cached functions, which always run last.

  - **Edge Function Properties**:
    - `function`: Name of the edge function.
    - `path`: URL pattern to trigger the function (must start with `/`).
    - `excludedPath`: Excludes specific routes from `path` (supports string or array).
    - `pattern`: Regex-based path matching.
    - `excludedPattern`: Excludes specific regex patterns (single or array).
    - `cache`: Enables response caching (cached functions run after non-cached ones) set to 'manual' to opt in.

  - **Netlify.toml config examples**
    ```toml
    [[edge_functions]]
      path = "/admin"
      function = "auth"

    [[edge_functions]]
      path = "/admin"
      function = "injector"
      cache = "manual"

    [[edge_functions]]
      path = "/blog/*"
      function = "auth"

    [[edge_functions]]
      path = "/blog/*"
      function = "rewriter"

    [[edge_functions]]
      pattern = "/products/(.*)"
      excludedPattern = "/products/things/(.*)"
      function = "highlight"

    [[edge_functions]]
      path = "/*"
      excludedPath = "/img/*"
      function = "common"
  ```
  - **Execution Order for Edge Functions**:
    1. **Configuration-based** edge functions (`netlify.toml`) run first.
    2. **Framework-generated** edge functions execute before user-defined functions.
    3. **Non-cached** edge functions execute before cached functions.
    4. **Inline-declared** edge functions override duplicate `netlify.toml` functions.
    5. **Multiple inline edge functions** run alphabetically by filename.

  - **Caveats & Special Cases**:
    - If an edge function returns a response, redirects for that path DO NOT occur.
    - Edge functions DO NOT execute for rewritten static routing targets.
    - `fetch()` or `URL()` triggers a **new request chain**, re-running matching functions.
    - Use `context.next()` to continue processing instead of re-triggering functions.
    - Function failure behavior depends on its **error handling configuration**.

  #### Edge functions limitations
  - 20 MB (compressed) code size limit
  - 512 MB per deployment memory limit
  - 50ms per request CPU execution time (excludes waiting time)
  - 40 seconds Response header timeout
  - **Not compatible with these Netlify features**:
    - Netlify's split testing feature
    - Custom Headers (including basic authentication) from _headers or netlify.toml config
    - Netlify prerendering feature on paths served by edge functions
  - Be aware that multiple framework adapters may generate conflicting edge functions
  - **Restrictions**:
    - Can only rewrite requests to same-site URLs (use `fetch()` for external content)
    - Cached edge functions override existing static files
    - No local caching; HTTP cache headers are ignored in local testing
    - Not included in Netlifyâ€™s HIPAA-compliant hosting offering

  ## Netlify Blobs

  - Prefer using Netlify Blobs over creating a new database unless a flat file is not appropriate data layer, if explicitly asking to use a tool, or the dev needs to created relational structures or search that's more appropriate for databases
  - Blobs do not require configuration to use, everything is automatically provisions, and devs can simply start using them via any Netlify compute. The API will be the same across all compute types.
  - ensure `@netlify/blobs` NPM module is installed
  - Requirements and limits
    - Requires Fetch API support (Node.js 18+ recommended) - a fetch function can be provided to the store
    - Store names cannot exceed 64 bytes
    - Object keys cannot exceed 600 bytes
    - Maximum object size: 5GB
    - Local development uses a sandboxed store

  ### Netlify Blobs API

  ```typescript
    export interface BlobMetadata {
      [key: string]: any;
    }

    export interface BlobData<T = string> {
      data: T | null;
      etag: string;
      metadata: BlobMetadata;
    }

    export interface ListResult {
      blobs: { etag: string; key: string }[];
      directories?: string[];
    }

    interface GetKeyOptions {
      type?: 'arrayBuffer' | 'blob' | 'json' | 'stream' | 'text'
    }

    interface GetKeyAndMetadataOptions {
      type?: 'arrayBuffer' | 'blob' | 'json' | 'stream' | 'text',
      etag?: string;
    }

    // THESE ARE THE ONLY STORE METHODS. DO NOT MAKE UP NEW ONES
    interface Store {

      // Creates or overwrites a blob entry.
      // example: await store.set('key-name', 'contents-of key');
      // - NEVER add metadata unless instructed to.
      set(key: string, value: ArrayBuffer | Blob | string, { metadata?: object }): Promise<void>;

      // Stores a JSON-serializable object.
      // example: await store.setJSON('key-name', {version: 'a', someBoolean: true});
      // - NEVER add metadata unless instructed to.
      setJSON(key: string, value: any, { metadata?: object }): Promise<void>;

      // Retrieves a stored blob.
      // example: await store.get('key-name');
      // - NEVER add the second arg unless you need an explicit type 'arrayBuffer' | 'blob' | 'json' | 'stream' | 'text'.
      // - Instead of using JSON.parse(blob), use store.get('key-name', {type: 'json'})
      // - if the blob is missing, it will resolve the promise with a null value
      get(key: string, getOpt?: GetKeyOptions): Promise<any | null>;

      // Retrieves a blob along with metadata
      // example: await store.getWithMetadata('key-name');
      // - NEVER add the second getOpts arg unless you need an explicit type or have an etag to check against.
      // - AVOID adding it unless it's reliably available but IF an etag is provided, it will only return the blob if the etag is different that what's stored.
      // - if the blob is missing, it will resolve the promise with a null value
      getWithMetadata(key: string, getOpts?: GetKeyAndMetadataOptions): Promise<{ data: any, etag: string, metadata: object } | null>;

      // Retrieves metadata of a blob WITHOUT downloading the data.
      // example: await store.getMetadata('key-name');
      // - NEVER add the second getOpts arg unless you need an explicit type or have an etag to check against.
      // - AVOID adding it unless it's reliably available but IF an etag is provided, it will only return the blob if the etag is different that what's stored.
      // - if the blob is missing, it will resolve the promise with a null value
      getMetadata(key: string, getOpts?: GetKeyAndMetadataOptions): Promise<{ etag: string, metadata: object } | null>;

      // Lists blobs in the store with optional hierarchical browsing.
      // example:
      //      const { blobs } = await store.list()
      //      // blobs === [ { etag: 'etag1', key: 'some-key' }, { etag: 'etag2', key: 'another-key' } ]
      //
      // - NEVER add the options arg unless you need an explicit reduce the searched data.
      //    -- ONLY if you have to reduce searched data, use `prefix: 'some-prefix'` to pull blobs that start with that prefix value. Use `directories: true` to include the full directory path on the `key`
      // - By default, the list() method retrieves all pages, meaning you'll always get the full list of results. This can be slow or memory intensive. To paginate, pass the `paginate: true` in the options to turn the response into an AsyncIterator that allows you to for-of loop through the blobs in the store.
      // - if store path is empty, the blobs will resolve the promise with an empty array
      list(options?: { directories?: boolean, paginate?: boolean. prefix?: string }): Promise<{ blobs: BlobResult[], directories: string[] }> | AsyncIterable<{ blobs: BlobResult[], directories: string[] }>

      // Deletes a blob.
      // example: await store.delete('key-name');
      // - The return value is always resolves to `undefined`, regardless of whether or not there was an object to delete.
      delete(key: string): Promise<void>;
    }

    interface GetDeployStoreOptions extends Partial<ClientOptions> {
      deployID?: string;
      name?: string;
      region?: Region;
    }

    // Returns a store instance for managing blobs. This is global scoped data across all deploys.
    // example: const store = getStore('my-store');
    // - ONLY add the options argument if the user needs strong consistency
    export function getStore(name: string, options?: { consistency?: 'strong' | 'eventual' }): Store;

    // Returns a deploy-specific store instance for managing blobs tied to a deploy.
    // example: const store = getDeployStore('my-store');
    // - ONLY add the options argument if the user needs strong consistency
    declare const getDeployStore: (input?: GetDeployStoreOptions | string) => Store;
    interface GetStoreOptions extends Partial<ClientOptions> {
        deployID?: string;
        name?: string;
    }

    // Lists all stores available on a site.
    // example:
    //    const { stores } = await listStores();
    //      // [ "beauty", "construction" ]
    // - By default, the listStores() method retrieves all pages, meaning you'll always get the full list of results. This can be slow or memory intensive. To paginate, pass the `paginate: true` in the options to turn the response into an AsyncIterator that allows you to for-of loop through the blobs in the store.
    // - DO NOT pass options unless paginating.
    declare function listStores(options?: {
        paginate?: boolean;
    }): Promise<ListStoresResponse> | AsyncIterable<ListStoresResponse>;

    interface ListStoresResponse {
        stores: string[];
        next_cursor?: string;
    }

  ```

  ## File-Based Uploads
  With file-based uploads, write blobs to deploy-specific stores after the site build completes. Useful for frameworks and other tools integrating with Netlify as it does not require a build plugin.

  Put files in `.netlify/blobs/deploy/*` for deploy specific
  ```
  .netlify/
  â”œâ”€ blobs/
  |  â”œâ”€ deploy/
  â”‚  |  â”œâ”€ beauty/
  â”‚  â”‚  |  â””â”€ nails.jpg
  ```
  To attach metadata to a blob via file upload flows, include a JSON file that prefixes the corresponding blob filename with $ and has a .json extension. For example:
  ```
  â”œâ”€ blobs/
  |  â”œâ”€ deploy/
  â”‚  |  â”œâ”€ beauty/
  â”‚  â”‚  |  â”œâ”€ nails.jpg
  â”‚  â”‚  |  â””â”€ $nails.jpg.json
  ```

  ## Blob consistency models
  - By default, blobs are "eventually consistent" - Fast reads, updates/deletions propagated within 60 seconds.
  - To have strong consistency that ensures updates are immediately visible at the cost of slower reads. set the `consistency` field to `'strong'` on the store instantiation.
  - There is no concurrency control built in, last write wins. Add object-locking mechanisms if you need concurrency guarantees.

  Example:
  ```javascript
  const store = getStore({ name: "animals", consistency: "strong" });
  await store.set("dog", "dog");
  const dog = await store.get("dog");
  ```

  ## Storage scopes
  - blobs can be stored in a deploy-specific scope or at a global scope
  - deploy-specific blobs sync with deploys and are removed with deploy deletions. `getDeployStore()` is used to interact with deploy specific stores.
  - global scope blobs are not automatically cleaned up and are consistent across all branches. `getStore()` is used for global scope.
  - Build plugins and file-based uploads must write to deploy-specific stores.
  - ALWAYS When creating logic that saves to global scope, ensure that non-production data does not get stored in these global stores. This keeps production data isolated from test data. To do that, check for the environment and choose which store to use depending on the environment.

  #### Examples of blob usage

  ```javascript
    // basic writing to a deploy store
    import { getDeployStore } from "@netlify/blobs";
    const store = getDeployStore("construction");
  ```

  ```javascript
    // basic writing to a global store
    import { getStore } from "@netlify/blobs";
    const store = getStore("construction");
  ```

  ```javascript
    // using global store if in production, otherwise use deploy scope store
    import { getStore, getDeployStore } from "@netlify/blobs";

    function getBlobStore(...storeOptions){

      if((Netlify.context?.deploy.context === 'production'){
        return getStore(...storeOptions);
      }

      return getDeployStore(...storeOptions)
    }

    const store = getBlobStore("construction");
  ```

  ---

  ## Netlify Image CDN
  - All Netlify sites have a `/.netlify/images` route supported by their site without any additional enablement.
  - Transform images via query parameters in requests to `/.netlify/images`.
  - NEVER introduce circular dependencies with urls redirecting to urls that redirect back to the same url in a loop
  - when using the ?url={URL} parameter, ensure the url is a URI encoded component.
  - Supported transformations:
    - **source**: Required, specifies image URL (relative or remote).
    - **size**: `w` (width) and `h` (height) in pixels.
    - **fit**: Determines how the image is resized (`contain`, `cover`, `fill`).
    - **position**: Cropping alignment (`top`, `bottom`, `left`, `right`, `center`).
    - **format**: Convert to `avif`, `jpg`, `png`, `webp`, `gif`, or `blurhash`.
    - **quality**: Controls lossy format quality (`q`, 1-100, default 75).

  ### Example transformations
  ```html
    <!-- get an image hosted on this site and change its size and format -->
    <img src="/.netlify/images?url=/image.jpg&w=100&h=100&fit=cover&fm=webp&q=80" />

    <!-- get an image hosted externally and change its size and format -->
    <img src="/.netlify/images?url=https://example.com/path/to/image&w=40&h=10&fm=jpg&q=80" />
  ```

  ### Caching & deployment behavior
  - Transformed images are cached at the edge.
  - Source images are cached for future transformations.
  - After a new deploy cached images are invalidated and so images can be reprocessed in case of changes
  - Cache-busting via asset fingerprinting is recommended if you must finely control cache key.
  - In order to use externally hosted (aka remote) images the domain pattern must be allowlisted in the Netlify `netlify.toml`.
    - Allow remote sources using:
      ```toml
      [images]
        remote_images = ["https://externalexample.com/.*"]
      ```
      - only absolute urls to external servers need to be in remote_images

  ### Redirects & Rewrites
  - If you do not want to use the default `/.netlify/images` path, a redirect or rewrite can be used to have a different url.
  - Define reusable transformation routes in `_redirects` or `netlify.toml` files.
  - When doing so, the parameters can remain parameters to pass in or can be statically defined.
  - Examples:
    - netlify.toml to use /transform-my-images/{imagePath}
      ```toml
        [[redirects]]
          from = "/transform-my-images/*"
          to = "/.netlify/images?url=/:splat&w=50&h=50"
          status = 200
      ```
    - _redirects to use /transform-all/{...imagePath}
      ```
        /transform-all/* /.netlify/images?url=/:splat&w=50&h=50 200
      ```

  ### Custom headers
  - Custom headers can ONLY be applied to images hosted on the same domain.
  - ONLY do this when explicitly asked
  - Examples:
    - netlify.toml to use /transform-my-images/{imagePath}
      ```toml
        [[headers]]
          for = "/source-images/*"
          [headers.values]
            Cache-Control = "public, max-age=604800, must-revalidate"
      ```
    - _headers to use /{...imagePath}
      ```
        /source-images/* Cache-Control: public, max-age=604800, must-revalidate
      ```
  ### Image CDN framework support
  Netlify Image CDN integrates with frameworks for automatic optimizations:
  - **Angular**: `NgOptimizedImage` component will use Image CDN automatically
  - **Astro**: `<Image />` component will use Image CDN automatically
  - **Gatsby**: set `NETLIFY_IMAGE_CDN=true` and use the Contentful, Drupal, or WordPress source plugins.
  - **Next.js**: set `remotePatterns` in `next.config.js`
  - **Nuxt**: `nuxt/image` module will use Image CDN automatically

  ---

  ## Environment Variables
  - securely create, manage, and use environment variables across sites. These variables can be set via the UI, CLI, API, or configuration files.
  - when setting environment variables, Netlify local environment and cloud environment will make these variables available.
  - **Precedence**: `netlify.toml` overrides UI/CLI/API variables, and site-specific variables take precedence over shared ones.

  ### Creating Environment Variables
  Variables can be created and managed using:
  - **Netlify UI**: Suggest using if they don't want to provide the values directly to this agent. They can navigate to it via the path "Site configuration > Environment variables".
  - **Netlify CLI**: Prefer using this if the agent can run commands. This requires the site to be linked.
  - **Netlify Configuration (`netlify.toml`)**: Defines variables at the repository level. ONLY use this for environment variables where the site is not linked yet and the values are not sensitive.

  ### Netlify CLI Command
  - The site must be linked first before the CLI will add variables. See the rules for initializing and linking sites for how to do this.
  - Use `env:set` for changes, `env:unset` to delete. `env:import` to import from a dotenv`.env` file.

  #### Example usage of env var CLI
  - Basic setting an environment variable for the site
    ```sh
      netlify env:set API_KEY "not-a-secret"
    ```
  - Setting an environment variable that should be treated as a secret
    ```sh
        netlify env:set API_KEY "secret-value" --secret
    ```

  ### Example `netlify.toml` Configuration
  - Using the netlify.toml the configuration can be specific to certain branches/deploy contexts.
  - examples
    ```toml
      # Production context: all deploys from the Production branch
      # set in your siteâ€™s Branches settings in the UI will inherit
      # these settings. You can define environment variables
      # here but we recommend using the Netlify UI for sensitive
      # values to keep them out of your source repository.
      [context.production]
        publish = "output/"
        command = "make publish"
        environment = { NODE_VERSION = "14.15.3" }

      # Here is an example of how to define context-specific
      # environment variables. Be mindful when using this
      # option and avoid committing sensitive values to public
      # source repositories.
      [context.deploy-preview.environment]
        NOT_PRIVATE_ITEM = "not so secret"

      # Branch Deploy context: all deploys that are not from
      # a pull/merge request or from the Production branch
      # will inherit these settings.
      [context.branch-deploy.environment]
        NODE_ENV = "development"

      # Dev context: environment variables set here
      # are available for local development environments
      # run using Netlify Dev. These values can be
      # overwritten on branches that have a more specific
      # branch context configured.
      [context.dev.environment]
        NODE_ENV = "development"

      # Specific branch context: all deploys from
      # this specific branch will inherit these settings.
      [context.staging.environment] # staging is a branch name
        NODE_ENV = "development"
    ```

  ### `.env` File Handling
  - Netlify builds do not read `.env` files directly
  - Import `.env` variables into Netlify using the UI or CLI (`netlify env:import .env`).
  - Export Netlify variables via UI or CLI (`env:list`) only after confirming where the output will be stored.
  - Do not write production context values to `.env` by default.

  ### Export `.env` Variables
  ```sh
  # list the production deploy context values in .env format
  netlify env:list --plain --context production

  # only after explicit user confirmation:
  # 1. confirm .env.local is gitignored
  # 2. confirm the user wants a local production-context export
  # 3. remind the user not to commit the file
  netlify env:list --plain --context production > .env.local
  ```

  ---

  # Creating new sites

  - do not add redirects to netlify.toml or _redirects unless requested
  - do not add custom headers to the netlify.toml or _headers unless requested

  # Initializing sites or linking them
  - determine if a site is linked by checking if `PROJECT_FOLDER/.netlify/state.json` file exists and it has a populated `siteId` value.
  - if the site is not linked, run `netlify init` to allow the user to set up the site with Netlify. If the user deploys manually, it will set up the site to use Netlify automatically. If the user decides to set up a repo, they might have to set up the repo first. If the site is already set up on netlify then run `netlify link` for the user to input the credentials to link.

</ProviderContext>


title: An endless wasteland littered with an infinite number of swords stuck in the…

content: An endless wasteland littered with an infinite number of swords stuck in the ground, digitial artwork, 4k, artstation


credit: "Game Theory for Students: Easy and Engaging Learning" by Alex-lucian (https://incantory.ai/prompts-chat/game-theory-for-students-easy-and-engaging-learning), licensed CC0-1.0

originalAuthor: Alex-lucian

copyrightHolder: Alex-lucian

content:
Act as a Patient Teacher. You are a knowledgeable and patient instructor in game theory, aiming to make complex concepts accessible to students.

Your task is to:
1. Introduce the fundamental principles of game theory, such as Nash equilibrium, dominant strategies, and zero-sum games.
2. Provide clear, simple explanations and real-world examples that illustrate these concepts in action.
3. Use relatable scenarios, like everyday decision-making games, to help students grasp abstract ideas easily.

You will:
- Break down each concept into easy-to-understand parts.
- Engage students with interactive and thought-provoking examples.
- Encourage questions and foster an interactive learning environment.

Rules:
- Avoid overly technical jargon unless previously explained.
- Focus on clarity and simplicity to ensure comprehension.

Example:
Explain Nash Equilibrium using the example of two companies deciding on advertising strategies. Discuss how neither company can benefit by changing their strategy unilaterally if they are both at equilibrium.


title: Sherlock Holmes, hyper realistic, sharp focus


title: Selfie of the last person in the world after apocalypse

content: selfie of the last person in the world after apocalypse


ref: diffusiondb/elderly-werner-hertzog

title: Elderly werner hertzog

title: Elderly werner hertzog

content: elderly werner hertzog, hyperrealistic portrait, bladerunner street, disco elysium style, photo realistic, dynamic lighting, artstation, poster, volumetric lighting, very detailed face, 4 k, award winning


title: Array of 3 d streetlamp models

title: Array of 3 d streetlamp models

content: array of 3 d streetlamp models, unreal engine, top view, 4 k, spritesheet


summary: Create a hyper-realistic 3D diorama-style model of {{landmarkname|EIFFEL TOWER}}. The model should appear as a miniature, set on a raised cross-section of earth that reveals soil and rock layers…

credit: "World Landmarks: Hyper-Realistic 3D Dioramas" by serkanozcan (https://incantory.ai/prompts-chat/world-landmarks-hyper-realistic-3d-dioramas), licensed CC0-1.0

originalAuthor: serkanozcan

copyrightHolder: serkanozcan

type: string

default: EIFFEL TOWER

content: Create a hyper-realistic 3D diorama-style model of {{landmark_name|EIFFEL TOWER}}. The model should appear as a miniature, set on a raised cross-section of earth that reveals soil and rock layers beneath a lush grassy surface. The structure must be highly detailed and proportionally accurate, surrounded by tiny realistic elements like region-appropriate street lamps, native trees, shrubs, water features like small fountains, and historically or culturally fitting pathways. The scene should evoke the unique character of {{landmark_name|EIFFEL TOWER}}’s surrounding landscape. The environment must include a soft white background to draw full attention to the model. Include the text “{{landmark_name|EIFFEL TOWER}}” in large, bold, elegant lettering prominently displayed on a big sign or billboard at the front of the diorama, easily readable and eye-catching, along with a large national flag on a tall, prominent flagpole positioned beside {{landmark_name|EIFFEL TOWER}}, clearly visible and waving. 1080x1080 dimension


ref: prompts-chat/frontend-developer

title: Frontend Developer

summary: name: frontend-developer description: "Use this agent when building user interfaces, implementing React/Vue/Angular components, handling state management, or optimizing frontend performance. This…

credit: "Frontend Developer" by ersinyilmaz (https://incantory.ai/prompts-chat/frontend-developer), licensed CC0-1.0

originalAuthor: ersinyilmaz

copyrightHolder: ersinyilmaz

title: Frontend Developer

content:
---
name: frontend-developer
description: "Use this agent when building user interfaces, implementing React/Vue/Angular components, handling state management, or optimizing frontend performance. This agent excels at creating responsive, accessible, and performant web applications. Examples:\n\n<example>\nContext: Building a new user interface\nuser: \"Create a dashboard for displaying user analytics\"\nassistant: \"I'll build an analytics dashboard with interactive charts. Let me use the frontend-developer agent to create a responsive, data-rich interface.\"\n<commentary>\nComplex UI components require frontend expertise for proper implementation and performance.\n</commentary>\n</example>\n\n<example>\nContext: Fixing UI/UX issues\nuser: \"The mobile navigation is broken on small screens\"\nassistant: \"I'll fix the responsive navigation issues. Let me use the frontend-developer agent to ensure it works perfectly across all device sizes.\"\n<commentary>\nResponsive design issues require deep understanding of CSS and mobile-first development.\n</commentary>\n</example>\n\n<example>\nContext: Optimizing frontend performance\nuser: \"Our app feels sluggish when loading large datasets\"\nassistant: \"Performance optimization is crucial for user experience. I'll use the frontend-developer agent to implement virtualization and optimize rendering.\"\n<commentary>\nFrontend performance requires expertise in React rendering, memoization, and data handling.\n</commentary>\n</example>"
model: sonnet
color: blue
tools: Write, Read, Edit, Bash, Grep, Glob, WebSearch, WebFetch
permissionMode: default
---

You are an elite frontend development specialist with deep expertise in modern JavaScript frameworks, responsive design, and user interface implementation. Your mastery spans React, Vue, Angular, and vanilla JavaScript, with a keen eye for performance, accessibility, and user experience. You build interfaces that are not just functional but delightful to use.

Your primary responsibilities:

1. **Component Architecture**: When building interfaces, you will:
   - Design reusable, composable component hierarchies
   - Implement proper state management (Redux, Zustand, Context API)
   - Create type-safe components with TypeScript
   - Build accessible components following WCAG guidelines
   - Optimize bundle sizes and code splitting
   - Implement proper error boundaries and fallbacks

2. **Responsive Design Implementation**: You will create adaptive UIs by:
   - Using mobile-first development approach
   - Implementing fluid typography and spacing
   - Creating responsive grid systems
   - Handling touch gestures and mobile interactions
   - Optimizing for different viewport sizes
   - Testing across browsers and devices

3. **Performance Optimization**: You will ensure fast experiences by:
   - Implementing lazy loading and code splitting
   - Optimizing React re-renders with memo and callbacks
   - Using virtualization for large lists
   - Minimizing bundle sizes with tree shaking
   - Implementing progressive enhancement
   - Monitoring Core Web Vitals

4. **Modern Frontend Patterns**: You will leverage:
   - Server-side rendering with Next.js/Nuxt
   - Static site generation for performance
   - Progressive Web App features
   - Optimistic UI updates
   - Real-time features with WebSockets
   - Micro-frontend architectures when appropriate

5. **State Management Excellence**: You will handle complex state by:
   - Choosing appropriate state solutions (local vs global)
   - Implementing efficient data fetching patterns
   - Managing cache invalidation strategies
   - Handling offline functionality
   - Synchronizing server and client state
   - Debugging state issues effectively

6. **UI/UX Implementation**: You will bring designs to life by:
   - Pixel-perfect implementation from Figma/Sketch
   - Adding micro-animations and transitions
   - Implementing gesture controls
   - Creating smooth scrolling experiences
   - Building interactive data visualizations
   - Ensuring consistent design system usage

**Framework Expertise**:
- React: Hooks, Suspense, Server Components
- Vue 3: Composition API, Reactivity system
- Angular: RxJS, Dependency Injection
- Svelte: Compile-time optimizations
- Next.js/Remix: Full-stack React frameworks

**Essential Tools & Libraries**:
- Styling: Tailwind CSS, CSS-in-JS, CSS Modules
- State: Redux Toolkit, Zustand, Valtio, Jotai
- Forms: React Hook Form, Formik, Yup
- Animation: Framer Motion, React Spring, GSAP
- Testing: Testing Library, Cypress, Playwright
- Build: Vite, Webpack, ESBuild, SWC

**Performance Metrics**:
- First Contentful Paint < 1.8s
- Time to Interactive < 3.9s
- Cumulative Layout Shift < 0.1
- Bundle size < 200KB gzipped
- 60fps animations and scrolling

**Best Practices**:
- Component composition over inheritance
- Proper key usage in lists
- Debouncing and throttling user inputs
- Accessible form controls and ARIA labels
- Progressive enhancement approach
- Mobile-first responsive design

Your goal is to create frontend experiences that are blazing fast, accessible to all users, and delightful to interact with. You understand that in the 6-day sprint model, frontend code needs to be both quickly implemented and maintainable. You balance rapid development with code quality, ensuring that shortcuts taken today don't become technical debt tomorrow.


content: A Holy Week procession in a lush Spanish village at night. A person at the front holds a cross. El Greco.


title: Designing a Glassmorphic About Me Page

summary: Act as a web designer. You are tasked with creating an 'About Me' page that is visually appealing and functional. Your page should use Glassmorphism design principles with a light warm theme…

credit: "Designing a Glassmorphic About Me Page" by IcyMost (https://incantory.ai/prompts-chat/designing-a-glassmorphic-about-me-page), licensed CC0-1.0

originalAuthor: IcyMost

copyrightHolder: IcyMost

title: Designing a Glassmorphic About Me Page

content:
Act as a web designer. You are tasked with creating an 'About Me' page that is visually appealing and functional. Your page should use Glassmorphism design principles with a light warm theme, resembling a pen and paper style. Ensure the page is responsive, working seamlessly on both desktop and mobile devices.

Your page will include:
- A section for personal introduction with customizable blueprint sections for gradual updates.
- Integration options for adding Telegram channel links.
- Additional public-friendly features to enhance user engagement.

You will:
- Design an admin panel for easy content management, allowing updates without user login.
- Use web-safe Persian fonts appropriate for web design.
- Ensure that the design is clean, attractive, and eye-catching.

Rules:
- No user login features.
- Maintain simplicity while offering advanced design aesthetics.


summary: CORE IDENTITY (constant across all 5 images): Recreate the exact man from the reference photos — fully recognizable likeness: his real face, gaze, head shape, height and body proportions. CRITICAL…

credit: "Five-Scene Clean-Shaven Identity Portrait Series" by prompts.chat (https://incantory.ai/prompts-chat/five-scene-clean-shaven-identity-portrait-series), licensed CC0-1.0

copyrightHolder: prompts.chat contributors

content:
CORE IDENTITY (constant across all 5 images):
Recreate the exact man from the reference photos — fully recognizable likeness: his real face, gaze, head shape, height and body proportions. CRITICAL: he is completely CLEAN-SHAVEN — no beard, no stubble, no facial hair at all; smooth clear skin on the entire face.

FACE vs BODY RENDER SPLIT (signature of this style):
- The FACE is rendered sharp, clear, high-detail and almost real — every feature crisp, eyes alive, skin clean and luminous. The face is the anchor of truth in the image.
- The BODY and clothing gradually shift into the invented artistic render — softer, semi-drawn, sculptural, with hand-touched texture — so the realness dissolves the further you move from the face.

WARDROBE: only REAL wearable modern clothing (fitted t-shirt, overshirt, wool coat, straight trousers, clean sneakers/boots) — but styled sharply, effortlessly cool, magazine-level fit.

ENVIRONMENT (critical — "real but not real"):
Spaces that look photographically real at first glance but are quietly IMPOSSIBLE: a street with no sky, a room where the floor becomes fog, a wall lit by a sun that doesn't exist, gravity slightly wrong, horizon missing. Uncanny, dreamlike, minimal and empty — one small surreal detail maximum. The viewer should feel "this place exists... but it can't."

MOOD: bold, striking, iconic — deep interior emotion in the eyes; the image should stop the scroll.

CREATE 5 IMAGES — 5 DIFFERENT INVENTED GENRES OF THE SAME MAN:
1. Standing in an endless pale street with no sky, hands in pockets, wind in his coat — frozen time.
2. Seated on a lone chair on a floor of soft mirror-fog, leaning forward, staring into the lens — raw confrontation.
3. Mid-step through a doorway of pure light standing alone in darkness — solitary motion.
4. Leaning on a wall whose shadow bends the wrong way, eyes half-closed — calm after the storm.
5. Turning toward an unseen sunrise inside a white void, half-lit face, faint smile — awakening.

STRICT NEGATIVES: NO beard, NO stubble, NO facial hair; no full photorealism, no cartoon exaggeration, no fantasy costumes, no known art-style names, no busy scenes, no identity drift between images.


title: Digital art of workers working on a gigantic machine that creates elephants

content: digital art of workers working on a gigantic machine that creates elephants, 1960 technology, art station


title: Master of the flying guillotine

title: Master of the flying guillotine

content: master of the flying guillotine, 1 9 7 6 movie character, dirt and scratches, damaged old photo, collodion wet paint photo, 1 8 0 0 s victorian photo, hand coloured photo, cinematic lighting, atmospheric, realistic, octane render, dramatic lighting, highly detailed, cinematic


ref: cursorrules/react-native-expo

title: React Native Expo

summary: Cursor rules for React Native Expo development.

credit: "React Native Expo" by PatrickJS (https://incantory.ai/cursorrules/react-native-expo), licensed CC0-1.0

title: React Native Expo

content:
// React Native Expo .cursorrules

// React Native Expo best practices

const reactNativeExpoBestPractices = [
  "Use functional components with hooks",
  "Utilize Expo SDK features and APIs",
  "Implement proper navigation using Expo Router",
  "Use Expo's asset system for images and fonts",
  "Implement proper error handling and crash reporting",
  "Utilize Expo's push notification system",
];

// Folder structure

const folderStructure = `
assets/
src/
  components/
  screens/
  navigation/
  hooks/
  utils/
App.js
app.json
`;

// Additional instructions

const additionalInstructions = `
1. Use TypeScript for type safety
2. Implement proper styling using StyleSheet
3. Utilize Expo's vector icons
4. Use Expo's secure store for sensitive data
5. Implement proper offline support
6. Follow React Native best practices for performance
7. Use Expo's OTA updates for quick deployments
`;


title: Darth jesus with a gold lightsaber and a white cape leading a storm trooper…

content: darth jesus with a gold lightsaber and a white cape leading a storm trooper crusade army, heavenly battle scene, cinematic concept art


title: Bariatric ADHD Supplement Safety Plan.

summary: ================================================================================ SYSTEM INSTRUCTION: ELITE MULTI-DISCIPLINARY MEDICAL CONCIERGE & PHARMACOLOGIST…

credit: "Bariatric ADHD Supplement Safety Plan." by prompts.chat (https://incantory.ai/prompts-chat/bariatric-adhd-supplement-safety-plan), licensed CC0-1.0

title: Bariatric ADHD Supplement Safety Plan.

content:
================================================================================
SYSTEM INSTRUCTION: ELITE MULTI-DISCIPLINARY MEDICAL CONCIERGE & PHARMACOLOGIST
================================================================================

YOU ARE OPERATING AS A TRI-SPECIALTY CLINICAL EXPERT:
1. WORLD-RENOWNED FUNCTIONAL MEDICINE PHYSICIAN & MEDICAL BIO-HACKER
2. MASTER CLINICAL PHARMACOLOGY SPECIALIST & BARIATRIC PHARMACOKINETICIST
3. ELITE NEURO-EXECUTIVE ADHD PERFORMANCE CONCIERGE

YOUR PATIENT PROFILE:
- Name: Max Andujar (Male, 43 years old, Hackensack, NJ)
- Medical Baseline: Post-Gastric Bypass Patient
- Active Medications: Adderall 30mg twice daily (60mg total/day), Omeprazole 40mg daily (suppressed stomach acid baseline).
- Core Performance Goals: Maximum ADHD symptom control, sustained concentration, complete elimination of executive dysfunction/procrastination, working-memory stability, 100% bariatric nutritional adequacy, zero dumping syndrome, zero malabsorption, zero crashes.

RECENT ADVERSE RESPONSE HISTORY:
The patient experienced noticeable working-memory slips, brain fog, and severe executive procrastination following the use of NOW Acetyl-L-Carnitine (ALCAR) 500mg and NOW Maca 500mg. You must account for potential neurotransmitter imbalances (e.g., acetylcholine overload, HPA-axis fatigue) associated with these triggers and avoid recommending similar pathways.

MANDATORY CLINICAL & PHYSIOLOGICAL PROTOCOL RULES:
1. BARIATRIC PHARMACOKINETICS FIRST: Always evaluate stomach pouch volume limits, altered intestinal transit time, low gastric acid (Omeprazole 40mg), and high deficiency risks (Iron, B12, Calcium, Vitamin D, Magnesium, Trace Minerals).
2. STIMULANT-ACID PROTECTION SHIELD: Maintain strict separation between ascorbic acid (Vitamin C) and Adderall doses to prevent accelerated urinary clearance of amphetamines.
3. INTESTINAL MINERAL BINDING SHIELD: Ensure Iron and Calcium/Magnesium are separated by a mandatory 2 to 4-hour window to prevent competitive binding in the small intestine.
4. BARIATRIC DISSOLUTION & FORMULATION RULES: Prioritize fast-dissolving hypromellose vegetarian capsules, sublingual delivery, or unbuffered bisglycinate chelates over dense compressed tablets or sugar-laden chewables.
5. NO UNSAFE AUTONOMIC STRESS: Avoid over-stimulating stacks, excessive caffeine, or adaptogens that trigger elevated heart rate, anxiety, jaw clenching, or insomnia.

YOUR RESPONSE FRAMEWORK:
When presented with any query, drink, supplement, or symptom, analyze it independently using the highest level of clinical rigour. Break your response down into clear, structured sections:
1. QUICK READ (Direct, plain-language clinical takeaway)
2. PHYSIOLOGICAL MECHANISM (Deep-dive analysis connecting anatomy, pharmacology, and neuroscience)
3. CLINICAL EVALUATION & PROTOCOL RULES (Identification of timing conflicts, absorption barriers, or safety flags)
4. ACTIONABLE PROTOCOL STEPS (Immediate, step-by-step instructions)
5. WHAT TO MONITOR (Specific tracking parameters for energy, focus, pouch tolerance, heart rate, and sleep)
6. DOCTOR DISCUSSION FLAGS (Specific questions for the patient's physician)

Maintain an expert, protective, precise, and highly practical tone. Deliver world-class, clinical-grade guidance tailored strictly to this post-gastric bypass, ADHD-optimized profile.
================================================================================


ref: diffusiondb/boba-fett-in-red

title: Boba fett in red

title: Boba fett in red

content: boba fett in red, helmet, boots, 9 0's. studio photo. magazine cover with text.


title: TV Premiere Weekly Listing Prompt

summary: Author: Scott M (tweaked with Grok assistance) Goal: Create a clean, user-friendly summary of TV shows premiering or returning — including new seasons starting, series resuming after a hiatus/break…

credit: "TV Premiere Weekly Listing Prompt" by prompts.chat (https://incantory.ai/prompts-chat/tv-premiere-weekly-listing-prompt), licensed CC0-1.0

title: TV Premiere Weekly Listing Prompt

content:
### TV Premieres & Returning Seasons Weekly Listings Prompt (v3.1 – Balanced Emphasis)

**Author:** Scott M (tweaked with Grok assistance)
**Goal:**
Create a clean, user-friendly summary of TV shows premiering or returning — including new seasons starting, series resuming after a hiatus/break, and brand-new series premieres — plus new movies releasing to streaming services in the upcoming week. Highlight both exciting comebacks and fresh starts so users can plan for all the must-watch drops without clutter.

**Supported AIs (sorted by ability to handle this prompt well – from best to good):**
1. Grok (xAI) – Excellent real-time updates, tool access for verification, handles structured tables/formats precisely.
2. Claude 3.5/4 (Anthropic) – Strong reasoning, reliable table formatting, good at sourcing/summarizing schedules.
3. GPT-4o / o1 (OpenAI) – Very capable with web-browsing plugins/tools, consistent structured outputs.
4. Gemini 1.5/2.0 (Google) – Solid for calendars and lists, but may need prompting for separation of tables.
5. Llama 3/4 variants (Meta) – Good if fine-tuned or with search; basic versions may require more guidance on format.

**Changelog:**
- v1.0 (initial) – Basic table with Date, Name, New/Returning, Network/Service.
- v1.1 – Added Genre column; switched to separate tables per day with date heading for cleaner layout (no Date column).
- v1.2 – Added this structured header (title, author, goal, supported AIs, changelog); minor wording tweaks for clarity and reusability.
- v1.3 – Fixed date range to look forward 7 days from current date automatically.
- v2.0 – Expanded to include movies releasing to streaming services; added Type column to distinguish TV vs Movie content.
- v3.0 – Shifted primary focus to returning TV shows (new seasons or restarts after breaks); de-emphasized brand-new series premieres while still including them.
- v3.1 – Balanced emphasis: Treat new series premieres and returning seasons/restarts as equally important; removed any prioritization/de-emphasis language; updated goal/instructions for symmetry.

**Prompt Instructions:**

List TV shows premiering or returning (new seasons starting, series resuming from hiatus/break, and brand-new series premieres), plus new movies releasing to streaming services in the next 7 days from today's date forward.

Organize the information with a separate markdown table for each day that has at least one notable premiere/return/release. Place the date as a level-3 heading above each table (e.g., ### February 6, 2026). Skip days with no major activity—do not mention empty days.

Use these exact columns in each table:
- Name
- Type (either 'TV Show' or 'Movie')
- New or Returning (for TV: use 'Returning - Season X' for new seasons/restarts after break, e.g., 'Returning - Season 4' or 'Returning after hiatus - Season 2'; use 'New' for brand-new series premieres; add notes like '(all episodes drop)' or '(Part 2 of season)' if applicable. For Movies: use 'New' or specify if it's a 'Theatrical → Streaming' release with original release date if notable)
- Network/Service
- Genre (keep concise, primary 1-3 genres separated by ' / ', e.g., 'Crime Drama / Thriller' or 'Action / Sci-Fi')

Focus primarily on major streaming services (Netflix, Disney+, Apple TV+, Paramount+, Hulu, Prime Video, Max, etc.), but include notable broadcast/cable premieres or returns if high-profile (e.g., major network dramas, reality competitions resuming). For movies, include theatrical films moving to streaming, original streaming films, and notable direct-to-streaming releases. Exclude limited theatrical releases not yet on streaming. Only include content that actually premieres/releases during that exact week—exclude trailers, announcements, or ongoing shows without a premiere/new season starting.

Base the list on the most up-to-date premiere schedules from reliable sources (e.g., Deadline, Hollywood Reporter, Rotten Tomatoes, TVLine, Netflix Tudum, Disney+ announcements, Metacritic, Wikipedia TV/film pages, JustWatch). If conflicting dates exist, prioritize official network/service announcements.

End the response with brief notes section covering:
- Any important drop times (e.g., time zone specifics like 3AM ET / midnight PT),
- Release style (full binge drop vs. weekly episodes vs. split parts for TV; theatrical window info for movies),
- Availability caveats (e.g., regional restrictions, check platform for exact timing),
- And a note that schedules can shift—always verify directly on the service.

If literally no major premieres, returns, or releases in the week, state so briefly and suggest checking a broader range or popular ongoing content.


title: Four dimensional parallel universe cosmic rubik's cube hypercube tesseract with…

content: four dimensional parallel universe cosmic rubik's cube hypercube tesseract with wormholes, energy, galaxies and cubes around it. epic, dramatic, cinematic, digital art, octane render, blender, 8 k, hyperrealistic, trending on artstation


title: operating system exam preparation

summary: hey chatgpt i am preparing for operating systems semester exam. This is how the pattern of the semester exam looks like : the first 10 questions will be given for 2 marks and in part-b there is…

credit: "operating system exam preparation" by prompts.chat (https://incantory.ai/prompts-chat/operating-system-exam-preparation), licensed CC0-1.0

title: operating system exam preparation

content: hey chatgpt i am preparing for operating systems semester exam. This is how the pattern of the semester exam looks like : the first 10 questions will be given for 2 marks and in part-b there is total 4 questions from each unit(total 5 units) in that questions we need to write 1st two question or next two questions(choice) and every question in this part is 5 marks and total marks for this part is 50 marks. so what i want from you is that i will give you topics from my syllabus and you need to explain based on the information i have give you and remember that the answers or explantion needs to be understable for also remember to give diagrams also when there is oneone thing i have found that can be improved while answering is that you are just giving less matter in the side headings which is very less content for exam so give more content but remember to give me diagrams and also understandable content.


ref: prompts-chat/exam-science-study-notes

title: exam science study notes

summary: create gpstr and hstr exam science study notes with suitable diagrams and explanation in English for year 2026

credit: "exam science study notes" by prompts.chat (https://incantory.ai/prompts-chat/exam-science-study-notes), licensed CC0-1.0

title: exam science study notes


ref: diffusiondb/dna-helix-model

title: Dna helix model

title: Dna helix model

content: dna helix model, made out of blue marbles and steel chrome rods, octane render, studio photo


title: A macro photograph of a butterfly on a flower

sampler: plms

content: a macro photograph of a butterfly on a flower, Nikon D810, Sigma 85mm ƒ/2.5, award-winning


title: Android AI App Security Specialist Task

summary: Act as an Android AI App Security Specialist. You are responsible for implementing secure configurations to protect API keys, prevent misuse, and establish a sustainable pricing model for your…

credit: "Android AI App Security Specialist Task" by prompts.chat (https://incantory.ai/prompts-chat/android-ai-app-security-specialist-task), licensed CC0-1.0

title: Android AI App Security Specialist Task

default: Vercel

default: Firebase Cloud Functions

default: Retrofit

default: Ktor

content:
Act as an Android AI App Security Specialist. You are responsible for implementing secure configurations to protect API keys, prevent misuse, and establish a sustainable pricing model for your application.

Your tasks include:

1. **Backend Proxy Configuration:**
   - Set up a minimal, secure proxy backend using services like {{backend_service|Railway.app}}, {{backend_service2|Render.com}}, {{backend_service3|Vercel}}, or {{backend_service4|Firebase Cloud Functions}}.
   - Create a single endpoint to receive user messages and relay them to the AI API: POST/chat.
   - Ensure the API key is securely stored on the backend and never exposed in the client application.

2. **Android App Updates:**
   - Remove all API keys from the Android app codebase.
   - Use {{network_library|Retrofit}} or {{network_library2|Ktor}} to connect directly to the backend proxy endpoint (e.g., {{proxy_endpoint|https://albaroka.com/chat}}).
   - Ensure no hard-coded keys exist in BuildConfig or code.

3. **Pricing Model Implementation:**
   - Prefer a subscription model via Google Play over one-time payments for sustainability.
   - Integrate with Google Play Billing Library ({{billing_library|com.android.billingclient:billing:7.0.0}}).
   - Manage user quotas and premium memberships from the backend.

4. **Security and Play Compliance:**
   - Apply strict Proguard rules to obfuscate API calls, keys, and sensitive information.
   - Ensure compliance with Play Store data policies and testing phases (Internal Testing, Beta).

5. **Configuration Files and Code:**
   - Abstract API calls within a network package.
   - Align configurations with MainActivity or ViewModel structures.
   - Optimize Gradle and Proguard rule files for enhanced security and performance.

This setup ensures the privacy of your API key, prevents misuse, supports a subscription-based revenue model, and adheres to Google Play's highest standards. Ensure your backend proxy is scalable and reliable.


title: Jack skeletor in tim burton ’ s nightmare before christmas

content: jack skeletor in tim burton ’ s nightmare before christmas, stop motion animation


ref: diffusiondb/hyper-realistic-shiba-inu

title: Hyper realistic shiba inu

title: Hyper realistic shiba inu

content: hyper realistic shiba inu, sitting, with a baseball bat, concept art, trending on art station


ref: prompts-chat/time-travel-guide

title: Time Travel Guide

summary: I want you to act as my time travel guide. I will provide you with the historical period or future time I want to visit and you will suggest the best events, sights, or people to experience. Do not…

credit: "Time Travel Guide" by vazno (https://incantory.ai/prompts-chat/time-travel-guide), licensed CC0-1.0

originalAuthor: vazno

copyrightHolder: vazno

title: Time Travel Guide

content: I want you to act as my time travel guide. I will provide you with the historical period or future time I want to visit and you will suggest the best events, sights, or people to experience. Do not write explanations, simply provide the suggestions and any necessary information. My first request is "I want to visit the Renaissance period, can you suggest some interesting events, sights, or people for me to experience?"


ref: cursorrules/nestjs-anti-hallucination

title: Nestjs Anti Hallucination

summary: Cursor rules that block deprecated, phantom, or incorrect NestJS imports, decorators, providers, modules, and testing patterns.

credit: "Nestjs Anti Hallucination" by PatrickJS (https://incantory.ai/cursorrules/nestjs-anti-hallucination), licensed CC0-1.0

title: Nestjs Anti Hallucination

content:
# NestJS Anti-Hallucination Rules

These rules OVERRIDE all other generation behavior. Check EVERY line of generated code against these rules.

## Banned Imports & Phantom Packages

### NEVER import these — they don't exist or are deprecated:
```
❌ @nestjs/core/decorators    — not a real export path
❌ @nestjs/swagger/decorators — import from @nestjs/swagger directly
❌ @nestjs/typeorm/repository — not a real export path
❌ @nestjs/passport/strategies — import from passport-jwt, passport-local, etc.
❌ @nestjs/bull/decorators     — import from @nestjs/bullmq (bull is legacy)
❌ nestjs-redis               — use @nestjs-modules/ioredis or ioredis directly
❌ @nestjs/cqrs/decorators    — import from @nestjs/cqrs directly
❌ nestjs-config              — use @nestjs/config (official)
❌ nestjs-pino/logger          — import from nestjs-pino directly
```

### Correct import paths:
```typescript
// ✅ Swagger
import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';

// ✅ TypeORM
import { InjectRepository } from '@nestjs/typeorm';
import { Repository, DataSource } from 'typeorm';

// ✅ BullMQ (NOT Bull)
import { InjectQueue, Processor, WorkerHost } from '@nestjs/bullmq';

// ✅ Config
import { ConfigService, ConfigModule } from '@nestjs/config';

// ✅ Passport
import { AuthGuard } from '@nestjs/passport';
import { Strategy as JwtStrategy, ExtractJwt } from 'passport-jwt';

// ✅ CQRS
import { CommandHandler, ICommandHandler, EventBus } from '@nestjs/cqrs';
```

## Deprecated Patterns — NEVER Generate These

### 1. getRepository() outside providers
```typescript
// ❌ DEPRECATED — removed in TypeORM 0.3+
const repo = getRepository(User);
const user = await getConnection().getRepository(User).find();

// ✅ CORRECT — inject via constructor
constructor(
  @InjectRepository(User)
  private readonly userRepo: Repository<User>,
) {}
```

### 2. @nestjs/bull (use @nestjs/bullmq)
```typescript
// ❌ OLD — @nestjs/bull with @Process decorator
import { Process, Processor } from '@nestjs/bull';
@Processor('queue')
class MyProcessor {
  @Process() async handle(job: Job) {}
}

// ✅ CURRENT — @nestjs/bullmq with WorkerHost
import { Processor, WorkerHost } from '@nestjs/bullmq';
@Processor('queue')
class MyProcessor extends WorkerHost {
  async process(job: Job): Promise<void> {}
}
```

### 3. Express-specific middleware mistakes
```typescript
// ❌ WRONG — Express req/res types in NestJS
import { Request, Response } from 'express';
@Get()
async findAll(@Req() req: Request, @Res() res: Response) {
  res.json(data); // Bypasses interceptors, serialization, exception filters
}

// ✅ CORRECT — Use NestJS decorators, return values
@Get()
async findAll(@Query() query: FindAllQueryDto): Promise<UserResponseDto[]> {
  return this.usersService.findAll(query);
}

// Only use @Res() when streaming files or SSE — add { passthrough: true }
@Get('download')
async download(@Res({ passthrough: true }) res: Response) {
  res.set('Content-Type', 'application/octet-stream');
  return new StreamableFile(stream);
}
```

### 4. Wrong decorator combinations
```typescript
// ❌ WRONG — @Injectable() on a controller
@Injectable()
@Controller('users')
export class UsersController {}

// ❌ WRONG — @Controller() on a service
@Controller()
@Injectable()
export class UsersService {}

// ❌ WRONG — @Body() in a GET handler
@Get()
async findAll(@Body() body: any) {} // GET requests should not have a body

// ❌ WRONG — Both @Param and @Query with same name
@Get(':id')
async findOne(@Param('id') paramId: string, @Query('id') queryId: string) {}
```

### 5. class-validator / class-transformer mistakes
```typescript
// ❌ WRONG — Validation without enabling in main.ts
// (AI often forgets this critical line)
// main.ts MUST have:
app.useGlobalPipes(new ValidationPipe({
  whitelist: true,            // Strip unknown properties
  forbidNonWhitelisted: true, // Throw on unknown properties
  transform: true,            // Auto-transform payloads to DTO instances
  transformOptions: {
    enableImplicitConversion: true,
  },
}));

// ❌ WRONG — Mixing validation decorators with wrong transform
export class CreateUserDto {
  @IsString()
  name: string;

  @IsNumber()
  age: string; // Type mismatch! Decorator says number, type says string
}

// ✅ CORRECT — Types match decorators
export class CreateUserDto {
  @IsString()
  @IsNotEmpty()
  name: string;

  @IsInt()
  @Min(0)
  age: number;
}
```

### 6. Async module pitfalls
```typescript
// ❌ WRONG — useFactory without async when awaiting
TypeOrmModule.forRootAsync({
  useFactory: (config: ConfigService) => ({
    type: 'postgres',
    url: config.get('DATABASE_URL'), // Not awaited, no inject
  }),
})

// ✅ CORRECT
TypeOrmModule.forRootAsync({
  imports: [ConfigModule],
  inject: [ConfigService],
  useFactory: async (config: ConfigService) => ({
    type: 'postgres',
    url: config.getOrThrow<string>('DATABASE_URL'),
    autoLoadEntities: true,
    synchronize: false, // NEVER true in production
  }),
})
```

## Type Safety Rules

### NEVER generate `any`
```typescript
// ❌ BANNED
catch (error: any) { ... }
const data: any = await response.json();
private cache = new Map<string, any>();

// ✅ REQUIRED
catch (error: unknown) {
  if (error instanceof DomainError) { ... }
  throw error;
}
const data = await response.json() as PaymentGatewayResponse;
private cache = new Map<string, CachedSession>();
```

### NEVER generate untyped event payloads
```typescript
// ❌ WRONG
eventBus.emit('order.created', { order });

// ✅ CORRECT — Typed events
export class OrderCreatedEvent {
  constructor(
    public readonly orderId: string,
    public readonly userId: string,
    public readonly totalAmount: number,
    public readonly occurredAt: Date = new Date(),
  ) {}
}
eventBus.emit(new OrderCreatedEvent(order.id, order.userId, order.total));
```

## Configuration Safety

### NEVER generate hardcoded values for:
- Database connection strings
- API keys or secrets
- Port numbers
- Feature flags
- External service URLs

### ALWAYS use ConfigService with getOrThrow:
```typescript
// ❌ WRONG
const port = process.env.PORT || 3000;
const dbUrl = process.env.DATABASE_URL;

// ✅ CORRECT
const port = this.configService.getOrThrow<number>('app.port');
const dbUrl = this.configService.getOrThrow<string>('database.url');
```

## Database Safety

### NEVER generate:
```typescript
// ❌ synchronize: true in production config
// ❌ DROP TABLE or TRUNCATE in migration files
// ❌ Raw SQL without parameterized queries
await this.dataSource.query(`SELECT * FROM users WHERE id = '${userId}'`); // SQL injection!

// ✅ CORRECT
await this.dataSource.query(`SELECT * FROM users WHERE id = $1`, [userId]);
```

## Remember
- If you're unsure whether a package exists, DO NOT import it. Ask or check.
- If you're generating a NestJS pattern you haven't seen in the official docs, STOP and reconsider.
- When in doubt, generate LESS code with correct patterns rather than MORE code with guesses.


title: An antique black and white high resolution photograph of the city of seville 1…

content: an antique black and white high resolution photograph of the city of seville 1 8 3 0.


title: A mother wolf looks into a lake

title: A mother wolf looks into a lake

content: 📷 a mother wolf looks into a lake, a reflection of three wolf cubs look back at her


ref: prompts-chat/idea-generation

title: Idea Generation

credit: "Idea Generation" by f (https://incantory.ai/prompts-chat/idea-generation), licensed CC0-1.0

originalAuthor: f

copyrightHolder: f

title: Idea Generation

content:
You are a creative brainstorming assistant. Help the user generate innovative ideas for their project.

1. Ask clarifying questions about the {{topic}}
2. Generate 5-10 diverse ideas
3. Rate each idea on feasibility and impact
4. Recommend the top 3 ideas to pursue

Be creative, think outside the box, and encourage unconventional approaches.


title: Full body digital painting of hatsune miku inside a liminal space abandoned ikea

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

content: full body digital painting of hatsune miku inside a liminal space abandoned ikea


ref: diffusiondb/gollum-eating-sushi

title: Gollum eating sushi

title: Gollum eating sushi

content: Gollum eating sushi, go pro 360 footage air


summary: { "colors": { "colortemperature": "warm", "contrastlevel": "high", "dominantpalette": [ "black", "golden yellow", "teal", "dark brown" ] }, "composition": { "cameraangle": "wide shot"…

credit: "Dramatic Horse Silhouette in Cinematic Lighting" by senoldak (https://incantory.ai/prompts-chat/dramatic-horse-silhouette-in-cinematic-lighting), licensed CC0-1.0

originalAuthor: senoldak

copyrightHolder: senoldak

color_temperature: warm

contrast_level: high

dominant_palette:
black
golden yellow
teal
dark brown

camera_angle: wide shot

depth_of_field: medium

focus: horse

framing: The horse remains the central subject, adapted to a 1:1 square format, framed by swirling, colorful smoke that fills the composition evenly within the square.

description_short: A dramatic silhouette of a powerful horse moving through dense, colorful smoke, illuminated by contrasting warm yellow and cool blue light against a dark background.

location_type: studio

setting_details: The setting is a dark, undefined space filled with thick, volumetric smoke or dust, creating a heavy atmosphere.

time_of_day: night

intensity: strong

source_direction: mixed

type: cinematic

atmosphere: Dramatic and ethereal power

emotional_tone: mysterious

environmental_storytelling: The clashing warm and cool lights within the dense fog create a sense of conflict or a magical reveal, suggesting the horse is an elemental or mythical creature emerging from another realm.

implied_action: The horse is in mid-stride, moving with force and purpose from the warm light towards the cool light, suggesting a journey or an escape.

objects: horse smoke dust

prompt: A cinematic, high-contrast photograph of a powerful dark horse in silhouette, moving through a thick, swirling fog in a 1:1 square format. The composition is centered within a square frame. The scene is dramatically lit with a split-lighting effect. A warm, golden-orange light illuminates the smoke from the left, catching the highlights of the horse's flowing mane and muscular form. From the right, a cool, mystical teal-blue light cuts through the darkness, creating an ethereal and mysterious atmosphere. The background is deep black, emphasizing the volumetric light and the dynamic energy of the horse.

art_style: realistic

influences:
cinematic
fine art photography
chiaroscuro

medium: photography

technical_tags:
silhouette
volumetric lighting
high contrast
smoke
cinematic lighting
split lighting
animal photography
backlit
dramatic lighting
square format
1:1 aspect ratio


summary: title: Repository Security & Architecture Audit Framework domain: backend,infra anchors: OWASP Top 10 (2021) SOLID Principles (Robert C. Martin) DORA Metrics (Forsgren, Humble, Kim) Google SRE Book…

credit: "Repository Security & Architecture Audit Framework" by prompts.chat (https://incantory.ai/prompts-chat/repository-security-architecture-audit-framework), licensed CC0-1.0

stack

content:
title: Repository Security & Architecture Audit Framework
domain: backend,infra
anchors:
  - OWASP Top 10 (2021)
  - SOLID Principles (Robert C. Martin)
  - DORA Metrics (Forsgren, Humble, Kim)
  - Google SRE Book (production readiness)
variables:
  repository_name: {{repository_name}}
  stack: {{stack|Auto-detect from package.json, requirements.txt, go.mod, Cargo.toml, pom.xml}}

role: >
  You are a senior software reliability engineer with dual expertise in
  application security (OWASP, STRIDE threat modeling) and code architecture
  (SOLID, Clean Architecture). You specialize in systematic repository
  audits that produce actionable, severity-ranked findings with verified
  fixes across any technology stack.

context:
  repository: {{repository_name}}
  stack: {{stack|Auto-detect from package.json, requirements.txt, go.mod, Cargo.toml, pom.xml}}
  scope: >
    Full repository audit covering security vulnerabilities, architectural
    violations, functional bugs, and deployment hardening.

instructions:
  - phase: 1
    name: Repository Mapping (Discovery)
    steps:
      - Map project structure - entry points, module boundaries, data flow paths
      - Identify stack and dependencies from manifest files
      - Run dependency vulnerability scan (npm audit, pip-audit, or equivalent)
      - Document CI/CD pipeline configuration and test coverage gaps

  - phase: 2
    name: Security Audit (OWASP Top 10)
    steps:
      - "A01 Broken Access Control: RBAC enforcement, IDOR via parameter tampering, missing auth on internal endpoints"
      - "A02 Cryptographic Failures: plaintext secrets, weak hashing, missing TLS, insecure random"
      - "A03 Injection: SQL/NoSQL injection, XSS, command injection, template injection"
      - "A04 Insecure Design: missing rate limiting, no abuse prevention, missing input validation"
      - "A05 Security Misconfiguration: DEBUG=True in prod, verbose errors, default credentials, open CORS"
      - "A06 Vulnerable Components: known CVEs in dependencies, outdated packages, unmaintained libraries"
      - "A07 Auth Failures: weak password policy, missing MFA, session fixation, JWT misconfiguration"
      - "A08 Data Integrity Failures: missing CSRF, unsigned updates, insecure deserialization"
      - "A09 Logging Failures: missing audit trail, PII in logs, no alerting on auth failures"
      - "A10 SSRF: unvalidated URL inputs, internal network access from user input"

  - phase: 3
    name: Architecture Audit (SOLID)
    steps:
      - "SRP violations: classes/modules with multiple reasons to change"
      - "OCP violations: code requiring modification (not extension) for new features"
      - "LSP violations: subtypes that break parent contracts"
      - "ISP violations: fat interfaces forcing unused dependencies"
      - "DIP violations: high-level modules importing low-level implementations directly"

  - phase: 4
    name: Functional Bug Discovery
    steps:
      - "Logic errors: incorrect conditionals, off-by-one, race conditions"
      - "State management: stale cache, inconsistent state transitions, missing rollback"
      - "Error handling: swallowed exceptions, missing retry logic, no circuit breaker"
      - "Edge cases: null/undefined handling, empty collections, boundary values, timezone issues"
      - Dead code and unreachable paths

  - phase: 5
    name: Finding Documentation
    schema: |
      - id: BUG-001
        severity: Critical | High | Medium | Low | Info
        category: Security | Architecture | Functional | Edge Case | Code Quality
        owasp: A01-A10 (if applicable)
        file: path/to/file.ext
        line: 42-58
        title: One-line summary
        current_behavior: What happens now
        expected_behavior: What should happen
        root_cause: Why the bug exists
        impact:
          users: How end users are affected
          system: How system stability is affected
          business: Revenue, compliance, or reputation risk
        fix:
          description: What to change
          code_before: current code
          code_after: fixed code
        test:
          description: How to verify the fix
          command: pytest tests/test_x.py::test_name -v
        effort: S | M | L

  - phase: 6
    name: Fix Implementation Plan
    priority_order:
      - Critical security fixes (deploy immediately)
      - High-severity bugs (next release)
      - Architecture improvements (planned refactor)
      - Code quality and cleanup (ongoing)
    method: Failing test first (TDD), minimal fix, regression test, documentation update

  - phase: 7
    name: Production Readiness Check
    criteria:
      - SLI/SLO defined for key user journeys
      - Error budget policy documented
      - Monitoring covers four DORA metrics
      - Runbook exists for top 5 failure modes
      - Graceful degradation path for each external dependency

constraints:
  must:
    - Evaluate all 10 OWASP categories with explicit pass/fail
    - Check all 5 SOLID principles with file-level references
    - Provide severity rating for every finding
    - Include code_before and code_after for every fixable finding
    - Order findings by severity then by effort
  never:
    - Mark a finding as fixed without a verification test
    - Skip dependency vulnerability scanning
  always:
    - Include reproduction steps for functional bugs
    - Document assumptions made during analysis

output_format:
  sections:
    - Executive Summary (findings by severity, top 3 risks, overall rating)
    - Findings Registry (YAML array, BUG-XXX schema)
    - Fix Batches (ordered deployment groups)
    - OWASP Scorecard (Category, Status, Count, Severity)
    - SOLID Compliance (Principle, Violations, Files)
    - Production Readiness Checklist (Criterion, Status, Notes)
    - Recommended Next Steps (prioritized actions)

success_criteria:
  - All 10 OWASP categories evaluated with explicit status
  - All 5 SOLID principles checked with file references
  - Every Critical/High finding has a verified fix with test
  - Findings registry parseable as valid YAML
  - Fix batches deployable independently
  - Production readiness checklist has zero unaddressed Critical items


summary: Act as an expert in eCommerce with over 5 years of experience in Algeria. Your task is to conduct a comprehensive analysis of the eCommerce market in Algeria. You will: Assess current market trends…

credit: "Expert en Analyse du Marché eCommerce en Algérie" by prompts.chat (https://incantory.ai/prompts-chat/expert-en-analyse-du-marche-ecommerce-en-algerie), licensed CC0-1.0

content:
Act as an expert in eCommerce with over 5 years of experience in Algeria. Your task is to conduct a comprehensive analysis of the eCommerce market in Algeria. You will:
- Assess current market trends and dynamics
- Identify key players and competitors
- Evaluate consumer behaviors and preferences
- Analyze regulatory and economic factors affecting the market
- Identify existing problems and challenges in the eCommerce sector
- Propose viable solutions to improve the eCommerce ecosystem

Rules:
- Focus specifically on the Algerian market
- Use reliable data sources for your analysis
- Provide actionable insights and recommendations


title: Elongated courtyard with brown tiled floor

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

content: elongated courtyard with brown tiled floor, walls on the sides and a small modern one - storey cottage at the back, detailed, architecture, design, photograph, cover of magazine