{
  "markdown": "# sdlc-skills\n\n**The content layer for AI-assisted software delivery.** Role-based agent\npersonas (BA, Tech Lead, PM, devs, QA, PA), workflow skills (TDD,\nbugfix, code review, task completion, memory, …), and a registry that\npulls proven skills from Matt Pocock, Jesse Vincent (obra/superpowers),\nand Paul Hudson so you don't have to reinvent them.\n\nInstall via the npx one-shot or a native plugin manifest and use the\nagents + skills directly in any AI IDE (Claude Code, Cursor, Gemini CLI,\nGitHub Copilot CLI, Windsurf, Codex).\n\n## Architecture\n\n```mermaid\nflowchart TB\n    subgraph sdlc[\"sdlc-skills — content + install resolution\"]\n        direction TB\n        agents[/\"factories/<br/>agent + skill content\"/]\n        skills[/\"orphan skills/<br/>standalone-only content\"/]\n        registry[(\"skills.json<br/>catalog: orphan + external\")]\n        installer([\"bin/init.mjs<br/>npx installer\"])\n        agents --- skills\n        skills --- registry\n        registry --- installer\n    end\n\n    subgraph consumers[\"consumers\"]\n        direction LR\n        ides[\"AI IDEs<br/>Claude Code • Cursor<br/>Gemini CLI • Copilot CLI<br/>Windsurf\"]\n    end\n\n    subgraph externals[\"upstream external skill sources\"]\n        direction LR\n        ext_matt[[\"mattpocock/skills<br/>skills/engineering/tdd\"]]\n        ext_obra[[\"obra/superpowers<br/>brainstorming, debugging,<br/>verification, ...\"]]\n        ext_tws[[\"twostraws/*-Agent-Skill<br/>SwiftUI, SwiftData,<br/>Swift Testing, Concurrency\"]]\n        ext_msft[[\"microsoft/playwright-cli<br/>playwright-cli\"]]\n    end\n\n    installer ==>|fetch at install time| ext_matt\n    installer ==>|fetch at install time| ext_obra\n    installer ==>|fetch at install time| ext_tws\n    installer ==>|fetch at install time| ext_msft\n\n    sdlc ==>|direct install via<br/>plugin manifest or npx| ides\n```\n\n(Node shapes convey grouping so colors aren't needed: `/ /` parallelograms\nfor content dirs, `( )` round-ended for the installer, cylinders for the\nregistry, `[[ ]]` subroutines for external sources. GitHub's Mermaid\nrenderer uses theme-adaptive colors in both light and dark mode.)\n\nAgents are **self-describing** — each `AGENT.md` carries its own metadata\n(role, group, theme, aliases, skills, model). IDE plugin systems read it at\ninstall time. Nothing duplicated.\n\nMost agents and skills live inside factories (`factories/<id>/agents/` and\n`factories/<id>/skills/`). The top-level `agents/` and `skills/` directories\nhold only standalone-only \"orphan\" content: one agent (`personal-assistant`)\nand eight skills (`deep-research`, `gathering-context`, `verifying-outcomes`,\n`microsoft-365`, `obsidian-vault`, `tosca-automation`, `vividus`,\n`xray-testing`). `skills.json` registers those orphan monorepo skills and\nthe external skills fetched from upstream.\n\nExternal skills (Matt Pocock's `tdd`, Jesse Vincent's `brainstorming` /\n`systematic-debugging` / etc., Paul Hudson's Swift skills) live in their\nupstream repos. The installer resolves each agent's declared skill list\nagainst `skills.json`, clones external repos on first install into\n`~/.cache/sdlc-skills/registry/`, and copies the subdir into your project's\nskills directory (or symlinks it with `--symlink`).\n\n## What lands in your project\n\nAfter `npx … init` + a scout run, your target project has two top-level\ndirectories plus the IDE's native install location:\n\n```\nyour-project/\n├── .claude/                  ← IDE-native install (or .cursor/, .windsurf/, .github/)\n│   ├── agents/<role>/        agent config (AGENT.md + SOUL.md)\n│   └── skills/<name>/        skill content (SKILL.md + references)\n│\n├── .agents/                  ← IDE-neutral content — every agent reads\n│   ├── profile.md            scout output: project card\n│   ├── architecture.md       scout output: system design\n│   ├── conventions.md        scout output: coding standards\n│   ├── testing.md            scout output: test infrastructure\n│   ├── team-comms.md         scout output: transport + roster\n│   ├── onboarding.md         scout's audit trail\n│   └── memory/<role>/        memory-skill dir: MEMORY.md index,\n│                             curated entries (incl. scout-seeded\n│                             project_briefing.md), daily/, snapshot.md\n│\n├── AGENTS.md                 scout output: full team reference\n└── CLAUDE.md                 scout output: 80-line auto-loaded context\n```\n\n`.agents/` holds content every agent reads regardless of IDE. Nothing\nin `.agents/` is host-specific — it works identically under Claude Code,\nCursor, Gemini CLI, Copilot CLI, and Windsurf.\n\nScout (`scout` agent, run once when onboarding) populates everything\nunder `.agents/` plus `AGENTS.md` / `CLAUDE.md` at the root. Re-run\nscout whenever the stack evolves to refresh.\n\n## Install — pick one path\n\nThere are really two paths: the **full experience** (npx installer) and\nthe **monorepo-only fallbacks** (native IDE plugins for people who don't\nwant to be happy).\n\n| Path | Fetches external skills? | When to pick |\n|---|---|---|\n| **npx installer** ⭐ | ✅ Yes | Any IDE. Full catalog. One command. This is the happy path. |\n| Native IDE plugins | ❌ Monorepo only | You don't want Node installed. Trade-off: no external skills, manual team assembly. |\n\n> **Adopting a whole team?** Each factory has a deep, scenario-based onboarding\n> guide under [`docs/onboarding/`](docs/onboarding/) — start at the\n> [index](docs/onboarding/README.md) to pick yours:\n> [feature-development](docs/onboarding/feature-development.md) (dev team),\n> [manual-qa](docs/onboarding/manual-qa.md) (manual-QA team),\n> [test-automation](docs/onboarding/test-automation.md) (TMS → merged-test\n> pipeline: install → MCP inventory → scout seed →\n> `.agents/test-automation.yaml` → single-case pilot → scale-up), or\n> [product-management](docs/onboarding/product-management.md) (PO discovery team:\n> raw ask → verified, prioritized hypothesis → engineering handoff).\n\n> **Why the split?** The native IDE plugin systems (Claude Code, Cursor,\n> Gemini CLI, Copilot CLI) only see skills present locally in this repo —\n> they don't know how to fetch from upstream. The\n> npx installer reads `skills.json` and resolves external dependencies\n> automatically (Matt Pocock's TDD, Jesse Vincent's debugging skills,\n> Paul Hudson's Swift skills). If you want the full catalog, use the\n> ⭐ path.\n\n### 1. npx installer (recommended)\n\nOne command installs agents, their declared monorepo skills, and their\nexternal skills together. Works for Claude Code, Cursor, Windsurf, GitHub\nCopilot, and Codex (IDE targets detected automatically). Agents install in\neach host's native form — directories for Claude/Cursor/Windsurf, flat\n`.agent.md` for Copilot, TOML for Codex.\n\n```bash\n# A team factory — the whole team in one shot (agents, their skills,\n# per-role stack briefings, and team conventions). See factories/SPEC.md.\nnpx github:arozumenko/sdlc-skills init --factory feature-development   # cross-platform delivery: pick python-dev, js-dev, test-automation-engineer, ios-dev, android-dev\nnpx github:arozumenko/sdlc-skills init --factory manual-qa     # manual-QA team (live browser testing via Playwright MCP)\nnpx github:arozumenko/sdlc-skills init --factory test-automation  # TMS-driven automation pipeline (analyst → implementer → reviewer, led by Tal)\nnpx github:arozumenko/sdlc-skills init --factory product-management  # PO discovery pipeline (raw ask → verified, prioritized hypotheses)\n\n# Full catalog, all detected IDEs\nnpx github:arozumenko/sdlc-skills init --all\n\n# A specific team — every declared skill comes along automatically\n# (monorepo + external; externals are git-cloned then copied in — add --symlink to link instead)\nnpx github:arozumenko/sdlc-skills init --agents ba,tech-lead,ios-dev,android-dev\n\n# Specific skills (overrides the auto-resolve)\nnpx github:arozumenko/sdlc-skills init --skills bugfix-workflow,code-review\n\n# Narrow to one IDE target\nnpx github:arozumenko/sdlc-skills init --agents ios-dev --target claude\n\n# Update an existing install\nnpx github:arozumenko/sdlc-skills init --all --update\n```\n\n**Team factories.** A factory is a named team preset that installs a curated\nset of agents (with their skills), seeds per-role stack briefings into\n`.agents/memory/<role>/`, splices team conventions into `AGENTS.md` /\n`CLAUDE.md`, applies per-role **skill overlays**, and can **seed reference\nfiles** into the project — one command instead of hand-listing roles. Four\nship today:\n\n| Factory | Roster | What it's for |\n|---|---|---|\n| `feature-development` | core roles (scout, ba, project-manager, tech-lead, qa-engineer) + picked dev roles | Cross-platform delivery team — interactive picker selects any of `python-dev` (FastAPI/FastMCP backend), `js-dev` (JS/TS frontend), `test-automation-engineer` (web automation), `ios-dev` (Swift/SwiftUI), `android-dev` (greenfield Kotlin/Compose); core roles auto-tune per picked platforms. |\n| `manual-qa` | 7 factory-local agents (app-profiler, test-sizer, test-author, test-run-lead, test-runner, test-reporter, qa-auditor) | Manual-QA team — `app-profiler` onboards the app, then `test-run-lead` orchestrates a run: authoring (`test-author`) and sizing (`test-sizer`) cases when needed, running them live via Playwright MCP (`test-runner`), and reporting (`test-reporter`). Also ships a specialist audit mode: `qa-auditor` runs security/accessibility/privacy/performance/responsive/UX/SEO passes via Playwright MCP, writes a findings report, and codifies notable findings into regression TC cases. Ships its own agents and seeds the test-case/report-format reference docs into `.agents/manual-qa/knowledge/`. |\n| `test-automation` | shared core (scout) + test-automation-engineer + qa-engineer + factory-local `test-automation-lead` (Tal) | Automation-focused team — Tal orchestrates the analyst → implementer → reviewer pipeline, owns test-framework architecture and the automation merge gate. Pins `test-automation-workflow` + `test-case-analysis`; TMS-agnostic. |\n| `product-management` | 2 factory-local agents (product-owner, discovery-researcher) | PO discovery pipeline — `product-owner` (Priya) drives intake triage, persona/outcome framing, opportunity-tree mapping, and prioritization end to end; `discovery-researcher` (Sam) is dispatched for stakeholder interviews and evidence verification. Ships 10 factory-local skills and seeds an empty `docs/discovery/` scaffold. |\n\nSee [`factories/SPEC.md`](factories/SPEC.md) and each factory's `README.md` to\nauthor your own. (`--bundle` still works as a silent back-compat alias for\n`--factory` — the flag used before this repo's factories rename.)\n\nInstall locations:\n\n| Target | Directory | Drop path |\n|---|---|---|\n| Claude Code | `.claude/` | `.claude/agents/<name>/`, `.claude/skills/<name>/` |\n| Cursor | `.cursor/` | `.cursor/agents/<name>/`, `.cursor/skills/<name>/` |\n| Windsurf | `.windsurf/` | `.windsurf/agents/<name>/`, `.windsurf/skills/<name>/` |\n| GitHub Copilot CLI | `.github/` | `.github/agents/<name>.agent.md` (flat file), `.github/skills/<name>/` |\n\n**Copilot CLI note.** Copilot CLI expects agents as flat\n`<name>.agent.md` files, not as directories. The installer handles this\nautomatically when `--target copilot` is selected: it flattens\n`AGENT.md` + `SOUL.md` into a single file with a `## Persona` section,\nand rewrites `model: sonnet` → `model: claude-sonnet-4.6` so Copilot CLI\npicks a concrete model. The other targets keep the directory layout.\n\n**Skills-inventory injection (non-Claude targets).** Claude Code\npreloads each SKILL.md declared in the agent's `skills:` frontmatter\ndirectly into the subagent's context at startup, so the agent already\nhas the skill content before it reads its own AGENT.md. Copilot CLI,\nCursor, and Windsurf have no documented preload — Copilot silently\ndiscards unknown frontmatter keys. The installer fills the gap only\nwhere it exists: for Copilot / Cursor / Windsurf targets, every\ninstalled AGENT.md gets a bracketed `<!-- SKILLS-INJECTED: START -->`\nsection listing declared skills with their descriptions from\n`skills.json`. Claude Code agents do not receive this section (it\nwould duplicate the preload). The block is idempotent on `--update` —\nre-runs replace in place, never duplicate.\n\nExternal skills are cloned once into the shared cache at\n`~/.cache/sdlc-skills/registry/<owner>__<repo>/` (override with\n`SDLC_SKILLS_CACHE_DIR` or `XDG_CACHE_HOME`), then **copied** into the\nproject's skills dir by default — so the install is self-contained and\nportable (git, zip, Docker, Windows, and sandboxed/jailed agent runtimes\nthat don't follow symlinks all work). Pass **`--symlink`** to symlink from\nthe cache instead (a live link, dedups across projects) when your runtime\nhandles symlinks and you'd rather not duplicate the content.\n\nRun `npx github:arozumenko/sdlc-skills init --help` for the full flag list.\n\n### Repairing an existing Copilot CLI install — `fix-copilot`\n\nIf a project already has agents installed as directories under\n`.github/agents/<name>/` (older sdlc-skills release, manual drop,\ninstall from upstream before this fix landed), run:\n\n```bash\nnpx github:arozumenko/sdlc-skills init fix-copilot\n```\n\nThis scans `.github/agents/`, flattens each directory into\n`<name>.agent.md`, and rewrites the `model:` line for Copilot\ncompatibility. Four modes for handling the paired `SOUL.md`:\n\n| `--soul <mode>` | What happens to `SOUL.md` |\n|---|---|\n| `memory` (default) | Relocated to `.agents/memory/<name>/SOUL.md` (IDE-neutral per-role dir, co-located with memory-skill content); source directory removed; in-file reference rewritten as an `@`-prefixed auto-import (matches the existing `@.agents/memory/<name>/snapshot.md` convention) |\n| `inline` | Appended as `## Persona` inside the flat agent file; source directory removed |\n| `keep` | Left in place at `<name>/SOUL.md`; flat agent file's reference rewritten |\n| `sibling` | Moved to `<name>.soul.md` next to the agent file; reference rewritten |\n\nAdd `--dry-run` to preview, or `--no-normalize-model` to keep the\noriginal `model:` value. Full help: `init fix-copilot --help`.\n\n### 2. Monorepo-only fallbacks (for when you refuse to install Node)\n\nEach of these paths reads the native plugin manifest this repo ships and\ninstalls **only the monorepo content** — the orphan `skills/` entries plus the\nfactory-owned agents/skills the manifest points at. External skills (Matt\nPocock's TDD, the superpowers skills, the twostraws Swift skills) are not\nfetched. If you want those, go back to path 1.\n\n**Claude Code plugin marketplace** — `.claude-plugin/marketplace.json`\n\n```bash\n/plugin marketplace add arozumenko/sdlc-skills\n/plugin install sdlc-skills@sdlc-skills\n# Or individual entries: /plugin install ios-dev@sdlc-skills  etc.\n```\n\n**Cursor native plugin** — `.cursor-plugin/plugin.json`\n\nPoint Cursor's plugin manager at this repo URL; it reads the manifest\nand installs skills + agents from the discovered orphan and factory dirs.\n\n**Gemini CLI extension** — `gemini-extension.json` + `GEMINI.md`\n\n```bash\ngemini extensions install https://github.com/arozumenko/sdlc-skills\n```\n\nThe `GEMINI.md` context file catalogs every agent and skill for on-demand\nloading.\n\n**GitHub Copilot CLI / generic** — `AGENTS.md`\n\n`AGENTS.md` at the repo root describes the content for any tool that\nfollows the AGENTS.md convention. Copilot CLI reads it when the repo is\ncloned into your project.\n\n### 3. agentskills.io / third-party consumption\n\nEvery `SKILL.md` in this repo — the orphans under `skills/<name>/` and the\nfactory-owned skills under `factories/<id>/skills/<name>/` — follows the\n[agentskills.io](https://agentskills.io) spec (`name` + `description`\nfrontmatter). Any skill runtime (Vercel, custom frameworks, other IDEs) can\npoint directly at a `SKILL.md` directory.\n\n## Catalog\n\n### Agents (catalog across factories)\n\n| Agent | Persona | Role |\n|---|---|---|\n| `ba` | Alex | Business analyst — turns requirements into user stories with acceptance criteria |\n| `tech-lead` | Rio | Decomposes user stories into technical tasks with dependencies; owns framework-scale decisions for test automation |\n| `project-manager` | Max | Distributes tasks, tracks team state, escalates blockers, owns the merge gate |\n| `python-dev` | Py | Python implementation — owns its own repo clone and branch |\n| `js-dev` | Jay | JavaScript / TypeScript implementation — owns its own repo clone and branch |\n| `ios-dev` | Io | iOS/Swift implementation — SwiftUI, SwiftData, Swift Testing (no simulator) |\n| `android-dev` | Dan | Android/Kotlin implementation — **greenfield Compose only**, Room/DataStore, Hilt (no device or emulator) |\n| `qa-engineer` | Sage | Tests PRs, reports findings, executes TMS cases and emits Automation-Friendly Specs via the `test-case-analysis` skill |\n| `test-automation-engineer` | Axel | Implements automation from AFS specs in the project's existing framework (Playwright / Cypress / pytest / JUnit / NUnit / WDIO) |\n| `scout` | Kit | Maps unfamiliar codebases — explores, documents patterns, flags risks |\n| `test-automation-lead` | Tal | Runs the analyst → implementer → reviewer pipeline, owns the automation merge gate and test-framework architecture (`test-automation` factory) |\n| `product-owner` | Priya | Runs the discovery loop end to end — intake triage, persona/outcome framing, opportunity-tree mapping, prioritization; guards the promotion gate (`product-management` factory) |\n| `discovery-researcher` | Sam | Gathers and stress-tests evidence — stakeholder interviews, market/desk research, adversarial verification; dispatched by `product-owner` (`product-management` factory) |\n| `personal-assistant` | Octo | Conversational assistant: vault, email, calendar, daily brief (standalone orphan) |\n\nThe **`manual-qa`** factory ships a separate live-browser manual-QA team (functional\nroles rather than named personas), all driving a running app via Playwright MCP:\n\n| Agent | Role |\n|---|---|\n| `test-run-lead` | Orchestrates a run — assembles the suite, dispatches a runner per case, triggers the report |\n| `test-author` | Turns rough ideas / bug reports / stories into formatted `TC-NNN` cases |\n| `test-sizer` | Rates case size/complexity (S/M/L) before authoring; flags Large ones to split |\n| `test-runner` | Executes one case against the running app, returns a structured JSON result |\n| `test-reporter` | Turns runner results into a Markdown run report |\n| `app-profiler` | Onboards a web app and writes the shared `app_profile.md` every manual-qa agent reads |\n| `qa-auditor` | Specialist web auditor — Step-0 Playwright evidence collection then specialist audit passes (security, accessibility, privacy, performance, responsive, UX, SEO); writes a findings report and codifies notable findings into regression TC cases |\n\n### Skills\n\nMost skills are factory-owned (under `factories/<id>/skills/`). Eight orphan skills\nlive in the top-level `skills/` dir and are available standalone. The full set\ninstallable via factories is listed below.\n\n**SDLC-coupled (9, factory-owned):**\n\n| Skill | What it does |\n|---|---|\n| `plan-feature` | Feature planning workflow used by BA / Tech Lead |\n| `implement-feature` | Feature implementation workflow used by devs |\n| `bugfix-workflow` | Structured bug investigation: reproduce → root cause → fix → regression test |\n| `reproducing-issues` | Turn a vague bug report into repeatable steps with a CONFIRMED / CANNOT-REPRODUCE / PARTIAL verdict (reproduction only) |\n| `root-cause-analysis` | Trace a confirmed bug to its exact cause — execution-path tracing, classification, impact/regression (investigation only) |\n| `test-case-analysis` | Execute a TMS case, capture stable selectors, flag defects, emit an Automation-Friendly Spec (AFS). Used by qa-engineer |\n| `test-automation-workflow` | End-to-end test automation — explore → specify (AFS) → implement → review. Pluggable TMS adapters (Zephyr / TestRail / Xray / Azure / markdown) over HTTP or MCP |\n| `seeding-a-project` | Scout's project onboarding / configuration flow (feature-development factory; the test-automation factory's automation-specific variant is `seeding-automation-project`) |\n| `completing-a-task` | Five-step task completion protocol: verify → commit → PR → comment → notify |\n\n**Other skills (18, mix of factory-owned and orphan):**\n\n| Skill | What it does |\n|---|---|\n| `code-review` | Structured code review checklist and reporting |\n| `session-retrospective` | Assisted reinforcement — distill lessons from a finished session into memory (feature-development, test-automation) |\n| `mobile-testing` | Manual mobile-app testing via Appium / device-farm sessions (manual-qa factory) |\n| `git-workflow` | Branching, commits, PR conventions |\n| `playwright-testing` | E2E browser testing with Playwright |\n| `browser-verify` | Quick visual / smoke verification in a browser |\n| `issue-tracking` | GitHub / Linear / GitLab issue management |\n| `xray-testing` | Xray CRUD + results import — Tests, Preconditions, Test Sets/Plans, Executions, Runs. Xray Cloud (GraphQL) + Server/DC (REST). Stdlib Python CLI fallback |\n| `atlassian-content` | Jira issue/comment authoring (ADF, API v3) + Confluence pages (storage format) with accountId mentions and post-creation verification |\n| `tosca-automation` | Tricentis TOSCA Cloud full lifecycle — TestCases, Modules (Html + SapEngine), Reusable Blocks, Playlists, Inventory/folders, TSU import/export. Bundled Typer CLI (`tosca_cli.py`) |\n| `vividus` | Vividus BDD framework — bootstrap, configure, author `.story` files. 47+ plugins (web, REST, mobile/Appium, DB, messaging, AWS/Azure, visual, accessibility), BOM-pinned versions, suite/profile/environment triple, MCP-server grounding. Templates in `assets/` |\n| `verifying-outcomes` | Verify a task actually achieved its stated goal |\n| `gathering-context` | Targeted codebase exploration before changes |\n| `deep-research` | Multi-source research and synthesis |\n| `memory` | Persistent file-based memory across conversations |\n| `obsidian-vault` | Read / write the user's Obsidian second brain |\n| `microsoft-365` | Microsoft Graph (email / calendar / Teams) integration |\n| `xlsx-reader` | Read `.xlsx` spreadsheets (test cases, checklists, requirement matrices) into Markdown for agent ingestion. Owned by the `manual-qa` factory |\n\n**Product management (10, factory-owned by `product-management`):**\n\n| Skill | What it does |\n|---|---|\n| `intake-triage` | Front door for raw asks — verdicts each Act Now / Plan Next / Collect More Signal / Decline-or-Defer and mints in-scope items as Problems |\n| `define-personas` | Author and maintain canonical persona cards (surface, goals, pains, JTBD, evidence) referenced by stable slug |\n| `define-outcomes` | Draft, stress-test, and ratify measurable outcome anchors (dated baseline + target + timeframe) in `outcomes.md` |\n| `opportunity-tree` | Maintain the opportunity–solution tree over existing artifacts — the disguise test + Olsen scoring, regenerates the outcome-tree board |\n| `journeys-to-hypotheses` | Convergence pass — classify each journey COVERED / GAP / OUT-OF-SCOPE and author missing Problem + Hypothesis stubs |\n| `prioritize-bets` | Rank incubating/promotable hypotheses (RICE default; WSJF/ICE options); confidence derived from each bet's evidence band |\n| `stakeholder-interview` | Prepare a VOI-ordered interview guide, or synthesize raw notes into evidence and propagate answers into hypotheses |\n| `grill-decision` | Socratic one-question-at-a-time stress-test of a decision or hypothesis, capturing outcomes inline (DEC records, edits) |\n| `capture-learning` | Record a problem → outcome → lesson when a hypothesis closes or an experiment concludes |\n| `discovery-status` | Read-only pipeline dashboard — gate state, what's blocked and on whom, the exact next action per item |\n\n### External skills (fetched by the installer)\n\nDeclared in `skills.json` with `repo:` + optional `subdir:`. The npx\ninstaller clones each into `~/.cache/sdlc-skills/registry/` on first\ninstall and copies the subdir into your project's skills dir (or symlinks\nit with `--symlink`). Native\nIDE plugin paths do **not** fetch these — use the installer for the full\ncatalog. Every entry currently tracks `ref: main` (a repo's default branch),\nso upstream content can change under an installed project between installs.\n\n| Skill | Source | Used by |\n|---|---|---|\n| `tdd` | [`mattpocock/skills`](https://github.com/mattpocock/skills) → `skills/engineering/tdd/` | `python-dev`, `js-dev`, `ios-dev`, `android-dev` |\n| `brainstorming` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/brainstorming/` | `ba` |\n| `systematic-debugging` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/systematic-debugging/` | devs + `qa-engineer` |\n| `verification-before-completion` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/verification-before-completion/` | devs + `qa-engineer` |\n| `requesting-code-review` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/requesting-code-review/` | devs |\n| `receiving-code-review` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/receiving-code-review/` | devs |\n| `writing-skills` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/writing-skills/` | `tech-lead` |\n| `subagent-driven-development` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/subagent-driven-development/` | `project-manager` |\n| `dispatching-parallel-agents` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/dispatching-parallel-agents/` | `project-manager` |\n| `swiftui-pro` | [`twostraws/SwiftUI-Agent-Skill`](https://github.com/twostraws/SwiftUI-Agent-Skill) | `ios-dev` |\n| `swiftdata-pro` | [`twostraws/SwiftData-Agent-Skill`](https://github.com/twostraws/SwiftData-Agent-Skill) | `ios-dev` |\n| `swift-testing-pro` | [`twostraws/Swift-Testing-Agent-Skill`](https://github.com/twostraws/Swift-Testing-Agent-Skill) | `ios-dev` |\n| `swift-concurrency-pro` | [`twostraws/Swift-Concurrency-Agent-Skill`](https://github.com/twostraws/Swift-Concurrency-Agent-Skill) | `ios-dev` |\n| `playwright-cli` | [`microsoft/playwright-cli`](https://github.com/microsoft/playwright-cli) → `skills/playwright-cli/` | `qa-engineer`, `test-automation-engineer` |\n| `playwright-best-practices` | [`currents-dev/playwright-best-practices-skill`](https://github.com/currents-dev/playwright-best-practices-skill) → `playwright-best-practices/` | `qa-engineer`, `test-automation-engineer`, `manual-qa` agents |\n| `fastapi` | [`fastapi/fastapi`](https://github.com/fastapi/fastapi) → `fastapi/.agents/skills/fastapi` | `feature-development` web overlay (`python-dev`, `tech-lead`) |\n| `fastmcp-server` | [`davila7/claude-code-templates`](https://github.com/davila7/claude-code-templates) | `feature-development` web overlay |\n| `vercel-react-best-practices` | [`vercel-labs/agent-skills`](https://github.com/vercel-labs/agent-skills) → `skills/react-best-practices` | `feature-development` web overlay (`js-dev`, `tech-lead`) |\n| `setup-xcuitest` | [`appium/skills`](https://github.com/appium/skills) → `skills/setup-xcuitest` | `feature-development` iOS overlay (`qa-engineer`) |\n| `xcuitest-real-device-config` | [`appium/skills`](https://github.com/appium/skills) → `skills/xcuitest-real-device-config` | `feature-development` iOS overlay (`qa-engineer`) |\n| `appium-troubleshooting` | [`appium/skills`](https://github.com/appium/skills) → `skills/appium-troubleshooting` | `feature-development` iOS + Android overlays (`qa-engineer`) |\n| `setup-uiautomator2` | [`appium/skills`](https://github.com/appium/skills) → `skills/setup-uiautomator2` | `feature-development` Android overlay (`qa-engineer`) |\n| `compose-state-and-effects` | [`chrisbanes/skills`](https://github.com/chrisbanes/skills) → `skills/compose-state-and-effects` | `android-dev`, `feature-development` Android overlay (`tech-lead`) |\n| `kotlin-concurrency-and-flow` | [`chrisbanes/skills`](https://github.com/chrisbanes/skills) → `skills/kotlin-concurrency-and-flow` | `android-dev`, `feature-development` Android overlay (`tech-lead`) |\n| `compose-ui-testing-patterns` | [`chrisbanes/skills`](https://github.com/chrisbanes/skills) → `skills/compose-ui-testing-patterns` | `android-dev`, `feature-development` Android overlay (`qa-engineer`) |\n| `testing-setup` | [`android/skills`](https://github.com/android/skills) → `testing/testing-setup` | `android-dev`, `feature-development` Android overlay (`tech-lead`, `qa-engineer`) |\n| `android-cli` | [`android/skills`](https://github.com/android/skills) → `devtools/android-cli` | No agent or overlay — installs only via an explicit `--skills android-cli` |\n\n## Using these agents and skills\n\nThese agents and skills install cleanly into Claude Code, Cursor,\nWindsurf, Copilot CLI, and Codex. A BA can draft stories, a tech-lead can\nreview a PR, `plan-feature` and `bugfix-workflow` run end-to-end with\njust `git` and `gh`.\n\n**Context auto-injected at session start (via the `hooks/` scripts):**\n\n- `.agents/memory/<role>/snapshot.md` — each role's persistent memory,\n  injected per dispatch by the `agent-start` hook on Claude Code, Codex,\n  and Copilot CLI (their per-agent start hooks); re-fires on every\n  dispatch, so it survives `/clear` and compaction.\n- `.agents/role-overrides.md`, `profile.md`, `workflow.md`, `testing.md`,\n  `conventions.md`, `team-comms.md` — lean shared project context, injected\n  by the `session-start` hook (parent session) and by `agent-start` (each\n  dispatched subagent, which gets a fresh context), re-injected after\n  `/clear` or compaction. Big manuals (`AGENTS.md`, `docs/`) are not\n  injected — agents read those on demand.\n\nA missing file is skipped (safe on first run). On Cursor (whose\n`subagentStart` is permission-only) and Kiro (whose `agentSpawn` carries\nno agent name), the `session-start` hook adds a roster reminder pointing\neach role at the `memory` skill instead. See\n[`hooks/README.md`](hooks/README.md) for wiring and the portability matrix.\n\nEvery agent works as a subagent dispatched by the host IDE. Every\n`skills/<name>/` skill is self-contained. Developer agents work on your\nworking tree; coordinate merges manually when multiple devs are active.\n\n## Repository layout\n\n```\nsdlc-skills/\n├── .claude-plugin/\n│   ├── plugin.json             # Claude Code plugin metadata\n│   └── marketplace.json        # Claude Code marketplace entry list\n├── .cursor-plugin/\n│   └── plugin.json             # Cursor native plugin manifest\n├── agents/                     # orphan-only personas (personal-assistant); standalone install\n│   └── <agent-name>/\n│       ├── AGENT.md            # frontmatter (group, theme, aliases, skills) + instructions\n│       └── SOUL.md             # personality / voice / working style\n├── skills/                     # orphan-only skills (8 entries); standalone install\n│   └── <skill-name>/\n│       ├── SKILL.md            # frontmatter: name + description\n│       ├── references/         # optional supporting docs\n│       └── scripts/            # optional helper scripts\n├── bin/\n│   ├── init.mjs                # npx installer — resolves + fetches externals\n│   └── validate-factories.mjs    # factory manifest validator (CI + npm run validate:factories)\n├── factories/                    # team presets — one command installs a whole team\n│   ├── SPEC.md                 # factory manifest spec\n│   └── <factory-id>/            # feature-development, manual-qa, test-automation, product-management\n│       ├── factory.json         # roster, briefings, skillOverlays, seed, instructions\n│       ├── README.md           # roster + install\n│       ├── instructions.md     # spliced into AGENTS.md / CLAUDE.md\n│       ├── briefings/<role>.md # seeded into .agents/memory/<role>/\n│       ├── knowledge/          # reference docs seeded into the project (manual-qa)\n│       ├── agents/<name>/      # agents this factory owns (real copies; divergence OK)\n│       └── skills/<name>/      # skills this factory owns\n├── skills.json                 # catalog: monorepo + external skill sources\n├── AGENTS.md                   # generic / GitHub Copilot CLI fallback\n├── GEMINI.md                   # Gemini CLI context file\n├── gemini-extension.json       # Gemini CLI extension manifest\n├── package.json                # bin: { init: ./bin/init.mjs }\n├── LICENSE\n└── README.md\n```\n\n## Adding content\n\n1. **New factory agent** → create `factories/<factory-id>/agents/<name>/AGENT.md`\n   (with YAML frontmatter: `name`, `description`, `model`, `color`, `group`,\n   `theme`, `aliases`, `skills`) and a `SOUL.md`. Declare it in `factory.json`\n   under `localAgents`. No separate registry needed.\n2. **New factory skill** → create `factories/<factory-id>/skills/<name>/SKILL.md`\n   with agentskills.io frontmatter (`name`, `description`). Declare it in\n   `factory.json` under `localSkills`. No `skills.json` entry needed.\n3. **New orphan monorepo skill** (standalone, no factory) → create\n   `skills/<name>/SKILL.md`. Register in `skills.json` with\n   `{\"id\": \"<name>\", \"monorepo\": \"sdlc-skills\", \"name\": \"<name>\"}`.\n4. **New external skill** → register in `skills.json` with\n   `{\"id\": \"<name>\", \"repo\": \"owner/repo\", \"ref\": \"main\", \"subdir\": \"path/to/skill\"}`.\n   The installer will clone + copy on first install (or symlink with `--symlink`).\n5. **Reference the new skill in an agent's `skills:` list** —\n   the installer auto-resolves it on the next run.\n\nEvery factory ships a `FACTORY.md` catalog descriptor (YAML frontmatter:\n`name`, `description`, `owner`, `authors`, `sdlc_phase`, `support_level`,\n`use_cases`, optional `project_deployments`) — see\n[`factories/SPEC.md`](factories/SPEC.md) for the schema. Any agent or skill\ncan opt out of the generated marketplace catalogs with `discoverable: false`\nin its own frontmatter; it still installs normally, it's just not listed.\n\nNo build step, no generated manifests. The installer discovers factory content\nat runtime and reads `skills.json` for orphan/external skill resolution — add\na folder or a registry entry, it shows up on the next `init` run.\n\n## Acknowledgements\n\nExternal skills are fetched from upstream at install time — this repo\nre-distributes nothing, only catalogs and wires.\n\n- **[`mattpocock/skills`](https://github.com/mattpocock/skills)** — Matt Pocock. `skills/engineering/tdd/` (vertical-slice tracer bullets, integration-style tests, interface design for testability). MIT.\n- **[`obra/superpowers`](https://github.com/obra/superpowers)** — Jesse Vincent. `brainstorming`, `systematic-debugging`, `verification-before-completion`, `requesting-code-review`, `receiving-code-review`, `writing-skills`. MIT.\n- **Paul Hudson's Swift agent skills** — [`twostraws/SwiftUI-Agent-Skill`](https://github.com/twostraws/SwiftUI-Agent-Skill), [`twostraws/SwiftData-Agent-Skill`](https://github.com/twostraws/SwiftData-Agent-Skill), [`twostraws/Swift-Testing-Agent-Skill`](https://github.com/twostraws/Swift-Testing-Agent-Skill), [`twostraws/Swift-Concurrency-Agent-Skill`](https://github.com/twostraws/Swift-Concurrency-Agent-Skill). Powers the `ios-dev` agent. MIT.\n- **[`microsoft/playwright-cli`](https://github.com/microsoft/playwright-cli)** — Microsoft Playwright. `skills/playwright-cli/` (drive Playwright from the command line — browser launch, navigation, snapshot/locator interaction, tabs and storage, network mocking, tracing, test generation). Used by `qa-engineer` and `test-automation-engineer`. Apache-2.0.\n- **[`fastapi/fastapi`](https://github.com/fastapi/fastapi)** — Sebastián Ramírez. Official FastAPI agent skill. `feature-development` web/backend overlay. MIT.\n- **[`appium/skills`](https://github.com/appium/skills)** — Appium. XCUITest and UiAutomator2 environment setup, real-device config, and troubleshooting. `feature-development` iOS + Android QA overlays. Apache-2.0.\n- **Chris Banes' Compose/Kotlin agent skills** — [`chrisbanes/skills`](https://github.com/chrisbanes/skills). `compose-state-and-effects`, `kotlin-concurrency-and-flow`, `compose-ui-testing-patterns`. Powers the `android-dev` agent. Apache-2.0.\n- **[`android/skills`](https://github.com/android/skills)** — official Google Android skills. `testing-setup` — used by the `feature-development` Android overlay and `android-dev`; `android-cli` — in no agent or overlay, opt-in only via an explicit `--skills android-cli`. Apache-2.0.\n- **Factory-overlay / QA skills** also fetched from [`currents-dev/playwright-best-practices-skill`](https://github.com/currents-dev/playwright-best-practices-skill) (Playwright selector/wait guidance), [`vercel-labs/agent-skills`](https://github.com/vercel-labs/agent-skills) (React best practices), and [`davila7/claude-code-templates`](https://github.com/davila7/claude-code-templates) (`fastmcp-server`) — see each repo for its license.\n\nThanks to all maintainers.\n\n## License\n\nMIT — see [LICENSE](./LICENSE).\n",
  "bytes": 36943,
  "sha": "85d90e9d57595c7bebd9e6f88a6b4f58a0b2d9aeaf18b66c6fd12c93315cd531",
  "repo_slug": "arozumenko/sdlc-skills",
  "fonte": "repo",
  "truncated": false,
  "api": "https://agentalog.com/api/listings/plg_arozumenko_sdlc_skills_11133641/readme"
}