skills.rest
emvnuel
emvnuelCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

cdd-design-pillars

Quantify cognitive load in Jakarta EE/MicroProfile codebases during code reviews.

1|1|Updated Dec 27, 2025
Search Tags:#refactoring#cognitive-load#code-design#jakarta-ee#microprofile
One-click install
npx skills add https://github.com/emvnuel/SKILL.md --skill cdd-design-pillars
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: cdd-design-pillars
Source: https://github.com/emvnuel/SKILL.md/tree/main/cdd-design-pillars
Command: npx skills add https://github.com/emvnuel/SKILL.md --skill cdd-design-pillars

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Measures and guides reduction of cognitive load in Jakarta EE/MicroProfile code, helping teams design simpler, safer, and more maintainable software.

Core Features & Use Cases

  • Quantifies intrinsic cognitive load in domains (entities, services, controllers) and sets practical load limits per component.
  • Promotes Boundary Separation, Valid State, and Encapsulation as core design pillars to reduce complexity.
  • Useful during code reviews, architecture discussions, and when deciding whether to extract abstractions or refactor

Quick Start

  1. Inspect a module's critical paths and tally cognitive load points using the Pillars guidelines.
  2. Identify hotspots where complexity exceeds recommended limits and propose targeted abstractions or boundary changes.
  3. Document the planned refactor rationale and ensure changes align with the pillars.

Frequently Asked Questions about cdd-design-pillars

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

FAQPage Schema
How do I reduce cognitive load in Jakarta EE and MicroProfile codebases?▼

To reduce cognitive load in Jakarta EE code, quantify intrinsic load per component, enforce boundary separation, valid state, and encapsulation pillars, then refactor hotspots that exceed recommended complexity limits during code reviews.

What is cognitive load measurement and when do I need it for Jakarta EE services?▼

Cognitive load measurement tallies complexity points across entities, services, and controllers to identify when a component exceeds safe maintainability thresholds, guiding targeted abstraction extraction or boundary changes in MicroProfile modules.

How do I measure complexity in MicroProfile entities and controllers during code reviews?▼

Measure complexity by inspecting critical paths, tallying cognitive load points per domain component using the Pillars guidelines, then flagging services or controllers that surpass practical load limits for refactoring.

When should I extract abstractions across Jakarta EE modules?▼

Extract abstractions when cognitive load hotspots exceed recommended limits in entities, services, or controllers, and document the refactor rationale to ensure alignment with boundary separation and encapsulation pillars.

Does this cognitive load approach work for existing Jakarta EE projects or only new ones?▼

It works for existing Jakarta EE projects by applying the Pillars guidelines during code reviews and architecture discussions, identifying complexity hotspots in current modules, and proposing targeted refactors to constrain load.

What are the limitations of using cognitive load pillars for MicroProfile refactoring decisions?▼

The approach requires manual inspection of critical paths and assumes adherence to the cdd pillars cookbook guidance, so it provides directional complexity guidance rather than automated refactoring for Jakarta EE codebases.

Related Skills

Explore More Software Engineering Skills→
emvnuelemvnuel
1

ddd-da-massa

Apply Domain-Driven Design patterns to Jakarta EE web applications.

Community
Advanced
johwerjohwer

improve-codebase-architecture

Audit React and .NET codebases to map module boundaries and propose refactors.

Community
Advanced
mauriciodelriomauriciodelrio
3

clean-code-principles

Enforce clean code principles in TypeScript code generation and refactoring.

Community
Advanced
CuriousLearnerCuriousLearner
27

complexity-analyzer

Measure code complexity metrics and identify high-complexity areas in software projects.

Community
Advanced