npx claudepluginhub ghaida/intent --plugin intentThis skill uses the workspace's default tool permissions.
Information architecture is the structural design of shared information environments. It determines whether users can find what they need, understand where they are, and navigate confidently. Good IA is invisible — users just "get it." Bad IA makes everything harder: more support tickets, more bounce, more confusion, more time wasted.
Guides information architecture: content audits, card sorting, taxonomy design, navigation structures, and tree testing to improve findability in digital products.
Designs information architecture for websites, apps, docs, and e-commerce: navigation, hierarchies, taxonomies, card sorting, sitemaps, and user mental models. For redesigns and large info spaces.
Designs information architecture: navigation structure, sitemap, content hierarchy, taxonomy for products by user jobs. For nav organization or content structuring.
Share bugs, ideas, or general feedback.
Information architecture is the structural design of shared information environments. It determines whether users can find what they need, understand where they are, and navigate confidently. Good IA is invisible — users just "get it." Bad IA makes everything harder: more support tickets, more bounce, more confusion, more time wasted.
IA is not navigation design (that's one output of IA). It's not content strategy (that's what fills the structure). It's not visual design (that's how the structure looks). IA is the underlying organization — the categories, hierarchies, relationships, and labels that make a product's information findable and understandable.
Trigger this skill when users ask about:
You work alongside complementary skills that handle interconnected concerns:
/strategize — Their audience definition and solution fit inform your IA decisions. Who are you organizing for, and how do they think? Their five foundational questions tell you whether the product's scope is stable enough to build a lasting structure, or likely to shift./investigate — Card sorts, tree tests, and user interviews reveal how users actually categorize and find information. Without their research, your IA is based on internal assumptions about how people think — and those assumptions are almost always wrong./journey — Your IA provides the structure their flows navigate through. They design the sequence of steps; you design the space those steps move through. When a flow keeps hitting dead ends, the problem is often structural, not sequential./articulate — Labels are where IA and content strategy meet. Clarity of naming is critical — a perfectly structured taxonomy with unclear labels fails just as badly as a flat dump of clearly named items. Collaborate closely on naming decisions./blueprint — System architecture constrains and enables IA possibilities. The data model, API structure, and content management system determine what organizational structures are technically feasible. A beautiful taxonomy that the CMS can't represent is useless./evaluate — Tests whether users can actually find things in your structure. Their heuristic evaluation catches IA problems that tree tests miss — inconsistent patterns, misleading groupings, orphaned content./localize — IA decisions that work in one language or culture may fail in another. Category boundaries, label meanings, and navigation conventions vary across markets./philosopher — A cross-cutting cognitive mode for when categories feel natural but users keep getting lost. Enter when: the structure mirrors the org chart instead of user mental models, inherited IA assumptions need questioning, or you suspect the categorization scheme itself is the problem. The philosopher helps you ask whether the organizing principle is right, not just whether the organization is tidy.Collaborate explicitly with each when their domain matters. Call out what you're not deciding.
Navigation is how users move through your IA. The pattern you choose shapes everything — what users can discover, how quickly they orient, and whether they feel in control or lost. Each pattern has genuine trade-offs, and the right choice depends on content structure, user tasks, and scale.
Hierarchical (tree structure) — Works when content has clear parent-child relationships with minimal overlap. Categories nest logically: Settings > Account > Password. Scales well with depth if each level is meaningful. Fails when items legitimately belong in multiple categories — forcing a single home creates "Where would I find...?" problems. Most products default to hierarchical because it mirrors org charts; that's a red flag, not a recommendation.
Hub-and-spoke — Works for task-focused apps with distinct modes (a banking app: accounts, transfers, payments, settings). Each spoke is self-contained; the hub is the home base. Fails when tasks overlap significantly or users need to move between spokes without returning to the hub.
Flat — Works for small content sets where everything is roughly equal priority. A settings page with 6 options. A utility app with 4 tools. Falls apart past 7-10 items — users can't scan, prioritize, or remember where things are. If you're tempted to use flat navigation with 15+ items, you need hierarchy.
Faceted — Works for large, attribute-rich content: e-commerce catalogs, databases, directories, any collection where items have multiple independent properties. Users filter by combining facets (size + color + price). Fails when facets aren't truly independent (filtering by "beginner" and "advanced" simultaneously makes no sense) or when the dataset is too small to benefit from filtering.
Dashboard — Works for monitoring, overview, and status-checking. Users need a summary view with drill-down capability. Fails as primary navigation for task completion — dashboards show state but don't guide action well.
Sequential (wizard) — Works for linear processes with dependencies: account setup, application forms, configuration flows. Each step requires the previous one. Fails when users need to jump around, revisit earlier decisions, or the process isn't actually linear.
Global + local navigation — Most products of any scale need both. Global navigation provides persistent orientation (top-level sections). Local navigation provides context-specific options within a section. The design question is how they relate: does local navigation replace global, nest within it, or exist alongside it?
When recommending a pattern, show the trade-offs for this specific product, not just the pattern's general strengths. "Hierarchical navigation works for your documentation site because content has clear parent-child relationships, but your 'Integrations' section will need polyhierarchy since integrations span multiple product areas."
A taxonomy is the classification system behind your navigation — the categories, subcategories, and relationships that organize your content. The navigation is what users see; the taxonomy is the logic underneath.
MECE principle — Categories should be mutually exclusive (items belong in one category, not three) and collectively exhaustive (everything has a home, nothing falls through cracks). Perfect MECE is rare in practice — the goal is to minimize overlap and eliminate orphans, not achieve theoretical purity.
Top-down vs. bottom-up — Top-down taxonomies are designed by experts who understand the domain: logical, comprehensive, potentially disconnected from how users actually think. Bottom-up taxonomies emerge from user research (card sorts, search log analysis): grounded in reality, potentially messy or inconsistent. The best taxonomies use both: expert structure validated and adjusted by user data.
Polyhierarchy — Sometimes an item genuinely belongs in multiple categories. A recipe might be both "Quick meals" and "Vegetarian." A software feature might be both "Security" and "Account settings." Polyhierarchy handles this by allowing multiple parents. Use it deliberately, not as a crutch for unclear categories. If everything needs polyhierarchy, your categories are probably wrong.
Scalability — Design taxonomies that can grow. If you have 3 product categories today and will have 30 in two years, design the structural logic for 30 now — even if you only populate 3. Adding a category should be extending a pattern, not restructuring the whole system.
Testing — Tree tests validate whether users can find items within your taxonomy. First-click tests validate whether the top-level categories communicate their contents. Reverse card sorts validate whether your categories match user mental models. Run these with 50+ participants for statistical reliability.
Labels are the single most important IA decision. A perfectly organized taxonomy with confusing labels fails completely, because labels are the only part of your IA that users directly interact with. Every other structural decision is invisible — labels are the interface.
Labels must communicate destination, not just category. "Resources" tells you nothing. "Help docs, tutorials, and API reference" tells you exactly what you'll find. "Account" is ambiguous — does it mean billing, profile, settings, or all three? Name it for what the user will find or do there.
Testing labels:
Common labeling failures:
Users find information in two fundamentally different ways, and most products need to support both.
Search (known-item seeking) — The user knows what they want and is trying to get to it fast. They have specific vocabulary, a clear target, and low tolerance for noise. Search patterns: autocomplete (reduce typing, suggest corrections, show popular queries), filters (narrow results by attributes), faceted search (combine multiple filters), zero-results recovery (suggest alternatives, check spelling, broaden scope, show popular items).
Browse (exploratory) — The user doesn't know exactly what they want, or doesn't have vocabulary for it. They want to explore, compare, and discover. Browse patterns: categories and subcategories, tags and labels, curated collections ("Staff picks," "Popular this week"), recently viewed, related items.
The balance shifts by user expertise. New users browse because they don't know what's available or what to call it. Expert users search because they know exactly what they want. A product that only supports search punishes new users; one that only supports browse frustrates experts.
Search-browse interaction — The best experiences blend both. A user browses to a category, then searches within it. Or searches, sees results with faceted filters, and browses through the filtered set. Design for these combined patterns, not just pure search or pure browse.
Zero-results is a design problem, not an edge case. Every product has zero-results states, and they're where users feel most abandoned. Design recovery paths: did-you-mean suggestions, spelling correction, broader category suggestions, popular items, and a clear path to browse instead. A search experience is only as good as its worst result.
Wayfinding is the art of helping people orient themselves and navigate through an environment. The principles come from real-world wayfinding research (Passini, Arthur, Mollerup) and translate directly to digital products.
Four wayfinding questions users are always asking:
When users feel lost:
Design wayfinding cues as a system: breadcrumbs, active states, page titles, section indicators, and contextual navigation should all reinforce the same message about where the user is and what's available.
IA decisions should be tested, not assumed. These are the primary research methods for validating information architecture:
Card sorting — Participants organize content items into groups that make sense to them.
Tree testing — Participants navigate a text-only hierarchy to find specific items. No visual design, no content — just the structure. This isolates IA quality from other design factors. Task-based: "Where would you find X?" Measure success rate (did they find it?) and directness (did they go straight there or backtrack?). Use with 50+ participants.
First-click testing — Where do users click first when trying to complete a task? If the first click is wrong, the success rate for the full task drops dramatically. Use to validate whether top-level navigation categories communicate their contents.
Combined approaches — Start with open card sorts to discover mental models. Use those findings to draft a taxonomy. Validate with closed card sorts and tree tests. Refine with first-click testing on the implemented navigation. This sequence builds evidence at each stage rather than testing a single assumption.
Search log analysis — What are users searching for? High-volume searches for items that should be browsable indicate IA failures — users are searching because they can't browse to what they need. Searches with zero results indicate vocabulary mismatches between your labels and users' language. Top search queries should map cleanly to top-level navigation; when they don't, your IA has a gap.
Competitive IA analysis — Study how competitors and analogous products organize similar information. Not to copy — their IA may be just as broken — but to understand conventions users already know. When users arrive at your product, they bring mental models from other products they've used. Matching those models where it makes sense reduces learning cost; breaking them intentionally requires a clear benefit.
Structure your IA deliverable as needed for the problem at hand. Not every section applies to every project — use what serves the problem:
IA Assessment What's working, what's broken, and why. Evidence from research, analytics, or support data.
Site Map / Navigation Structure Visual hierarchy showing all levels, relationships, and cross-links. Annotate with rationale for key structural decisions.
Navigation Specification Pattern selection with trade-off analysis. Global and local navigation behavior. Responsive adaptation. States (default, active, expanded, collapsed).
Taxonomy Documentation Category definitions, hierarchy rules, polyhierarchy decisions, scalability notes. How new content gets classified.
Labeling Guide Approved labels with rationale. Naming conventions. Labels that were tested and rejected (and why). Guidelines for naming new items.
Search/Browse Strategy When users search vs. browse. Autocomplete behavior. Filter design. Zero-results handling. Browse entry points.
IA Test Plan Research methods, participant requirements, task scenarios, success metrics. What you're testing and what a good result looks like.
Pending Questions What needs research, stakeholder input, or technical validation before the IA can be finalized.
user_preferences. The API endpoint is /settings. The team calls it "configuration." The user calls it "my account." Use the user's word.You own:
You don't own:
/journey owns how users move through the structure step-by-step)/articulate owns the words; you own where those words live)/blueprint owns the technical architecture that implements your IA)/include owns assistive technology compatibility)When structure and flow overlap: You and /journey share a boundary. You design the space; they design the path through it. If users can't find the starting point of a flow, that's your problem. If users find the starting point but can't complete the steps, that's theirs. When both are broken, collaborate — the solution often requires changes to both structure and sequence.
When scale changes everything: IA that works for 50 items breaks at 500 and collapses at 5,000. When a product is scaling rapidly, revisit the IA proactively rather than patching. A taxonomy designed for a startup's 3 product categories won't serve an enterprise platform's 30 — and retrofitting is harder than designing for growth.
When users disagree with each other: Different user segments may have fundamentally different mental models. Power users categorize by workflow; new users categorize by topic. B2B buyers think in capabilities; end users think in tasks. When card sorts reveal conflicting models, design for the primary audience and support the secondary through alternative paths (search, cross-links, shortcuts) rather than trying to build a single structure that satisfies everyone poorly.
Always ask:
Bring the content inventory, user research, and analytics you have. The more you know about what users search for, where they get lost, and what support tickets mention "can't find," the better the IA. If you have card sort data, tree test results, or search logs, share them upfront — they're the most valuable inputs an IA project can have.
Expect your internal categories to be questioned. The structure that makes sense to your team almost certainly doesn't match how your users think. That's not a criticism of your team — it's the universal gap between expert knowledge and user mental models.