feature-module-architect

Scaffolds feature modules with colocation and a 500 LOC/file limit.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/d-oit/do-novelist-ai --skill feature-module-architect
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: feature-module-architect
Source: https://github.com/d-oit/do-novelist-ai/tree/main/.claude/skills/feature-module-architect
Command: npx skills add https://github.com/d-oit/do-novelist-ai --skill feature-module-architect

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Scaffolds feature modules following feature-based architecture with colocated code and a 500 LOC file limit.

Core Features & Use Cases

  • Standard Feature Structure: Components, hooks, services, types, utils, and index.ts.
  • 500 LOC Limit: Hard enforcement to keep files maintainable.
  • Colocation: Related code kept together within a feature.
  • Public API: Exports via index.ts for other features.

Quick Start

Create a new feature under src/features/{feature-name} with the standard folders and a public index.ts.

Frequently Asked Questions about feature-module-architect

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I organize feature code with colocation in TypeScript?

Colocation groups related TypeScript code—components, hooks, services, types—within a single feature folder at src/features/{feature-name}/. This keeps feature logic together, improves maintainability, and makes dependencies explicit through a public index.ts API.

What's the best way to structure a scalable frontend module architecture?

Use feature-based architecture with standard folders (components, hooks, services, types, utils) under src/features/{feature-name}/, enforcing a 500 LOC per-file limit. This pattern prevents monolithic files, keeps concerns separated, and enables independent feature scaling.

How do I enforce file size limits in my TypeScript frontend codebase?

Apply a hard 500 LOC per-file limit across your feature modules. When a file approaches the limit, split functionality into smaller, focused files within the same feature folder and re-export through the public API via index.ts.

Can I refactor large scattered TypeScript files into organized modules?

Yes. Gather scattered feature code into src/features/{feature-name}/ with standard subdirectories, apply the 500 LOC constraint to force decomposition, and expose only necessary exports through index.ts to maintain a clean public API.

When should I use feature-based architecture over flat folder structures?

Use feature-based architecture when managing multiple frontend features to avoid tangled dependencies, improve code discoverability, and enforce modularity boundaries. The 500 LOC limit ensures files remain testable and maintainable as codebases grow.

How do I maintain a public API surface across feature modules?

Define exports in each feature's index.ts file, selectively exposing only components, hooks, and utilities meant for cross-feature use. This creates a predictable contract and prevents internal implementation details from leaking to other features.