Skip to content
Skills Library
Programming · Writing

module-subpages

/module-subpages

How to write the per-type subpages of a hierarchical module reference — the per-type loop, sub-domain nesting, and the sub-domain index page. Use when a module's design plan chose the hierarchical layout (core-family or multi-domain shapes); a flat module page has no subpages.

Author
zio ↗
Repository
zio-skills ↗
Licence
Apache-2.0
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

How to write the per-type subpages of a hierarchical module reference — the per-type loop, sub-domain nesting, and the sub-domain index page. Use when a module's design plan chose the hierarchical layout (core-family or multi-domain shapes); a flat module page has no subpages.

Original author description

How to write the per-type subpages of a hierarchical module reference — the per-type loop, sub-domain nesting, and the sub-domain index page. Use when a module's design plan chose the hierarchical layout (core-family or multi-domain shapes); a flat module page has no subpages.

How it works

  1. The per-type loop
  2. Sub-domain nesting
  3. Prose written by hand
Original SKILL.md headings · 60 lines, 476 words
SKILL.md preview
---
name: module-subpages
description: How to write the per-type subpages of a hierarchical module reference — the per-type loop, sub-domain nesting, and the sub-domain index page. Use when a module's design plan chose the hierarchical layout (core-family or multi-domain shapes); a flat module page has no subpages.
---

# Module Reference Subpages

A hierarchical module reference is an index page plus one subpage per type. The index carries the
narrative; the subpages carry the API. Skip everything here for a flat layout (`single-core` or `dsl`) —
a flat page documents its types inline and has no subpages.

## The per-type loop

For EACH type in the plan's `typeGroups` — each group has a `label` and its `types`, each with a `kind`:

1. Delegate to the `researcher` subagent for that type's full public API, writing to
   `.flowrite/research/data-type-<type-kebab>.md`. One delegation per type, and read each file before
   drafting from it.
2. Delegate to the `drafter` subagent for the subpage. Tell it:
   - the research file path,
   - the page path `docs/reference/<module-kebab>/<type-kebab>.md`,
   - how this type relates to its siblings, from the module research's relationships,
   - its group `label`, and its `kind`.

**One delegation per type, both steps.** Give each type its own researcher call and its own drafter
call, even when two types look small enough to batch:
✅ two drafter delegations, one per subpage ❌ one delegation asking for "TWO per-type subpages"
Batching is where a subpage picks up its sibling's API: a module run handed the drafter `Lens`'s
research alongside `Iso`'s plan and produced a page naming four methods `Lens` does not have. Two types
is where batching looks safe; four is where it stops being.

**There is no design step for a subpage.** No plan exists for it, and none should be invented: the
drafter decides the sections from the structure template and the research it was given. Never reuse
another type's plan — a module run once handed the drafter `Lens`'s research alongside `Iso`'s plan and
produced a page naming four methods `Lens` does not have.

`kind` sets the depth: a `core` type gets a full page, a `supporting` type gets a minimal one. Fold a
homogeneous family of variants onto one page rather than writing near-identical pages.

## Sub-domain nesting

With two or more sub-domains, nest a directory per sub-domain:

```
docs/reference/<module-kebab>/index.md                       ← the module map
docs/reference/<module-kebab>/<sub-domain-kebab>/index.md    ← one per sub-domain
docs/reference/<module-kebab>/<sub-domain-kebab>/<type>.md   ← the types
```

Each sub-domain `index.md` follows the **"Sub-domain index page"** template in `module-ref-structure`:

1. Lead with the sub-domain's entry-point object, if it has one, documented comprehensively and
   organized by behaviour or task — a subsection per capability. It gets no page of its own, so this is
   its only coverage.
2. A problem-first end-to-end `## Usage` recipe.
3. The type roster, grouped by domain concern.

## Prose written by hand

You write the sub-domain index pages yourself with the `write` tool rather than delegating them, so no
role's instructions supply the writing-style rules — apply them from your own `writing-style` skill.
The rule that matters most here: **link each sibling type's first prose mention to its subpage**, as
``[`TracerProvider`](./tracer-provider.md)``. Verify a page exists before linking to it.

Versions

The database has no other skills named module-subpages.

Database snapshot: 13.11.2026 · package version aab755ac73a3 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 85{setup-skill-name}
    Sets up {module-name} module in a project. Use when the user requests to 'install {module-code} module', 'configure {module-name}', or 'setup {module-name}'.
  • 95docs-module-ref
    Write reference documentation for a module containing multiple related data types. Use when documenting a cohesive domain model (HTTP model, resource management) where types work together. Produces comprehensive type-level pages plus module-level narrative showing relationships,…
  • 100frontend-architecture
    Defines a Clean Architecture and reusable component structures for frontend. Especially useful when the user wants to organize pages, tables, lists, item cards, subpages, and modal dialogs in a predictable and maintainable way. Applies to React, Vue, Svelte, or similar frameworks.
  • 100design-an-interface
    Generate multiple radically different interface designs for a module using parallel sub-agents. Use when user wants to design an API, explore interface options, compare module shapes, or mentions "design it twice".
  • 100port-c-module
    Guide for porting a C module to Rust. Use this when starting to port a C module to Rust.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.