#documentation

Write a detailed PRD for a new feature. Sections: 1. Overview (problem statement, goals, success metrics). 2. User personas and use cases. 3. User stories with acceptance criteria. 4. Functional requirements (detailed specifications). 5. Non-functional requirements (performance, security, scalability). 6. Design mocks and user flows. 7. Technical considerations and dependencies. 8. Launch plan and rollout strategy. 9. Open questions and risks. Use clear, unambiguous language. Collaborate with engineering and design. Keep as living document.

Create a production-quality Jupyter notebook template. Structure: 1. Markdown header with title, author, date, and objective. 2. Table of contents with anchor links. 3. Environment setup cell (imports, configs, random seed). 4. Exploratory Data Analysis section with visualizations. 5. Modeling section with clear train/test split. 6. Results summary with key metrics and business recommendations. Use consistent styling, hide warnings, and include inline documentation.

Create developer-friendly API documentation. Structure: 1. Overview with quick start guide and authentication. 2. Endpoint reference with request/response examples. 3. Interactive API explorer (Swagger/Postman style). 4. Code samples in multiple languages (Python, JavaScript, cURL). 5. Error codes and troubleshooting guide. 6. Rate limiting and best practices. 7. Webhook documentation with payload examples. 8. Changelog and versioning information. Use clear, concise language with real-world use cases.

Document a complete design system in code. Components to include: 1. Typography scale (H1-H6, Body, Caption). 2. Color variables for Primary, Secondary, Error, Success. 3. Button set (Primary, Outline, Ghost, Sizes). 4. Modal/Dialog patterns. 5. Form inputs with error states. Use Storybook for documentation and Tailwind for utility-first implementation.

Create a professional README.md for an open-source project. Essential sections: 1. Project title with logo and badges (build status, version, license). 2. One-line description and key features. 3. Installation instructions with code blocks. 4. Quick start guide with minimal example. 5. API reference or usage documentation. 6. Contributing guidelines and code of conduct link. 7. License and acknowledgments. Use clear formatting, screenshots, and GIFs for visual appeal.

A tool to auto-generate Hugging Face model cards. Sections to include: 1. Model Description (Architecture, Parameters). 2. Training Data (Datasets used). 3. Evaluation Results (MMLU, HumanEval scores). 4. Intended Use and Biases. 5. Citation info. Minimalist layout with badges for 'Transformers', 'PyTorch', 'Safetensors'.

Create and maintain comprehensive product documentation ecosystem. Documentation types: 1. User guides: step-by-step instructions for end users. 2. API documentation: endpoints, parameters, examples. 3. Admin documentation: configuration, troubleshooting. 4. Developer docs: SDKs, integration guides. 5. Release notes: feature updates, bug fixes. Content strategy: 1. Audience-based: different docs for different user types. 2. Progressive disclosure: basic → advanced information. 3. Multimedia: screenshots, videos, interactive tutorials. 4. Search optimization: logical structure, good navigation. Maintenance workflow: 1. Documentation requirements in user stories. 2. Review process: technical accuracy, clarity. 3. Version control: docs synchronized with product releases. 4. Analytics: track usage, identify gaps. 5. User feedback: ratings, comments, improvement suggestions. Tools: GitBook, Notion, Confluence for authoring, Algolia for search. Success metrics: documentation usage, support ticket reduction, user satisfaction scores. Keep docs current: assign ownership, regular audits, automated link checking.

Write effective code documentation. Levels: 1. Code comments (explain why, not what - complex logic only). 2. Function/method docs (parameters, return values, exceptions - JSDoc, docstrings). 3. README (setup, usage, examples). 4. API documentation (OpenAPI/Swagger for REST). 5. Architecture docs (system design, diagrams). 6. Changelog (version history). Best practices: Keep docs close to code. Update with code changes. Use examples. Avoid obvious comments. Document assumptions and edge cases. Use diagrams (C4 model, UML). Tools: Sphinx, Doxygen, MkDocs. Good code is self-documenting, but docs add context.

Generate documentation for the following TypeScript function in JSDoc format. The function accepts a user object and returns a formatted greeting string. Make sure to document the parameters, their types, and the return value.

Scale through process documentation. Approach: 1. Document recurring processes. 2. Standard Operating Procedures (SOPs). 3. Decision-making frameworks. 4. Tools and system guides. 5. Video walkthroughs. 6. Knowledge base. 7. Version control for updates. 8. Ownership assignment. Use Notion or Confluence. Document as you go. Enables delegation and consistency. Critical for growth.

