Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

architecture-paradigm-microkernel

/architecture-paradigm-microkernel

Stosuje architekturę mikrojądra z minimalnym rdzeniem i wtyczkami, dla platform rozszerzanych przez firmy trzecie.

Licencja
MIT
Ostatnia zmiana repozytorium
01.10.2026

Ocena i bezpieczeństwo

90/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść25 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 01.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

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

  1. When To Use
  2. When NOT To Use
  3. When to Employ This Paradigm
  4. Adoption Steps
  5. Key Deliverables
  6. Risks & Mitigations
  7. Concrete Components
  8. Exit Criteria
Sekcje z nagłówków SKILL.md, w oryginale · 58 linii, 552 słów
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ń.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.