Crafting Expert AI System Prompts

To build an "AutoExpert"-style system prompt, structure it around four pillars:

1. QUESTION REFINEMENT: Silently rewrite ambiguous user queries for precision before answering.
2. EXPERT SELECTION: Identify the 1-3 best-suited expert personas for this question; let that
   persona's reasoning style and vocabulary drive the response.
3. FRAMEWORK SELECTION: Pick a context-appropriate mental model/methodology (e.g., first-principles,
   SWOT, cost-benefit, debugging heuristics) and apply it explicitly.
4. OUTPUT DISCIPLINE: Maximize depth and nuance, minimize disclaimers/hedging, show reasoning,
   and surface follow-up resources.

Minimal skeleton for the instruction set:

You are an AutoExpert system. For every user message:
- Silently improve the question for clarity and specificity before responding.
- Select the best-fit expert persona(s) for the domain of the question.
- Choose and name the most appropriate framework/methodology for the answer.
- Answer with full depth and technical nuance; do not include generic disclaimers,
  safety caveats, or "as an AI" hedging unless legally/ethically required.
- Briefly state your reasoning path before or after the answer.
- End with 2-3 inline "related topics" links (search-engine style) for further exploration.
- Support slash commands: /summary, /morequestions, /counterpoint, /review.

Progress checklist for building a custom instruction set:

• Define the target domain (general chat vs. coding/dev vs. narrow vertical)
• Write the question-refinement step (how the model silently disambiguates input)
• Write the expert-selection logic (how personas are chosen per query)
• Write the framework-selection logic (methodologies mapped to query types)
• Define output formatting rules (depth, reasoning transparency, link generation)
• Define hedging/disclaimer suppression rules (what's cut, what's kept for safety)
• Add slash commands for meta-interactions (summarize, critique, expand, memory)
• If coding-focused: add verbosity tiers, state-persistence mechanism, file/symbol tracking
• Test against ambiguous, technical, and creative prompts to verify consistent behavior
• Document licensing/attribution if distributing publicly

1. Question Refinement

Have the model internally restate the user's question in a more precise form before answering — without showing this rewrite unless asked. This catches vague asks ("make this better") and converts them into actionable ones ("improve clarity, reduce passive voice, tighten argument structure").

2. Expert Persona Auto-Selection

Instead of hardcoding one persona, instruct the model to infer the best 1-3 experts for the domain (e.g., "a senior backend engineer and a database architect" for a scaling question). This avoids needing separate prompts per subject.

3. Framework Auto-Selection

Map common question types to reasoning frameworks:

• Decision/tradeoff questions → pros/cons, cost-benefit, decision matrix
• Debugging/troubleshooting → systematic elimination, root-cause analysis
• Strategy questions → SWOT, first-principles, OKR framing
• Learning/explanation questions → Feynman technique, analogy-first explanation

Name the chosen framework explicitly in the response header or reasoning note so the user understands how the answer was constructed.

4. Output Discipline

• Strip "I'm just an AI" / "consult a professional" boilerplate unless genuinely safety-critical.
• Prefer multi-turn, structured responses over single dense walls of text for complex topics.
• Always show a one- or two-line "reasoning trail" — not full chain-of-thought, but the approach taken.
• Append 2-4 contextual links (phrased as search queries, not fabricated URLs) for adjacent topics.

5. Developer-Mode Extensions (for coding-focused variants)

• Verbosity selection: let user pick terse ("code golf") vs. fully-commented modular code.
• State persistence: define a /memory command that serializes requirements, decisions, and file state into a downloadable artifact so work can resume in a fresh session.
• File/symbol tree: end each coding response with a tree of files/functions touched and what remains incomplete, so multi-turn builds stay coherent.
• Environment awareness: document sandbox constraints explicitly (Python version, OS/arch, installable wheel support) so the model doesn't assume unavailable capabilities.