[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7DKDSKX93QGEEQ25WSSRXDC":3,"skill-same:01M7DKDSKX93QGEEQ25WSSRXDC":51},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":30,"commitSha":31,"skillDirectory":32,"forksCount":33,"repositoryHtmlUrl":34,"repositoryHomepageUrl":6,"ownerHtmlUrl":35,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":36,"install":37,"resources":50},"01M7DKDSKX93QGEEQ25WSSRXDC","frontend-architecture",null,"A portable, framework-agnostic architecture style for any React or React Native frontend. Organizes apps into feature modules with page\u002Fscreen directories, a strict server-state vs UI-state split, barrel-only cross-module imports, co-located styles, and clear component-promotion rules....","Hazek-dc\u002FPresensiGuru_FaceNet_EMAR","Hazek-dc","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F75208960?v=4","01M7DEQV5B4YGS86A81DYH81DR","Hazek","01M7DEQV5XP4TM0C6NTHXCXCHR",1,"MIT","https:\u002F\u002Fgithub.com\u002FHazek-dc\u002FPresensiGuru_FaceNet_EMAR\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Ffrontend-architecture\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: frontend-architecture\ndescription: A portable, framework-agnostic architecture style for any React or React Native frontend. Organizes apps into feature modules with page\u002Fscreen directories, a strict server-state vs UI-state split, barrel-only cross-module imports, co-located styles, and clear component-promotion rules....\nrisk: unknown\nsource: https:\u002F\u002Fgithub.com\u002Fstareezy-1\u002Ffrontend-architecture-skill\u002Ftree\u002Fmain\u002Fskills\u002Ffrontend-architecture\nsource_repo: stareezy-1\u002Ffrontend-architecture-skill\nsource_type: community\ndate_added: 2026-07-01\nlicense: MIT\nlicense_source: https:\u002F\u002Fgithub.com\u002Fstareezy-1\u002Ffrontend-architecture-skill\u002Fblob\u002Fmain\u002FLICENSE\n---\n\n# Frontend Architecture (portable, module-based)\n## When to Use\n\nUse this skill when you need a portable, framework-agnostic architecture style for any React or React Native frontend. Organizes apps into feature modules with page\u002Fscreen directories, a strict server-state vs UI-state split, barrel-only cross-module imports, co-located styles, and clear component-promotion rules....\n\n\n> Portable skill — readable by Claude Code, OpenCode, Codex, Cursor, Windsurf, and others.\n> This skill describes a **structure and a set of rules**, not a component library, a state library, or a visual style.\n> It is deliberately global: the same module\u002Fpage\u002Fstate model maps onto\n> **Next.js (App Router)**, **React + Vite (SPA)**, **Remix**, and **Expo \u002F React Native**, and it works\n> with **any** state-management and styling stack.\n\nThe goal: a codebase where any contributor can instantly answer three questions —\n**\"where does this code live?\"**, **\"what is allowed to import what?\"**, and **\"is this server state or UI state?\"** —\nwithout asking anyone. The structure makes the answers obvious.\n\n---\n\n## 0. The five core ideas\n\n1. **Feature modules own their world.** Each feature is a self-contained `modules\u002F{feature}\u002F` folder with its own pages, components, hooks, state, types, and a single public barrel.\n2. **Pages\u002Fscreens are directories, not files.** A route is a folder that co-locates its component, its styles, and the components\u002Fhooks used only by it.\n3. **State is split by origin.** Server data lives in a query\u002Fcache layer. UI\u002Fclient state lives in a store. They never overlap — regardless of which libraries you pick.\n4. **Imports cross boundaries only through barrels.** Reaching into another module's internals is forbidden; you import from `@\u002Fmodules\u002F{feature}` and nothing deeper.\n5. **Code is promoted, not pre-placed.** It starts as local as possible and moves outward only when a second consumer appears.\n\nEverything below is the mechanical application of these five ideas. None of it is tied to a specific library — pick your stack in Sections 4 and 6.\n\n---\n\n## 1. Directory layout\n\nThe shape is identical across frameworks; only the routing layer on top differs (see Section 7).\n\n```\nsrc\u002F\n├── app\u002F or routes\u002F or navigation\u002F   ← framework routing layer (thin — see §7)\n├── modules\u002F                         ← feature modules (the heart of the app)\n│   └── {feature}\u002F\n│       ├── index.ts                 ← PUBLIC BARREL — the only cross-module entry point\n│       ├── README.md                ← what this module owns, its routes, its data deps\n│       ├── components\u002F              ← components reused by 2+ pages IN THIS MODULE\n│       ├── pages\u002F                   ← page\u002Fscreen directories (one per route)\n│       │   └── {page}\u002F\n│       │       ├── {page}.tsx               ← the page\u002Fscreen component\n│       │       ├── {page}.styles.ts         ← ALL styling for this page\n│       │       ├── index.ts                 ← re-exports the page component\n│       │       ├── components\u002F              ← components used ONLY by this page\n│       │       ├── hooks\u002F                   ← hooks used ONLY by this page\n│       │       ├── constants\u002F\n│       │       └── README.md                ← route, params, permissions, data deps\n│       ├── hooks\u002F                   ← data hooks (query\u002Fmutation) + module hooks\n│       ├── stores\u002F                  ← UI\u002Fclient state store(s) — never server data\n│       ├── services\u002F                ← data-access (API calls) for this feature\n│       ├── utils\u002F                   ← pure module utilities (co-located *.test.ts)\n│       ├── constants\u002F\n│       └── types\u002F                   ← module request\u002Fresponse + view-model types\n└── shared\u002F                          ← cross-module building blocks\n    ├── components\u002F                  ← components used by 2+ MODULES\n    ├── hooks\u002F                       ← cross-cutting hooks\n    ├── api-client\u002F                  ← one typed client; the only place that talks to the network\n    ├── store\u002F                       ← root store wiring (if your state lib needs one — see §4)\n    ├── utils\u002F                       ← formatters, cn()\u002Fclsx, helpers\n    ├── constants\u002F\n    └── types\u002F\n```\n\nEvery folder that can be empty at scaffold time keeps a `.gitkeep` so the structure is visible from day one.\n\n---\n\n## 2. Feature modules\n\nA module is a vertical slice of the product (e.g. `auth`, `billing`, `dashboard`, `settings`). It contains everything that feature needs and exposes a deliberately small surface.\n\n### 2.1 The barrel (`index.ts`) is the contract\n\n`modules\u002F{feature}\u002Findex.ts` is the **only** thing other modules and the routing layer may import from. It re-exports:\n\n- Page\u002Fscreen components the router mounts.\n- Data hooks other features legitimately need.\n- The store hook\u002Fslice and its public types.\n- Shared constants \u002F types other features depend on.\n\n```ts\n\u002F\u002F CORRECT — consume the public surface\nimport { InvoiceListPage, useInvoiceList } from \"@\u002Fmodules\u002Finvoice\";\n\n\u002F\u002F WRONG — reaching into internals couples you to private structure\nimport { InvoiceListPage } from \"@\u002Fmodules\u002Finvoice\u002Fpages\u002Finvoice-list\u002Finvoice-list\";\n```\n\nKeep the barrel curated. If something isn't exported, it's private by design. Group exports with short comments (pages, hooks, store, types) — future readers use the barrel as the module's API docs.\n\n### 2.2 One module = one bounded context\n\nDon't create `utils` modules or `components` modules. Modules map to product capabilities, not to technical layers. Technical building blocks live in `shared\u002F`.\n\n### 2.3 Module README\n\nEach module's `README.md` states: what it owns, which routes render its pages, its data dependencies (which endpoints\u002Fhooks), and any cross-module rules. This is the first thing a new contributor reads.\n\n---\n\n## 3. Pages\u002Fscreens as directories\n\nA page is a route the router mounts (a \"screen\" in React Native). It is **always a folder**, never a loose file — even when it starts as a single component. This keeps growth in place: when the page needs a sub-component or a hook, there is already a home for it.\n\n```\npages\u002F{page}\u002F\n├── {page}.tsx          ← the page\u002Fscreen component\n├── {page}.styles.ts    ← every style for this page (no inline styles — see §5)\n├── index.ts            ← export { PageComponent } from \".\u002F{page}\"\n├── components\u002F         ← used ONLY by this page\n├── hooks\u002F              ← used ONLY by this page\n├── constants\u002F\n└── README.md           ← route, params, permissions, data deps\n```\n\nThe page README is short and high-signal: route path, expected params, required permissions\u002Fauth, and the hooks it depends on. It is the contract between the page and the rest of the app.\n\n**Why folders from the start:** a page that begins as one file inevitably grows a sub-row component, a derived-totals hook, a styles file. If the page is a file, those land in arbitrary places. If the page is a folder, they have an obvious home and the diff stays readable.\n\n---\n\n## 4. State: split by origin (non-negotiable, library-agnostic)\n\nTwo kinds of state, two homes. Mixing them is the most common architectural failure this skill exists to prevent. **The split is mandatory; the libraries are your choice.**\n\n| State kind            | Examples                                                                          | Lives in                                                                                |\n| --------------------- | --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |\n| **Server state**      | fetched entities, lists, aggregates — anything the API owns                       | a **query\u002Fcache layer** (e.g. TanStack Query, RTK Query, SWR, Apollo)                   |\n| **UI \u002F client state** | open dialogs, table filters\u002Fsort, wizard step, draft being typed, preview toggles | a **client store** (e.g. Zustand, Redux Toolkit, MobX, Jotai, Valtio, or React Context) |\n\n### 4.1 Hard rules (independent of library)\n\n- **Never mirror server responses into the client store.** No copying fetched entities into Zustand\u002FRedux\u002FMobX. The query\u002Fcache layer is the single source of truth for server data.\n- **Never fetch inside components.** Components read server data from a data hook and UI state from a store selector. They don't call the network client directly.\n- **Never drive continuous values through re-render state.** Scroll progress, pointer position, drag offset — use refs \u002F animation values, not render state (it re-renders the tree every frame).\n- **One store boundary per module.** Whatever library you use, give each module one cohesive store unit (a Zustand hook, a Redux slice, a MobX class, a Jotai atom group) accessed via the module barrel. Components subscribe to the smallest slice they need to avoid needless re-renders.\n\n### 4.2 Choosing a client-state library — same shape, different syntax\n\nPick one per project and stay consistent. Each maps onto \"one store unit per module\" cleanly. Note the **`I` interface-naming convention**: state interfaces are prefixed with `I` (e.g. `IFeatureUiState`).\n\n**Zustand** — `modules\u002F{feature}\u002Fstores\u002F{feature}.store.ts`\n\n```ts\nimport { create } from \"zustand\";\n\nexport interface IFeatureUiState {\n  isPreviewOpen: boolean;\n  filter: string;\n  togglePreview: () => void;\n  setFilter: (filter: string) => void;\n  reset: () => void;\n}\n\nconst INITIAL_STATE = { isPreviewOpen: false, filter: \"\" } as const;\n\nexport const useFeatureUiStore = create\u003CIFeatureUiState>()((set) => ({\n  ...INITIAL_STATE,\n  togglePreview: () => set((s) => ({ isPreviewOpen: !s.isPreviewOpen })),\n  setFilter: (filter) => set({ filter }),\n  reset: () => set({ ...INITIAL_STATE }),\n}));\n```\n\n**Redux Toolkit** — `modules\u002F{feature}\u002Fstores\u002F{feature}.slice.ts` (registered in `shared\u002Fstore\u002F`)\n\n```ts\nimport { createSlice, type PayloadAction } from \"@reduxjs\u002Ftoolkit\";\n\nexport interface IFeatureUiState {\n  isPreviewOpen: boolean;\n  filter: string;\n}\n\nconst initialState: IFeatureUiState = { isPreviewOpen: false, filter: \"\" };\n\nexport const featureUiSlice = createSlice({\n  name: \"featureUi\",\n  initialState,\n  reducers: {\n    togglePreview: (s) => {\n      s.isPreviewOpen = !s.isPreviewOpen;\n    },\n    setFilter: (s, action: PayloadAction\u003Cstring>) => {\n      s.filter = action.payload;\n    },\n    reset: () => initialState,\n  },\n});\n```\n\n**MobX** — `modules\u002F{feature}\u002Fstores\u002F{feature}.store.ts`\n\n```ts\nimport { makeAutoObservable } from \"mobx\";\n\nexport interface IFeatureUiState {\n  isPreviewOpen: boolean;\n  filter: string;\n}\n\nexport class FeatureUiStore implements IFeatureUiState {\n  isPreviewOpen = false;\n  filter = \"\";\n  constructor() {\n    makeAutoObservable(this);\n  }\n  togglePreview = () => {\n    this.isPreviewOpen = !this.isPreviewOpen;\n  };\n  setFilter = (filter: string) => {\n    this.filter = filter;\n  };\n  reset = () => {\n    this.isPreviewOpen = false;\n    this.filter = \"\";\n  };\n}\n```\n\n**Jotai** — `modules\u002F{feature}\u002Fstores\u002F{feature}.atoms.ts`\n\n```ts\nimport { atom } from \"jotai\";\nexport const isPreviewOpenAtom = atom(false);\nexport const filterAtom = atom(\"\");\n```\n\n> Whichever you choose, keep the rules in §4.1 constant. The skill cares that server and UI state are separated and that each module owns one store unit — not which library draws the box.\n\n### 4.3 Data layer (server state)\n\nAll network access goes through **one typed client** in `shared\u002Fapi-client\u002F`. Modules wrap it in query\u002Fmutation hooks and a **key factory** so caches and invalidation stay consistent.\n\n```ts\n\u002F\u002F modules\u002Finvoice\u002Fhooks\u002FinvoiceKeys.ts — hierarchical key factory (TanStack Query style)\nexport const invoiceKeys = {\n  all: [\"invoices\"] as const,\n  lists: () => [...invoiceKeys.all, \"list\"] as const,\n  list: (params: IListParams) => [...invoiceKeys.lists(), params] as const,\n  details: () => [...invoiceKeys.all, \"detail\"] as const,\n  detail: (id: string) => [...invoiceKeys.details(), id] as const,\n} as const;\n```\n\nInvalidating `lists()` refreshes every filtered page; `detail(id)` targets one entity. (RTK Query\u002FSWR\u002FApollo express the same idea with tags\u002Fkeys.) Components never write raw `fetch()` — they call `useInvoiceList()` \u002F `useCreateInvoice()`.\n\n---\n\n## 5. Styling: co-located, no inline styles (styling-library agnostic)\n\nKeep styling out of JSX and out of the component body. Each page or component has a **co-located styles file**. The rule is constant; the syntax follows your styling stack.\n\n- **Tailwind (web):** `{name}.styles.ts` exports named class strings composed with `cn()` (clsx + tailwind-merge); variants via `cva`. JSX references `styles.header`.\n- **CSS Modules \u002F vanilla-extract:** a co-located `{name}.module.css` \u002F `{name}.css.ts`; JSX references `styles.header`.\n- **styled-components \u002F Emotion:** a co-located `{name}.styles.ts` exporting styled components.\n- **Tamagui (web + native):** a co-located `{name}.styles.ts` exporting `styled(...)` components or a `createStyledContext` \u002F `useStyle` token set; reference Tamagui tokens (`$background`, `$space.4`) — never hardcoded values inline. Tamagui is the recommended choice when you target **both web and React Native** from one codebase.\n- **React Native StyleSheet \u002F Nativewind:** a co-located `{name}.styles.ts` exporting `StyleSheet.create({...})` (or Nativewind classnames). JSX references `styles.header`.\n\n```ts\n\u002F\u002F invoice-list.styles.ts (Tailwind example)\nexport const invoiceListStyles = {\n  page: \"flex flex-col gap-8\",\n  header: \"flex flex-col gap-1.5\",\n  title: \"text-3xl font-semibold tracking-tight\",\n} as const;\n```\n\n```ts\n\u002F\u002F invoice-list.styles.ts (Tamagui example — works on web AND native)\nimport { styled, YStack, Text } from \"tamagui\";\n\nexport const InvoiceListPage = styled(YStack, { flex: 1, gap: \"$8\" });\nexport const InvoiceListHeader = styled(YStack, { gap: \"$1.5\" });\nexport const InvoiceListTitle = styled(Text, {\n  fontSize: \"$8\",\n  fontWeight: \"600\",\n});\n```\n\n**No inline `style={{...}}` literals in the component body**, on any stack. Why: styling drifts and duplicates when it lives inline. A co-located styles file gives one place to audit spacing rhythm, theme correctness, and responsive behavior per surface. Document non-obvious choices (accent locks, breakpoints) in comments there.\n\nThis skill does not dictate the _visual_ design — pair it with a design\u002Fcomponent skill for that. It dictates only _where styling lives_.\n\n---\n\n## 6. Naming conventions\n\nConsistent naming makes the structure self-describing.\n\n- **Interfaces are prefixed with `I`** — `IFeatureUiState`, `IInvoiceListParams`, `IUserProfile`. Type aliases (unions, mapped types, primitives) are **not** prefixed (`type SortDirection = \"asc\" | \"desc\"`).\n- **Components**: `PascalCase` files and exports — `InvoiceListPage.tsx`, `LineItemRow.tsx`.\n- **Pages\u002Fscreens**: `kebab-case` directories, the component file matches — `pages\u002Finvoice-list\u002Finvoice-list.tsx`.\n- **Hooks**: `useCamelCase` — `useInvoiceList`, `useFeatureUiStore`.\n- **Stores**: `{feature}.store.ts` (Zustand\u002FMobX), `{feature}.slice.ts` (Redux), `{feature}.atoms.ts` (Jotai). Hook is `use{Feature}{Purpose}Store`.\n- **Styles**: `{name}.styles.ts` co-located with its owner.\n- **Constants**: `SCREAMING_SNAKE_CASE` values; `kebab-case` or `camelCase` files.\n- **Barrels**: always `index.ts`.\n\n---\n\n## 7. Framework adapters\n\nThe module\u002Fpage\u002Fstate model is constant. Only the thin routing layer on top changes. Pages always live in `modules\u002F`; the routing layer just **mounts** them.\n\n### 7.1 Next.js (App Router)\n\n- `src\u002Fapp\u002F` holds route segments and route groups (`(marketing)`, `(app)`, `(public)`) for layout\u002Fauth boundaries. Route files are thin: import a page component from a module barrel and render it.\n- Default to **Server Components**; mark interactive leaves `\"use client\"`. Providers (query client, store, theme) live in a `\"use client\"` boundary.\n\n```tsx\n\u002F\u002F app\u002F(app)\u002Finvoices\u002Fpage.tsx — thin route file\nimport { InvoiceListPage } from \"@\u002Fmodules\u002Finvoice\";\nexport default function Page() {\n  return \u003CInvoiceListPage \u002F>;\n}\n```\n\n### 7.2 React + Vite (SPA)\n\n- A `src\u002Froutes\u002F` (or single `router.tsx`) declares the route table (React Router \u002F TanStack Router) and maps paths to module page components. Everything is client-side. Wrap the tree once with the query-client and store\u002Ftheme providers at the app root.\n\n### 7.3 Remix\n\n- Route modules in `app\u002Froutes\u002F` stay thin and re-export\u002Fmount module page components; loaders\u002Factions delegate to the module's `services\u002F`. Module boundaries are unchanged.\n\n### 7.4 Expo \u002F React Native\n\n- Routing is **Expo Router** (file-based, in `app\u002F`) or React Navigation (`navigation\u002F`). Route\u002Fscreen files are thin and import screen components from module barrels.\n- \"Pages\" are \"screens\" — same directory pattern: `pages\u002F{screen}\u002F{screen}.tsx` + `{screen}.styles.ts`.\n- Query layer + client store run unchanged (TanStack Query, Zustand, Redux, MobX, Jotai all work in RN). The typed `api-client` is shared logic and works as-is.\n- Styling uses **Tamagui** (recommended for shared web+native), `StyleSheet`, or Nativewind. Keep module logic DOM-free.\n\n```tsx\n\u002F\u002F app\u002Finvoices\u002Findex.tsx (Expo Router) — thin screen file\nimport { InvoiceListScreen } from \"@\u002Fmodules\u002Finvoice\";\nexport default InvoiceListScreen;\n```\n\n### 7.5 Sharing across web + native\n\nIf you target both web and Expo, push framework-free code (types, validators, formatters, the API client contract) into a shared package consumed by both apps, and prefer **Tamagui** for components that must render on both. Module boundaries stay the same on both sides.\n\n---\n\n## 8. Conventions checklist (enforce in review)\n\n- [ ] New feature → new `modules\u002F{feature}\u002F` with `index.ts` + `README.md`, not files scattered into `shared\u002F`.\n- [ ] New route → a **page\u002Fscreen directory** (`{page}.tsx` + `{page}.styles.ts` + `index.ts` + `README.md`), not a loose file.\n- [ ] Cross-module imports go through the barrel (`@\u002Fmodules\u002F{feature}`) — no deep internal paths.\n- [ ] Server data is in the query\u002Fcache layer; UI state is in the module store; **neither leaks into the other** (whatever libraries are chosen).\n- [ ] No `fetch()` in components — only typed data hooks built on the shared client.\n- [ ] No inline styles — co-located `{name}.styles.ts` (Tailwind\u002FCSS Modules\u002FTamagui\u002FStyleSheet\u002Fstyled-components).\n- [ ] Components\u002Fhooks\u002Futils placed at the narrowest scope; promoted only when a 2nd consumer appears.\n- [ ] One store unit per module, accessed via the barrel, with selectors and a `reset`.\n- [ ] Interfaces use the `I` prefix; components\u002Fhooks\u002Ffiles follow §6.\n- [ ] Query keys\u002Ftags come from a per-module factory; invalidation is hierarchical.\n- [ ] Routing files are thin — they mount module pages and own only layout\u002Fauth boundaries.\n- [ ] Module\u002Fpage READMEs updated when routes, params, or data deps change.\n\n---\n\n## 9. Component promotion (start local, move outward)\n\nA component is born in the narrowest scope that uses it and is **promoted** only when a second consumer appears. Never pre-place a component \"because it might be reused.\"\n\n| A component used by…   | Lives in                          | Imported as                        |\n| ---------------------- | --------------------------------- | ---------------------------------- |\n| Only one page          | `pages\u002F{page}\u002Fcomponents\u002F`        | relative path within the page      |\n| 2+ pages in one module | `modules\u002F{feature}\u002Fcomponents\u002F`   | `@\u002Fmodules\u002F{feature}` (via barrel) |\n| 2+ modules             | `shared\u002Fcomponents\u002F`              | `@\u002Fshared\u002F...`                     |\n| 2+ apps \u002F repos        | a published design-system package | the package name                   |\n\nThe same ladder applies to **hooks**, **utils**, and **constants**: local → module → shared → package. Promotion is a deliberate move (update the import sites), not a guess made up front.\n\n---\n\n## 10. How to apply this skill\n\n**Scaffolding a new app:** create `src\u002Fmodules\u002F`, `src\u002Fshared\u002F`, and the framework routing layer (§7). Add the shared `api-client`, the query layer, and your chosen client-store provider. Drop a store template into the first module.\n\n**Adding a feature:** create `modules\u002F{feature}\u002F` with the full subfolder set (`pages\u002F components\u002F hooks\u002F stores\u002F services\u002F utils\u002F constants\u002F types\u002F`), a curated `index.ts`, and a `README.md`. Build the first screen as a page directory.\n\n**Deciding where code goes:** ask \"who consumes this?\" → narrowest scope wins (§9). Ask \"where did this data come from?\" → server = query layer, UI = store (§4).\n\n**Reviewing structure:** run the checklist in §8. The most valuable catches are state-origin leaks (server data in the client store) and deep cross-module imports (bypassing the barrel) — both erode the architecture fastest.\n\n---\n\n## Publishing \u002F installing this skill\n\nThis skill follows the Anthropic `SKILL.md` format and is portable across agents. To make it installable and discoverable (e.g. on skills.sh \u002F `npx skills`):\n\n1. Put this folder under a `skills\u002F` directory in a **public GitHub repo** (path like `skills\u002Ffrontend-architecture\u002FSKILL.md`).\n2. Keep the frontmatter `name` and a high-signal `description` (above) — that description is what discovery indexes match against.\n3. Install from any project with: `npx skills add \u003Corg>\u002F\u003Crepo> --skill \"frontend-architecture\"`.\n4. Non-`SKILL.md` agents can be pointed here from `AGENTS.md` \u002F `CLAUDE.md`; Kiro can mirror it as a steering file.\n\n## Limitations\n\n- Use this skill only when the task clearly matches its upstream source and local project context.\n- Verify commands, generated code, dependencies, credentials, and external service behavior before applying changes.\n- Do not treat examples as a substitute for environment-specific tests, security review, or user approval for destructive or costly actions.\n","# Frontend Architecture (portable, module-based)\n## When to Use\n\nUse this skill when you need a portable, framework-agnostic architecture style for any React or React Native frontend. Organizes apps into feature modules with page\u002Fscreen directories, a strict server-state vs UI-state split, barrel-only cross-module imports, co-located styles, and clear component-promotion rules....\n\n\n> Portable skill — readable by Claude Code, OpenCode, Codex, Cursor, Windsurf, and others.\n> This skill describes a **structure and a set of rules**, not a component library, a state library, or a visual style.\n> It is deliberately global: the same module\u002Fpage\u002Fstate model maps onto\n> **Next.js (App Router)**, **React + Vite (SPA)**, **Remix**, and **Expo \u002F React Native**, and it works\n> with **any** state-management and styling stack.\n\nThe goal: a codebase where any contributor can instantly answer three questions —\n**\"where does this code live?\"**, **\"what is allowed to import what?\"**, and **\"is this server state or UI state?\"** —\nwithout asking anyone. The structure makes the answers obvious.\n\n---\n\n## 0. The five core ideas\n\n1. **Feature modules own their world.** Each feature is a self-contained `modules\u002F{feature}\u002F` folder with its own pages, components, hooks, state, types, and a single public barrel.\n2. **Pages\u002Fscreens are directories, not files.** A route is a folder that co-locates its component, its styles, and the components\u002Fhooks used only by it.\n3. **State is split by origin.** Server data lives in a query\u002Fcache layer. UI\u002Fclient state lives in a store. They never overlap — regardless of which libraries you pick.\n4. **Imports cross boundaries only through barrels.** Reaching into another module's internals is forbidden; you import from `@\u002Fmodules\u002F{feature}` and nothing deeper.\n5. **Code is promoted, not pre-placed.** It starts as local as possible and moves outward only when a second consumer appears.\n\nEverything below is the mechanical application of these five ideas. None of it is tied to a specific library — pick your stack in Sections 4 and 6.\n\n---\n\n## 1. Directory layout\n\nThe shape is identical across frameworks; only the routing layer on top differs (see Section 7).\n\n```\nsrc\u002F\n├── app\u002F or routes\u002F or navigation\u002F   ← framework routing layer (thin — see §7)\n├── modules\u002F                         ← feature modules (the heart of the app)\n│   └── {feature}\u002F\n│       ├── index.ts                 ← PUBLIC BARREL — the only cross-module entry point\n│       ├── README.md                ← what this module owns, its routes, its data deps\n│       ├── components\u002F              ← components reused by 2+ pages IN THIS MODULE\n│       ├── pages\u002F                   ← page\u002Fscreen directories (one per route)\n│       │   └── {page}\u002F\n│       │       ├── {page}.tsx               ← the page\u002Fscreen component\n│       │       ├── {page}.styles.ts         ← ALL styling for this page\n│       │       ├── index.ts                 ← re-exports the page component\n│       │       ├── components\u002F              ← components used ONLY by this page\n│       │       ├── hooks\u002F                   ← hooks used ONLY by this page\n│       │       ├── constants\u002F\n│       │       └── README.md                ← route, params, permissions, data deps\n│       ├── hooks\u002F                   ← data hooks (query\u002Fmutation) + module hooks\n│       ├── stores\u002F                  ← UI\u002Fclient state store(s) — never server data\n│       ├── services\u002F                ← data-access (API calls) for this feature\n│       ├── utils\u002F                   ← pure module utilities (co-located *.test.ts)\n│       ├── constants\u002F\n│       └── types\u002F                   ← module request\u002Fresponse + view-model types\n└── shared\u002F                          ← cross-module building blocks\n    ├── components\u002F                  ← components used by 2+ MODULES\n    ├── hooks\u002F                       ← cross-cutting hooks\n    ├── api-client\u002F                  ← one typed client; the only place that talks to the network\n    ├── store\u002F                       ← root store wiring (if your state lib needs one — see §4)\n    ├── utils\u002F                       ← formatters, cn()\u002Fclsx, helpers\n    ├── constants\u002F\n    └── types\u002F\n```\n\nEvery folder that can be empty at scaffold time keeps a `.gitkeep` so the structure is visible from day one.\n\n---\n\n## 2. Feature modules\n\nA module is a vertical slice of the product (e.g. `auth`, `billing`, `dashboard`, `settings`). It contains everything that feature needs and exposes a deliberately small surface.\n\n### 2.1 The barrel (`index.ts`) is the contract\n\n`modules\u002F{feature}\u002Findex.ts` is the **only** thing other modules and the routing layer may import from. It re-exports:\n\n- Page\u002Fscreen components the router mounts.\n- Data hooks other features legitimately need.\n- The store hook\u002Fslice and its public types.\n- Shared constants \u002F types other features depend on.\n\n```ts\n\u002F\u002F CORRECT — consume the public surface\nimport { InvoiceListPage, useInvoiceList } from \"@\u002Fmodules\u002Finvoice\";\n\n\u002F\u002F WRONG — reaching into internals couples you to private structure\nimport { InvoiceListPage } from \"@\u002Fmodules\u002Finvoice\u002Fpages\u002Finvoice-list\u002Finvoice-list\";\n```\n\nKeep the barrel curated. If something isn't exported, it's private by design. Group exports with short comments (pages, hooks, store, types) — future readers use the barrel as the module's API docs.\n\n### 2.2 One module = one bounded context\n\nDon't create `utils` modules or `components` modules. Modules map to product capabilities, not to technical layers. Technical building blocks live in `shared\u002F`.\n\n### 2.3 Module README\n\nEach module's `README.md` states: what it owns, which routes render its pages, its data dependencies (which endpoints\u002Fhooks), and any cross-module rules. This is the first thing a new contributor reads.\n\n---\n\n## 3. Pages\u002Fscreens as directories\n\nA page is a route the router mounts (a \"screen\" in React Native). It is **always a folder**, never a loose file — even when it starts as a single component. This keeps growth in place: when the page needs a sub-component or a hook, there is already a home for it.\n\n```\npages\u002F{page}\u002F\n├── {page}.tsx          ← the page\u002Fscreen component\n├── {page}.styles.ts    ← every style for this page (no inline styles — see §5)\n├── index.ts            ← export { PageComponent } from \".\u002F{page}\"\n├── components\u002F         ← used ONLY by this page\n├── hooks\u002F              ← used ONLY by this page\n├── constants\u002F\n└── README.md           ← route, params, permissions, data deps\n```\n\nThe page README is short and high-signal: route path, expected params, required permissions\u002Fauth, and the hooks it depends on. It is the contract between the page and the rest of the app.\n\n**Why folders from the start:** a page that begins as one file inevitably grows a sub-row component, a derived-totals hook, a styles file. If the page is a file, those land in arbitrary places. If the page is a folder, they have an obvious home and the diff stays readable.\n\n---\n\n## 4. State: split by origin (non-negotiable, library-agnostic)\n\nTwo kinds of state, two homes. Mixing them is the most common architectural failure this skill exists to prevent. **The split is mandatory; the libraries are your choice.**\n\n| State kind            | Examples                                                                          | Lives in                                                                                |\n| --------------------- | --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |\n| **Server state**      | fetched entities, lists, aggregates — anything the API owns                       | a **query\u002Fcache layer** (e.g. TanStack Query, RTK Query, SWR, Apollo)                   |\n| **UI \u002F client state** | open dialogs, table filters\u002Fsort, wizard step, draft being typed, preview toggles | a **client store** (e.g. Zustand, Redux Toolkit, MobX, Jotai, Valtio, or React Context) |\n\n### 4.1 Hard rules (independent of library)\n\n- **Never mirror server responses into the client store.** No copying fetched entities into Zustand\u002FRedux\u002FMobX. The query\u002Fcache layer is the single source of truth for server data.\n- **Never fetch inside components.** Components read server data from a data hook and UI state from a store selector. They don't call the network client directly.\n- **Never drive continuous values through re-render state.** Scroll progress, pointer position, drag offset — use refs \u002F animation values, not render state (it re-renders the tree every frame).\n- **One store boundary per module.** Whatever library you use, give each module one cohesive store unit (a Zustand hook, a Redux slice, a MobX class, a Jotai atom group) accessed via the module barrel. Components subscribe to the smallest slice they need to avoid needless re-renders.\n\n### 4.2 Choosing a client-state library — same shape, different syntax\n\nPick one per project and stay consistent. Each maps onto \"one store unit per module\" cleanly. Note the **`I` interface-naming convention**: state interfaces are prefixed with `I` (e.g. `IFeatureUiState`).\n\n**Zustand** — `modules\u002F{feature}\u002Fstores\u002F{feature}.store.ts`\n\n```ts\nimport { create } from \"zustand\";\n\nexport interface IFeatureUiState {\n  isPreviewOpen: boolean;\n  filter: string;\n  togglePreview: () => void;\n  setFilter: (filter: string) => void;\n  reset: () => void;\n}\n\nconst INITIAL_STATE = { isPreviewOpen: false, filter: \"\" } as const;\n\nexport const useFeatureUiStore = create\u003CIFeatureUiState>()((set) => ({\n  ...INITIAL_STATE,\n  togglePreview: () => set((s) => ({ isPreviewOpen: !s.isPreviewOpen })),\n  setFilter: (filter) => set({ filter }),\n  reset: () => set({ ...INITIAL_STATE }),\n}));\n```\n\n**Redux Toolkit** — `modules\u002F{feature}\u002Fstores\u002F{feature}.slice.ts` (registered in `shared\u002Fstore\u002F`)\n\n```ts\nimport { createSlice, type PayloadAction } from \"@reduxjs\u002Ftoolkit\";\n\nexport interface IFeatureUiState {\n  isPreviewOpen: boolean;\n  filter: string;\n}\n\nconst initialState: IFeatureUiState = { isPreviewOpen: false, filter: \"\" };\n\nexport const featureUiSlice = createSlice({\n  name: \"featureUi\",\n  initialState,\n  reducers: {\n    togglePreview: (s) => {\n      s.isPreviewOpen = !s.isPreviewOpen;\n    },\n    setFilter: (s, action: PayloadAction\u003Cstring>) => {\n      s.filter = action.payload;\n    },\n    reset: () => initialState,\n  },\n});\n```\n\n**MobX** — `modules\u002F{feature}\u002Fstores\u002F{feature}.store.ts`\n\n```ts\nimport { makeAutoObservable } from \"mobx\";\n\nexport interface IFeatureUiState {\n  isPreviewOpen: boolean;\n  filter: string;\n}\n\nexport class FeatureUiStore implements IFeatureUiState {\n  isPreviewOpen = false;\n  filter = \"\";\n  constructor() {\n    makeAutoObservable(this);\n  }\n  togglePreview = () => {\n    this.isPreviewOpen = !this.isPreviewOpen;\n  };\n  setFilter = (filter: string) => {\n    this.filter = filter;\n  };\n  reset = () => {\n    this.isPreviewOpen = false;\n    this.filter = \"\";\n  };\n}\n```\n\n**Jotai** — `modules\u002F{feature}\u002Fstores\u002F{feature}.atoms.ts`\n\n```ts\nimport { atom } from \"jotai\";\nexport const isPreviewOpenAtom = atom(false);\nexport const filterAtom = atom(\"\");\n```\n\n> Whichever you choose, keep the rules in §4.1 constant. The skill cares that server and UI state are separated and that each module owns one store unit — not which library draws the box.\n\n### 4.3 Data layer (server state)\n\nAll network access goes through **one typed client** in `shared\u002Fapi-client\u002F`. Modules wrap it in query\u002Fmutation hooks and a **key factory** so caches and invalidation stay consistent.\n\n```ts\n\u002F\u002F modules\u002Finvoice\u002Fhooks\u002FinvoiceKeys.ts — hierarchical key factory (TanStack Query style)\nexport const invoiceKeys = {\n  all: [\"invoices\"] as const,\n  lists: () => [...invoiceKeys.all, \"list\"] as const,\n  list: (params: IListParams) => [...invoiceKeys.lists(), params] as const,\n  details: () => [...invoiceKeys.all, \"detail\"] as const,\n  detail: (id: string) => [...invoiceKeys.details(), id] as const,\n} as const;\n```\n\nInvalidating `lists()` refreshes every filtered page; `detail(id)` targets one entity. (RTK Query\u002FSWR\u002FApollo express the same idea with tags\u002Fkeys.) Components never write raw `fetch()` — they call `useInvoiceList()` \u002F `useCreateInvoice()`.\n\n---\n\n## 5. Styling: co-located, no inline styles (styling-library agnostic)\n\nKeep styling out of JSX and out of the component body. Each page or component has a **co-located styles file**. The rule is constant; the syntax follows your styling stack.\n\n- **Tailwind (web):** `{name}.styles.ts` exports named class strings composed with `cn()` (clsx + tailwind-merge); variants via `cva`. JSX references `styles.header`.\n- **CSS Modules \u002F vanilla-extract:** a co-located `{name}.module.css` \u002F `{name}.css.ts`; JSX references `styles.header`.\n- **styled-components \u002F Emotion:** a co-located `{name}.styles.ts` exporting styled components.\n- **Tamagui (web + native):** a co-located `{name}.styles.ts` exporting `styled(...)` components or a `createStyledContext` \u002F `useStyle` token set; reference Tamagui tokens (`$background`, `$space.4`) — never hardcoded values inline. Tamagui is the recommended choice when you target **both web and React Native** from one codebase.\n- **React Native StyleSheet \u002F Nativewind:** a co-located `{name}.styles.ts` exporting `StyleSheet.create({...})` (or Nativewind classnames). JSX references `styles.header`.\n\n```ts\n\u002F\u002F invoice-list.styles.ts (Tailwind example)\nexport const invoiceListStyles = {\n  page: \"flex flex-col gap-8\",\n  header: \"flex flex-col gap-1.5\",\n  title: \"text-3xl font-semibold tracking-tight\",\n} as const;\n```\n\n```ts\n\u002F\u002F invoice-list.styles.ts (Tamagui example — works on web AND native)\nimport { styled, YStack, Text } from \"tamagui\";\n\nexport const InvoiceListPage = styled(YStack, { flex: 1, gap: \"$8\" });\nexport const InvoiceListHeader = styled(YStack, { gap: \"$1.5\" });\nexport const InvoiceListTitle = styled(Text, {\n  fontSize: \"$8\",\n  fontWeight: \"600\",\n});\n```\n\n**No inline `style={{...}}` literals in the component body**, on any stack. Why: styling drifts and duplicates when it lives inline. A co-located styles file gives one place to audit spacing rhythm, theme correctness, and responsive behavior per surface. Document non-obvious choices (accent locks, breakpoints) in comments there.\n\nThis skill does not dictate the _visual_ design — pair it with a design\u002Fcomponent skill for that. It dictates only _where styling lives_.\n\n---\n\n## 6. Naming conventions\n\nConsistent naming makes the structure self-describing.\n\n- **Interfaces are prefixed with `I`** — `IFeatureUiState`, `IInvoiceListParams`, `IUserProfile`. Type aliases (unions, mapped types, primitives) are **not** prefixed (`type SortDirection = \"asc\" | \"desc\"`).\n- **Components**: `PascalCase` files and exports — `InvoiceListPage.tsx`, `LineItemRow.tsx`.\n- **Pages\u002Fscreens**: `kebab-case` directories, the component file matches — `pages\u002Finvoice-list\u002Finvoice-list.tsx`.\n- **Hooks**: `useCamelCase` — `useInvoiceList`, `useFeatureUiStore`.\n- **Stores**: `{feature}.store.ts` (Zustand\u002FMobX), `{feature}.slice.ts` (Redux), `{feature}.atoms.ts` (Jotai). Hook is `use{Feature}{Purpose}Store`.\n- **Styles**: `{name}.styles.ts` co-located with its owner.\n- **Constants**: `SCREAMING_SNAKE_CASE` values; `kebab-case` or `camelCase` files.\n- **Barrels**: always `index.ts`.\n\n---\n\n## 7. Framework adapters\n\nThe module\u002Fpage\u002Fstate model is constant. Only the thin routing layer on top changes. Pages always live in `modules\u002F`; the routing layer just **mounts** them.\n\n### 7.1 Next.js (App Router)\n\n- `src\u002Fapp\u002F` holds route segments and route groups (`(marketing)`, `(app)`, `(public)`) for layout\u002Fauth boundaries. Route files are thin: import a page component from a module barrel and render it.\n- Default to **Server Components**; mark interactive leaves `\"use client\"`. Providers (query client, store, theme) live in a `\"use client\"` boundary.\n\n```tsx\n\u002F\u002F app\u002F(app)\u002Finvoices\u002Fpage.tsx — thin route file\nimport { InvoiceListPage } from \"@\u002Fmodules\u002Finvoice\";\nexport default function Page() {\n  return \u003CInvoiceListPage \u002F>;\n}\n```\n\n### 7.2 React + Vite (SPA)\n\n- A `src\u002Froutes\u002F` (or single `router.tsx`) declares the route table (React Router \u002F TanStack Router) and maps paths to module page components. Everything is client-side. Wrap the tree once with the query-client and store\u002Ftheme providers at the app root.\n\n### 7.3 Remix\n\n- Route modules in `app\u002Froutes\u002F` stay thin and re-export\u002Fmount module page components; loaders\u002Factions delegate to the module's `services\u002F`. Module boundaries are unchanged.\n\n### 7.4 Expo \u002F React Native\n\n- Routing is **Expo Router** (file-based, in `app\u002F`) or React Navigation (`navigation\u002F`). Route\u002Fscreen files are thin and import screen components from module barrels.\n- \"Pages\" are \"screens\" — same directory pattern: `pages\u002F{screen}\u002F{screen}.tsx` + `{screen}.styles.ts`.\n- Query layer + client store run unchanged (TanStack Query, Zustand, Redux, MobX, Jotai all work in RN). The typed `api-client` is shared logic and works as-is.\n- Styling uses **Tamagui** (recommended for shared web+native), `StyleSheet`, or Nativewind. Keep module logic DOM-free.\n\n```tsx\n\u002F\u002F app\u002Finvoices\u002Findex.tsx (Expo Router) — thin screen file\nimport { InvoiceListScreen } from \"@\u002Fmodules\u002Finvoice\";\nexport default InvoiceListScreen;\n```\n\n### 7.5 Sharing across web + native\n\nIf you target both web and Expo, push framework-free code (types, validators, formatters, the API client contract) into a shared package consumed by both apps, and prefer **Tamagui** for components that must render on both. Module boundaries stay the same on both sides.\n\n---\n\n## 8. Conventions checklist (enforce in review)\n\n- [ ] New feature → new `modules\u002F{feature}\u002F` with `index.ts` + `README.md`, not files scattered into `shared\u002F`.\n- [ ] New route → a **page\u002Fscreen directory** (`{page}.tsx` + `{page}.styles.ts` + `index.ts` + `README.md`), not a loose file.\n- [ ] Cross-module imports go through the barrel (`@\u002Fmodules\u002F{feature}`) — no deep internal paths.\n- [ ] Server data is in the query\u002Fcache layer; UI state is in the module store; **neither leaks into the other** (whatever libraries are chosen).\n- [ ] No `fetch()` in components — only typed data hooks built on the shared client.\n- [ ] No inline styles — co-located `{name}.styles.ts` (Tailwind\u002FCSS Modules\u002FTamagui\u002FStyleSheet\u002Fstyled-components).\n- [ ] Components\u002Fhooks\u002Futils placed at the narrowest scope; promoted only when a 2nd consumer appears.\n- [ ] One store unit per module, accessed via the barrel, with selectors and a `reset`.\n- [ ] Interfaces use the `I` prefix; components\u002Fhooks\u002Ffiles follow §6.\n- [ ] Query keys\u002Ftags come from a per-module factory; invalidation is hierarchical.\n- [ ] Routing files are thin — they mount module pages and own only layout\u002Fauth boundaries.\n- [ ] Module\u002Fpage READMEs updated when routes, params, or data deps change.\n\n---\n\n## 9. Component promotion (start local, move outward)\n\nA component is born in the narrowest scope that uses it and is **promoted** only when a second consumer appears. Never pre-place a component \"because it might be reused.\"\n\n| A component used by…   | Lives in                          | Imported as                        |\n| ---------------------- | --------------------------------- | ---------------------------------- |\n| Only one page          | `pages\u002F{page}\u002Fcomponents\u002F`        | relative path within the page      |\n| 2+ pages in one module | `modules\u002F{feature}\u002Fcomponents\u002F`   | `@\u002Fmodules\u002F{feature}` (via barrel) |\n| 2+ modules             | `shared\u002Fcomponents\u002F`              | `@\u002Fshared\u002F...`                     |\n| 2+ apps \u002F repos        | a published design-system package | the package name                   |\n\nThe same ladder applies to **hooks**, **utils**, and **constants**: local → module → shared → package. Promotion is a deliberate move (update the import sites), not a guess made up front.\n\n---\n\n## 10. How to apply this skill\n\n**Scaffolding a new app:** create `src\u002Fmodules\u002F`, `src\u002Fshared\u002F`, and the framework routing layer (§7). Add the shared `api-client`, the query layer, and your chosen client-store provider. Drop a store template into the first module.\n\n**Adding a feature:** create `modules\u002F{feature}\u002F` with the full subfolder set (`pages\u002F components\u002F hooks\u002F stores\u002F services\u002F utils\u002F constants\u002F types\u002F`), a curated `index.ts`, and a `README.md`. Build the first screen as a page directory.\n\n**Deciding where code goes:** ask \"who consumes this?\" → narrowest scope wins (§9). Ask \"where did this data come from?\" → server = query layer, UI = store (§4).\n\n**Reviewing structure:** run the checklist in §8. The most valuable catches are state-origin leaks (server data in the client store) and deep cross-module imports (bypassing the barrel) — both erode the architecture fastest.\n\n---\n\n## Publishing \u002F installing this skill\n\nThis skill follows the Anthropic `SKILL.md` format and is portable across agents. To make it installable and discoverable (e.g. on skills.sh \u002F `npx skills`):\n\n1. Put this folder under a `skills\u002F` directory in a **public GitHub repo** (path like `skills\u002Ffrontend-architecture\u002FSKILL.md`).\n2. Keep the frontmatter `name` and a high-signal `description` (above) — that description is what discovery indexes match against.\n3. Install from any project with: `npx skills add \u003Corg>\u002F\u003Crepo> --skill \"frontend-architecture\"`.\n4. Non-`SKILL.md` agents can be pointed here from `AGENTS.md` \u002F `CLAUDE.md`; Kiro can mirror it as a steering file.\n\n## Limitations\n\n- Use this skill only when the task clearly matches its upstream source and local project context.\n- Verify commands, generated code, dependencies, credentials, and external service behavior before applying changes.\n- Do not treat examples as a substitute for environment-specific tests, security review, or user approval for destructive or costly actions.\n",{"name":5,"risk":24,"source":25,"license":15,"date_added":26,"description":7,"source_repo":27,"source_type":28,"license_source":29},"unknown","https:\u002F\u002Fgithub.com\u002Fstareezy-1\u002Ffrontend-architecture-skill\u002Ftree\u002Fmain\u002Fskills\u002Ffrontend-architecture",1782864000000,"stareezy-1\u002Ffrontend-architecture-skill","community","https:\u002F\u002Fgithub.com\u002Fstareezy-1\u002Ffrontend-architecture-skill\u002Fblob\u002Fmain\u002FLICENSE","main","b1e4ffadb4f933bbbcaa03a83f8b9929171ac28b",".agents\u002Fskills\u002Ffrontend-architecture",0,"https:\u002F\u002Fgithub.com\u002FHazek-dc\u002FPresensiGuru_FaceNet_EMAR","https:\u002F\u002Fgithub.com\u002FHazek-dc","2026-10-22 08:36:44",{"source":8,"skillName":5,"commands":38,"prompt":48,"zipAvailable":49},[39,42,45],{"tool":40,"command":41},"npx","npx skills add Hazek-dc\u002FPresensiGuru_FaceNet_EMAR --skill frontend-architecture",{"tool":43,"command":44},"bunx","bunx skills add Hazek-dc\u002FPresensiGuru_FaceNet_EMAR --skill frontend-architecture",{"tool":46,"command":47},"pnpm","pnpm dlx skills add Hazek-dc\u002FPresensiGuru_FaceNet_EMAR --skill frontend-architecture","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FHazek-dc\u002FPresensiGuru_FaceNet_EMAR\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Ffrontend-architecture\u002FSKILL.md",true,[],[52,59,66,73,80,87],{"skillNo":53,"name":54,"nameZh":6,"description":55,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":56,"categories":57,"keywords":58,"publishedAt":19},"01M7DS6GGYRZAYD33PFPS8Z2T3","testing-best-practices","Laravel test design and review. Use when selecting coverage, naming or structuring tests, choosing assertions or test data, isolating dependencies, testing HTTP or security boundaries, improving suite performance, or reviewing test value. Use framework guidance or search-docs for Pest and PHPUnit syntax.","https:\u002F\u002Fgithub.com\u002FHazek-dc\u002FPresensiGuru_FaceNet_EMAR\u002Fblob\u002Fmain\u002Fattendance-web\u002F.claude\u002Fskills\u002Ftesting-best-practices\u002FSKILL.md",[],[],{"skillNo":60,"name":61,"nameZh":6,"description":62,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":63,"categories":64,"keywords":65,"publishedAt":19},"01M7DS6BC3AW7HTPRHE2TTVKWM","tailwindcss-development","Always invoke when the user's message includes 'tailwind' in any form. Also invoke for: building responsive grid layouts (multi-column card grids, product grids), flex\u002Fgrid page structures (dashboards with sidebars, fixed topbars, mobile-toggle navs), styling UI components (cards, tables, navbars, pricing sections, forms, inputs, badges), adding dark mode variants, fixing spacing or typography, and Tailwind v3\u002Fv4 work. The core use case: writing or fixing Tailwind utility classes in HTML templates (Blade, JSX, Vue). Skip for backend PHP logic, database queries, API routes, JavaScript with no HTML\u002FCSS component, CSS file audits, build tool configuration, and vanilla CSS.","https:\u002F\u002Fgithub.com\u002FHazek-dc\u002FPresensiGuru_FaceNet_EMAR\u002Fblob\u002Fmain\u002Fattendance-web\u002F.claude\u002Fskills\u002Ftailwindcss-development\u002FSKILL.md",[],[],{"skillNo":67,"name":68,"nameZh":6,"description":69,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":70,"categories":71,"keywords":72,"publishedAt":19},"01M7DS66GE6B11MYJDVC74HXM4","laravel-best-practices","Apply this skill whenever writing, reviewing, or refactoring Laravel PHP code. This includes creating or modifying controllers, models, migrations, form requests, policies, jobs, scheduled commands, service classes, and Eloquent queries. Triggers for N+1 and query performance issues, caching strategies, authorization and security patterns, validation, error handling, queue and job configuration, route definitions, and architectural decisions. Also use for Laravel code reviews and refactoring existing Laravel code to follow best practices. Covers any task involving Laravel backend PHP code patterns.","https:\u002F\u002Fgithub.com\u002FHazek-dc\u002FPresensiGuru_FaceNet_EMAR\u002Fblob\u002Fmain\u002Fattendance-web\u002F.claude\u002Fskills\u002Flaravel-best-practices\u002FSKILL.md",[],[],{"skillNo":74,"name":75,"nameZh":6,"description":76,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":77,"categories":78,"keywords":79,"publishedAt":19},"01M7DS5ZW717DMS6P1E90AQCKV","infer-conventions","Use this skill to analyze how a Laravel application is actually written and record its conventions as shared rules. Trigger when the user wants to detect, infer, document, or standardize project conventions or coding style, set up or grow `.ai\u002Frules`, resolve mixed or conflicting patterns (e.g. \"are we using Form Requests or inline validation?\"), or onboard agents and teammates to \"how we do things here\". Covers: a systematic sweep of ~49 Laravel convention dimensions (validation, models, architecture, testing, frontend, database, console), open-ended house-pattern discovery, conflict reporting, and recording rules scoped to the right paths via the Boost `record-rule` MCP tool. Only run this skill when the user explicitly asks for it; never start a sweep as part of another task. Do not use for one-off code review, enforcing formatting a linter already handles, or editing `.ai\u002Frules` files by hand.","https:\u002F\u002Fgithub.com\u002FHazek-dc\u002FPresensiGuru_FaceNet_EMAR\u002Fblob\u002Fmain\u002Fattendance-web\u002F.claude\u002Fskills\u002Finfer-conventions\u002FSKILL.md",[],[],{"skillNo":81,"name":82,"nameZh":6,"description":83,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":84,"categories":85,"keywords":86,"publishedAt":19},"01M7DS5W12RGCVJTFQJ1N0GB8E","inertia-react-development","Develops Inertia.js v2 React client-side applications. Activates when creating React pages, forms, or navigation; using \u003CLink>, \u003CForm>, useForm, or router; working with deferred props, prefetching, or polling; or when user mentions React with Inertia, React pages, React forms, or React navigation.","https:\u002F\u002Fgithub.com\u002FHazek-dc\u002FPresensiGuru_FaceNet_EMAR\u002Fblob\u002Fmain\u002Fattendance-web\u002F.claude\u002Fskills\u002Finertia-react-development\u002FSKILL.md",[],[],{"skillNo":88,"name":89,"nameZh":6,"description":90,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":91,"categories":92,"keywords":93,"publishedAt":19},"01M7DS5PVDPMPCWSK2RXPDC9BB","deploying-to-cloud","Deploys and manages Laravel applications on Laravel Cloud using the `cloud` CLI. Use when the user wants to deploy an app, ship to Cloud, create or manage applications, environments, databases, caches, object storage, queues, domains, instances, background processes, secrets, compute, scheduled tasks, or Laravel Cloud infrastructure; or check billing, usage, or spend. Triggers on deployment, shipping, Cloud management, environment setup, database provisioning, billing or usage queries, the `cloud` CLI, and Laravel Cloud deployment troubleshooting.","https:\u002F\u002Fgithub.com\u002FHazek-dc\u002FPresensiGuru_FaceNet_EMAR\u002Fblob\u002Fmain\u002Fattendance-web\u002F.claude\u002Fskills\u002Fdeploying-to-cloud\u002FSKILL.md",[],[]]