Showcase: My one-click blog post outline generator in Botsonic.

I've been evaluating Botsonic for the last quarter, primarily to automate repetitive documentation tasks for our internal engineering knowledge base. While the out-of-the-box features are impressive, the real power—as with most tools in this category—lies in customizing it for specific, high-value workflows. I wanted to share a detailed breakdown of a bot I've built that addresses a common, yet surprisingly time-consuming, task for our content team: generating a structured, actionable outline for a technical blog post from a raw, often vague, idea.

The goal was to move beyond a simple list of headings. The bot needed to produce a framework that a writer could immediately use, complete with suggested subsections, key technical points to cover, and even prompts for data visualization or code examples. The challenge was in crafting the instructions (the "Knowledge Base") and the initial prompt to yield consistent, high-quality results.

Here's the core of the bot's configuration, focusing on the custom instructions that guide its behavior.

**Botsonic Knowledge Base (Custom Instructions):**
```
You are an expert technical content strategist specializing in cloud-native infrastructure, DevOps, and SRE practices. Your task is to transform a raw topic idea into a comprehensive, ready-to-write blog post outline.

Your output MUST be a structured outline with the following sections:

1. **Working Title:** Suggest 2-3 title options that are clear, keyword-aware, and compelling for a technical audience.
2. **Objective & Audience:** A one-sentence goal for the post and a description of the intended reader (e.g., "Platform engineers tasked with cost optimization").
3. **Core Structure:** This is the main outline, using H2 and H3 headings.
- **Introduction (H2):** List 3 key points the intro must cover (pain point, relevance, promise).
- **The Problem / Context (H2):** Outline the specific technical challenge or landscape.
- **Main Body (H2):** Break this into logical sub-sections (H3). For each H3, provide:
* A 1-sentence description of the subsection's content.
* 2-3 bullet points for key technical arguments or steps.
* A suggestion for a diagram, table, or code example if applicable (e.g., "Diagram: Architecture flow before/after," "Code block: Terraform snippet for policy attachment").
- **Implementation / Best Practices (H2):** Provide actionable advice, warnings about common pitfalls, and configuration notes.
- **Conclusion & Next Steps (H2):** Summarize key takeaways and suggest practical actions or further reading.
4. **Keywords & Technical Terms:** Generate a short list of relevant primary and secondary keywords and jargon that should be naturally included.
5. **Resources to Cite:** Suggest internal documentation links, official project docs, or foundational papers the writer should reference.

Always ask one clarifying question if the topic is broad, to scope the outline appropriately (e.g., "Should we focus on Kubernetes cost monitoring or broader cloud FinOps?").
```

**Example Interaction & Output:**

When prompted with a topic like "reducing AWS RDS costs," the bot first asks a clarifying question: "Should the focus be on instance right-sizing, leveraging Aurora serverless, or implementing read replicas for scaling?" Once scoped (e.g., "instance right-sizing for production PostgreSQL workloads"), it generates the full outline as specified.

The resulting outline includes H2/H3 headings, and under the "Main Body" section, you might get an H3 like:
```
### **Right-Sizing Methodology: Metrics Over Guesswork**
*Description: Outline the step-by-step process for moving from static instance selection to data-driven resizing.*
- Key Points:
- Identify core metrics: `CPUUtilization`, `DatabaseConnections`, `ReadLatency`, `WriteLatency` from CloudWatch.
- The role of Performance Insights in identifying dominant wait events and SQL queries.
- Establishing baseline and peak usage patterns over a full business cycle (e.g., 4 weeks).
- Visualization Suggestion: **Table** comparing key metrics for t3.medium vs. r5.large instances based on sample workload.
```

This level of detail transforms the bot from a generic idea generator into a true force multiplier. It enforces a consistent, high-quality structure across all technical content and significantly reduces the "blank page" problem for writers. The bot handles the scaffolding, allowing the writer to focus their expertise on deepening the technical content within a proven framework.

From an infrastructure perspective, building this bot was akin to writing a detailed Terraform module: you define the input variables (the raw topic), the module logic (the custom instructions), and you get a predictable, production-ready output (the structured outline). The cost optimization angle is clear—it reduces the time-to-first-draft for our content team by an estimated 60-70%, which directly translates to engineering hours saved.