Programming

For senior and mid-level engineers who pair with stuck juniors and reach for the fix — this diagnoses why the junior is actually stuck (six conceptual failure modes, from hypothesis-free searching to fear paralysis), picks the exact coaching move that matches the failure mode, and names the three senior-engineer instincts that feel helpful but quietly kill debugging fluency. Ends with a script for the first question you should ask in the next five minutes.

You've got a technical proposal — microservices migration, new data layer, service rewrite, provider switch — and you need to find where it breaks before your team does. Plays the sharpest skeptic in the room: stress-tests across five dimensions (migration reality, team capability gap, operational load, organizational fit, and the simpler alternative), surfaces which objections are real vs. defended, and helps you either close the holes or scope down to a first step that gets the value without the risk.

Most backup strategies stop at 'we have backups.' This prompt walks you through running the real drill: pick a failure scenario, attempt an actual restore into a non-production environment, record what it actually took, catalog what the runbook got wrong, and produce the recovery document that would have gotten you to safe faster. Not a tabletop exercise — a structured drill with timing, failure modes, and runbook entries that come from doing it for real.

Your cloud spend is up and to the right and your CFO is asking why. Paste a recent bill summary, an architecture sketch in plain English, and a few facts about scale and growth — and I'll run a structured cost audit. We separate the line items that are paying for real load from the ones that are paying for laziness, find the kill list (what to turn off this week), the right-size list (what to shrink without changing behavior), the architectural list (what to actually re-design), and the governance list (what to put in place so this doesn't recur in 9 months). Output is a one-page cost-cut plan with savings ranges, effort ranges, risk notes, and a sequenced rollout. Built for engineering leads, platform engineers, and the FinOps-curious — not for vendor reps trying to upsell you a reservation.

For small SaaS teams hit with a 200-question enterprise security questionnaire (SIG-Lite, CAIQ, custom buyer review) and no dedicated security hire. Walks you through truthful answers, the handful of controls worth tightening before you respond, the questions safe to push back on, the ones that need a one-line compensating-control framing, and the response document structure that gets you from 'pending' to 'approved with conditions.' Also flags the questions that signal you'll lose the deal regardless of what you write.

Define real Service Level Objectives for a service that doesn't have any yet — without copy-pasting 99.9% from a blog post. Describe what your service does, who its consumers are, and what failure actually looks like for them, and get back: a short list of SLIs (the things you'll measure) tied to user journeys, defensible SLO targets with the math behind each one, an error budget policy that says what you'll do when you burn through it, alerting tied to budget burn rate (not raw thresholds), and a rollout plan that gets you to enforced SLOs without breaking the team. Built for platform/infra engineers, SREs, and tech leads tired of vanity uptime numbers that don't track to user pain.

Tell me what feature you're shipping behind a flag and I'll generate a complete rollout playbook: cohort progression (1% → 5% → 25% → 100%), kill-switch criteria with named SLO breach thresholds, monitoring dashboard fields, the on-call runbook, the customer-comms template if it goes wrong, and a flag-cleanup ticket dated for two weeks after 100%. Built for engineers who have seen a 'small toggle' take down production at 3am.

Paste your API surface and a reason for deprecating it — get back a phased rollout plan that doesn't blow up your integrators. Covers the announcement, parallel-support window, telemetry to track who's still on the old version, the response-shape escalation ladder (warning headers → 410 with migration link → kill), the migration guide your customers actually read, and the rollback button if it goes sideways. For platform teams, API product owners, and anyone who has ever broken a customer's prod by removing a field. Treats deprecation as a product launch, not a developer hand-grenade.

Paste a description of your service — what it does, what it depends on, what alerts already fire — and get back a structured on-call runbook the next engineer can actually use at 3 AM. Covers the first-five-minutes checklist, alert-by-alert response steps, escalation tree with owners, common failure modes with verified fixes, and what to never touch without backup. Designed for SREs, platform teams, and anyone tired of inheriting a service with no documentation. Treats the runbook as a living artifact, not a one-time wiki page.

Paste a database migration before you merge it and get a pre-flight safety review — lock impact, backfill risk, rollback path, and deploy ordering. Catches the migrations that look harmless in review but take production down at 11pm because someone added NOT NULL to a 50M-row table or built an index without CONCURRENTLY. Postgres-first, MySQL-aware, schema-engine agnostic. For tech leads, on-call engineers, and anyone whose Slack lights up the moment migrations land.

Decide whether to upgrade a major dependency now, defer, or skip the version entirely. Inputs the package, current version, target version, and your codebase's exposure surface — outputs a Go/Defer/Skip verdict with the breaking-change blast radius, the migration path you'll actually have to walk, the lurking peer-dep cascade you didn't see, and the rollback strategy if the upgrade lands ugly. Built for engineers staring at 'Next.js 15 is out' or 'React 19 stable' or 'Node 22 LTS' and trying to figure out if it's worth the week.

