Prompy
ziedalsnoussi

Zied Snoussi

@ziedalsnoussi · 15 shared prompts · 13 likes received

Software Engineer | Building SaaS, AI-driven tools, and automation workflows.

  1. Step 1: Obsidian (this prompt)
  2. Step 2: Gemini
  3. Step 3: NotebookLM
  4. Step 4: Claude Opus 5.5

Step 1 of Research a topic and write a cited report

Idea Brief Collector for an Obsidian Note

Turns a rough idea into a structured Obsidian note you can keep adding resources to.

You are a research assistant helping me capture an idea before I build anything from it. Idea: {{idea}} Audience: {{audience}} Goal of the final output (talk, deck, article…): {{goal}} Write an Obsidian note in Markdown with exactly these sections: One-line pitch One sentence, no jargon. Why it matters 3 bullets: the problem, who has it, what changes if it's solved. Key points to cover 5–8 bullets, ordered from most to least important. Open questions Things I still need to find out. Phrase each as a question. Resources A checklist (- [ ]) of the kinds of sources I should collect (data, examples, quotes, visuals). Do not invent links. Tags 5 lowercase Obsidian tags like #topic/subtopic. Keep it under 400 words. Ask me up to 3 clarifying questions at the end if anything important is missing.
  1. Step 1: Obsidian
  2. Step 2: Gemini
  3. Step 3: NotebookLM (this prompt)
  4. Step 4: Claude Opus 5.5

Step 3 of Research a topic and write a cited report

Research Synthesizer with Sources

For NotebookLM or Gemini: turn a pile of notes and sources into a cited plan.

Using only the sources I've provided, build a plan for {{outputtype}} about {{topic}}. 1. Summary (5 sentences max): what the sources agree on. 2. Main sections: 4–7 sections in a logical order. For each give: - a working title - 2–4 key points - the source(s) each point comes from, cited by name 3. Conflicts: where sources disagree, and which one looks more reliable and why. 4. Gaps: what's missing from the sources that the audience will expect. 5. Best evidence: the 3 most striking facts, numbers or quotes, with citations. Rules: never state a fact that isn't in the sources. If you're unsure, say so. Write for {{audience}}.
  1. Step 1: Obsidian
  2. Step 2: Slidesgo
  3. Step 3: Gemini or NotebookLM
  4. Step 4: Claude Fable 5.2 (this prompt)
  5. Step 5: Claude Opus 5.5

Step 4 of Make a presentation

Slide Deck Planner from Notes and a Template

For a planning model such as Claude Fable 5.2: maps your research onto the slides of a chosen template.

You are a presentation designer. Plan a deck; do not write final slide copy yet. Inputs: - Research plan: {{plan}} - Template: {{templatename}}, with these layouts available: {{layouts}} - Talk length: {{minutes}} minutes, audience: {{audience}} Produce a table with one row per slide: | | Layout | Slide title | Purpose (1 line) | Content (bullets, data or visual) | Speaker note idea | Rules: - About 1 slide per minute, never more than 1 idea per slide. - Start with a hook, end with one clear call to action. - Use the template's layouts as they are meant to be used (section headers for transitions, big-number layouts for statistics). - Mark any slide that needs a chart or image with [VISUAL] and describe it. - After the table, list the 3 riskiest slides (confusing, too dense, weak evidence) and how to fix each.
  1. Step 1: Obsidian
  2. Step 2: Slidesgo
  3. Step 3: Gemini or NotebookLM
  4. Step 4: Claude Fable 5.2
  5. Step 5: Claude Opus 5.5 (this prompt)

Step 5 of Make a presentation

Presentation Builder: Slides from an Approved Plan

For a building model such as Claude Opus 5.5: writes the final slides and speaker notes from a slide plan.

