"I need to create comprehensive API documentation for our new REST API that external developers will use. Context: We built a payment processing API with 23 endpoints across 5 resource types (payments, customers, refunds, webhooks, reports). Current situation: we have the API built and tested internally, but documentation is just scattered Postman collections and Slack conversations. We're launching publicly in 3 weeks and need professional docs. What to document: Authentication (OAuth 2.0 + API keys), rate limiting (100 req/min per API key), all endpoints with request/response examples, error codes and handling, webhook event types, SDKs for JavaScript and Python, getting started guide, common use cases. Specific requirements: 1) Document POST /v1/payments endpoint including required fields (amount, currency, payment_method, customer_id), optional fields (description, metadata, idempotency_key), all possible response codes (200 success, 400 validation error, 401 unauthorized, 402 payment declined, 429 rate limit, 500 server error), 2) Real working code examples in curl, JavaScript (Node.js), and Python, 3) Explanation of idempotency (critical for payments), 4) Webhook signature verification process, 5) Testing guide using sandbox environment. Format: needs to work in our existing docs site (built with Docusaurus). Audience: range from experienced developers who just need reference to new developers who need hand-holding. Include: API versioning strategy, breaking vs non-breaking changes policy, deprecation timeline, sandbox vs production environments, support contacts. Make it similar quality to Stripe's API docs (the gold standard). Our developers complain current docs are too technical and missing context - need balance between complete reference and usability."

"Generate documentation for our GraphQL schema - we're transitioning from REST to GraphQL and need to document our new API for our frontend team and eventual public use. Context: Our GraphQL API serves an e-commerce platform with queries for products, categories, cart, orders, and user management. Schema has 15 queries, 12 mutations, 3 subscriptions, 40+ custom types. Problem: GraphQL's introspection provides basic type info but doesn't explain business logic, usage patterns, or best practices. What I need documented: 1) Overview of GraphQL basics for developers new to it (what's different from REST, how to construct queries, understanding fragments and variables), 2) Authentication approach (JWT tokens in headers), 3) Detailed documentation for key queries like 'products' including all available filters (category, price range, search term, stock status, brand), sorting options, pagination (cursor-based, not offset), and response shape examples, 4) Mutations documentation showing required input variables, validation rules, success and error responses, 5) Real-world usage examples: 'How to fetch product list with filtering', 'How to add item to cart', 'How to complete checkout flow', 6) Performance guidance: query complexity limits, how to use DataLoader to avoid N+1 queries, rate limiting. Technical details: Schema uses Relay spec for pagination, custom scalars for DateTime and Money types, union types for search results. Audience: Our frontend developers (React with Apollo Client), and potentially external partners. Format: Markdown files for our internal wiki, but structure should work for GraphQL Playground. Include: common error patterns (querying too many nested levels, missing required fields), debugging tips, GraphQL-specific considerations vs. REST (overfetching vs. underfetching), and performance implications of certain query patterns. Make it practical - less 'here's the schema' and more 'here's how to actually use this effectively.'"

"Create SDK reference documentation for our Python client library that wraps our REST API - we built an SDK but adoption is low because developers don't understand how to use it beyond basic examples. Context: Our SDK is for a cloud storage API (think similar to AWS S3 or Google Cloud Storage). SDK handles authentication, retries, multipart uploads, error handling, but developers keep implementing these themselves because they don't know the SDK capabilities. What to document: 1) Installation and setup (pip install, authentication setup with API keys, initialization with optional configuration), 2) Core concepts: Client object, Bucket operations, Object operations, Upload/Download patterns, 3) Complete method reference for Storage Client class: 18 public methods including create_bucket(), list_buckets(), upload_file(), download_file(), delete_object(), generate_presigned_url(), 4) Real-world code examples: 'Upload large file with progress callback', 'Batch download with error handling', 'Implement resumable uploads', 'Generate temporary public URLs', 5) Advanced patterns: connection pooling, async support, custom retry policies, using context managers, 6) Migration guide from our old SDK (v1.x to v2.x - breaking changes in authentication), 7) Troubleshooting common issues: SSL certificate errors, timeout handling, permission errors, rate limit responses. Structure each method documentation with: signature, parameters with types and descriptions, return value, exceptions that can be raised, basic usage example, advanced usage example. Audience: Python developers ranging from beginner to advanced - many are data scientists not software engineers, so can't assume deep Python knowledge. Format: Sphinx-generated docs hosted on ReadTheDocs. Current problems: developers don't know difference between upload_file (simple, synchronous, for small files) and upload_fileobj (streaming, for large files) and choose wrong one, then blame our SDK for being slow. Include: performance comparison, when to use which method, memory implications. Also document: configuration options, environment variables, logging integration, testing with mocks. Make it searchable and scannable - developers need to quickly find 'how do I upload a file with metadata?' without reading everything."