Drop your feature list into this prompt and you get back a clean 3-tier taxonomy ready for technical documentation. One structured pass, and the whole architecture of your docs clicks into place. The author of this r/PromptEngineering post shared it as a solution for onboarding flows, and I’d argue it’s one of those deceptively simple frameworks that docs teams walk right past every day.
The Problem This Solves
Most feature docs fail before anyone writes a word. Someone dumps 50 features onto a page, organizes them by however the code shipped, and hopes users figure it out. They don’t. New users get buried in advanced options they don’t need yet. Power users waste time digging through basics to find the edge cases they actually care about.
The real cost is user trust. When someone opens your docs and can’t tell what they should learn first versus what they can safely ignore for now, they stop reading and go look for a YouTube tutorial instead. Good structure tells users where they are in the journey before they have to ask.
The fix isn’t better writing. It’s better structure before any writing starts. And the 3-Tier Taxonomy prompt handles that structure in one pass.
How the Taxonomy Works
The framework splits features into three layers:
- Core, features every user needs from day one
- Advanced, features that unlock real power once the basics are solid
- Experimental, features that are niche, in progress, or come with honest caveats
When you run your features through this prompt, you’re not just sorting a list. You’re building a mental model for users before they touch the product. Core features become your onboarding guide. Advanced features become the natural “what’s next” section. Experimental features get their own clearly labeled space with expectations set upfront.
That Experimental tier deserves more credit than it usually gets. Most docs either hide experimental features entirely or bury them next to stable ones with a small asterisk no one reads. Giving them a named tier does two things: it protects you from support tickets when something breaks, and it actually signals to curious power users that interesting things are happening in that corner of the product. Transparency here builds trust rather than eroding it.
One commenter in the thread flagged that this same architecture transfers directly to AI agent system prompts: Core behaviors always active, Advanced patterns that fire in specific contexts, Experimental capabilities off by default. The principle scales wherever you need layered logic.
Another commenter added a smart check: run a quick validation pass with real user tasks after you generate the taxonomy. AI classifies logically, but users don’t always adopt in logical order. A small reality check tightens the tiers and catches edge cases before they become a confusing onboarding moment.
Why It Works as a Prompt
The technique uses constraint-based classification. You’re not asking the model to summarize or describe features. You’re asking it to make categorical decisions with explicit criteria and justify each one. That’s where language models reason best.
The “explain why each feature belongs in its tier” clause is the key mechanic. It forces reasoning out loud, so you can audit the logic, catch misclassifications, and share the rationale with your team. You’re not just getting a sorted list. You’re getting a documented decision log you can actually defend in a doc review.
That audit step matters more than most people expect. When you can see the model’s reasoning, you’ll often catch one or two features that landed in the wrong tier not because the AI was wrong, but because the feature itself is ambiguous. Surfacing that ambiguity early, before a writer spends two hours on it, is one of the better time saves this prompt quietly delivers.
🛠 Use Cases
- SaaS onboarding flows, build a Core to Advanced progression that matches how users actually grow into the product
- API documentation, separate endpoints by complexity so beginners aren’t hit with edge-case parameters on page one
- AI agent system prompts, layer behaviors by activation context: always-on, situational, experimental
- Internal wikis, classify tools or processes by how often and broadly they get used across the team
- Product roadmap communications, frame features for stakeholders using the same three-tier logic your docs already use
Prompt of the Day
Here is the prompt the Redditor shared, reproduced exactly:
“Take these [Features]. Group them into a ‘3-Tier Taxonomy’ (Core, Advanced, Experimental). Explain why each feature belongs in its tier.”
Replace [Features] with your actual list. Paste it in as a bulleted or numbered list for cleaner output. If you’re working with more than 50 features, run it in batches by category to keep the reasoning tight.
Two variations worth testing once you have the base down:
- Add a persona: “You are a technical writer with 10 years of SaaS experience.” This shifts classification toward user-facing logic instead of engineering logic.
- Add an audience constraint: “Classify these for a non-technical user who has never used the product.” This forces Core choices to be genuinely beginner-appropriate, not just “basic” by developer standards.
A third variation that’s underused: add a time constraint to the prompt. Something like “Classify these assuming a user has 30 minutes to get their first result.” That framing pushes the model to think about activation speed, not just feature complexity, and it usually produces a tighter Core tier than a complexity-only sort would.
Head to the original r/PromptEngineering thread to see how the community is extending this pattern into agent architectures, system prompt layering, and onboarding design. Worth reading if you work anywhere near docs or product structure.
Frequently Asked Questions
Q: Can I use this taxonomy approach beyond documentation?
Yes. The 3-tier taxonomy works equally well for structuring AI agent system prompts , grouping behaviors as Core (always active), Advanced (context-specific), and Experimental (testing). An open-source registry at github.com/caliber-ai-org/ai-setup (888+ stars) collects these prompt architecture patterns from engineers building real agent configs, if you want to see how others apply it.
Q: Why does categorizing features into tiers help LLMs respond better?
When you organize features semantically, LLMs allocate attention strategically , instead of treating 50 items equally, the model learns to weight relevant tiers based on context. Here’s a pro tip: wrap each tier in distinct XML tags (like <core_features> and <advanced_patterns>) to give the LLM deterministic boundaries for retrieval. This cuts hallucination significantly and makes testing specific behaviors much easier.
Q: How do I know if my tier structure matches how users actually learn?
Validate your tiers against real user tasks, not just logical grouping. A feature might belong in Advanced based on technical logic, but if 90% of users need it early, it should move to Core. Test your taxonomy with actual users to make sure the adoption path matches reality, not assumptions.
The ‘Conceptual Hierarchy’ for Technical Docs.
by u/Significant-Strike40 in PromptEngineering