Nm Abstract Modular Skills

Build composable skill modules with hub-and-spoke loading

Security Scan

The skill's files, instructions, and requirements are consistent with a documentation-first framework for building modular skills; it requests no credentials, installs nothing, and performs no unexpected actions.

Purpose & Capability

Name/description (modular/hub-and-spoke skill design) match the content: guidance, templates, and examples for modular skills. The documents reference tooling and patterns that are coherent with the stated purpose.

Instruction Scope

SKILL.md and module pages instruct running various scripts (skill-analyzer, token-estimator, module_validator, etc.) and reference relative paths and shared modules. Those scripts are not included in this package (the skill is instruction-only), so using the provided commands requires additional repository files or a separate plugin. The enforcement-patterns content recommends strong 'YOU MUST' style enforcement in some categories, which can cause an agent to prefer this skill aggressively—this is a behavioral design choice rather than a direct security issue.

Install Mechanism

No install spec and no code files are included. That minimizes risk: nothing is downloaded or written to disk by an installer in this package.

Credentials

The skill declares no required environment variables, credentials, or config paths. The instructions do not ask for secrets or unrelated system credentials.

Persistence & Privilege

always is false and the skill does not request persistent system presence or elevated privileges. It does not attempt to modify other skills or global agent config.

Assessment

This is a documentation-only skill for designing modular skills; it does not request secrets or install code. Before relying on its command examples, confirm the referenced scripts (skill-analyzer, token-estimator, module_validator, etc.) actually exist in your environment or repository — the SKILL.md assumes those tools are available elsewhere. Also be aware the enforcement-patterns module recommends strong, prescriptive trigger language (e.g., 'YOU MUST'), which can make an agent prefer this skill inappropriately; review and soften enforcement language if you want more balanced behavior. If you plan to run any scripts the documentation references, inspect those script files first (in the source repo or plugin) so you know what filesystem or network access they perform.

Night Market Skill — ported from claude-night-market/abstract. For the full experience with agents, hooks, and commands, install the Claude Code plugin.

Table of Contents

• Overview
• Quick Start
• Workflow and Tasks
• Quality Checks
• Resources

Modular Skills Design

Overview

This framework breaks complex skills into focused modules to keep token usage predictable and avoid monolithic files. We use progressive disclosure: starting with essentials and loading deeper technical details via @include or Load: statements only when needed. This approach prevents hitting context limits during long-running tasks.

Modular design keeps file sizes within recommended limits, typically under 150 lines. Shallow dependencies and clear boundaries simplify testing and maintenance. The hub-and-spoke model allows the project to grow without bloating primary skill files, making focused modules easier to verify in isolation and faster to parse.

Core Components

Three tools support modular skill development:

• skill-analyzer: Checks complexity and suggests where to split code.
• token-estimator: Forecasts usage and suggests optimizations.
• module_validator: Verifies that structure complies with project standards.

Design Principles

We design skills around single responsibility and loose coupling. Each module focuses on one task, minimizing dependencies to keep the architecture cohesive. Clear boundaries and well-defined interfaces prevent changes in one module from breaking others. This follows Anthropic's Agent Skills best practices: provide a high-level overview first, then surface details as needed to maintain context efficiency.

Module Ownership (IMPORTANT)

Deprecated: skills/shared/modules/ directories. This pattern caused orphaned references when shared modules were updated or removed.

Current pattern: Each skill owns its modules at skills/<skill-name>/modules/. When multiple skills need the same content, the primary owner holds the module and others reference it via relative path (e.g., ../skill-authoring/modules/anti-rationalization.md). The validator flags any remaining skills/shared/ directories.

Quick Start

Skill Analysis

Analyze modularity using scripts/analyze.py. You can set a custom threshold for line counts to identify files that need splitting.

python scripts/analyze.py --threshold 100

From Python, use analyze_skill from abstract.skill_tools.

Token Usage Planning

Estimate token consumption to verify your skill stays within budget. Run this from the skill directory:

python scripts/tokens.py

Module Validation

Check for structure and pattern compliance before deployment.

python scripts/abstract_validator.py --scan

Workflow and Tasks

Start by assessing complexity with skill_analyzer.py. If a skill exceeds 150 lines, break it into focused modules following the patterns in ../../docs/examples/modular-skills/. Use token_estimator.py to check efficiency and abstract_validator.py to verify the final structure. This iterative process maintains module maintainability and token efficiency.

Quality Checks

Identify modules needing attention by checking line counts and missing Table of Contents. Any module over 100 lines requires a TOC after the frontmatter to aid navigation.

# Find modules exceeding 100 lines
find modules -name "*.md" -exec wc -l {} + | awk '$1 > 100'

Standards Compliance

Our standards prioritize concrete examples and a consistent voice. Always provide actual commands in Quick Start sections instead of abstract descriptions. Use third-person perspective (e.g., "the project", "developers") rather than "you" or "your". Each code example should be followed by a validation command. For discoverability, descriptions must include at least five specific trigger phrases.

TOC Template

## Table of Contents

- [Section Name](#section-name)
- [Examples](#examples)
- [Troubleshooting](#troubleshooting)

Resources

Shared Modules: Cross-Skill Patterns

Standard patterns for triggers, enforcement language, and anti-rationalization:

• Trigger Patterns: See trigger-patterns.md
• Enforcement Language: See enforcement-language.md
• Anti-Rationalization: See anti-rationalization.md

Skill-Specific Modules

Detailed guides for implementation and maintenance:

• Enforcement Patterns: See modules/enforcement-patterns.md
• Core Workflow: See modules/core-workflow.md
• Implementation Patterns: See modules/implementation-patterns.md
• Migration Guide: See modules/antipatterns-and-migration.md
• Design Philosophy: See modules/design-philosophy.md
• Troubleshooting: See modules/troubleshooting.md
• Optimization Techniques: See modules/optimization-techniques.md - reducing large skill file sizes through externalization, consolidation, and progressive loading

Tools and Examples

• Tools: skill_analyzer.py, token_estimator.py, and abstract_validator.py in ../../scripts/.
• Examples: See ../../docs/examples/modular-skills/ for reference implementations.