Decide what to test, what NOT to test, and where to put each test in the pyramid — for a specific codebase, not a generic 'unit + integration + e2e' template. Inputs your stack, the change risk profile, team size, and CI budget — outputs a tiered test plan with concrete test names, the boundaries you should mock vs. the ones you must hit live, the contract tests that prevent your N+1 service drift problem, and the kill list of low-value tests already burning CI minutes. Built for engineers tired of '100% coverage' theater and the test pyramid PDF that doesn't survive contact with their actual repo.

You shipped an LLM feature and have no idea if it's working. This prompt builds you an end-to-end eval suite — ground-truth dataset, golden examples, regression set, LLM-as-judge rubrics with calibration, edge cases, and the metrics that actually predict user pain (not just BLEU/ROUGE theater). Inputs your feature, your model, your stack, and what 'good' looks like. Outputs a runnable eval plan with offline + online pieces, version-pinning strategy for model upgrades (Claude 4.6 → 4.7, GPT-5, etc.), and the failure modes you didn't think to look for. Built for AI engineers who keep getting asked 'is the new model better?' and don't have a real answer.

Your engineering org has a list of 200 'should fix' items and is paying down the wrong half. This prompt scores tech debt on the four dimensions that actually predict pain — blast radius, frequency, effort, strategic alignment — and forces you into three buckets: fix now, fix when you next touch the area, and never (the kill list). Outputs a prioritized roadmap, the items to publicly stop apologizing for, and the language to push back when leadership asks 'why haven't you fixed X.' Built for tech leads, EMs, and staff engineers who keep getting steamrolled by the squeaky-wheel debt and need a defensible framework.

A multi-mode platform engineering advisor for building internal developer platforms. Route between four modes — golden path design, paved road audit, developer portal scaffolding, or platform API design — depending on what you're solving. Helps platform teams cut cognitive load without becoming a bottleneck, so product engineers ship faster on a paved road instead of reinventing wheels in dirt.

A phased protocol for rebuilding observability dashboards that actually get used on-call. Paste your existing panels or describe your stack — it audits, kills noise, sorts by audience (RED vs USE vs business), rebuilds with proper drill-paths, and schedules the prune cycle so the dashboard doesn't rot back into wallpaper.

A devil's advocate for your monitoring and alerting setup. Paste your alert rules, dashboards, or describe your observability stack — it will ruthlessly challenge every alert, kill the noise, and rebuild what's left into a system on-call engineers actually trust.

A cost optimization advisor for AI-powered applications. Describe your LLM usage — models, prompts, volumes, pipelines — and it will build a weighted cost-quality comparison across optimization strategies, showing exactly where your tokens are bleeding and which fixes give you the best ROI.

A structured data generation architect for testing, training, and development. Describe your schema, domain, and constraints — it walks you through a phased protocol to produce realistic synthetic datasets that respect relationships, distributions, edge cases, and privacy boundaries.

Describe your current architecture and target state — monolith to microservices, framework swap, language migration, cloud provider move — and get a phased migration plan with risk assessment, rollback gates, and the strangler fig pattern applied to your specific codebase. Identifies the critical path, flags hidden coupling that will bite you mid-migration, estimates team-weeks per phase, and designs the parallel-run strategy so you never have a 'big bang' cutover moment. For tech leads planning migrations they can't afford to get wrong.

Paste your dependency list (package.json, requirements.txt, Cargo.toml, go.mod, or any manifest) and get a full license compatibility audit. Flags GPL contamination risks, commercial use restrictions, attribution gaps, and copyleft infection chains before your legal team has to.

Describe your application's architecture — what it does, how data flows, who accesses it — and get a structured threat model using STRIDE methodology. Outputs attack surfaces, threat scenarios ranked by risk, and specific mitigations you can implement this sprint.

Paste your failing CI/CD logs, pipeline config, or error output and get a structured diagnosis — root cause, fix, and prevention strategy. Works with GitHub Actions, GitLab CI, Jenkins, CircleCI, and more.

Paste any cryptic error message, stack trace, or warning and get a plain-English explanation of what went wrong, why, and exactly how to fix it. Covers every language and framework.

Generate well-structured Architectural Decision Records from a brief description of a technical decision. Captures context, alternatives evaluated, trade-offs, and consequences in a format your future self will thank you for.

Describe your git situation in plain English — messy merges, detached HEAD, accidentally committed secrets, lost work — and get the exact sequence of commands to fix it, with explanations of what each one does and what could go wrong.

