Prompy

Explore

What the community is sharing right now.

ziedalsnoussi@ziedalsnoussi4d ago

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 | |------------------|-------------------|-----------------------------------|--------| | | | | |
ziedalsnoussi@ziedalsnoussi4d ago

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) | |------------------|---------------------------------------------|------------------------|----------------------------------| | | | | |
ziedalsnoussi@ziedalsnoussi4d ago

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
ziedalsnoussi@ziedalsnoussi4d ago

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
ziedalsnoussi@ziedalsnoussi4d ago

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)
ziedalsnoussi@ziedalsnoussi4d ago

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 | |------------|------------------|---------|-------------------| | | | | |
ziedalsnoussi@ziedalsnoussi4d ago

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.