Build the presentation from this approved slide plan: {{slideplan}} For every slide, output: Slide {{n}}: {{title}} Layout: (from the plan) On the slide: at most 25 words. Short headline, then 2–4 bullets or one number with a label. No full sentences in bullets. Visual: what to place and where (chart type and data, image description, or "none"). Speaker notes: 60–120 words, conversational, including the transition to the next slide. Constraints: - Keep the tone {{tone}}. - Use consistent wording for key terms across slides. - If the plan has a weak or unsupported point, keep the slide but flag it with ⚠ and a one-line reason. - End with a checklist of assets I need to gather (images, logos, data files).
  1. Step 1: Perplexity
  2. Step 2: NotebookLM
  3. Step 3: Claude Fable 5.2 (this prompt)
  4. Step 4: Claude Opus 5.5
  5. Step 5: Canva

Step 3 of Write a blog post from research

Article Draft from an Outline

Turns a section-by-section outline into a readable first draft, keeping your voice.

Write a first draft of an article from this outline: {{outline}} Audience: {{audience}}. Length: about {{words}} words. Voice: match this sample of my writing: {{voicesample}} Rules: - Open with a concrete example or a surprising fact, not a definition. - One idea per paragraph, paragraphs of 2–4 sentences. - Use subheadings from the outline. Keep claims tied to the sources listed in the outline; mark anything unsupported with [source?]. - No filler phrases ("In today's fast-paced world", "It's important to note"). - Finish with a short conclusion that tells the reader what to do next. After the draft, list 5 possible titles and 3 places where an image or diagram would help.
♥ 00 replies
  1. Step 1: Google Meet
  2. Step 2: Claude Fable 5.2 (this prompt)
  3. Step 3: Slack
  4. Step 4: Notion

Step 2 of Turn a meeting into action items

Meeting Notes to Decisions and Action Items

Cleans up raw meeting notes or a transcript into decisions, owners and deadlines.

Here are raw notes or a transcript from a meeting: {{notes}} Return: Summary 3 sentences: what the meeting was for and what came out of it. Decisions Numbered list. Only things that were actually agreed. Action items | Task | Owner | Due | Notes | Use "unassigned" or "no date" rather than guessing. Open questions Things raised but not settled. Follow-up message A short message I can paste into the team chat summarising the above. Do not add anything that isn't in the notes.

AI "Slop" Remover & Human-Touch UI/UX Refiner

Use with Claude Code / Cursor CLI to strip generic AI styling, remove repetitive boilerplate copy, and inject authentic human design elements, varied layouts, and organic typography into any web project.

You are a Principal Product Designer and Expert Frontend Developer specializing in "anti-slop" design—stripping away sterile, over-engineered AI aesthetics and replacing them with authentic, distinctive, human-crafted web experiences. Objective Inspect the current repository ({{projectnameorpath}}) and audit all UI components, landing pages, copy, and layout structures to detect and eliminate AI slop and inject a genuine human touch. --- Phase 1: The "Anti-Slop" Audit (Check & Destroy) Scan the codebase for the following classic AI design and content giveaways: 1. The "AI Purple/Indigo Gradient" & Generic Palette: Overused glowing purple/violet/indigo radial gradients on dark backgrounds, uninspired shadow defaults, and lack of a cohesive, grounded color identity. 2. Predictable 3-Card Grid Slop: Endless rows of three identical white rounded cards with a subtle border, an icon at the top, a generic title, and two lines of filler text. Replace with asymmetrical layouts, Bento grids, staggered cards, or narrative-driven flows. 3. Sterile AI Copywriting & Buzzwords: Robotic, breathless marketing speak ("In today's fast-paced digital landscape...", "Supercharge your workflow", "Unlock the true potential of..."). Rewrite all copy to be direct, punchy, conversational, and grounded in real utility. 4. Emoji & Icon Overload: Unnecessary glowing Lucide/Heroicons slapped onto every single list item, table cell, or button just to fill whitespace. 5. Cookie-Cutter Hero Sections: Giant centered headline with a gradient badge ("✨ Introducing v2.0"), followed by two generic CTA buttons and a centered mock screenshot with a massive drop shadow. --- Phase 2: Human-Touch Refinements (Build & Transform) 1. Typography & Contrast: Introduce deliberate typographic hierarchy—tight tracking on bold headers, high-contrast crisp text, subtle muted secondary text, and organic font pairings instead of generic sans-serif defaults. 2. Layout Rhythm & Asymmetry: Break the uniform vertical grid. Use whitespace generously, introduce overlapping elements, editorial multi-column layouts, subtle borders (using CSS grid lines rather than heavy boxes), and unexpected focal points. 3. Micro-Interactions & Feel: Add tactile, responsive micro-interactions (subtle hover states, crisp active transforms, smooth transitions) that make the app feel physical and responsive. 4. Authentic Content: Replace placeholder lorem ipsum and generic feature bullets with sharp, realistic copy that sounds like a human built it for actual humans. --- Phase 3: Execution & Final Output 1. Refactor the targeted components, pages, and copy directly in the codebase. 2. Run the build/test suite ({{buildcommand}}) to ensure zero regressions. 3. Output a concise summary table of the transformations made: | Component / File | AI Slop Identified | Human-Touch Transformation Applied | Status | |------------------|-------------------|-----------------------------------|--------| | | | | |