Paste any regular expression and get a plain-English breakdown of what it matches, why each part exists, and where it could break. Works in reverse too: describe a pattern in words and get a tested regex with edge-case warnings.

Paste any SQL query and get a plain-English explanation, performance analysis, and optimized rewrite. Works in reverse too: describe what you need in words and get production-ready SQL with proper indexing hints.

Describe an app idea in casual language and get a complete project scaffold — tech stack recommendation, file structure, working starter code, and a step-by-step build plan. Built for the 'vibe coding' era where you ship first and refine later.

A data engineering expert that transforms messy, real-world data into clean, analysis-ready datasets using pandas, SQL, or any tool you throw at it. Handles missing values, type coercion, deduplication, reshaping, and all the unglamorous work that makes analysis possible.

Design user interfaces that remain perfectly legible to humans while confusing and obstructing automated AI scrapers through visual and structural obfuscation.

A ruthlessly practical API design reviewer that evaluates REST, GraphQL, and gRPC APIs for consistency, developer experience, security, and long-term maintainability — like having a senior platform engineer on call.

Designs, reviews, and evolves database schemas with an eye for normalization, query performance, migration safety, and real-world access patterns — not just textbook theory.

Designs multi-step prompt chains and workflows that break complex tasks into sequenced, composable prompts — each step feeding the next — for reliable, high-quality AI output at scale.

Takes any one-shot AI prompt and re-architects it into a full agentic workflow — with tool definitions, memory strategy, error recovery, and a control loop — turning a single instruction into a reusable, autonomous system.

Turn AI into a research intelligence analyst that maps emerging trends across scientific papers, identifies converging fields, spots under-explored gaps, and predicts which research directions will matter in 2-3 years.

Expert architect for designing distributed multi-device ecosystems using HarmonyOS and Huawei's Pangu AI models.

Conduct structured open-source intelligence investigations on any entity — person, company, domain, or event — using systematic OSINT methodology and public data analysis.

Upgrade any AI prompt into a multi-pass reflective reasoning pipeline — making LLMs think harder, self-critique, and produce dramatically better outputs using test-time compute techniques.

Design a robust framework for an AI agent capable of managing and executing a digital inheritance plan through secure, context-aware triggers and agentic handshakes.

Redesign modern technology using the minimalist, wood-paneled, and circuit-exposed aesthetic of the original 1976 Apple I computer.

Structured post-mortem analysis for AI agent workflows that fail, loop, hallucinate, or produce wrong results. Systematic root-cause analysis with actionable fixes.

Design production-grade APIs from requirements using contract-first methodology. Generates OpenAPI specs, GraphQL schemas, error taxonomies, versioning strategies, and SDK-friendly designs.

Design and run controlled failure experiments for your infrastructure. Generates realistic chaos scenarios, blast radius analysis, rollback plans, and post-experiment reports.

A sophisticated analytical framework for benchmarking and mapping the latency landscapes and architectural efficiency of DeepSeek vs OpenAI models.

An interactive system design interview coach that walks you through designing large-scale distributed systems with structured feedback, trade-off analysis, and back-of-envelope calculations.

An advanced meta-framework for orchestrating multi-LLM workflows with automated PII sanitization, data masking, and secure context re-integration.

A meta-prompt that forces any AI model to systematically critique, verify, and improve its own output before delivering the final answer — reducing hallucinations and catching logical errors.

An adversarial testing framework that stress-tests your AI prompts and system instructions for vulnerabilities — jailbreaks, prompt injection, edge cases, and failure modes.

Transforms chaotic incident timelines into structured, blameless postmortem documents with root cause analysis, contributing factors, and actionable follow-ups.

A structured guide for productive vibe coding sessions — translating natural language intent into working software through AI coding tools like Cursor, Claude Code, Bolt, and Lovable.

A specialized AI framework designed to analyze, verify, and stress-test digital voting systems and legislative compliance for future election cycles.

Systematically excavates and documents unfamiliar or legacy codebases, producing navigable maps of architecture, dependencies, conventions, and buried knowledge.

A high-level systems engineering prompt designed to architect autonomous robotic systems using NVIDIA's 2026 Rubin platform and Isaac SDK.

A sophisticated meta-cognitive framework for AI agents to self-audit their reasoning, identify risks, and ensure alignment before executing high-impact tasks.

A sophisticated framework for implementing safety interrupts and ethical handoffs in high-agency AI systems, designed for governance and strategic system design.

Converts T20 cricket match statistics into intricate, data-driven 3D kinetic sculptures through parametric design logic.

A unique architectural framework that applies ancient Roman engineering principles—durability, gravity-led flow, and monumental scaling—to modern SaaS infrastructure design.

A high-level physics framework for converting stadium acoustic energy into dynamic, frequency-reactive light simulations.

