[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7514BFQERGD2VYPD6JNJ7HM":3,"skill-same:01M7514BFQERGD2VYPD6JNJ7HM":44},{"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":24,"commitSha":25,"skillDirectory":26,"forksCount":14,"repositoryHtmlUrl":27,"repositoryHomepageUrl":6,"ownerHtmlUrl":28,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":29,"install":30,"resources":43},"01M7514BFQERGD2VYPD6JNJ7HM","planning-and-task-breakdown",null,"Breaks work into ordered tasks. Use when you have a spec or clear requirements and need to break work into implementable tasks. Use when a task feels too large to start, when you need to estimate scope, or when parallel work is possible.","chrisbarrantes\u002Fmandrel","chrisbarrantes","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F4534419?v=4","01M7511VXT2H7WE09JE4ZMBESG","Chris Barrantes","01M7511VYGPFHQCE9HNVKES0QN",0,"MIT","https:\u002F\u002Fgithub.com\u002Fchrisbarrantes\u002Fmandrel\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fcore\u002Fplanning-and-task-breakdown\u002FSKILL.md",[],[],"2026-11-12 13:55:43",false,"---\nname: planning-and-task-breakdown\ndescription:\n  Breaks work into ordered tasks. Use when you have a spec or clear requirements\n  and need to break work into implementable tasks. Use when a task feels too\n  large to start, when you need to estimate scope, or when parallel work is\n  possible.\n---\n\n# Planning and Task Breakdown\n\n## Policy Capsule\n\n- Enter Plan Mode before writing any code: read the spec + relevant codebase, map dependencies, list risks. Planning output is a plan document, not implementation.\n- Slice work **vertically** — one user-visible path per task — not horizontally (all DB, then all API, then all UI).\n- Every task carries: a one-paragraph description, explicit acceptance criteria, a verification step (test\u002Fbuild\u002Fmanual check), declared dependencies, files-likely-touched, and an estimated scope (XS–L).\n- Cap individual tasks at scope **M** (3–5 files) where possible and never start an **XL** task — break it down further. Triggers for further decomposition: >2 hours of agent work, >3 acceptance bullets, two independent subsystems touched, or \"and\" in the title.\n- Order tasks by dependency graph (foundations first) and by risk (high-risk tasks early to fail fast).\n- Insert explicit checkpoints every 2–3 tasks: tests pass, build clean, end-to-end flow works, human review before proceeding.\n- Distinguish parallelization classes — safe (independent slices, docs), must-be-sequential (migrations, shared state), and needs-coordination (shared API contract — define the contract first).\n- Capture risks + mitigations and any open questions for human input as first-class plan sections.\n- Do not start implementation until every task has acceptance criteria, a verification step, ordered dependencies, and human approval of the plan.\n\n## Overview\n\nDecompose work into small, verifiable tasks with explicit acceptance criteria.\nGood task breakdown is the difference between an agent that completes work\nreliably and one that produces a tangled mess. Every task should be small enough\nto implement, test, and verify in a single focused session.\n\n## When to Use\n\n- You have a spec and need to break it into implementable units\n- A task feels too large or vague to start\n- Work needs to be parallelized across multiple agents or sessions\n- You need to communicate scope to a human\n- The implementation order isn't obvious\n\n**When NOT to use:** Single-file changes with obvious scope, or when the spec\nalready contains well-defined tasks.\n\n## The Planning Process\n\n### Step 1: Enter Plan Mode\n\nBefore writing any code, operate in read-only mode:\n\n- Read the spec and relevant codebase sections\n- Identify existing patterns and conventions\n- Map dependencies between components\n- Note risks and unknowns\n\n**Do NOT write code during planning.** The output is a plan document, not\nimplementation.\n\n### Step 2: Identify the Dependency Graph\n\nMap what depends on what:\n\n```text\nDatabase schema\n    │\n    ├── API models\u002Ftypes\n    │       │\n    │       ├── API endpoints\n    │       │       │\n    │       │       └── Frontend API client\n    │       │               │\n    │       │               └── UI components\n    │       │\n    │       └── Validation logic\n    │\n    └── Seed data \u002F migrations\n```\n\nImplementation order follows the dependency graph bottom-up: build foundations\nfirst.\n\n### Step 3: Slice Vertically\n\nInstead of building all the database, then all the API, then all the UI — build\none complete feature path at a time:\n\n**Bad (horizontal slicing):**\n\n```text\nTask 1: Build entire database schema\nTask 2: Build all API endpoints\nTask 3: Build all UI components\nTask 4: Connect everything\n```\n\n**Good (vertical slicing):**\n\n```text\nTask 1: User can create an account (schema + API + UI for registration)\nTask 2: User can log in (auth schema + API + UI for login)\nTask 3: User can create a task (task schema + API + UI for creation)\nTask 4: User can view task list (query + API + UI for list view)\n```\n\nEach vertical slice delivers working, testable functionality.\n\n### Step 4: Write Tasks\n\nEach task follows this structure:\n\n```markdown\n## Task [N]: [Short descriptive title]\n\n**Description:** One paragraph explaining what this task accomplishes.\n\n**Acceptance criteria:**\n\n- [ ] [Specific, testable condition]\n- [ ] [Specific, testable condition]\n\n**Verification:**\n\n- [ ] Tests pass: `npm test -- --grep \"feature-name\"`\n- [ ] Build succeeds: `npm run build`\n- [ ] Manual check: [description of what to verify]\n\n**Dependencies:** [Task numbers this depends on, or \"None\"]\n\n**Files likely touched:**\n\n- `src\u002Fpath\u002Fto\u002Ffile.ts`\n- `tests\u002Fpath\u002Fto\u002Ftest.ts`\n\n**Estimated scope:** [Small: 1-2 files | Medium: 3-5 files | Large: 5+ files]\n```\n\n### Step 5: Order and Checkpoint\n\nArrange tasks so that:\n\n1. Dependencies are satisfied (build foundation first)\n2. Each task leaves the system in a working state\n3. Verification checkpoints occur after every 2-3 tasks\n4. High-risk tasks are early (fail fast)\n\nAdd explicit checkpoints:\n\n```markdown\n## Checkpoint: After Tasks 1-3\n\n- [ ] All tests pass\n- [ ] Application builds without errors\n- [ ] Core user flow works end-to-end\n- [ ] Review with human before proceeding\n```\n\n## Task Sizing Guidelines\n\n| Size   | Files | Scope                                 | Example                              |\n| ------ | ----- | ------------------------------------- | ------------------------------------ |\n| **XS** | 1     | Single function or config change      | Add a validation rule                |\n| **S**  | 1-2   | One component or endpoint             | Add a new API endpoint               |\n| **M**  | 3-5   | One feature slice                     | User registration flow               |\n| **L**  | 5-8   | Multi-component feature               | Search with filtering and pagination |\n| **XL** | 8+    | **Too large — break it down further** | —                                    |\n\nIf a task is L or larger, it should be broken into smaller tasks. An agent\nperforms best on S and M tasks.\n\n**When to break a task down further:**\n\n- It would take more than one focused session (roughly 2+ hours of agent work)\n- You cannot describe the acceptance criteria in 3 or fewer bullet points\n- It touches two or more independent subsystems (e.g., auth and billing)\n- You find yourself writing \"and\" in the task title (a sign it is two tasks)\n\n## Plan Document Template\n\n```markdown\n# Implementation Plan: [Feature\u002FProject Name]\n\n## Overview\n\n[One paragraph summary of what we're building]\n\n## Architecture Decisions\n\n- [Key decision 1 and rationale]\n- [Key decision 2 and rationale]\n\n## Task List\n\n### Phase 1: Foundation\n\n- [ ] Task 1: ...\n- [ ] Task 2: ...\n\n### Checkpoint: Foundation\n\n- [ ] Tests pass, builds clean\n\n### Phase 2: Core Features\n\n- [ ] Task 3: ...\n- [ ] Task 4: ...\n\n### Checkpoint: Core Features\n\n- [ ] End-to-end flow works\n\n### Phase 3: Polish\n\n- [ ] Task 5: ...\n- [ ] Task 6: ...\n\n### Checkpoint: Complete\n\n- [ ] All acceptance criteria met\n- [ ] Ready for review\n\n## Risks and Mitigations\n\n| Risk   | Impact         | Mitigation |\n| ------ | -------------- | ---------- |\n| [Risk] | [High\u002FMed\u002FLow] | [Strategy] |\n\n## Open Questions\n\n- [Question needing human input]\n```\n\n## Parallelization Opportunities\n\nWhen multiple agents or sessions are available:\n\n- **Safe to parallelize:** Independent feature slices, tests for\n  already-implemented features, documentation\n- **Must be sequential:** Database migrations, shared state changes, dependency\n  chains\n- **Needs coordination:** Features that share an API contract (define the\n  contract first, then parallelize)\n\n## Common Rationalizations\n\n| Rationalization                | Reality                                                                                      |\n| ------------------------------ | -------------------------------------------------------------------------------------------- |\n| \"I'll figure it out as I go\"   | That's how you end up with a tangled mess and rework. 10 minutes of planning saves hours.    |\n| \"The tasks are obvious\"        | Write them down anyway. Explicit tasks surface hidden dependencies and forgotten edge cases. |\n| \"Planning is overhead\"         | Planning is the task. Implementation without a plan is just typing.                          |\n| \"I can hold it all in my head\" | Context windows are finite. Written plans survive session boundaries and compaction.         |\n\n## Red Flags\n\n- Starting implementation without a written task list\n- Tasks that say \"implement the feature\" without acceptance criteria\n- No verification steps in the plan\n- All tasks are XL-sized\n- No checkpoints between tasks\n- Dependency order isn't considered\n\n## Verification\n\nBefore starting implementation, confirm:\n\n- [ ] Every task has acceptance criteria\n- [ ] Every task has a verification step\n- [ ] Task dependencies are identified and ordered correctly\n- [ ] No task touches more than ~5 files\n- [ ] Checkpoints exist between major phases\n- [ ] The human has reviewed and approved the plan\n","# Planning and Task Breakdown\n\n## Policy Capsule\n\n- Enter Plan Mode before writing any code: read the spec + relevant codebase, map dependencies, list risks. Planning output is a plan document, not implementation.\n- Slice work **vertically** — one user-visible path per task — not horizontally (all DB, then all API, then all UI).\n- Every task carries: a one-paragraph description, explicit acceptance criteria, a verification step (test\u002Fbuild\u002Fmanual check), declared dependencies, files-likely-touched, and an estimated scope (XS–L).\n- Cap individual tasks at scope **M** (3–5 files) where possible and never start an **XL** task — break it down further. Triggers for further decomposition: >2 hours of agent work, >3 acceptance bullets, two independent subsystems touched, or \"and\" in the title.\n- Order tasks by dependency graph (foundations first) and by risk (high-risk tasks early to fail fast).\n- Insert explicit checkpoints every 2–3 tasks: tests pass, build clean, end-to-end flow works, human review before proceeding.\n- Distinguish parallelization classes — safe (independent slices, docs), must-be-sequential (migrations, shared state), and needs-coordination (shared API contract — define the contract first).\n- Capture risks + mitigations and any open questions for human input as first-class plan sections.\n- Do not start implementation until every task has acceptance criteria, a verification step, ordered dependencies, and human approval of the plan.\n\n## Overview\n\nDecompose work into small, verifiable tasks with explicit acceptance criteria.\nGood task breakdown is the difference between an agent that completes work\nreliably and one that produces a tangled mess. Every task should be small enough\nto implement, test, and verify in a single focused session.\n\n## When to Use\n\n- You have a spec and need to break it into implementable units\n- A task feels too large or vague to start\n- Work needs to be parallelized across multiple agents or sessions\n- You need to communicate scope to a human\n- The implementation order isn't obvious\n\n**When NOT to use:** Single-file changes with obvious scope, or when the spec\nalready contains well-defined tasks.\n\n## The Planning Process\n\n### Step 1: Enter Plan Mode\n\nBefore writing any code, operate in read-only mode:\n\n- Read the spec and relevant codebase sections\n- Identify existing patterns and conventions\n- Map dependencies between components\n- Note risks and unknowns\n\n**Do NOT write code during planning.** The output is a plan document, not\nimplementation.\n\n### Step 2: Identify the Dependency Graph\n\nMap what depends on what:\n\n```text\nDatabase schema\n    │\n    ├── API models\u002Ftypes\n    │       │\n    │       ├── API endpoints\n    │       │       │\n    │       │       └── Frontend API client\n    │       │               │\n    │       │               └── UI components\n    │       │\n    │       └── Validation logic\n    │\n    └── Seed data \u002F migrations\n```\n\nImplementation order follows the dependency graph bottom-up: build foundations\nfirst.\n\n### Step 3: Slice Vertically\n\nInstead of building all the database, then all the API, then all the UI — build\none complete feature path at a time:\n\n**Bad (horizontal slicing):**\n\n```text\nTask 1: Build entire database schema\nTask 2: Build all API endpoints\nTask 3: Build all UI components\nTask 4: Connect everything\n```\n\n**Good (vertical slicing):**\n\n```text\nTask 1: User can create an account (schema + API + UI for registration)\nTask 2: User can log in (auth schema + API + UI for login)\nTask 3: User can create a task (task schema + API + UI for creation)\nTask 4: User can view task list (query + API + UI for list view)\n```\n\nEach vertical slice delivers working, testable functionality.\n\n### Step 4: Write Tasks\n\nEach task follows this structure:\n\n```markdown\n## Task [N]: [Short descriptive title]\n\n**Description:** One paragraph explaining what this task accomplishes.\n\n**Acceptance criteria:**\n\n- [ ] [Specific, testable condition]\n- [ ] [Specific, testable condition]\n\n**Verification:**\n\n- [ ] Tests pass: `npm test -- --grep \"feature-name\"`\n- [ ] Build succeeds: `npm run build`\n- [ ] Manual check: [description of what to verify]\n\n**Dependencies:** [Task numbers this depends on, or \"None\"]\n\n**Files likely touched:**\n\n- `src\u002Fpath\u002Fto\u002Ffile.ts`\n- `tests\u002Fpath\u002Fto\u002Ftest.ts`\n\n**Estimated scope:** [Small: 1-2 files | Medium: 3-5 files | Large: 5+ files]\n```\n\n### Step 5: Order and Checkpoint\n\nArrange tasks so that:\n\n1. Dependencies are satisfied (build foundation first)\n2. Each task leaves the system in a working state\n3. Verification checkpoints occur after every 2-3 tasks\n4. High-risk tasks are early (fail fast)\n\nAdd explicit checkpoints:\n\n```markdown\n## Checkpoint: After Tasks 1-3\n\n- [ ] All tests pass\n- [ ] Application builds without errors\n- [ ] Core user flow works end-to-end\n- [ ] Review with human before proceeding\n```\n\n## Task Sizing Guidelines\n\n| Size   | Files | Scope                                 | Example                              |\n| ------ | ----- | ------------------------------------- | ------------------------------------ |\n| **XS** | 1     | Single function or config change      | Add a validation rule                |\n| **S**  | 1-2   | One component or endpoint             | Add a new API endpoint               |\n| **M**  | 3-5   | One feature slice                     | User registration flow               |\n| **L**  | 5-8   | Multi-component feature               | Search with filtering and pagination |\n| **XL** | 8+    | **Too large — break it down further** | —                                    |\n\nIf a task is L or larger, it should be broken into smaller tasks. An agent\nperforms best on S and M tasks.\n\n**When to break a task down further:**\n\n- It would take more than one focused session (roughly 2+ hours of agent work)\n- You cannot describe the acceptance criteria in 3 or fewer bullet points\n- It touches two or more independent subsystems (e.g., auth and billing)\n- You find yourself writing \"and\" in the task title (a sign it is two tasks)\n\n## Plan Document Template\n\n```markdown\n# Implementation Plan: [Feature\u002FProject Name]\n\n## Overview\n\n[One paragraph summary of what we're building]\n\n## Architecture Decisions\n\n- [Key decision 1 and rationale]\n- [Key decision 2 and rationale]\n\n## Task List\n\n### Phase 1: Foundation\n\n- [ ] Task 1: ...\n- [ ] Task 2: ...\n\n### Checkpoint: Foundation\n\n- [ ] Tests pass, builds clean\n\n### Phase 2: Core Features\n\n- [ ] Task 3: ...\n- [ ] Task 4: ...\n\n### Checkpoint: Core Features\n\n- [ ] End-to-end flow works\n\n### Phase 3: Polish\n\n- [ ] Task 5: ...\n- [ ] Task 6: ...\n\n### Checkpoint: Complete\n\n- [ ] All acceptance criteria met\n- [ ] Ready for review\n\n## Risks and Mitigations\n\n| Risk   | Impact         | Mitigation |\n| ------ | -------------- | ---------- |\n| [Risk] | [High\u002FMed\u002FLow] | [Strategy] |\n\n## Open Questions\n\n- [Question needing human input]\n```\n\n## Parallelization Opportunities\n\nWhen multiple agents or sessions are available:\n\n- **Safe to parallelize:** Independent feature slices, tests for\n  already-implemented features, documentation\n- **Must be sequential:** Database migrations, shared state changes, dependency\n  chains\n- **Needs coordination:** Features that share an API contract (define the\n  contract first, then parallelize)\n\n## Common Rationalizations\n\n| Rationalization                | Reality                                                                                      |\n| ------------------------------ | -------------------------------------------------------------------------------------------- |\n| \"I'll figure it out as I go\"   | That's how you end up with a tangled mess and rework. 10 minutes of planning saves hours.    |\n| \"The tasks are obvious\"        | Write them down anyway. Explicit tasks surface hidden dependencies and forgotten edge cases. |\n| \"Planning is overhead\"         | Planning is the task. Implementation without a plan is just typing.                          |\n| \"I can hold it all in my head\" | Context windows are finite. Written plans survive session boundaries and compaction.         |\n\n## Red Flags\n\n- Starting implementation without a written task list\n- Tasks that say \"implement the feature\" without acceptance criteria\n- No verification steps in the plan\n- All tasks are XL-sized\n- No checkpoints between tasks\n- Dependency order isn't considered\n\n## Verification\n\nBefore starting implementation, confirm:\n\n- [ ] Every task has acceptance criteria\n- [ ] Every task has a verification step\n- [ ] Task dependencies are identified and ordered correctly\n- [ ] No task touches more than ~5 files\n- [ ] Checkpoints exist between major phases\n- [ ] The human has reviewed and approved the plan\n",{"name":5,"description":7},"main","22b1847659cc2a98f4fb8c24858f2199d91fda66",".agents\u002Fskills\u002Fcore\u002Fplanning-and-task-breakdown","https:\u002F\u002Fgithub.com\u002Fchrisbarrantes\u002Fmandrel","https:\u002F\u002Fgithub.com\u002Fchrisbarrantes","2026-05-27 08:16:47",{"source":8,"skillName":5,"commands":31,"prompt":41,"zipAvailable":42},[32,35,38],{"tool":33,"command":34},"npx","npx skills add chrisbarrantes\u002Fmandrel --skill planning-and-task-breakdown",{"tool":36,"command":37},"bunx","bunx skills add chrisbarrantes\u002Fmandrel --skill planning-and-task-breakdown",{"tool":39,"command":40},"pnpm","pnpm dlx skills add chrisbarrantes\u002Fmandrel --skill planning-and-task-breakdown","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fchrisbarrantes\u002Fmandrel\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fcore\u002Fplanning-and-task-breakdown\u002FSKILL.md",true,[],[45,52,59,66,73,80],{"skillNo":46,"name":47,"nameZh":6,"description":48,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":49,"categories":50,"keywords":51,"publishedAt":19},"01M75171YZD373TXY5ZWJNXGS9","no-capsule-skill","Fixture without a Policy Capsule section.","https:\u002F\u002Fgithub.com\u002Fchrisbarrantes\u002Fmandrel\u002Fblob\u002Fmain\u002Ftests\u002Forchestration\u002Ffixtures\u002Fskill-capsule\u002Fno-capsule-skill\u002FSKILL.md",[],[],{"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},"01M7516ZA88ESAAY3JWXBNA56K","backend-security-patterns","Combined backend protocols for authentication (Clerk JWT verification) and PII-safe observability. Use when handling auth on the server, verifying Clerk webhooks via `svix`, scoping metadata via `publicMetadata`\u002F `privateMetadata`, or sanitizing logs to keep emails, tokens, and request bodies out of telemetry.","https:\u002F\u002Fgithub.com\u002Fchrisbarrantes\u002Fmandrel\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fstack\u002Fsecurity\u002Fbackend-security-patterns\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},"01M7516WFQMKD2NGFMDNFG6C4A","vitest","Writes fast, isolated unit and integration tests with Vitest. Use when each test must run on file-save without shared state — `vi.mock()` for external deps, `vi.spyOn()` for call monitoring, AAA structure, and edge-case coverage for null\u002Fundefined\u002Fboundary inputs.","https:\u002F\u002Fgithub.com\u002Fchrisbarrantes\u002Fmandrel\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fstack\u002Fqa\u002Fvitest\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},"01M7516T8FX7B0B0D510EE2FAP","playwright","Robust E2E browser testing with Playwright. Use when writing browser-driven tests — leverage auto-waiting (no `waitForTimeout`), prefer user-visible locators (`getByRole`, `getByText`, `getByLabel`) over CSS\u002FXPath, reuse `storageState` for auth, and enable trace-on-first-retry for CI debugging.","https:\u002F\u002Fgithub.com\u002Fchrisbarrantes\u002Fmandrel\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fstack\u002Fqa\u002Fplaywright\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},"01M7516PHY868BJXHHZJ0FRYSX","playwright-bdd","Wires Gherkin `.feature` files to Playwright via the `playwright-bdd` library. Use when running BDD scenarios on a Playwright runtime — pairs with the `gherkin-authoring` skill (scenario prose) and the `playwright` skill (browser conventions). Drives execution by tag expression with trace-first debugging and Playwright-native sharding.","https:\u002F\u002Fgithub.com\u002Fchrisbarrantes\u002Fmandrel\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fstack\u002Fqa\u002Fplaywright-bdd\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},"01M7516KEGSBBFJXRZWYBKYM4P","lighthouse-baseline","Codifies the capture-and-check baseline pattern for long-running quality signals (Lighthouse scores, bundle size, p95 latency, runtime memory). Use when wiring a new metric that needs a baseline file, paired :capture \u002F :check npm scripts, a tolerance-bounded gate, and a weekly refresh cadence — the goal is a hard CI signal that ratchets only with intent.","https:\u002F\u002Fgithub.com\u002Fchrisbarrantes\u002Fmandrel\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fstack\u002Fqa\u002Flighthouse-baseline\u002FSKILL.md",[],[]]