panacea-navigator

Map PANaCEa repository structure to architectural layers for code placement.

Updated Nov 16, 2025
One-click install
npx skills add https://github.com/aaronjullger-lgtm/PANaCEa --skill panacea-navigator
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: panacea-navigator
Source: https://github.com/aaronjullger-lgtm/PANaCEa/tree/main/.agents/skills/panacea-navigator
Command: npx skills add https://github.com/aaronjullger-lgtm/PANaCEa --skill panacea-navigator

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill provides a compact map of the PANaCEa repository to help engineers decide where code belongs, speeding feature work and debugging by aligning tasks with the correct layers.

Core Features & Use Cases

  • Architecture map: Quick reference of major directories and their roles within PANaCEa.
  • Decision guidance: Helps determine where new features, fixes, or refactors should be implemented (frontend, backend, data layer).
  • Onboarding aid: Accelerates ramp-up for new contributors by clarifying file ownership and data flow.

Quick Start

Review the PANaCEa repository structure to decide where new code belongs and how features should be integrated.

Frequently Asked Questions about panacea-navigator

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

FAQPage Schema
How do I navigate a codebase to decide where new features belong in the architecture?

To navigate a codebase and decide where new features belong, map the repository structure to its architectural layers using defined file ownership rules. This ensures code changes land in the intended frontend, backend, or data layer during feature work.

What is the best way to map repository structure for onboarding new contributors?

Mapping repository structure for onboarding involves providing a compact architecture map that clarifies directory roles and data flow. This accelerates ramp-up by helping new contributors understand file ownership and where to implement fixes.

How do I trace data flow across repository layers during debugging?

Tracing data flow across repository layers during debugging requires mapping the codebase to its architectural structure. This clarifies how data moves between frontend, backend, and data layers to pinpoint exactly where changes or fixes should be applied.

Can I use architectural mapping rules to guide refactoring across multiple layers?

Yes, architectural mapping rules guide refactoring across multiple layers by specifying file ownership decisions. This ensures that structural changes and refactors are implemented in the correct architectural layer, maintaining codebase integrity and alignment.

Does this codebase navigation approach work without external dependencies?

Yes, this codebase navigation approach works without external dependencies. It relies solely on internal mapping rules and structural knowledge of the repository to guide file ownership and layer placement for feature work and debugging.

When should I not rely on a static architectural map for codebase navigation?

You should not rely solely on a static architectural map when the repository structure undergoes rapid, unmapped changes. If file ownership rules are outdated, layer mapping may misguide feature placement and disrupt intended data flow.