Design sophisticated Agent-First interfaces using Visual Anchors to maintain context and state for high-reasoning models like Gemini 2.5.

A specialized diagnostic tool for identifying and fixing logic gaps, state leakage, and context degradation in multi-agent AI workflows.

A meta-orchestration prompt that turns local LLMs into strategic project managers, focusing on task decomposition and human-in-the-loop governance.

A sophisticated particle simulation framework designed to model the physics, lighting, and fluid-like behavior of flower petals in cultural festivities.

A high-fidelity text-based simulator for calculating orbital trajectories and mass-driver launches from the lunar surface.

An expert systems-level refactoring tool designed to strip away code bloat and optimize for extreme hardware scarcity and energy efficiency.

An advanced prompt designed to optimize reasoning chains for maximum efficiency, mimicking DeepSeek-V3's efficiency-first logic architecture.

A sophisticated framework for architecting autonomous agent workflows across multiple platforms and APIs using S26 logic standards.

A specialized designer for aerial light shows that translate ancient mathematical patterns into precise, synchronized drone movements and 3D visual narratives.

Design advanced bio-electronic interfaces and real-time monitoring systems for internal organ health using material science and IoT protocols.

A high-intensity, narrative-driven 30-day curriculum designed to master complex data structures and algorithms through gamified challenges.

A high-level framework for evaluating the safety, alignment, and risk profiles of autonomous AI agents using hypothetical 2026 NIST standards.

An advanced framework for translating abstract atmospheric 'vibes' into functional, reactive design systems and high-quality frontend code.

A high-level technical persona designed to analyze bugs at the syntax, logic, and architectural levels simultaneously.

Architect and deploy complex multi-agent workflows by defining specialized AI roles, communication protocols, and task orchestration logic.

Design sophisticated multi-agent ecosystems with specialized roles, communication protocols, and task orchestration logic.

A high-level engineering prompt designed to transform abstract logic into production-grade, secure, and highly optimized code structures.

A high-level software architect that scaffolds production-ready, modular GitHub repositories with full documentation and CI/CD pipelines.

Transform any simple business idea into a comprehensive Micro-SaaS blueprint covering MVP features, tech stack, and a multi-phase launch strategy.

A comprehensive roadmap and architecture blueprinting tool for transforming a software idea into a fully functional, scalable SaaS product.

Transforms simple app ideas into comprehensive technical blueprints by simulating a multi-agent team including a PM, Architect, Lead Dev, and QA.

Transforms a single-sentence idea into a comprehensive Micro-SaaS blueprint, including technical architecture, data models, and GTM strategy.

A high-level AI persona for auditing codebases for architectural flaws, security vulnerabilities, and performance bottlenecks.

A sophisticated meta-prompt that transforms an AI into a systems architect capable of designing, modularizing, and self-optimizing complex multi-step workflows.

A comprehensive tool to transform a simple SaaS idea into a full-scale technical blueprint, including architecture, database schema, and an implementation roadmap.

Design sophisticated multi-agent AI systems with autonomous coordination, defined roles, and robust communication protocols for complex task resolution.

A multi-agent refinement system that uses specialized personas to recursively analyze, secure, and optimize source code for production-grade quality.

An advanced multi-pass prompt that forces the AI to act as a senior architect, critiquing and refactoring its own initial output for production-grade results.

Transform standard Python code into resilient, fault-tolerant systems capable of autonomous error detection and recovery.

Design and orchestrate sophisticated multi-agent networks to automate complex organizational workflows and decision-making processes.

A sophisticated AI architect designed to transform monolithic, technical-debt-heavy code into clean, modular, and modern software components.

Design a specialized squad of autonomous AI agents with distinct personas, goals, and interaction workflows to solve complex business and technical challenges.

Converts a single sentence idea into a full-scale SaaS architectural roadmap including MVP features, tech stack, and monetization strategy.

Transform messy, undocumented legacy code into clear logic, identified risks, and a modern refactoring roadmap.

Design and deploy a sophisticated multi-agent AI workforce blueprint to automate complex business workflows and digital operations.

A comprehensive, high-speed execution framework designed to take an AI business idea from concept to a live product launch in exactly one week.

An advanced system design assistant that transforms complex product requirements into comprehensive technical blueprints and architectural roadmaps.

A high-level architect prompt that converts raw SaaS ideas into detailed technical blueprints, including tech stack selection, database schemas, and a 6-week development roadmap.

Design complex, collaborative AI systems where specialized agents work together to solve multi-faceted problems through role-play and task orchestration.

Essential rules for iOS development with AI agents to prevent common issues.

A technical prompt for conducting thorough code reviews, identifying issues, and suggesting improvements.

Essential rules for iOS development with AI agents to prevent common issues and improve productivity.