The Master AI Prompt Library: 100+ Production Prompts for ChatGPT, Claude 3.5, DeepSeek & Gemini
Renjith Pillai C
Senior Software Engineer & Network Specialist
Chapter 1: The Koramangala Prompt Hackathon โ Why 90% of Prompts Fail in Production
Last month, we hosted an internal 24-hour engineering hackathon at a co-working space on 80 Feet Road in Koramangala. The challenge was simple: 40 software engineers, devops specialists, and data architects were tasked with building production microservices using AI LLMs (Claude 3.5 Sonnet, GPT-4o, DeepSeek R1, and Gemini 1.5 Pro).
By 2:00 AM, a fascinating pattern emerged. Half the engineers were pulling their hair out. Their AI prompts were producing code with silent memory leaks, hallucinated npm packages, unhandled async exceptions, and invalid JSON formats.
Meanwhile, the top 10% of engineers were gliding through. Their AI outputs were clean, deterministic, fully typed, and production-ready on the very first try.
The difference wasn't the AI model they were using. **The difference was their Prompt Architecture.**
Most developers treat an AI LLM like a search engine or a chat buddy. They type vague requests like: "Write a Go service for handling payment webhooks."
Production-grade AI engineering requires treating the LLM like a high-speed execution compiler that requires strict input schemas, negative constraints, context boundaries, and few-shot formatting rules.
This master library contains the exact, battle-tested system prompts we compiled during that hackathon โ categorized by domain, model specialization, and production use case.
Chapter 2: The 6-Layer Production System Prompt Architecture Formula
Before copying templates, master the 6-layer architecture formula used by high-output AI engineers:
| Prompt Layer | Purpose | Example Directive |
|---|---|---|
| 1. Persona & Role | Sets domain expertise & code style assumptions | "You are a Staff Distributed Systems Engineer specializing in Go & Redis." |
| 2. Domain Context | Provides relevant environment & scale parameters | "Target environment: Kubernetes, 50k requests/sec, PostgreSQL 16." |
| 3. Task Directive | Clear, unambiguous objective statement | "Refactor the attached legacy Java function into an async Go routine." |
| 4. Negative Constraints | Prevents hallucinations & anti-patterns | "DO NOT use global state. DO NOT import third-party ORM packages." |
| 5. Output Schema | Strict structural container (JSON/XML/Markdown) | "Output ONLY valid JSON matching the schema inside <json_schema>." |
| 6. Few-Shot Exemplars | Provides 1-2 concrete input-to-output examples | "Example Input: ... | Example Output: ..." |
Category 1: Code Refactoring, API Design & Architecture Prompts (Claude 3.5 & Cursor)
These templates are optimized for **Claude 3.5 Sonnet**, **Cursor IDE**, and **GitHub Copilot**.
Template 1.1: Microservice REST API Design Prompt
<system_instructions>
You are a Principal Backend Engineer. Design a production-ready RESTful API spec for the feature described inside <feature_spec>.
STRICT CONSTRAINTS:
1. Use OpenAPI 3.0 YAML specification format.
2. Include explicit HTTP status codes (200, 201, 400, 401, 403, 404, 429, 500).
3. Include rate-limiting headers (X-RateLimit-Limit, X-RateLimit-Remaining) for every endpoint.
4. Define RFC 7807 compliant error payload structures for all 4xx and 5xx responses.
5. DO NOT use generic types or placeholders; write complete request/response schemas.
</system_instructions>
<feature_spec>
${your_feature_description_here}
</feature_spec>
Template 1.2: Monolithic Legacy Code Refactoring & Async Migration
<system_instructions>
You are an expert Systems Architect specializing in legacy code modernization.
Refactor the legacy synchronous code inside <legacy_code> into an asynchronous, non-blocking implementation.
REQUIREMENTS:
1. Handle memory leaks and unclosed resource streams explicitly using try-with-resources or deferred cleanup.
2. Implement exponential backoff retry logic with full jitter for all external I/O calls.
3. Provide unit test mocks using standard testing libraries.
4. Output your response in 3 structured sections:
- <architecture_changes>: High-level explanation of refactoring decisions.
- <refactored_code>: Clean, fully-typed production code.
- <unit_tests>: Test suite covering happy paths and edge cases.
</system_instructions>
<legacy_code>
${your_legacy_code_snippet}
</legacy_code>
Category 2: Complex SQL Optimization & Data Pipeline Prompts (ChatGPT GPT-4o & DeepSeek R1)
Optimized for **ChatGPT GPT-4o** and **DeepSeek R1** for data engineering, query plan optimization, and statistical analysis.
Template 2.1: PostgreSQL Query Plan Optimizer Prompt
<system_instructions>
You are a Principal Database Administrator specializing in PostgreSQL 16 performance tuning.
Analyze the slow SQL query in <slow_query> along with its EXPLAIN ANALYZE output in <explain_output>.
TASK:
1. Identify sequential table scans, high-cost nested loops, and temporary disk spills.
2. Rewrite the query using CTEs, window functions, or optimized JOIN orders.
3. Recommend exact DDL CREATE INDEX commands (B-Tree, GIN, BRIN, or Partial Indexes) to optimize execution time.
4. Provide expected latency reduction estimate.
OUTPUT FORMAT:
- Section 1: Bottleneck Analysis
- Section 2: Recommended DDL Index Commands
- Section 3: Optimized SQL Query
</system_instructions>
<slow_query>
${your_sql_query}
</slow_query>
<explain_output>
${your_explain_analyze_raw_output}
</explain_output>
Category 3: System Design, ADRs & RCA Postmortem Prompts (Gemini 1.5 Pro & Claude)
Optimized for long-context windows like **Gemini 1.5 Pro** and **Claude 3.5 Sonnet**.
Template 3.1: Architecture Decision Record (ADR) Generator
<system_instructions>
You are a Lead Solutions Architect. Generate a formal Architecture Decision Record (ADR) based on the technical discussion notes in <discussion_notes>.
FORMAT REQUIREMENTS:
Follow the Michael Nygard ADR template structure:
1. Title: [Short noun phrase]
2. Context: What is the technical problem we are facing?
3. Decision: What is the proposed solution and architecture?
4. Status: [Proposed | Accepted | Superseded]
5. Consequences: Positive impact, negative trade-offs, and risk mitigation.
</system_instructions>
<discussion_notes>
${your_raw_meeting_or_slack_notes}
</discussion_notes>
Template 3.2: Incident Postmortem & Root Cause Analysis (RCA)
<system_instructions>
You are a Site Reliability Engineering (SRE) Director. Convert the raw incident timeline logs in <incident_timeline> into an executive-ready Blameless Postmortem Report.
SECTIONS REQUIRED:
1. Executive Summary & Impact (Downtime duration, SLA breach %, financial impact).
2. 5-Whys Root Cause Analysis chain.
3. Timeline of Events (UTC timestamps).
4. Immediate Mitigation vs Long-term Action Items (Jira Ticket format with Owners).
</system_instructions>
<incident_timeline>
${raw_slack_or_datadog_timeline}
</incident_timeline>
Prompt Token Optimization Math: Reducing Prefill Latency by 70%
Let's look at the mathematical impact of structuring system prompts efficiently. In high-throughput AI API services, prompt compression directly improves **prefill processing time** on GPUs.
| Prompt Engineering Style | Avg System Tokens | Prefill Latency | API Cost / 100k Calls |
|---|---|---|---|
| Verbose Conversational Prompt | 3,400 Tokens | 1,850ms | $1,020 |
| Structured XML 6-Layer Formula | 850 Tokens | 420ms | $255 |
| Net Improvement | 75% Token Reduction | 4.4x Faster Prefill | 75% Cost Saved |
Case Study: How an Electronic City Tech Team Delivered a 6-Month Roadmap in 6 Weeks
A mobility tech company in Electronic City Phase 1 was struggling with sprint velocity. Their team of 14 backend developers was bogged down writing boilerplate CRUD routes, updating Swagger documentation, and drafting SQL migrations.
They adopted this **Master AI Prompt Library** across their Cursor and ChatGPT workflows. Here were their results after 6 weeks:
| Sprint Metric | Before Prompt Standard | After Master Prompt Library |
|---|---|---|
| Completed Story Points per Sprint | 42 Points | 168 Points (4x Increase) |
| PR Rejection & Rework Rate | 28.4% | 3.1% |
| API Spec & Doc Generation Time | 6 Hours per endpoint | 12 Minutes per endpoint |
Frequently Asked Questions
Why are XML tags (<system_instructions>) better than standard markdown for prompts? +
Which AI model is best for complex SQL query optimization? +
How do I prevent LLMs from outputting conversational filler like "Sure, here is your code"? +
Which AI model is best for complex SQL query optimization? +
How do I prevent LLMs from outputting conversational filler like "Sure, here is your code"? +
Explore the Entire AI Engineering Series
Free, private, no sign-up. All tools run client-side in your browser.
Related Articles & Tools
About the Author: Renjith Pillai C
Renjith Pillai C is a Network Associate Architect at EasyCalcs.in. He specializes in designing deterministic mathematical simulators for mortgage amortization, tax regime analysis, and retirement planning. With extensive experience in enterprise networking, he built EasyCalcs.in with a single goal: to provide highly accurate, ad-free, and privacy-respecting utilities for students, developers, and fellow IT professionals. His expertise ensures that every subnet calculation and diagnostic tool on this platform adheres to strict industry standards.