architecture-paradigm-microkernel
/architecture-paradigm-microkernel
Stosuje architekturę mikrojądra z minimalnym rdzeniem i wtyczkami, dla platform rozszerzanych przez firmy trzecie.
- Autor
- athola ↗
- Repozytorium
- claude-night-market ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 01.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 01.10.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Stosuje architekturę mikrojądra z minimalnym rdzeniem i wtyczkami, dla platform rozszerzanych przez firmy trzecie.
Oryginalny opis (EN)
Applies microkernel architecture with minimal core and plugin extensibility. Use when building platforms where third parties extend core functionality.
Jak działa
- When To Use
- When NOT To Use
- When to Employ This Paradigm
- Adoption Steps
- Key Deliverables
- Risks & Mitigations
- Concrete Components
- Exit Criteria
Podgląd SKILL.md
--- name: architecture-paradigm-microkernel description: Applies microkernel architecture with minimal core and plugin extensibility. Use when building platforms where third parties extend core functionality. alwaysApply: false category: architectural-pattern tags: - architecture - microkernel - plugin - extensibility - platform-design dependencies: [] tools: [] usage_patterns: - paradigm-implementation - platform-development - extensibility-design complexity: high model_hint: deep estimated_tokens: 900 --- # The Microkernel (Plugin) Architecture Paradigm ## When To Use - Building extensible systems with plugin architectures - Products requiring customer-specific customizations ## When NOT To Use - Monolithic applications without plugin extensibility needs - Systems where all features are core and tightly coupled by design ## When to Employ This Paradigm - When building platforms, Integrated Development Environments (IDEs), data ingestion pipelines, or marketplaces where third parties need to extend core functionality. - When the core system requires extreme stability, while extensions and features must evolve and change rapidly. - When isolating optional dependencies and sandboxing untrusted code provided by plugins is critical. ## Adoption Steps 1. **Define Core Services**: Clearly delineate the minimal responsibilities of the microkernel, such as scheduling, component lifecycle management, core domain primitives, and messaging. 2. **Specify the Plugin Contract**: Design and document the formal contract for all plugins, including registration procedures, capability descriptors, lifecycle hooks (e.g., start, stop), and the permission model. 3. **Build the Extension Loader and Sandbox**: Implement the mechanisms for loading extensions, performing version compatibility checks, negotiating capabilities, and isolating plugins to prevent failures from cascading. 4. **Provide a Software Development Kit (SDK)**: To facilitate plugin development, provide an SDK with project templates, testing harnesses, and compatibility-checking tools. 5. **Govern the Release Process**: Maintain a clear compatibility matrix between core and plugin versions. Implement an automated regression test suite that validates core functionality against a variety of plugins. ## Key Deliverables - An Architecture Decision Record (ADR) describing the division of responsibilities between the core and plugins, along with the governance model for plugin development and certification. - Formal documentation for the security and permission model, detailing what capabilities are available to plugins. - An automated plugin validation pipeline that performs linting, runs tests, and executes the plugin within a sandbox environment. ## Risks & Mitigations - **Uncontrolled Plugin Proliferation**: - **Mitigation**: Without a curation process, the maintenance cost of supporting numerous plugins can become unsustainable. Enforce a formal certification process or a marketplace-style review for all third-party plugins. - **Version Skew Between Core and Plugins**: - **Mitigation**: Use semantic versioning (SemVer) rigorously for both the core and the plugins. Where necessary, provide abstraction layers or "shims" to maintain backward compatibility with older plugins. - **Core System Bloat**: - **Mitigation**: There is often pressure to add feature logic to the stable core. Aggressively resist this temptation. The core should remain minimal, with new features implemented as plugins whenever possible. ## Concrete Components Vocabulary for the tools and abstractions an implementation of this paradigm tends to carry. Not dependencies, and not ``tools:`` frontmatter. - ``plugin-loader``: discovers, validates, and activates plugins at runtime - ``sandbox-executor``: runs each plugin in an isolated context with a constrained capability set - ``sdk-generator``: produces language-specific SDKs from the kernel's stable interface ## Exit Criteria - [ ] An ADR documents the microkernel's minimal responsibilities, the plugin contract (registration, capability descriptors, lifecycle hooks), and the permission model. - [ ] A formal plugin SDK or specification (templates, testing harness, compatibility checker) exists before any third-party plugin development begins. - [ ] An automated plugin validation pipeline (lint, test, sandbox execution) is operational and gates plugin certification. - [ ] A compatibility matrix between core versions and supported plugin API versions is published and updated whenever the core plugin contract changes.
Wersje
W bazie nie ma innych skilli o nazwie architecture-paradigm-microkernel.
Migawka bazy z 13.11.2026 · wersja paczki fd29e4ba5f07 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100microkernel-pattern-guide
Pomaga projektować rozszerzalne systemy w architekturze mikrojądra: minimalny rdzeń i wymienne wtyczki wybierane przez rejestr, punkty rozszerzeń, negocjacja możliwości, moment wiązania i wstrzykiwanie zależności. - 90architecture-paradigm-client-server
Stosuje architekturę klient-serwer dla aplikacji webowych i mobilnych: scentralizowany backend, granice zaufania i synchronizacja offline-first. - 90architecture-paradigm-service-based
Stosuje architekturę usług o grubszym ziarnie dla niezależnych wdrożeń, gdy współdzielone bazy danych wykluczają mikroserwisy. - 90os-kernel-architecture
Wspiera decyzje architektoniczne o systemach operacyjnych i jądrach: monolit, mikrojądro, hybryda, unikernel, projekt schedulera, pamięć wirtualna, IPC, granice syscall i ABI oraz obsługa przerwań.