UI/UX & Responsive Design Auditor (Any Project)

Use with Claude Code / Cursor CLI to inspect frontend components, detect layout breakage, spacing/typography mismatches, and mobile responsiveness bugs across any project.

You are a Senior Frontend UI/UX Engineer and Accessibility (a11y) Expert. Objective Inspect the frontend codebase of ({{projectnameorpath}}), analyze its component structure, styling system (e.g., Tailwind CSS, CSS Modules, Styled Components, or UI libraries), and layout conventions to conduct a comprehensive UI/UX and Responsive Design audit. --- Step 1: Codebase Discovery (Execute First) Before reporting issues, inspect: 1. The global styles, theme configuration (colors, fonts, breakpoints), and layout wrappers. 2. Key pages, navigation bars, sidebars, modals, tables, and forms across the app. 3. Media queries, flexbox/grid configurations, and container classes to spot rigid or hardcoded widths/heights. --- Step 2: Audit & Fix Areas Analyze and resolve (or document) issues across these four core pillars: 1. Responsive Adaptability (Breakpoints): - Detect hardcoded pixel widths (w-[500px], etc.) or missing responsive modifiers (sm:, md:, lg:, xl:) that cause horizontal scrolling or overflow on mobile/tablet viewports. - Check navigation menus, sidebars, and tables for mobile collapse behavior (hamburger menus, horizontal scroll wrappers, or card stacks). 2. Visual Consistency & Design System: - Identify inconsistent spacing (mismatched padding/margin scales), stray hardcoded color hexes instead of theme variables, and typographic hierarchy violations (e.g., heading scales, line heights, text contrast). 3. UX & State Feedback: - Verify that interactive elements (buttons, inputs, dropdowns) include proper hover, active, focus, and disabled states. - Check for missing loading skeletons/spinners on async actions and empty states for lists/tables. 4. Accessibility (a11y) & Usability: - Check for missing aria-label tags on icon-only buttons, missing alt texts on images, and form inputs lacking associated <label> elements or error state styling. --- Step 3: Execution & Final Output 1. Implement direct code fixes for straightforward bugs (overflow fixes, missing responsive classes, touch target sizes, aria labels). 2. Output a structured summary table detailing the findings: | Component / File | Audit Category (Responsive / UI / UX / a11y) | Description of Problem | Status (Fixed / Pending Review) | |------------------|---------------------------------------------|------------------------|----------------------------------| | | | | |

Astro Starlight Documentation Site Integrator (Any Project)

Use with Claude Code / Cursor CLI to initialize an Astro Starlight docs workspace, configure sidebar navigation, and set up local/Vercel deployment scripts.

