India has 5.8 million software engineers (NASSCOM 2026). Most use AI reactively — asking random questions — instead of systematically incorporating it into their daily workflows. I've watched senior engineers at product companies use AI at a fraction of its potential because they treat it like a search engine rather than a structured collaborator.
These 30 prompts are built around what Indian engineers actually do: JIRA tickets, GitHub PRs, production incidents at 2 AM, and the specific stacks Indian companies run — Java for TCS/Infosys/banking, Python for startups, TypeScript for product companies. The generic "review my code" prompt gets you generic output. These get you specific, actionable feedback.
Code review prompts
1. PR review — bugs, security, style
Review this pull request. Identify: (1) potential bugs or logic errors, (2) security vulnerabilities, (3) style/convention violations against our codebase standards. For each issue: severity (critical/major/minor), location, explanation, and suggested fix.
Here's the code:
[CODE]
Works for any language. For Java (common in TCS/Infosys/banking stacks), add: "Pay special attention to null pointer exceptions and thread safety."
2. OWASP security review
Review this code specifically against the OWASP Top 10 vulnerabilities. For each relevant vulnerability: (1) is this code vulnerable? (2) what specific line/pattern causes it? (3) what's the remediation?
[CODE]
Run this before every PR that touches authentication, payment flows, or external data ingestion. The OWASP framing forces the model to be specific — you get "line 47 interpolates user input directly into the SQL query" instead of "watch out for SQL injection."
3. Performance review
Review this code for performance issues. Check for: N+1 database queries, unnecessary DB calls within loops, memory leaks or unbounded collection growth, blocking I/O in async contexts, inefficient algorithms where a simpler approach exists, and missing connection pool or cache usage where applicable.
For each issue: estimated impact (high/medium/low), the problematic code, and a concrete fix.
[CODE]
4. Code review for junior devs
Review this code and identify issues. Explain each issue at a level appropriate for a junior developer — someone joining from a tier-3 engineering college with 0-6 months of experience. Don't just say what's wrong; explain why it's a problem and what the correct mental model is.
Keep the tone constructive and educational. For each issue: what it is, why it matters, and the correct approach.
[CODE]
This is more useful for tech leads than the standard review prompt. You can share the output directly with the junior or use it to frame your own review conversation.
5. Banking-grade payment code review
Review this code with extra scrutiny for financial correctness. Check for: decimal precision handling (are we using BigDecimal / Python Decimal, not float?), idempotency (what happens if this request fires twice?), atomicity (which operations need to be in a transaction?), race conditions in concurrent payment scenarios, and proper handling of Indian payment rail edge cases — UPI timeout, NACH bounce, IMPS amount limits.
Flag anything that could result in money being debited without credit, or double-charged.
[CODE]
6. API contract review
Review this API design for: REST best practices (correct HTTP methods, status codes, resource naming), backward compatibility (changes that would break existing consumers), missing edge cases in the request/response contract, inconsistent naming conventions, and anything that will cause problems when 10+ services consume this endpoint.
The API is consumed by: [LIST OF CONSUMERS]
[API DEFINITION / OPENAPI SPEC]
7. Test coverage analysis
Review these unit tests and identify critical paths that aren't covered. For each gap: what scenario is untested, what could go wrong, and a suggested test case.
Business logic: [BRIEF DESCRIPTION]
Existing tests:
[TEST CODE]Implementation:
[IMPLEMENTATION CODE]
8. Architecture review for Indian e-commerce scale
Review this architecture design for readiness at Indian e-commerce scale. Specifically: festive season load spikes (10-50x normal traffic during Diwali/Big Billion Day), tier-2/3 user connectivity (2G fallback, high latency, small screen), COD order handling (which has different failure patterns than prepaid), geographic distribution across India (latency from South India to North India matters), and payment gateway failover (Razorpay, PayU, CCAvenue failure scenarios).
Architecture description: [DESCRIPTION]
Debugging prompts
9. Stack trace decoder
Explain this [Java/Python/Node.js] stack trace in plain English. For each frame in the trace: what it means. Then: list the 3 most likely root causes ranked by probability, what to check first for each, and the quickest way to confirm or eliminate each hypothesis.
Stack trace:
[STACK TRACE]
10. Production incident diagnosis
We have a production incident. Help me diagnose what happened.
Error log:
[LOG EXCERPT]Recent deployment diff (last deploy before incident):
[DIFF]Alerts that fired: [LIST]
Questions:
- What likely happened and why?
- What's the blast radius — who/what is affected?
- What are the immediate mitigation options (fastest to slowest)?
- What data should I collect right now before it rolls off?
11. Memory leak investigator
Analyze this memory usage pattern and help me identify a likely memory leak.
Memory graph description (or attach image): [DESCRIPTION — e.g., "steady 2MB/hour growth over 48 hours, GC doesn't clear it, restarts bring it back to baseline"]
Service characteristics: [LANGUAGE, RUNTIME, TRAFFIC PATTERN]
Recent code changes: [DESCRIPTION OR DIFF]
What patterns in this data suggest a leak? What are the top 3 most likely causes given the service profile? What tooling should I use to confirm each hypothesis?
12. Slow query analyser
Analyze this PostgreSQL EXPLAIN PLAN and suggest optimisations. For each suggestion: what the problem is, the fix (index DDL, query rewrite, or config change), and estimated improvement.
Table row counts: [SIZES]
Current query:
[QUERY]EXPLAIN ANALYZE output:
[EXPLAIN OUTPUT]
13. Race condition finder
Identify potential race conditions in this concurrent code. For each one: the specific scenario that triggers it, the bad state it produces, severity (data corruption / incorrect behavior / crash), and the fix.
This runs in a [high-concurrency web server / background job worker / other] context.
[CODE]
14. API timeout debugger
Help me diagnose this API timeout. Here's the timeline of events leading up to and during the timeout:
[TIMELINE — e.g., "T+0: Request received. T+100ms: DB query started. T+3200ms: DB query returned. T+3250ms: Downstream API call started. T+30000ms: Connection timeout"]
Configuration:
- Timeout limits: [LIST]
- Connection pool settings: [SETTINGS]
What's the failure point? What are the likely causes? What should I change?
15. Database connection pool exhaustion
Diagnose why we're hitting connection pool exhaustion. This is a [Spring Boot / Django / Express / other] application using [HikariCP / SQLAlchemy / pg / other].
Pool configuration:
[CONFIG]Access patterns: [DESCRIPTION — e.g., "50 RPS peak, 200ms average query time, 10 background threads"]
What's causing exhaustion? Is the pool too small, or are connections being leaked? What should the pool size be? What code patterns should I check for connection leaks?
HikariCP exhaustion is one of the most common prod incidents at Indian enterprise companies running Spring Boot. This prompt has saved me multiple 2 AM pages.
16. AWS Lambda cold start investigator
Help me diagnose and reduce cold starts in this AWS Lambda function. The function is [RUNTIME, e.g., Java 17 / Python 3.12 / Node 20].
Current cold start p99: [DURATION] Function configuration: [MEMORY, TIMEOUT, VPC YES/NO]
Function code (entry point):
[CODE]What's causing the cold start duration? What are the highest-impact fixes? Is Provisioned Concurrency justified here or is there a code-level fix?
Documentation prompts
17. README generator
Generate a complete README for this project. Include: project description (what it does and why), setup instructions (prerequisites, installation, configuration), environment variables table (name, description, example value, required/optional), usage examples with actual commands, API reference if applicable, and contributing guide.
Project purpose: [DESCRIPTION] Tech stack: [LIST] Codebase structure:
[DIRECTORY TREE OR DESCRIPTION]
18. OpenAPI spec from route code
Generate a complete OpenAPI 3.0 YAML specification for this [FastAPI / Spring] route. Include all request parameters, request body schema with field descriptions and validation constraints, all response codes with schema, and meaningful descriptions.
[ROUTE CODE]
19. Docstring generator
Add [Google-style Python docstrings / JavaDoc] to every function and class in this module. Include: what it does, all parameters (type, description, constraints), return value, exceptions that can be raised, and a usage example for non-obvious functions.
[CODE]
20. ADR writer
Write an Architecture Decision Record (ADR) based on this context. Use the standard format: Title, Status (Proposed/Accepted), Context, Decision, Consequences (positive and negative).
Context (the problem): [DESCRIPTION] Options considered: [LIST WITH BRIEF PROS/CONS] Decision made: [WHAT YOU CHOSE] Key reasons: [WHY]
21. Operational runbook
Create an operational runbook for on-call engineers managing this service. Include: service overview (what it does, who uses it, business impact of downtime), common alerts with diagnosis steps, escalation path, health check procedures, and links to relevant dashboards or queries.
Service description: [DESCRIPTION] Common failure modes we've seen: [LIST] Available tooling: [MONITORING STACK]
22. Incident post-mortem
Structure this incident timeline into a blameless post-mortem. Use these sections: Summary (1 paragraph), Impact, Timeline (sorted by time), Root Cause, Contributing Factors, What Went Well, Areas for Improvement, Action Items (owner, due date).
Keep the tone blameless — focus on system factors, not individual mistakes.
Raw timeline notes: [NOTES]
23. Onboarding guide
Write a 30-day onboarding guide for a new backend developer joining this codebase. Structure by week: Week 1 (understand the system), Week 2 (first contributions), Week 3 (independent feature work), Week 4 (production ownership). Include specific tasks, what to read, who to pair with (use role names, not personal names), and what "success" looks like by end of each week.
Codebase description: [WHAT IT IS] Tech stack: [LANGUAGES, FRAMEWORKS, INFRA] Team size: [NUMBER]
24. Technical debt catalogue
Review this module and create a technical debt catalogue. For each debt item: description, where in the code, severity (high/medium/low based on risk and user impact), estimated remediation effort in story points, and the recommended fix approach.
Prioritise by: high severity first, then by highest effort-to-impact ratio.
[CODE]
Productivity and workflow prompts
25. JIRA ticket writer
Convert this Slack discussion thread into well-formed JIRA tickets. For each ticket: title (action-oriented, 50-70 chars), type (Story/Bug/Task), description (background and what to do), acceptance criteria (testable, specific), story point estimate (Fibonacci: 1/2/3/5/8/13), and dependencies on other tickets.
Slack thread: [PASTE THREAD]
This alone saves 30 minutes per sprint planning. Paste the PM's messy Slack thread and get properly structured tickets back.
26. Sprint retrospective analyser
Analyze this sprint data and generate a structured retrospective agenda. Focus on patterns, not one-off events. Suggest: 3 things to keep doing (with evidence), 3 things to improve (with specific actions), and 1 experiment to try next sprint.
Sprint velocity: [PLANNED vs ACTUAL] Tickets completed vs carried over: [DATA] Main blockers mentioned: [LIST] Team size: [NUMBER]
27. Interview question generator
Generate 10 technical interview questions for a [Senior Backend / ML Engineer / Frontend] at a [Series B startup / large bank / product company]. For each question: the question itself, what a strong answer looks like (key concepts, depth expected), and a follow-up to probe deeper.
Technology focus: [STACK] Role level: [SENIOR / STAFF / PRINCIPAL]
28. 90-day learning plan
Create a structured 90-day learning plan for a developer wanting to learn [TECHNOLOGY/SKILL]. My current background: [DESCRIPTION — e.g., "3 years Java, no Kubernetes experience"].
Break it into 3 phases (30 days each): foundations, core competencies, production readiness. For each phase: specific topics, resources (books, docs, tutorials — be specific, not generic), practice projects, and how to verify I've actually learned it.
29. Technical explanation for stakeholders
Explain this technical constraint/decision in plain English for [a product manager / a CEO / a client] with no engineering background. Avoid all jargon. Use an analogy if it helps. Conclude with: what this means for them, what they need to decide (if anything), and what we need from them (if anything).
Technical situation: [DESCRIPTION]
The framing of "what they need to decide" and "what we need from them" keeps the explanation actionable instead of just informational.
30. Story point estimation helper
Break down this feature requirement into subtasks and estimate story points using the Fibonacci scale (1, 2, 3, 5, 8, 13). For each subtask: description, story point estimate, key assumptions, and risks that could increase the estimate.
Flag any subtask above 8 as a candidate for further breakdown.
Feature requirement: [DESCRIPTION OR JIRA TICKET TEXT]
Tech context: [STACK, EXISTING PATTERNS WE'D FOLLOW]
💡 Want to go deeper? These prompts work because they apply structured prompting techniques — system roles, specific output formats, constraint lists. Learn the underlying patterns in the MasterPrompting curriculum.
Next steps
These 30 prompts cover the daily workflow — code review, debugging, docs, and planning. The next layer is automating these workflows:
- Prompting for coding — deeper techniques for code generation
- Build your first AI agent — automate multi-step engineering tasks
- System prompts explained — build better system prompts for your engineering tools
- More profession-specific prompt guides
Try it now with AICredits.in
Access Claude, GPT-4o, Gemini, and 300+ models with UPI payment in ₹. No international card needed. Create free account →
