Software Development AI prompts
Prompts for developers: explaining unfamiliar code, writing tests, reviewing a change, debugging from an error message, drafting documentation and planning a refactor. Always run and review generated code yourself.
Search these 107 prompts in the app
107 Software Development prompts
- Add useful logging, metrics, and tracing to a servicePlans the instrumentation a service needs so you can answer what broke, where, and for whom when something goes wrong.
- Analyze a suspicious email a user reportedBreaks down a reported email's headers, links, and content into a phishing verdict and clear next steps.
- Analyze logs to find what went wrongReads logs to identify errors, patterns, and the likely root cause.
- Analyze security threats and vulnerabilitiesIdentifies vulnerabilities and threats and builds a prioritized remediation plan.
- Analyze test run results to find failure patterns and gapsTurns raw CI test results into clusters of failures, likely flaky tests, coverage gaps, and a prioritized fix list.
- Assess whether an application is ready to migrate to the cloudA readiness assessment and migration approach for one application, with dependencies, risks, effort, and the questions to answer first.
- Audit a codebase for bugs, risks, and tech debtA systematic review of a repository with prioritized findings and a remediation plan.
- Audit Linux password and login security settingsA checklist-driven review of password policy, PAM, account aging, and file permissions on Linux servers, with safe fixes.
- Audit my project's dependencies for security risks and bloatA prioritized review of outdated, vulnerable, duplicated, and unused packages, with a safe update order and lockfile hygiene.
- Audit the developer experience of my software package or APIA structured review of your docs, onboarding, community signals, and competitor position, with a prioritized list of developer-experience fixes.
- Break a feature into small, shippable pull requestsSplits a large feature into a sequence of small, independently mergeable PRs with a safe order and clear scope for each.
- Break my first coding project into small buildable stepsA milestone plan where every step leaves you with a working program and tells you what to learn next.
- Build a hardened golden machine image with PackerA Packer HCL2 template, unattended install config, and pipeline plan for reproducible, hardened VM or cloud images.
- Build a mobile app testing checklist that catches common bugsA mobile-specific test checklist and device matrix covering the bugs desktop testing misses: interruptions, connectivity, permissions, and OS fragmentation.
- Build a working app, tool, or game from a descriptionTurns a plain-English idea into a complete, runnable app — web tool, dashboard, or browser game.
- Check an admin script or command before running itExplains what an unfamiliar script or command will actually do, flags risky lines, and suggests a safer way to run it.
- Choose an open-source licenseCompares licenses for your project and explains obligations and compatibility.
- Compare virtualization platforms for my infrastructureA side-by-side comparison of hypervisor and virtualization options against your workloads, budget, skills, and migration constraints, with a recommendation.
- Convert code to another language or frameworkIdiomatic translation of code between languages or frameworks, with notes on differences.
- Create a guided CodeTour walkthrough of my codebaseA valid VS Code CodeTour .tour file that walks new developers through how your codebase works, step by step.
- Create a test plan and test casesA risk-based test strategy with test cases for functional, integration, and end-to-end testing.
- Debug an error and find the root causeReproduces, isolates, and fixes a bug — with a test to prevent it coming back.
- Define SLOs and alerts that only page for real problemsSets service level objectives and turns them into alert rules that catch user-facing problems without waking people up for noise.
- Deprecate an API endpoint with a migration guidePlans the deprecation of an API endpoint or field and writes the timeline, announcement, and migration guide for its consumers.
- Design a caching strategy with safe invalidationDecides what to cache, where, and for how long, with invalidation rules and failure modes so the cache doesn't serve wrong data.
- Design a database schemaEntities, relationships, keys, indexes, and migrations for your data model.
- Design a software architecture and weigh trade-offsArchitecture options, trade-offs, and a recommended design for a system.
- Design an APIResources, endpoints, request/response shapes, errors, auth, and versioning for a REST or GraphQL API.
- Design consistent API error responses developers can act onTurns unhelpful API errors into a consistent format with clear codes, statuses, and messages that tell callers exactly what to fix.
- Design input validation rules for my appConsistent validation rules for every input across client, server, and database, with security checks, error messages, and tests.
- Design tenant isolation for my multi-tenant SaaS appA recommended tenancy model with data isolation, noisy-neighbor controls, and tests that prove one customer can't see another's data.
- Diagnose and fix a flaky testWorks out why a test passes and fails intermittently, how to reproduce it, and how to fix the cause rather than adding retries.
- Diagnose and improve my mobile app's performanceA performance review of an iOS or Android app covering startup time, jank, memory, battery, network, and crashes, with tools and a fix plan.
- Diagnose slow launches and API cold starts in my mobile appA codebase-specific diagnosis of startup time, serverless cold starts, and network waste, with fixes ranked by impact on perceived speed.
- Explain what a piece of code doesPlain-language walkthrough of unfamiliar code: purpose, flow, key parts, and gotchas.
- Find and fix a race condition or concurrency bugAnalyzes code for race conditions, deadlocks, and lost updates, explains the exact interleaving that fails, and proposes a safe fix.
- Find which change caused a regressionCreates a systematic plan to pinpoint the commit, deploy, or config change that broke something that used to work.
- Fix a Git problemStep-by-step help for merge conflicts, undoing mistakes, branching, and recovering lost work.
- Generate realistic test or mock dataRealistic synthetic datasets in CSV, JSON, or SQL for testing and demos.
- Get a beginner-friendly code review of my first projectA ranked set of the five improvements that matter most, explained simply, plus what you did well and what to learn next.
- Get unstuck on a coding error with hints instead of the answerA plain-English explanation of your error and step-by-step hints, so you learn to debug instead of copying a fix.
- Implement a feature from a spec, with testsPlans and writes production-quality code for a feature, including tests and edge cases.
- Install and configure an SSL/TLS certificate on my serverStep-by-step HTTPS setup for your exact server and software, including renewal, redirects, and how to verify it worked.
- Investigate a suspicious sign-in on a user accountWorks through risky sign-in signals like impossible travel or MFA spam to decide if an account is compromised.
- Learn a programming language or conceptA patient coding tutor that explains concepts, gives exercises, and reviews your solutions.
- Make background jobs and webhooks safe to retryDesigns idempotency, retries, and dead-letter handling so jobs, queue consumers, and webhooks never double-charge or lose work.
- Make my research analysis reproducible and shareableOrganizes my project's data, code, and documentation so others (and future me) can rerun the analysis and get the same results.
- Plan a feature flag rollout and rollbackDesigns a staged release behind a feature flag, with audience steps, metrics to watch, kill criteria, and flag cleanup.
- Plan a major framework or dependency upgradeBuilds an incremental upgrade path for a framework, language, or library version, with breaking changes mapped to your codebase.
- Plan a time-boxed technical spikeScopes an investigation with a clear question, time-box, and exit criteria, and gives a template to report findings.
- Plan a touchscreen UI for an ESP32 or other microcontrollerA memory-aware screen design, library choice, and code structure for a display-based embedded project.
- Plan a zero-downtime database migrationCreates a step-by-step expand-and-contract plan for a schema or data change, with backfill, verification, and rollback at each step.
- Plan cross-browser and cross-device compatibility testingA prioritized browser and device test matrix, tooling choices, and checklist so your site or app works for your real users.
- Plan load and performance testingLoad test scenarios, targets, tooling, and how to read the results.
- Plan the architecture of a Unity game projectA Unity-specific architecture plan: folder and assembly structure, data with ScriptableObjects, scene flow, and system boundaries with C# signatures.
- Practice incident response with a simulated system outageAn interactive, turn-by-turn outage drill with realistic symptoms, consequences for your actions, and a scored debrief at the end.
- Protect my AI chatbot or LLM feature from prompt injection and data leaksA layered security plan and code-level checklist for LLM endpoints: injection defenses, data leakage controls, abuse limits, and logging.
- Reduce cloud costs and right-size capacityFinds waste and optimization opportunities in your cloud spend.
- Refactor code to be cleaner and easier to maintainImproves structure, naming, and design without changing behavior.
- Reply to code review comments I disagree withDrafts calm, evidence-based replies to review feedback so you can resolve disagreements without stalling the pull request.
- Respond to a secret leaked in a code repositoryWalks you through containing a leaked API key, password, or token: revoke, rotate, check for misuse, and clean up history.
- Respond to a security vulnerability report from an outside researcherA triage checklist, severity rating, and replies for a reported vulnerability, from first acknowledgment to fix and disclosure.
- Restyle a UI component to match a reference designRefactor a component's markup, styles, and accessibility to match a design-system reference while keeping its props, state, and logic intact.
- Review AI-generated code before I merge itChecks code written by an AI assistant for the specific mistakes these tools make: invented APIs, shallow tests, and hidden security gaps.
- Review an RPA workflow for errors, fragility, and best practicesA structured code review of a UiPath, Power Automate, or similar bot workflow, with issues ranked and explained before any changes.
- Review every change since my last release before shippingA pre-release review of all changes since a tag: missing translations, simplifications, breaking changes, security, and a draft changelog.
- Review firewall or cloud security group rules for risky openingsAudits a rule set for overly broad access, exposed admin ports, and stale rules, and proposes a tighter version.
- Review my code for bugs, security, and qualityA thorough code review with prioritized findings and suggested fixes.
- Review my customer-facing chatbot for security risksThreat review for an AI support bot covering prompt injection, data leaks, abuse, and unsafe actions, with prioritized fixes and tests.
- Set up CI/CD and infrastructure as codeCI/CD pipelines and IaC templates with environments, checks, and rollback.
- Set up environment config and secrets across dev, staging, and productionA clean plan for environment variables, secrets handling, and Docker config so each environment works and nothing sensitive leaks.
- Set up experiment tracking for a machine learning training runStep-by-step setup to log metrics, hyperparameters, and artifacts from your training script, locally or on a cluster.
- Solve a NixOS problem the declarative, reproducible wayA NixOS-native fix for a configuration, package, or service problem that survives rebuilds and can be rolled back.
- Speed up slow codeFinds performance bottlenecks and suggests faster approaches with measurable trade-offs.
- Summarize a cyber threat report into insights and actionsDistills a threat intelligence report into its key findings, attacker techniques, indicators, and the actions your security team should take.
- Summarize a malware analysis into IOCs and detection stepsTurns sandbox reports, threat intel, and analyst notes into a structured malware summary with indicators, ATT&CK mapping, and next actions.
- Threat-model a system (STRIDE)Systematically identifies threats to a system and the controls to mitigate them.
- Translate app string files without breaking keys or placeholdersTranslates localization files (.strings, JSON, XML, .po) while preserving keys, placeholders, comments, and syntax exactly.
- Triage a security alert and decide if it is a real threatWalks through a SIEM or EDR alert to a true/false positive call, a severity, and the next actions to take.
- Triage defects and assess regression riskPrioritizes bugs by severity and impact and flags regression risk.
- Troubleshoot a network connectivity or performance problemA structured, layer-by-layer diagnosis plan with the commands to run, what each result means, and the likely fix.
- Turn a threat report into Sigma detection rulesExtracts behaviors from a threat report, maps them to MITRE ATT&CK, and writes tuned Sigma rules with test notes.
- Understand a new codebase quicklyMaps an unfamiliar repository: architecture, key flows, conventions, and where to start.
- Vet an open-source library before adding itEvaluates a dependency for maintenance health, security, license fit, and lock-in so you can decide whether to adopt it.
- Write a clear commit messageConventional Commits–style messages from a diff or a description of changes.
- Write a clear, reproducible bug reportBug reports developers can act on immediately — steps, expected vs. actual, environment, and evidence.
- Write a detection query or SIEM rule from a descriptionTurns a threat you want to catch into a working query for your SIEM, with tuning notes and test cases.
- Write a getting-started guide for new engineers on my teamCreates a practical onboarding doc for your codebase: local setup, architecture tour, workflows, and a safe first task.
- Write a GitHub Sponsors page for my open-source workSponsor bio, tiers, impact story, and update templates that attract sponsors.
- Write a Nuclei template to detect a known vulnerabilityA working, low-false-positive Nuclei YAML template for detecting a specific vulnerability on systems you're authorized to test.
- Write a pull request descriptionA PR description reviewers love: what, why, how to test, and risks.
- Write a README and publish my first coding project on GitHubA clear README, a safe publishing checklist, and a short post to share what you built.
- Write a script to automate a repetitive taskBash, Python, or PowerShell scripts that automate a task safely, with instructions to run them.
- Write a security finding for a penetration test reportTurns your notes on a vulnerability into a clear, professional finding with risk rating, evidence, impact, and fix steps.
- Write a Semgrep rule to catch a risky code patternProduces a working Semgrep rule with test cases, so you can block a bug or security pattern across your codebase.
- Write a style guide that documents my app's existing design codeReverse-engineers colors, typography, spacing, and component patterns from your codebase into a STYLE_GUIDE.md developers and AI agents can follow.
- Write a technical design doc (RFC) reviewers can approveTurns a rough technical plan into a structured RFC with alternatives, risks, and open questions reviewers can sign off on.
- Write an incident postmortem and runbookA blameless postmortem with timeline, root cause, actions, and a runbook update.
- Write an instructions file for an AI coding agent (CLAUDE.md / AGENTS.md)Concise, high-signal project instructions that make AI coding agents follow your conventions.
- Write an on-call handoff noteSummarizes your on-call shift into a handoff the next engineer can act on: open issues, watch items, and context.
- Write and explain a regular expressionBuilds a regex from a description, explains it piece by piece, and tests it.
- Write documentation, a README, or API docsGenerates clear technical documentation from your code or notes.
- Write kind, actionable review comments on a teammate's pull requestTurns your rough review notes into clear comments labeled by severity, so the author knows what blocks merging and what doesn't.
- Write or review a network switch configuration changeA vendor-aware switch config for your requirement, plus a pre-change review, rollback steps, and verification commands.
- Write PowerShell commands to silently install or update softwareUnattended install or update commands for Windows using winget or Chocolatey, with verification and a fallback when silent install isn't possible.
- Write precise TypeScript types for my data and APIsSafer, readable TypeScript types that rule out impossible states, replace unsafe casts, and come with compile-time tests.
- Write unit tests for my codeComprehensive unit tests covering happy paths, edge cases, and failures.
Other topics
- Personal Life & Wellbeing
- Projects & Operations
- Data & Analysis
- Learning & Teaching
- Legal & Compliance
- Images, Video & Design
- Finance & Accounting
- Marketing & Brand
- HR & Hiring
- Productivity & Planning
- Sales
- Career & Job Search
- Email & Workplace Communication
- Content & Social Media
- Customer Support
- Business Strategy & Startups
- Thinking & Decisions
- Writing & Editing
- Leadership & Management
- Product & UX Design
- Working with AI
- Research & Summaries
- Meetings
- Presentations & Public Speaking
- SEO & Website
- Fun & Games
- Creative Writing