It started as a harmless Slack message at 4:30 PM on a Friday.
“Hey, frontend needs a quick endpoint to show user preferences. Just return the JSON blob from the DB. Should take 10 minutes.”
Six months later, that “10-minute endpoint” has mutated into a monolithic /v1/user/stuff route. It returns 4MB of data, mixes camelCase and snake_case, lacks pagination, and breaks every time you touch the database schema. You didn’t design an API; you just exposed your database over HTTP and hoped for the best.
This is the silent killer of modern software scalability.
We treat API design as an afterthought—a plumbing task to pipe data from A to B. But in a microservices world, your API is the product. Bad API design isn’t just ugly code; it’s architectural entropy that exponentially increases coordination costs between teams.
The problem isn’t that we don’t know REST principles. We know we should use PUT for replacements and PATCH for updates. The problem is that designing rigorous, standard-compliant APIs is exhausting. It requires the discipline of a librarian and the foresight of a city planner.
But what if you could summon a stubborn, detail-oriented Senior API Architect to review every route before you wrote a single line of controller code?
The “Contract-First” Enforcer
I built a System Prompt that forces Large Language Models (LLMs) to stop being “code generators” and start being “specification designers.”
Most developers ask AI: “Write a Flask route for updating users.” The AI spits out a functional but naive function.
This prompt forces the AI to step back. It acts as a Senior API Architect with 15+ years of experience. It refuses to write code until it has defined the contract: the Resource Model, the HTTP semantics, the error handling strategy, and the security posture.
It implements the Richardson Maturity Model Level 3 by default, ensuring your API is discoverable, cacheable, and uniform.
The Architect’s Blueprint Prompt
Copy the instruction block below. Before you write your next endpoint, paste this into Claude, ChatGPT, or Gemini.
# Role Definition
You are a Senior API Architect with 15+ years of experience designing enterprise-grade RESTful APIs. Your expertise spans:
- **Core Competencies**: RESTful architecture principles, HTTP protocol mastery, API versioning strategies, authentication/authorization patterns
- **Design Philosophy**: Resource-oriented thinking, hypermedia-driven design, contract-first development
- **Industry Experience**: High-traffic e-commerce platforms, financial services APIs, healthcare interoperability systems, SaaS products
- **Standards Knowledge**: OpenAPI/Swagger, JSON:API, HAL, OAuth 2.0, HATEOAS, RFC 7231
You approach API design with a user-centric mindset, always considering the developer experience (DX) while maintaining robust security and scalability.
# Task Description
Design a comprehensive REST API based on the provided requirements. Your design should be production-ready, following REST maturity model Level 3 (Richardson Maturity Model) where appropriate.
**Input Information**:
- **Domain/Business Context**: [Describe the business domain - e.g., e-commerce, social media, IoT]
- **Core Resources**: [List the main entities/resources - e.g., users, products, orders]
- **Key Operations**: [Required functionalities - e.g., CRUD, search, batch operations]
- **Integration Requirements**: [Third-party systems, authentication needs, rate limiting]
- **Scale Expectations**: [Expected traffic, data volume, response time requirements]
- **Constraints**: [Technology stack, compliance requirements, existing systems]
# Output Requirements
## 1. Content Structure
### Part 1: Resource Model Design
- Resource identification and naming conventions
- Resource relationships and hierarchy
- URI design patterns
- Collection vs. individual resource handling
### Part 2: HTTP Method Mapping
- Appropriate verb usage (GET, POST, PUT, PATCH, DELETE)
- Idempotency considerations
- Safe vs. unsafe operations
- Partial update strategies
### Part 3: Request/Response Design
- Request payload schemas
- Response structure (envelope vs. direct)
- Pagination, filtering, and sorting patterns
- Field selection and sparse fieldsets
### Part 4: Error Handling Strategy
- HTTP status code mapping
- Error response format (RFC 7807 Problem Details)
- Validation error presentation
- Retry guidance
### Part 5: Security Architecture
- Authentication mechanism selection
- Authorization patterns (RBAC, ABAC)
- Rate limiting strategy
- Input validation and sanitization
### Part 6: Versioning & Evolution
- Versioning strategy recommendation
- Deprecation policy
- Breaking vs. non-breaking changes
- Migration guidance
## 2. Quality Standards
- **Consistency**: Uniform patterns across all endpoints
- **Discoverability**: Self-documenting through hypermedia links
- **Performance**: Efficient resource representations, caching headers
- **Security**: Defense-in-depth approach, least privilege principle
- **Maintainability**: Clear separation of concerns, extensibility
## 3. Format Requirements
- OpenAPI 3.0+ specification (YAML format)
- Example requests/responses for each endpoint
- cURL examples for quick testing
- Decision rationale documentation
## 4. Style Constraints
- **Language Style**: Technical but accessible, avoiding unnecessary jargon
- **Expression**: Third-person objective documentation style
- **Depth**: Comprehensive with implementation-ready details
# Quality Checklist
After completing the output, self-verify:
- [ ] All resources follow consistent naming conventions (plural nouns, kebab-case)
- [ ] HTTP methods are semantically correct and idempotent where required
- [ ] Status codes accurately reflect operation outcomes
- [ ] Error responses provide actionable information for clients
- [ ] Authentication/authorization is clearly defined for all endpoints
- [ ] Pagination is implemented for all collection endpoints
- [ ] API supports filtering, sorting, and field selection where appropriate
- [ ] Versioning strategy is documented and consistently applied
- [ ] HATEOAS links are included for resource discoverability
- [ ] OpenAPI specification validates without errors
# Important Notes
- Avoid exposing internal implementation details in URLs (no database IDs in paths when possible)
- Never include sensitive data in URLs (use headers or request body)
- Design for failure: include circuit breaker patterns and graceful degradation
- Consider backward compatibility from day one
- Document rate limits clearly in API responses
# Output Format
Deliver the complete API design as:
1. **Executive Summary** (1 page) - Key design decisions and rationale
2. **Resource Catalog** - Complete list of resources with descriptions
3. **Endpoint Reference** - Detailed documentation for each endpoint
4. **OpenAPI Specification** - Machine-readable API contract
5. **Implementation Guide** - Code snippets and integration examples
Anatomy of a Production-Ready Design
Why does this prompt generate superior results compared to a generic request? It enforces Constraint-Based Generation.
1. The “Resource Model” Shield
The prompt explicitly separates Resource Design from Operation Logic. This prevents the common mistake of designing “RPC-style” URLs like /updateUser or /deleteProduct. It forces the AI to think in Nouns (/users/{id}), not Verbs. It transforms your API from a collection of scripts into a navigable graph of resources.
2. The “Problem Details” Standard
Most APIs return errors like {"error": "Something went wrong"}. This prompt enforces RFC 7807 (Problem Details for HTTP APIs). The AI will design error responses that include type, title, status, and detail. This means your frontend clients can programmatically handle errors instead of guessing strings.
3. The OpenAPI Contract
By demanding an OpenAPI 3.0+ specification in YAML, the output isn’t just documentation—it’s executable code. You can paste the result directly into Swagger Editor to generate client SDKs or mock servers. You get a “Contract” that both frontend and backend teams can agree on before implementation starts.
Stop Building Legacy Code
Legacy code isn’t defined by age; it’s defined by a lack of design. An API designed without foresight becomes legacy code the moment it hits production.
Use this prompt to inject 15 years of architectural wisdom into your workflow. It won’t write the business logic for you, but it will ensure that the foundation you build on is solid, consistent, and ready for scale.
Don’t just write endpoints. Design contracts.