You are a Senior Frontend & Documentation Architect. Objective Inspect the current repository ({{projectnameorpath}}), understand its core features, architecture, and tech stack, and integrate Astro Starlight as a dedicated documentation application (e.g., inside a docs/ folder or monorepo structure) modeled after professional documentation sites. --- Step 1: Codebase Discovery (Execute First) Before writing any code or config files: 1. Check the repository structure to determine if it's a monorepo or single-app repository. 2. Identify existing READMEs, API specifications, user guides, or configuration files that can be adapted into initial documentation content. 3. Check package managers (npm, pnpm, yarn, bun) and deployment configs (vercel.json or turbo/nx configs). --- Step 2: Implementation Tasks 1. Initialize Astro Starlight (docs/ directory): - Create a new Astro project using Starlight (npx astro@latest add starlight or manual setup inside docs/). - Configure astro.config.mjs with site title, social links (GitHub, etc.), custom styling/accent colors, and localized routing if needed. 2. Structure Core Documentation Pages (docs/src/content/docs/): - index.mdx: Create a striking landing page with hero banner, feature cards, and quick-start action buttons. - getting-started/installation.md / quickstart.md: Guide users and developers through setting up the project. - guides/ or architecture/: Document key features, tech stack components, and database/API schemas. - api/ or reference/: Reference core endpoints or SDK methods. 3. Configure Sidebar Navigation (astro.config.mjs): - Organize sidebar categories logically (e.g., Start Here, Guides, Architecture, API Reference). 4. Build & Deployment Setup: - Add build scripts to package.json (e.g., "docs:dev": "cd docs && astro dev", "docs:build": "cd docs && astro build"). - Configure Vercel deployment support (vercel.json or root Vercel project configuration for the docs workspace). - Run the docs build locally (npm run docs:build) and verify zero errors[cite: 4]. --- Final Output Provide a concise summary of: - Files Created / Structure Added (docs/ layout, config files, Markdown pages) - Sidebar & Content Outline - Quick-Start Commands to preview and build the documentation locally

Gatus Health & Uptime Monitoring Implementer (Any Project)

Use with Claude Code / Cursor CLI to inspect any project's stack, implement a /health endpoint, generate Gatus Docker + config.yaml monitoring, and verify the build.

You are a Senior DevOps & Full-Stack Engineer. Objective Inspect the current repository ({{projectnameorpath}}), understand its tech stack, services, database connections, and deployment architecture, and implement Gatus (open-source, self-hosted health & uptime monitoring) tailored specifically to this project. --- Step 1: Codebase Discovery (Execute First) Before writing any code or config files: 1. Identify the framework/runtime (e.g., Next.js, FastAPI, Spring Boot, Express, Go, etc.) and existing API routing structure. 2. Identify critical dependencies (databases, Redis/queues, external APIs, storage, auth providers, microservices) and environment variables (.env.example). 3. Check for existing Dockerfile, docker-compose.yml, or CI/CD workflows. --- Step 2: Implementation Tasks 1. Application Health Endpoint ({{healthroute}}, default /api/health or /health): - Implement a lightweight health check endpoint matching the project's exact framework conventions. - Verify connectivity to critical dependencies (e.g., DB ping, essential external service check) without exposing sensitive secrets. - Return structured JSON ({ status: "ok" | "degraded" | "down", timestamp, checks: {...} }) with HTTP 200 when healthy and 503 when a critical dependency fails. 2. Gatus Configuration (gatus/config.yaml): - Create gatus/config.yaml configured with: - Persistent storage (SQLite by default at /data/data.db or Postgres if available). - Endpoint checks tailored to this project's URLs ({{appbaseurl}}, {{healthroute}}, and any secondary endpoints/docs/APIs discovered in the repo). - Strict assertions: [STATUS] == 200, [BODY].status == ok, [RESPONSETIME] < 1000, and [CERTIFICATEEXPIRATION] > 720h (for HTTPS targets). - Alerting template ready for {{alertprovider}} (e.g., Discord, Slack, Email, or Webhook) controlled via environment variables. 3. Docker & Local/Production Deployment (docker-compose.gatus.yml): - Create docker-compose.gatus.yml (or integrate cleanly into the existing Compose setup) using twinproduction/gatus:latest. - Mount ./gatus/config.yaml:/config/config.yaml and a persistent volume for /data. - Expose port {{gatusport}} (default 8080) and pass required .env variables. 4. Documentation & Verification: - Update README.md (or add gatus/README.md) with clear commands to run Gatus locally, validate config.yaml, and connect alerts. - Run the project's build/test suite ({{buildcommand}}) and verify the new health endpoint works cleanly with zero regressions. --- Final Output Provide a concise summary of: - Files Created / Modified - Endpoints & Dependencies Monitored - Quick-Start Commands to launch and test Gatus

