# MASTER PROMPT — COMPLETE REFERENCE GUIDE & TUTORIAL
## Topic
**[ENTER TOPIC HERE]**
Example:
**GitHub Projects — Complete Tutorial**
## Topics / Scope
Cover the following topics completely:
[PASTE TOPICS HERE]
If no detailed topic list is provided, research the subject and create a logical, comprehensive curriculum covering the essential, intermediate, advanced, administration, troubleshooting, security, best-practice, and real-world usage areas relevant to the topic.
---
# Your Role
Act as a **senior practitioner, technical architect, trainer, documentation engineer, and subject-matter expert with 15–20+ years of practical industry experience**.
Your job is to create a **complete, production-quality reference guide and hands-on tutorial** that can be used by:
- Beginners learning the technology
- Working professionals
- DevOps / Developers / Administrators / Architects, where applicable
- Trainers conducting classroom or corporate training
- Engineers preparing for real-world implementation
- Readers using the document later as a reference handbook
The tutorial must combine:
**Concept → Why → How → Example → Practice → Real-world use case → Best practices → Troubleshooting**
Do not write shallow, generic, SEO-style content.
---
# 1. Research & Freshness Requirements
Before writing the tutorial, research the topic using **current and authoritative sources**.
Prioritize sources in this order:
1. Official product documentation
2. Official product/blog/release notes
3. Official GitHub repositories or examples
4. Standards/specifications
5. Vendor engineering documentation
6. Highly credible technical sources when official documentation is insufficient
The tutorial must reflect the **latest generally available functionality as of the current date**.
At the beginning of the document include:
> **Last Verified:** [Current Month YYYY]
Where functionality has recently changed, clearly explain:
- Current behavior
- Older/deprecated behavior, only when useful
- Migration considerations
- Renamed or replaced features
- Important limitations
Do **not** silently mix legacy and current versions.
If information cannot be verified, explicitly identify it instead of inventing an answer.
---
# 2. Audience & Teaching Style
Assume the reader understands basic computers/software but may be new to this specific technology.
Explain concepts in **simple English without sacrificing technical correctness**.
Use this teaching pattern wherever appropriate:
### What is it?
Explain the concept.
### Why do we need it?
Explain the problem it solves.
### How does it work?
Explain the internal or logical flow.
### When should we use it?
Provide practical situations.
### Example
Show a realistic example.
### Real-world use case
Explain how teams use it in practice.
### Best practices
Explain recommended implementation patterns.
### Common mistakes
Explain frequently encountered problems.
Avoid unnecessarily academic language.
Define important technical terms when they first appear.
---
# 3. Tutorial Architecture
Organize the tutorial as a progressive learning journey.
Use a structure similar to:
# [Technology] Complete Tutorial
## 1. Introduction
Explain:
- What it is
- Why it exists
- Problems it solves
- Who should use it
- Where it fits in the ecosystem
- Key capabilities
- Common real-world use cases
Include a simple architecture or conceptual diagram.
---
## 2. Core Concepts
Explain the fundamental building blocks before advanced configuration.
For every major concept include:
- Definition
- Purpose
- How it works
- Example
- Relationship with other concepts
Use diagrams and tables where useful.
---
## 3. Prerequisites
Include:
- Required account/access
- Tools
- Software
- Permissions
- Environment preparation
- Assumed knowledge
---
## 4. Getting Started
Provide a beginner-friendly, step-by-step walkthrough.
The reader should be able to complete a simple working implementation before proceeding to advanced topics.
---
## 5. Complete Feature Guide
Cover every supplied topic systematically.
Do not merely mention features.
Explain:
- Purpose
- Configuration
- Workflow
- Options
- Limitations
- Examples
- Use cases
- Best practices
---
## 6. Hands-On Examples
Provide practical examples progressing from simple to realistic.
Where relevant include:
- Configuration files
- CLI commands
- YAML
- JSON
- Terraform
- API examples
- Scripts
- Queries
- UI workflow steps
- Repository/project structures
Every code example must be:
- Syntactically correct
- Clearly formatted
- Explained
- Realistic
- Safe to experiment with
Do not insert code merely to make the tutorial appear technical.
---
## 7. Real-World Workflows
Demonstrate realistic scenarios.
Examples could include:
- Small team workflow
- Enterprise workflow
- Development lifecycle
- Automation workflow
- Administration workflow
- Project management workflow
- CI/CD integration
- Security workflow
Adapt these to the technology being discussed.
---
## 8. Architecture & Flow Diagrams
Use Mermaid diagrams wherever visual explanation improves understanding.
Use appropriate diagram types such as:
### Flowchart
```mermaid
flowchart TD
A[Start] --> B[Configure]
B --> C[Execute]
C --> D[Validate]
```
### Architecture Diagram
```mermaid
flowchart LR
User --> Application
Application --> Service
Service --> Database
```
### Sequence Diagram
```mermaid
sequenceDiagram
User->>System: Request
System->>Service: Process
Service-->>System: Response
System-->>User: Result
```
### State / Lifecycle Diagram
Use when explaining lifecycle or status transitions.
### Git Graph
Use when appropriate.
Do not create diagrams just for decoration.
Every diagram should make a concept easier to understand.
Immediately below important diagrams, provide a short explanation.
---
# 9. Tables
Use tables extensively where comparison is clearer than paragraphs.
Examples:
| Concept | Purpose | Example |
|---|---|---|
| Feature A | Explanation | Example |
| Feature B | Explanation | Example |
Useful tables may include:
- Feature comparisons
- Terminology
- Permissions
- Configuration options
- Commands
- Limitations
- Best practices
- Troubleshooting
- UI vs CLI vs API
- Free vs paid capability
- Recommended usage
Keep tables readable.
Do not create extremely wide tables unnecessarily.
---
# 10. Step-by-Step Procedures
For operational tasks, provide exact numbered steps.
Example:
### Creating X
1. Open ...
2. Select ...
3. Configure ...
4. Enter ...
5. Save ...
6. Verify ...
Then explain:
**Expected result:**
What the user should see.
**Verification:**
How to confirm the configuration works.
**Common failure:**
What may go wrong.
---
# 11. Use Cases
For important features include realistic use cases.
Use this format when useful:
### Use Case: Release Management
**Scenario:**
A software team needs to...
**Solution:**
Use...
**Workflow:**
```mermaid
flowchart LR
Issue --> Development --> Review --> Release
```
**Why this works:**
Explain the design decision.
---
# 12. Best Practices
Create a dedicated best-practices section covering areas such as:
- Naming conventions
- Security
- Permissions
- Maintainability
- Scalability
- Automation
- Organization
- Governance
- Cost, where applicable
- Performance, where applicable
- Team collaboration
Separate:
**Recommended**
from:
**Avoid**
where useful.
---
# 13. Common Mistakes
Explain common implementation mistakes.
Use a table where appropriate:
| Mistake | Why It Happens | Impact | Better Approach |
|---|---|---|---|
Focus on mistakes engineers actually encounter.
---
# 14. Troubleshooting Guide
Create a practical troubleshooting section.
Use a structure such as:
| Problem | Likely Cause | How to Diagnose | Solution |
|---|---|---|---|
Provide commands or diagnostic procedures where applicable.
---
# 15. Security & Permissions
If relevant to the technology, explain:
- Authentication
- Authorization
- Roles
- Permissions
- Secrets
- Tokens
- Least privilege
- Access control
- Auditability
- Common security risks
Include a permissions matrix when useful.
---
# 16. Automation & API
If the product supports automation, include:
- CLI
- API
- Webhooks
- SDK
- CI/CD integration
- Infrastructure as Code
- Automation examples
Explain when automation is preferable to manual UI operations.
---
# 17. Beginner → Intermediate → Advanced Mapping
Where useful, categorize functionality:
| Level | What to Learn |
|---|---|
| Beginner | Core concepts and basic workflows |
| Intermediate | Automation and team workflows |
| Advanced | Architecture, governance, APIs and scaling |
---
# 18. Quick Reference / Cheat Sheet
Create a compact section readers can return to later.
Include relevant:
- Commands
- Keyboard shortcuts
- Syntax
- Terminology
- Common configuration
- URLs
- API operations
- Workflow reminders
---
# 19. Hands-On Exercises
Create practical exercises.
For example:
### Exercise 1 — Beginner
**Objective:** ...
**Tasks:**
1. ...
2. ...
3. ...
**Expected outcome:** ...
### Exercise 2 — Intermediate
...
### Exercise 3 — Real-World
...
Exercises should reinforce important concepts rather than introduce unrelated complexity.
---
# 20. Complete Practical Project
Where appropriate, end with one realistic mini-project combining multiple concepts from the tutorial.
Include:
- Requirement
- Architecture
- Implementation
- Configuration
- Validation
- Expected result
- Improvement ideas
---
# 21. Interview / Knowledge-Check Questions
Include useful questions such as:
- Conceptual questions
- Scenario-based questions
- Troubleshooting questions
Do not make this excessively long unless the topic is certification-oriented.
---
# 22. FAQ
Include important questions readers are likely to ask after completing the tutorial.
---
# 23. Summary
Conclude with:
- Key concepts learned
- Recommended next steps
- What to practice
- Advanced areas to explore
---
# 24. References
Provide the most important authoritative sources used to verify the tutorial.
Prefer official documentation.
Do not fabricate links, features, commands, or citations.
---
# Markdown Formatting Requirements
The complete output must be delivered as a **single clean Markdown document**.
Use:
- `#` for document title
- `##` for major chapters
- `###` for topics
- `####` only when genuinely necessary
- Bullet lists for concise information
- Numbered lists for procedures
- Tables for comparisons
- Fenced code blocks with language names
- Mermaid fenced blocks for diagrams
- Blockquotes only for important notes/warnings
Avoid:
- Excessive heading nesting
- Excessive bold formatting
- Giant paragraphs
- Decorative emojis throughout technical documentation
- Repeating the same explanation
- Fake quotes
- Marketing language
- Filler text
Keep Markdown compatible with common Markdown editors.
---
# Code Quality Requirements
For every code/configuration example:
1. Use correct syntax.
2. Add the appropriate code-block language.
3. Explain what the code does.
4. Explain important lines where needed.
5. Mention prerequisites.
6. Mention expected output where relevant.
7. Avoid fake commands or APIs.
8. Clearly identify placeholders.
Example:
```bash
gh project list --owner my-organization
```
Explain the command immediately below it.
---
# Diagram Quality Requirements
Before adding a Mermaid diagram ask:
> Does this diagram explain something faster or more clearly than text?
If not, do not add it.
Diagrams should primarily explain:
- Architecture
- Workflow
- Lifecycle
- Relationships
- Data flow
- Request flow
- Automation flow
- Decision flow
Keep diagrams simple enough for students to understand.
---
# Content Quality Standard
The final guide should feel like a combination of:
- Official documentation
- A high-quality technical book
- An instructor-led workshop
- A production implementation handbook
- A practical troubleshooting reference
It must be detailed enough to serve as a **reference guide**, while remaining simple enough for a learner to follow sequentially.
Do not sacrifice readability merely to make the document longer.
---
# Important Quality Rules
Do NOT:
- Hallucinate features
- Invent commands
- Invent limitations
- Copy outdated tutorials
- Mix deprecated and current products without explanation
- Pad sections with generic content
- Repeat information simply to increase length
- Explain obvious concepts excessively
- Include irrelevant history
- Force every section into the same template when it does not fit
DO:
- Verify current functionality
- Use official terminology
- Explain concepts simply
- Provide realistic examples
- Connect related concepts
- Highlight limitations
- Mention important gotchas
- Show real-world workflows
- Explain WHY, not only HOW
---
# Final Quality-Control Pass
Before producing the final document, internally verify:
- Are all requested topics covered?
- Is the information current?
- Are legacy features clearly distinguished?
- Are examples technically valid?
- Are Mermaid diagrams syntactically reasonable?
- Are workflows easy to understand?
- Are tables useful rather than decorative?
- Are important limitations included?
- Are security concerns covered where relevant?
- Are use cases realistic?
- Can a beginner follow the tutorial?
- Is there enough depth for an experienced engineer to use it as a reference?
- Are repetitive sections removed?
- Is the Markdown clean?
Fix any weaknesses before returning the final document.
---
# Final Output Requirement
Return **only the finished Markdown tutorial**.
Do not give me:
- A plan for creating it
- An explanation of what you intend to write
- A partial outline instead of the tutorial
- Questions unless essential information is genuinely missing
Create the complete tutorial in the current response.
Target quality:
> **Industry-grade technical reference guide + training handbook + hands-on tutorial.**