skills.rest
FindMalek
FindMalekCOMMUNITY
Explore all skills by this author →
Website𝕏@foundmalekGitHub

dukkani-architecture

Define and enforce monorepo architecture boundaries for Dukkani apps and packages.

9|2|Updated Nov 10, 2025
Search Tags:#architecture#governance#monorepo#packages#boundaries#apps#dukkani
One-click install
npx skills add https://github.com/FindMalek/dukkani --skill dukkani-architecture
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: dukkani-architecture
Source: https://github.com/FindMalek/dukkani/tree/main/.cursor/skills/dukkani-architecture
Command: npx skills add https://github.com/FindMalek/dukkani --skill dukkani-architecture

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Defines and enforces clear monorepo boundaries for Dukkani, clarifying where code should live and how apps, packages, and domains interact to reduce cross-cutting changes.

Core Features & Use Cases

  • Establishes ownership models for apps (e.g., apps/) and packages (e.g., packages/), ensuring separation of concerns and preventing cross-app imports.
  • Documents recommended roles and responsibilities for each app and package, including API entrypoints, UI surfaces, and shared contracts via exported schemas.
  • Guides implementation defaults and governance (env, contracts, and canonical rules) to accelerate safe cross-domain changes.

Quick Start

Review your monorepo structure and align app boundaries, package ownership, and cross-domain rules according to the Dukkani guidelines.

Frequently Asked Questions about dukkani-architecture

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

FAQPage Schema
How do I enforce monorepo boundaries across multiple apps and packages?▼

To enforce monorepo boundaries, define ownership models for apps and packages, restricting cross-app imports to preserve separation of concerns. Use canonical project rules and domain MDC files to specify where code should live and how apps interact.

What's the best way to structure cross-domain changes in a multi-app codebase?▼

Structure cross-domain changes in a multi-app codebase by applying governance rules for environment variables and shared contracts. Guide implementation through exported schemas to ensure safe interactions between apps and packages.

How do I decide where code should live in a monorepo with apps and packages?▼

Decide where code should live by assigning specific roles to apps for API entrypoints and UI surfaces, while packages manage shared contracts. Reference canonical rules to determine the correct location for each module.

Can I prevent cross-app imports in a monorepo architecture?▼

Yes, you can prevent cross-app imports by establishing clear ownership models that separate concerns between apps and packages. Documenting recommended responsibilities and applying canonical project rules restricts unauthorized cross-domain dependencies.

Why do I need domain MDC files for monorepo package governance?▼

You need domain MDC files for monorepo package governance because they act as canonical project rules that define boundaries. They specify default implementation rules, ensuring structured cross-domain changes and clear package ownership.

Does a monorepo architecture governance model work without shared contracts?▼

A monorepo architecture governance model relies on shared contracts via exported schemas to function safely. Without these contracts, apps and packages lack the defined interaction rules needed to prevent cross-cutting changes.

Related Skills

Explore More Software Engineering Skills→
RayzerrekRayzerrek

unity-project-scout

Inspect Unity project version, packages, asmdef layout, and folder structure.

Community
Intermediate
GaryOcean428GaryOcean428

qig-purity-validation

Enforce QIG purity via AST audits and canonical import validation.

Community
Advanced
cenjiecenjie

api-contract-testing

Validate API contracts between consumers and providers in CI.

Community
Intermediate
huseyindenizhuseyindeniz
15

arch-audit

Detect architectural boundary and dependency violations across core, domain, and composition-root contexts.

Community
Advanced