Create compelling sales proposals. Structure: 1. Executive Summary (1 page): problem, solution, value, investment. 2. Customer Situation (0.5 page): restate their pains from discovery. 3. Proposed Solution (2 pages): how you solve each pain point, features mapped to benefits. 4. Implementation Plan (1 page): timeline, milestones, resources needed from each side. 5. Success Metrics (0.5 page): how you'll measure ROI. 6. Investment (1 page): pricing table, payment terms, what's included. 7. Why Us (1 page): relevant case studies, social proof. 8. Next Steps (0.5 page): clear CTA, decision timeline. Design: branded template, visuals (charts, screenshots), white space. Personalization: use their company name, industry-specific examples, reference past conversations. Follow-up: send via DocuSign or PandaDoc for tracking. Call to review within 24 hours.

Create clear, usable technical documentation that reduces support burden. Documentation hierarchy: 1. Getting started guide: installation, setup, first successful use. 2. User guides: task-oriented instructions with screenshots. 3. API reference: endpoints, parameters, examples, error codes. 4. Troubleshooting: common problems with step-by-step solutions. 5. FAQ: frequent questions from support tickets. Writing principles: 1. Task-oriented: focus on what users want to accomplish. 2. Scannable format: headings, bullet points, numbered steps. 3. Progressive disclosure: basic info first, advanced details in expandable sections. 4. Plain language: avoid jargon, explain technical terms. Information architecture: logical grouping, clear navigation, search functionality. Visual elements: screenshots with annotations, flowcharts for processes, code examples with syntax highlighting. Maintenance workflow: 1. Version control with product releases. 2. User feedback integration: comments, ratings, improvement suggestions. 3. Analytics tracking: most-viewed pages, drop-off points. Tools: GitBook for collaborative editing, Loom for video walkthroughs, Snagit for annotated screenshots.

Provide technical specifications. Format: 1. Confirm exact product model. 2. Provide comprehensive spec sheet. 3. Include dimensions, weight, materials. 4. List technical requirements (power, connectivity). 5. Provide performance metrics. 6. Include certifications and compliance. 7. Link to detailed documentation. 8. Offer to answer specific technical questions. Be thorough and accurate.

Create comprehensive sales playbook for consistency. Sections: 1. ICP and Buyer Personas (who we sell to, pain points, motivations). 2. Value Propositions (core message, differentiation per persona). 3. Sales Process (stages, exit criteria, average time per stage). 4. Methodology (MEDDIC, Challenger, SPIN - which we use). 5. Prospecting (channels, scripts, templates, cadences). 6. Discovery Questions (by persona, problem area). 7. Demo Guidelines (structure, key features to show, customization tips). 8. Objection Handling (top 10 objections, proven responses). 9. Closing Techniques (negotiation tactics, discount policies). 10. Tools and Resources (CRM, sales engagement, enablement content). 11. Metrics and KPIs (what we measure, targets). Format: living Wiki or PDF, searchable, visual (screenshots, flowcharts). Ownership: sales ops maintains, reps contribute. Update: quarterly reviews. Usage: onboarding (week 1 reading), certification (test knowledge), ongoing reference.

Create comprehensive API documentation for a RESTful service. Sections to include: 1. Authentication methods (API key, OAuth 2.0). 2. Endpoint reference with HTTP methods, parameters, and response schemas. 3. Code examples in Python, JavaScript, and cURL. 4. Error codes and troubleshooting guide. 5. Rate limiting and best practices. Use OpenAPI/Swagger spec format with interactive examples. Ensure clarity for both beginner and advanced developers.

Create a comprehensive PRD (Product Requirements Document) template. Sections: 1. Executive Summary (Problem, Solution, Success Metrics). 2. User Stories and Personas. 3. Functional Requirements (Must-have vs Nice-to-have). 4. Technical Constraints and Dependencies. 5. Success Criteria and KPIs. 6. Timeline and Milestones. 7. Open Questions and Risks. Use clear, unambiguous language. Include wireframes placeholders and acceptance criteria for each requirement.

Write comprehensive PRDs for complex product features. PRD structure: 1. Executive Summary (2-3 sentences): what you're building and why. 2. Problem Statement: user pain points with supporting data. 3. Success Metrics: how you'll measure success (leading and lagging indicators). 4. User Stories: core use cases with acceptance criteria. 5. Requirements: functional and non-functional (performance, security). 6. Design Mockups: wireframes or high-fidelity designs. 7. Technical Considerations: architecture, dependencies, risks. 8. Go-to-Market Plan: launch strategy and timeline. 9. Open Questions: items to resolve during development. Review process: stakeholder sign-off from engineering, design, marketing before development starts. Living document: update as requirements evolve, maintain change log. Tools: Confluence, Notion, Google Docs for collaboration. Template ensures nothing falls through cracks on complex projects.

Document components effectively with Storybook 7. Setup: 1. CSF3 format for stories. 2. Autodocs for prop table generation. 3. Controls addon for prop manipulation. 4. Actions addon for event logging. 5. Interactions testing with @storybook/test. 6. Accessibility checks with a11y addon. 7. Design tokens documentation. 8. MDX for custom documentation pages. Use composition for multiple projects and implement visual testing with Chromatic.