>_SkillsHub▋

> nginx-c-module-design

nginx C module directive design guidelines for creating admin-friendly configuration interfaces. This skill should be used when designing nginx module directives — deciding what to expose vs hardcode, naming conventions, scope placement, default values, variable design, and validation patterns. Triggers on tasks involving ngx_command_t design, directive naming, configuration API design, nginx module public interface, or directive deprecation.

fetch
$curl "https://skillshub.wtf/pproenca/dot-skills/nginx-c-module-design?format=md"
SKILL.md•nginx-c-module-design

nginx.org C Module Directive Design Best Practices

Comprehensive directive design guide for nginx C module authors, focused on creating clear, consistent, and admin-friendly configuration interfaces. Contains 46 rules across 8 categories, prioritized by impact to guide decisions about what to expose, how to name it, and how to evolve it safely.

When to Apply

Reference these guidelines when:

  • Deciding which values to expose as directives vs hardcode
  • Naming new directives and choosing argument types
  • Selecting scope placement (http, server, location)
  • Setting default values and validation behavior
  • Designing nginx variables for runtime data
  • Deprecating or renaming existing directives

Companion Skills

This skill focuses on design decisions (the "what" and "why"). For implementation mechanics, see:

  • nginx-c-modules — C implementation: memory pools, request lifecycle, config parsing, handlers, filters
  • nginx-c-perf — Performance: buffers, connections, locks, caching, timeouts
  • nginx-c-debug — Debugging: crash diagnosis, GDB, tracing, sanitizers

Rule Categories by Priority

PriorityCategoryImpactPrefix
1Exposure DecisionsCRITICALexpose-
2Naming ConventionsCRITICALnaming-
3Directive TypesHIGHtype-
4Scope DesignHIGHscope-
5Default ValuesMEDIUM-HIGHdefault-
6Validation & Error MessagesMEDIUMvalid-
7Variable DesignMEDIUMvar-
8Evolution & CompatibilityLOW-MEDIUMcompat-

Quick Reference

1. Exposure Decisions (CRITICAL)

2. Naming Conventions (CRITICAL)

3. Directive Types (HIGH)

4. Scope Design (HIGH)

5. Default Values (MEDIUM-HIGH)

6. Validation & Error Messages (MEDIUM)

7. Variable Design (MEDIUM)

8. Evolution & Compatibility (LOW-MEDIUM)

How to Use

Read individual reference files for detailed explanations and code examples:

Reference Files

FileDescription
references/_sections.mdCategory definitions and ordering
assets/templates/_template.mdTemplate for new rules
metadata.jsonVersion and reference information

> related_skills --same-repo

> rust-write-tests

Skill for writing expert-level Rust tests. Teaches the "What Could Break?" framework, five transformations from superficial to expert tests, flake hunting protocol, intent-based assertions, naming conventions, and a mandatory self-review checklist. Triggers on writing Rust tests, designing test cases, improving test quality, or reviewing test coverage.

> rust-implement

Write production-grade Rust code using a multi-pass approach. Design types first, then implement, then simplify, then verify with automated lint. Use this skill whenever writing new Rust functions, structs, modules, or features. Triggers on Rust implementation, new Rust code, Rust functions, Rust modules, error handling in Rust, async Rust, or type design in Rust.

> valid-skill

A valid test skill with proper formatting. This skill should pass all validations and serves as a reference for the expected format.

> too-long-skill

This skill has more than 500 lines which should fail validation.

┌ stats

installs/wk0
░░░░░░░░░░
github stars132
██████████
first seenMar 17, 2026
└────────────

┌ repo

pproenca/dot-skills
by pproenca
└────────────