MFE Skills plugin
Two skills for micro-frontend architecture: eight boundary rules from the O'Reilly book, violation detection and fixes
- 66 ★ on the repository
- Last commit
- MIT
Minimal access
Why this level
- The skills provide instructions and review rules and run nothing themselves
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add plugins/mfe-skillsDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewMinimal accessThe tool runs nothing and makes no network calls.
- The skills provide instructions and review rules and run nothing themselves
This is third-party code. Review the repository files before installing.
What it does
A set of two skills teaches an assistant micro-frontend boundaries through the eight rules from the book "Building Micro-Frontends" (O'Reilly). It covers Module Federation v1 and v2, Native Federation for Angular and Single SPA. The `understanding-mfe-architecture` skill activates on adoption decisions, boundary design and composition patterns, and `reviewing-mfe-boundaries` on code review, shell generation, violation detection and cross-MFE communication. The author tested the approach with an experiment: two agents got the same brief (React 19, Module Federation, a shell with home and catalog). Without the skills the result had imports between remotes, global state and hard-coded URLs, while with them the shell stayed thin, URLs came from a discovery manifest and each team owned its own paths. The skills report violations tied to a rule, severity and a remediation, plus advanced governance topics: feature flag scope, edge strategy, SSR ownership and fitness functions for CI (`ts-arch` and `jest`). Cursor gets `.mdc` rules, Codex gets `AGENTS.md` and Claude Code gets a plugin.
Who it is for. Architects and frontend teams building or reviewing micro-frontends on Module Federation, Native Federation or Single SPA.
Good fit when
- A team is deciding whether micro-frontends are needed and how to draw boundaries between domains
- An agent generates a shell or remotes and cross-imports between them must be excluded
- A shell integration review is under way with findings cited by rule number
- Boundaries must be enforced in CI with fitness functions on `ts-arch` and `jest`
Not a fit when
- The application is a monolith and splitting it into micro-frontends is not planned
- Component styling or general React advice is needed: the skills are about boundaries
- There is a single team and independent releases are not needed
Example request
Review this shell integration against the eight MFE boundary rules and cite rule numbersLimitations
The rules rest on the book and the author's views, and for your system you should supplement them with an `AGENTS.md` or `CLAUDE.md` describing team ownership, toolchain and known exceptions. The Canvas facilitation skill `micro-frontend-canvas` lives in a separate repository. Recommended installation differs: for Cursor copy the skill folders into `.cursor/skills/`, for Codex into `.codex/skills/` and for Antigravity into `.agents/skills/`. The skills only advise and review, and you enforce violations in CI yourself using the template in `docs/governance.md`. The experiment results come from one brief by the author.
How to disable. Run `/plugin uninstall mfe-skills` or delete the skill folders from `.cursor/skills/`, `.codex/skills/` and `.agents/skills/`.
FAQ
How do I install MFE Skills in Claude Code?
Run `/plugin marketplace add lucamezzalira/mfe-skills`, then `/plugin install mfe-skills@mfe-skills`. The skills are called as `/mfe-skills:understanding-mfe-architecture` and `/mfe-skills:reviewing-mfe-boundaries`.
Which technologies are covered?
Module Federation v1 and v2, Native Federation for Angular and Single SPA. The set is about architectural boundaries and is bundler-agnostic.
What does each of the two skills do?
`understanding-mfe-architecture` handles adoption decisions, boundaries and composition, and `reviewing-mfe-boundaries` handles code review, shell generation and violation detection.
Why does the project need AGENTS.md?
The skills give general rules, and `AGENTS.md` or `CLAUDE.md` tells the agent about team ownership, tooling and exceptions so the rules apply to your system.
Is there a sample project?
Yes, the `lucamezzalira/mfe-with-skills` repository: the `ecommerce-init-implementation` branch has a runnable app with a shell and five remotes.
Discussion
No questions or reviews yet.
Related
PluginsA Feature-Sliced Design 2.1 skill: the agent picks the frontend layer for code and keeps import boundaries intact.
Agent skill with Chinese-language rules for writing and reviewing product frontends: states, data flow and component structure
The building-ui skill opens an editable UI mock: you change it directly, then the agent implements it with TDD.
Front-End Checklist reviews frontend code and public pages against 386 rules for accessibility, SEO, performance and security.
A skill set for agent UI work: scope, restraint and motion rules plus checks of the result in the live app
Four official Material UI skills: styling, theming, Next.js integration and working alongside Tailwind CSS
README in short
The README explains why the skills exist, shows experiment results before and after, lists advanced governance and installation for Claude Code, Cursor, Codex, Copilot and Antigravity. A fifteen-minute walkthrough closes it.
README badge
Original SKILL.md
--- name: reviewing-mfe-boundaries description: Reviews and generates micro-frontend code against eight boundary rules from Building Micro-Frontends (O'Reilly), plus governance extensions for feature-flag scope, edge strategy, SSR ownership, and boundary fitness functions. Use when a user says "review my shell code", "is this a boundary violation?", "generate a Module Federation shell", "how do I mount this MFE?", "review my micro-frontend architecture", "set up event communication between MFEs", "create a new micro-frontend", "how should we use edge with MFEs?", "where should feature flags live?", or "how do I enforce boundaries in a monorepo?". Loads automatically when the user pastes shell integration code, Module Federation config, Single SPA registration, or Native Federation routes. Does not activate for component-level code within a single deployed unit, or for generic React, Vue, or Angular questions with no cross-team deployment angle. license: "MIT — Copyright (c) Luca Mezzalira" compatibility: Works in Claude.ai, Claude Code, and any Claude API environment. No external tools or MCP servers required. Covers React, Angular, Vue with Module Federation v1/v2, Native Federation, and Single SPA toolchains. metadata: author: luca-mezzalira version: "1.0" category: architecture tags: [micro-frontends, module-federation, native-federation, single-spa, angular, react, boundary-governance, edge-compute, ssr, feature-flags, fitness-functions] --- # MFE boundary health Reviews and generates micro-frontend code against the eight boundary rules from *Building Micro-Frontends* (O'Reilly). All rules are tool-agnostic. Full rule definitions, violation signals, and code-checkable patterns are in `references/rules-core-critical.md` (rules 3 and 4) and `references/rules-core-standard.md` (rules 1, 2, 5, 6, 7, 8). Load the file that covers the rule you need. **On every activation, apply this summary table directly — no file load needed:** | Rule | What to check in code | Severity | |---|---|---| | 1 — Business subdomain | Name reflects a business capability, not a UI element | High | | 2 — Minimal API surface | Fewer than 5 props; no full domain objects passed | Critical | | 3 — Hide implementation details | No direct imports from another MFE's internals | Critical | | 4 — Events not shared state | No shared store; shell handles `shell:*` only; domain events peer-to-peer or URL | Critical | | 5 — Independent deployment | No versioned URLs in shell config; no build-time MFE imports; no CI pipeline coupling | High | | 6 — Isolate failure | Every remote mount has a fallback in the shell | High | | 7 — Coarse-grained | Nesting depth > 1 (MFE inside MFE); more than 3 MFEs per view | High | | 8 — Single-team ownership | One team in CODEOWNERS; no cross-team sign-off on internals | High | For full rule definitions and violation signals: load `references/rules-core-critical.md` or `references/rules-core-standard.md`. For framework-specific patterns (MF v2, Angular/Native Federation, Single SPA): load `references/rules-toolchain.md`. For URL routing ownership (shell first segment, MFE deeper paths): load `references/routing-ownership.md`. For fix patterns and step-by-step remediation: load `references/remediation.md` when the user asks how to fix a violation or requests a migration plan. For framework-by-framework code generation patterns (React, Angular, Vue, Single SPA): load `references/code-patterns.md`. --- ## Cold start: new project If no boundaries exist yet, ask about the highest-priority unknown first — one question per turn. Do not generate implementation code until each check is resolved. **Check 1 — Team ownership** Ask: "Which team will own this micro-frontend end-to-end — design, development, deployment, and operations?" **If unresolved:** do not generate implementation code. Ask the user to install the **micro-frontend-canvas** skill and complete a canvas iteration (see https://github.com/lucamezzalira/mfe-canvas).