AI Prompts for Software Development

Help me design the architecture for a software project.

Project: [describe what you're building]
Scale: [expected users, data volume, growth rate]
Team size: [number of developers]
Tech constraints: [required technologies, cloud provider, existing systems]
Budget: [infrastructure budget range]
Timeline: [when does this need to ship]

Design:
1. High-level architecture diagram described in detail (services, databases, APIs)
2. Technology stack recommendation with reasoning for each choice
3. Data model overview with key entities and relationships
4. API design: RESTful vs. GraphQL vs. gRPC with justification
5. Scaling strategy: what changes when you go from 100 to 10,000 to 1M users
6. The top 3 architectural risks and how to mitigate them early

Review this code as if you were a senior developer on my team.

[Paste the code or pull request diff]

Context: [what this code does and why it was written]
Framework: [framework and version]
Team standards: [style guide, naming conventions, patterns used]
Critical areas: [security, performance, or maintainability priorities]

Review and provide:
1. Critical issues: bugs, security vulnerabilities, or data loss risks
2. Major improvements: design patterns, abstraction opportunities, performance gains
3. Minor suggestions: naming, readability, style consistency
4. Questions I'd ask in a PR review (things that need clarification from the author)
5. Test coverage gaps: what tests are missing for this code
6. An overall assessment: ship it, needs minor fixes, or needs significant rework

Help me build a testing strategy for my project.

Project type: [web app / mobile app / API / library / CLI tool]
Stack: [languages, frameworks, testing tools already in use]
Current test coverage: [percentage or 'none']
Team testing culture: [strong / weak / nonexistent]
Most critical features: [what absolutely cannot break]
CI/CD: [what you use for continuous integration]

Design:
1. A testing pyramid specific to my stack (unit, integration, e2e ratios)
2. What to test first: prioritized list of critical paths
3. Testing patterns and conventions to adopt (arrange-act-assert, fixtures, mocks)
4. 5 example test cases for my most critical feature
5. CI pipeline integration: how to run tests automatically
6. A realistic roadmap to go from current coverage to 80%+ in 30 days

Help me design a database schema for my application.

Application: [describe what the app does]
Data types: [list the main types of data you'll store]
Relationships: [describe how data connects: users have posts, orders have items, etc.]
Query patterns: [the most common reads and writes]
Scale: [expected data volume and growth rate]
Database: [PostgreSQL / MySQL / MongoDB / undecided]

Design:
1. Complete schema with tables, columns, types, and constraints
2. Primary and foreign key relationships with reasoning
3. Indexes for your most common query patterns
4. Normalization assessment: where to normalize vs. denormalize for performance
5. Migration strategy: how to evolve this schema as requirements change
6. Common query examples for the top 5 operations your app will perform

Help me set up a CI/CD pipeline for my project.

Project type: [web app / API / mobile / monorepo]
Stack: [languages, frameworks, build tools]
Source control: [GitHub / GitLab / Bitbucket]
Deploy target: [AWS / GCP / Azure / Vercel / Railway / Docker]
Current deployment: [manual / some automation / none]
Team size: [number of developers]

Build:
1. A complete CI pipeline configuration file (YAML) for my platform
2. Build, test, lint, and security scan stages with specific commands
3. Branch strategy: main, develop, feature branches with merge rules
4. Deployment strategy: blue-green, rolling, or canary with justification
5. Environment management: dev, staging, production configuration
6. Rollback procedure: how to revert a bad deployment in under 5 minutes

Help me assess and prioritize the technical debt in my project.

Project age: [how long it's been in development]
Team size: [developers working on it]
Known pain points: [parts of the codebase everyone avoids]
Recent incidents: [bugs or outages caused by old code]
Upcoming features: [what you need to build next]
Current tech stack: [languages, frameworks, versions]

Provide:
1. A technical debt assessment framework: categories and severity levels
2. Audit checklist: questions to identify hidden debt across the codebase
3. A prioritization matrix: impact vs. effort for each debt category
4. A 'pay down' plan: how to allocate 20% of sprint capacity to debt reduction
5. Quick wins: debt that can be fixed in under a day with high impact
6. How to communicate tech debt to non-technical stakeholders (with ROI framing)