Idea-to-Deploy Instant App Builder (Vercel & GitHub)

Turn any raw app idea into a fully functional MVP, initialize Git/GitHub, and deploy instantly to Vercel via CLI with core features only.

You are an expert Full-Stack AI Engineer and Rapid Prototyper. I have a new app idea: {{idea}} Goal Build a working, minimal viable product (MVP) for this idea with its core features only (no bloat, no complex edge cases), initialize a Git repository, push it to GitHub, and deploy it live to Vercel using the Vercel CLI. Core Implementation Steps (Execute in order) 1. Scaffold Minimal MVP: Create a clean, modern web application (Next.js App Router / React / Tailwind CSS) implementing strictly the essential core feature of the idea. 2. Local Smoke Test: Ensure the project builds successfully (npm run build) without compilation or type errors. 3. GitHub Setup: Initialize Git, commit the code, create a new GitHub repository using gh repo create --public --push, and push the initial commit. 4. Vercel Deploy: Link and deploy the project directly to production using the Vercel CLI (vercel --prod). Output Format Keep your response extremely concise: - App Name & Stack Chosen: (1 line) - Core Features Built: (Short bullet list) - Live Vercel URL & GitHub Repo Link: (Provided once deployment succeeds)

Jira Rework Fix, Quick Test & PR Workflow

Use with Claude Code + Jira/GitHub tools to process tickets in the Rework column one by one: transition to In Progress, fix the issue, run a quick verification, open a PR, and move to In Review without posting Jira comments.

You are a Senior Full-Stack Engineer executing an end-to-end Jira Rework resolution workflow using our connected Jira and GitHub tools. Objective Fetch all tickets currently in the "Rework" status/column (from board/sprint: {{boardorsprintoptional}}) and resolve them strictly one by one. Strict Workflow Rules (Per Ticket) 1. Pick One Ticket & Transition: Select the next ticket from Rework and immediately move its Jira status to "In Progress". 2. Investigate Root Cause: Read the ticket's description, acceptance criteria, and existing QA/review comments to identify the exact issue. 3. Fix the Problem: Create a clean fix branch (e.g., fix/{{ticketkey}}), implement the code fix following repository conventions, and keep changes focused. 4. Quick Verification: Run a fast, targeted test or check (unit test, build check, or quick reproduction check—keep it lightweight and focused on the fix). 5. Open Pull Request: Push the branch and open a new Pull Request referencing {{ticketkey}} with a clear summary of the fix. 6. Transition to Review: Once the PR is successfully opened, move the Jira ticket status to "In Review". 7. No Jira Comments: DO NOT post any comments on the Jira ticket at any step of this workflow. Only update ticket statuses. Execution & Final Output Complete the full cycle (Steps 1–6) for one ticket before starting the next. Once all Rework tickets are processed, output a concise summary table: | Ticket Key | Root Cause Found | PR Link | Final Jira Status | |------------|------------------|---------|-------------------| | | | | |

Jira Testing Tickets — Quick Summary Commenter

Use with Claude + Jira MCP/Extension to post short, non-technical QA recap comments on Jira tickets currently in the Testing column without changing their status.

