# Master Prompt: Create Gold-Standard, Up-to-Date Technical Tutorials
Now that you have provided the list of topics, please create **comprehensive, high-quality, Gold Standard tutorials for every topic**, following the exact topic list and maintaining a logical learning progression from beginner fundamentals to advanced, real-world implementation.
The tutorials must be suitable for beginners, students, developers, DevOps engineers, SREs, and working professionals. Assume the learner has **no prior knowledge of the specific technology or topic**. Never skip steps, assume undocumented knowledge, or leave gaps in the learning process.
## 1. Research, Accuracy, and Current Best Practices
- Use the latest stable versions, official documentation, recommended installation methods, and current industry best practices available at the time of writing.
- Verify version numbers, installation commands, configuration options, APIs, and code examples against authoritative sources whenever possible.
- Clearly state the tutorial's last-verified date and the software versions used.
- Prefer official documentation, vendor documentation, release notes, and trusted technical references.
- Do not invent commands, features, configuration parameters, outputs, or technical capabilities.
- Distinguish between stable features, experimental features, deprecated practices, and version-specific behavior.
- Include links to relevant official documentation and reference materials.
- If a detail cannot be verified, explicitly identify it rather than presenting it as a confirmed fact.
## 2. Logical Tutorial Structure
Organize each tutorial in a natural learning sequence, moving from fundamentals to practical usage and then advanced implementation.
Use the following structure wherever relevant:
1. **Title and Overview** — Explain what the learner will build or understand.
2. **Learning Objectives** — List the skills and knowledge the learner will gain.
3. **Prerequisites** — Explain required tools, accounts, permissions, software, and foundational knowledge.
4. **Introduction** — Define the technology or concept in simple, beginner-friendly language.
5. **Why It Is Needed** — Explain the problems it solves and when it should be used.
6. **Core Concepts** — Explain every important term, component, feature, and underlying mechanism.
7. **Architecture and Working Principles** — Explain how the components interact and how the technology works internally.
8. **Installation and Configuration** — Provide complete, platform-specific instructions.
9. **Getting Started** — Build a working example from scratch, step by step.
10. **Core Commands and Operations** — Explain essential commands, syntax, options, and practical usage.
11. **Hands-on Examples** — Provide progressively more realistic examples, from simple to intermediate and advanced.
12. **Real-World Use Cases** — Demonstrate how the technology is applied in production environments.
13. **Integration and Automation** — Cover relevant tools, APIs, CI/CD pipelines, cloud services, or other integrations.
14. **Security and Best Practices** — Cover secure configurations, permissions, secrets management, reliability, performance, and maintainability where applicable.
15. **Troubleshooting** — Explain common errors, their causes, diagnostic commands, and solutions.
16. **Practical Exercises** — Include tasks that allow learners to practice independently.
17. **Knowledge Check** — Add review questions with answers.
18. **Summary and Next Steps** — Recap the most important concepts and recommend what to learn next.
19. **Official References** — Provide authoritative documentation and further reading.
Adapt this structure to the subject. Do not force irrelevant sections into a tutorial, but never omit a section that is essential for successful implementation.
## 3. Platform-Specific Installation and Quick Code Sections
For every tutorial that involves installing or running software, provide separate installation and configuration instructions for:
- **Windows**
- **macOS**
- **Ubuntu Linux**
Create a clearly labeled **Quick Installation and Configuration** section near the beginning of the tutorial.
For each operating system, include:
- Prerequisites and required permissions.
- Required dependencies and their installation.
- Exact installation commands, with comments explaining what each command does.
- Configuration file creation or modification, where applicable.
- Environment variables and PATH configuration, where required.
- Service startup and enablement instructions, where applicable.
- Version verification commands.
- A simple validation test to confirm that the installation works.
- Common platform-specific problems and their solutions.
Use PowerShell or the appropriate Windows-native shell for Windows instructions, Terminal with the recommended package manager or installer for macOS, and Bash with appropriate package-management commands for Ubuntu.
Clearly identify commands that must be run as Administrator or with `sudo`. Do not mix commands from different operating systems without labeling them.
**Important:** Provide complete, copy-ready commands and configuration examples. Explain where each command should be executed, what the learner should expect, and how to confirm success. Where multiple installation methods exist, recommend the safest and most appropriate method for beginners and briefly explain the alternatives.
## 4. Step-by-Step Getting Started Guide
The Getting Started section must be a complete, hands-on walkthrough.
Assume the learner is starting from a clean environment and does not know the setup process.
For every procedure:
1. Explain the objective of the step.
2. State the prerequisites for that step.
3. Identify the terminal, directory, application, or configuration file to use.
4. Provide the exact command or complete code.
5. Explain important commands, parameters, flags, configuration fields, and code blocks.
6. Describe the expected output or visible result.
7. Show how to verify that the step succeeded.
8. Explain common errors and how to resolve them before proceeding.
9. Clearly identify what the learner should have completed before moving to the next step.
Never write vague instructions such as "configure the environment," "create the required files," "set up the server," or "run the application" without showing the learner exactly how to do so.
When a task requires several files, provide the directory structure and the complete contents of every required file. Do not use unexplained placeholders, omit important configuration, or reference files that have not been created in an earlier step.
The learner must be able to follow the tutorial sequentially and successfully reproduce the final result.
## 5. Code, Commands, and Practical Examples
All examples must be technically correct, relevant, runnable, and consistent with the versions specified in the tutorial.
- Use realistic scenarios instead of relying exclusively on theoretical examples.
- Present examples in increasing order of complexity.
- Explain code and commands in simple language.
- Include complete source code, configuration files, YAML manifests, scripts, API requests, or other artifacts wherever required.
- Use meaningful file names, directory structures, variable names, and comments.
- Explain important options and parameters, not just the overall command.
- Include sample outputs or expected results where useful.
- Demonstrate how to test, validate, debug, and modify each important example.
- Explain common mistakes and show corrected examples.
- Use safe defaults and avoid exposing credentials, tokens, passwords, or sensitive information.
- Include cleanup or rollback instructions when examples create resources, deploy services, or modify system configurations.
Avoid pseudocode when executable code is expected. If pseudocode is necessary, label it explicitly.
Do not claim that a command or test has been executed unless it has actually been executed in an appropriate environment.
## 6. Mermaid Diagrams and Tables
Use Mermaid diagrams and Markdown tables wherever they improve understanding.
Include appropriate diagrams such as:
- Architecture diagrams showing components and their relationships.
- Flowcharts explaining workflows and decision-making.
- Sequence diagrams illustrating interactions between services.
- Deployment diagrams explaining how applications or infrastructure are deployed.
- Data-flow diagrams explaining how information moves through the system.
For Mermaid diagrams:
- Use valid Mermaid syntax.
- Keep diagrams readable and avoid unnecessarily complex layouts.
- Explain the important components and connections immediately after each diagram.
- Ensure diagrams accurately match the commands, architecture, and implementation described in the tutorial.
Use tables for comparisons, prerequisites, operating-system differences, commands, configuration parameters, pros and cons, troubleshooting scenarios, and version differences.
Do not add diagrams or tables merely for decoration. Use them when they make complex information easier to understand.
## 7. Troubleshooting and Error Resolution
Create a practical troubleshooting section containing common beginner and real-world problems.
For each issue, include:
- The error message or observable symptom.
- The likely cause.
- The command or procedure used to diagnose it.
- The exact steps required to fix it.
- A verification step confirming that the fix worked.
- Prevention tips where appropriate.
Cover installation failures, incorrect permissions, missing dependencies, invalid configurations, network connectivity, service startup failures, incompatible versions, and other topic-specific problems.
Never recommend destructive commands without explaining their impact and providing appropriate safeguards.
## 8. Security, Reliability, and Production Readiness
Where relevant, explain:
- Secure installation and configuration.
- Least-privilege access and permissions.
- Secrets and credential management.
- Network security and exposure risks.
- Logging, monitoring, and health checks.
- Error handling, backups, recovery, and rollback.
- Performance optimization and scalability.
- Development versus staging versus production configurations.
- Common anti-patterns and deprecated practices.
Clearly distinguish between a learning environment and a production-ready implementation. Explain any limitations of the demonstration environment.
## 9. Teaching Style and Content Quality
Write in simple, clear, professional English.
- Define technical terminology before using it extensively.
- Explain complex concepts with practical analogies where appropriate.
- Expand acronyms on first use.
- Break complicated procedures into small, numbered steps.
- Explain both **what to do** and **why it matters**.
- Avoid unexplained jargon, excessive theory, repetitive content, and vague statements.
- Maintain consistent terminology, naming conventions, versions, and examples throughout each tutorial.
- Ensure that later sections build on concepts introduced earlier.
- Use callouts sparingly for important warnings, tips, and common mistakes.
- Make the content useful as a self-study resource, classroom training material, and professional reference.
## 10. Completeness and Quality Assurance
Before finalizing each tutorial, review it against these criteria:
- All assigned topics and important subtopics are covered.
- The content follows a logical progression from beginner to advanced.
- Technical claims and version-specific details have been checked against reliable sources where possible.
- Windows, macOS, and Ubuntu installation instructions are included wherever applicable.
- Commands and configuration examples are complete and correctly labeled.
- The Getting Started guide contains every necessary step.
- All referenced files are provided or explicitly identified as external prerequisites.
- Code examples are internally consistent and include validation instructions.
- Mermaid diagrams use valid syntax and represent the described architecture or workflow.
- Troubleshooting guidance includes actionable fixes and verification steps.
- Security and production considerations are addressed where relevant.
- Official references are included.
- No important step, dependency, configuration, or prerequisite has been silently skipped.
If an example cannot be executed or verified, clearly state that limitation. Do not fabricate test results, command outputs, citations, or successful execution claims.
## 11. Handling Multiple Topics
Apply this standard to **every topic in the original list**.
- Preserve all assigned topics and subtopics.
- Organize them in the most logical learning order without silently removing any requested topic.
- Explain dependencies between topics and introduce prerequisite concepts before they are needed.
- Avoid unnecessary duplication across tutorials. Where content overlaps, briefly recap the prerequisite and link to the relevant section.
- Give each topic enough depth to be useful independently.
- If the scope is too large for one response, divide the content into clearly numbered parts or individual tutorials. Maintain a coverage checklist and continue from the exact point where the previous part ended.
- Do not compress the material so much that essential explanations, commands, examples, or steps are lost.
## Final Instruction
Produce **Gold Standard technical learning material, not a superficial overview or a collection of copied documentation**.
Every tutorial must combine clear explanations, current technical information, complete installation instructions, hands-on implementation, working examples, diagrams, troubleshooting, security considerations, and authoritative references.
The final outcome should enable a beginner to understand the topic, install and configure the technology, implement a working example independently, verify the result, troubleshoot common problems, and understand how to apply the technology in real-world environments.
**Begin by reviewing the complete original topic list, identifying the prerequisites and dependencies, and presenting the proposed tutorial sequence. Then create the tutorials in that order, preserving the complete scope and applying all the quality standards above.**