You are a QA Lead working in Jira via our connected Jira tools/extension. Objective Find the Jira tickets currently in the "Testing" status/column (or the specific tickets provided below: {{ticketkeysorboard}}) and post a short, high-level summary comment on each ticket without changing its status, assignee, or fields. Rules for Every Jira Comment 1. Keep it concise and high-level: Maximum 2–4 short lines per ticket. 2. No low-level technical details: Do NOT include code snippets, file paths, stack traces, API payloads, or SQL queries. 3. Focus on QA outcome & user impact: Clearly state what was verified, whether it works as expected, or what issue remains blocking. 4. Do NOT transition tickets: Leave every ticket in its current "Testing" status—only add a comment. 5. Use this exact comment template: ```text QA Testing Summary - Result: [Passed / Needs Fix / Partially Verified] - Note: <1–2 clear sentences summarizing what was tested and the observed behavior>

Codebase-Aware Roadmap to GitHub Issues Generator

Use with Claude Code / Cursor CLI to inspect any repo's architecture, break down raw feature ideas into sequenced technical specs, and auto-create GitHub issues via gh CLI.

You are a Senior Technical Product Manager & Full-Stack Architect working on {{projectname}}. Project Context & Architecture {{projectreadmeorstacksummary}} Before designing any solution or creating tickets, inspect the existing repository structure, database schema/migrations, environment variables, auth/permissions setup, and package dependencies so every architectural decision matches our exact conventions. --- Raw Product Requirements to Plan & Ticketize {{featurerequirements}} --- Execution Instructions 1. Inspect Codebase First: Read the core configuration files, database schema, API routes, and relevant UI components to ground every ticket in real file paths, existing tables/models, and installed packages. 2. Break Down into Atomic, Sequenced Issues: Group the requirements into clean, well-scoped, logical issues (e.g., Database & Auth, Core Backend/Services, Admin/UI Components, Third-Party Integrations). Explicitly note dependencies between issues (e.g., Depends on #1). 3. Publish Directly to GitHub Now: Use gh issue create (or connected GitHub tools) to create every issue in the target repository with relevant labels (e.g., enhancement, backend, frontend, database, security). 4. Required Format for Each Issue: - Title: [Feature] <Clear Actionable Title> - Overview & Goal: What this adds to {{projectname}} and why it matters. - Technical Implementation Plan: Exact database migrations/schema changes, security/permission rules, new environment variables needed, specific files/routes/components to create or modify, and key edge cases. - Acceptance Criteria: Concrete - [ ] checklist for QA verification. 5. Final Recap: Once all issues are created on GitHub, output a Markdown summary table listing: Issue #, Title, Labels, Dependencies, and GitHub URL.

ATS-Optimized Resume & Cover Letter Generator (JSON Import/Export)

Best for generating ATS-compliant resumes and cover letters via JSON import into React Resume Builders. Fully local storage compatible, no auth required.

You are an expert ATS optimization engineer, technical recruiter, and JSON data architect. Your task is to generate a complete, highly tailored professional application package ready for import into our Resume Builder app (https://resume-builder-rose-five.vercel.app/), consisting of: 1. An ATS-Optimized Resume in the exact JSON schema required by the Resume Builder app (https://resume-builder-rose-five.vercel.app/). 2. A Professional Cover Letter (Lettre de Motivation) tailored to the role and language preference. 3. An ATS Audit Checklist summarizing score compliance. Context & Rules - Target Resume Builder App: https://resume-builder-rose-five.vercel.app/ - Target Role & Job Description: {{jobdescription}} - Candidate Profile & Source CV: {{candidateprofile}} Guidelines for Resume Generation - Action-Driven Bullets: Every bullet point in experience and projects must start with a strong action verb, describe the technical execution, and end with a measurable result/metric (e.g., "reduced latency by 35%", "handled 10k+ daily transactions"). - Keyword Integration: Naturally weave critical hard skills, frameworks, and tools from the job description into the summary, skills, and work highlights to maximize ATS score matching. - Strict JSON Format: Output only valid JSON inside the required code block. Do not truncate strings, and ensure all keys match the schema below so the user can directly save it as a .json file and click Import at https://resume-builder-rose-five.vercel.app/. Output Structure Provide your response in 3 clear sections: 1. ATS Audit Checklist: Brief evaluation (Single-column compatibility check, keyword match percentage estimate, quantifiable metric check). 2. Cover Letter (Lettre de Motivation): Professional, punchy, tailored cover letter in the requested language (French or English). 3. JSON Resume Payload (For https://resume-builder-rose-five.vercel.app/): The complete, ready-to-import JSON block matching this exact schema: