sdlc-skills

Role-based agents and workflow skills for software delivery (BA, Tech Lead, PM, devs, QA, PA).

Open source Open in the app JSON README (API)

About

Role-based agents and workflow skills for software delivery (BA, Tech Lead, PM, devs, QA, PA).

Details

Kind

Plugins

Topic

No topic detected

Publisher

arozumenko

Origin

gemini

Category

ferramentas

Version

0.2.0

Stars

20

Forks

11

Open pull requests

1

Last push

2026-09-04T12:29:45Z

Repository state

ativo

Language

JavaScript

License

MIT

Added

2026-08-30 14:13:39

Updated

2026-08-30 14:13:39

Origin id

arozumenko/sdlc-skills

README

# sdlc-skills

**The content layer for AI-assisted software delivery.** Role-based agent
personas (BA, Tech Lead, PM, devs, QA, PA), workflow skills (TDD,
bugfix, code review, task completion, memory, …), and a registry that
pulls proven skills from Matt Pocock, Jesse Vincent (obra/superpowers),
and Paul Hudson so you don't have to reinvent them.

Install via the npx one-shot or a native plugin manifest and use the
agents + skills directly in any AI IDE (Claude Code, Cursor, Gemini CLI,
GitHub Copilot CLI, Windsurf, Codex).

## Architecture

```mermaid
flowchart TB
    subgraph sdlc["sdlc-skills — content + install resolution"]
        direction TB
        agents[/"factories/<br/>agent + skill content"/]
        skills[/"orphan skills/<br/>standalone-only content"/]
        registry[("skills.json<br/>catalog: orphan + external")]
        installer(["bin/init.mjs<br/>npx installer"])
        agents --- skills
        skills --- registry
        registry --- installer
    end

    subgraph consumers["consumers"]
        direction LR
        ides["AI IDEs<br/>Claude Code • Cursor<br/>Gemini CLI • Copilot CLI<br/>Windsurf"]
    end

    subgraph externals["upstream external skill sources"]
        direction LR
        ext_matt[["mattpocock/skills<br/>skills/engineering/tdd"]]
        ext_obra[["obra/superpowers<br/>brainstorming, debugging,<br/>verification, ..."]]
        ext_tws[["twostraws/*-Agent-Skill<br/>SwiftUI, SwiftData,<br/>Swift Testing, Concurrency"]]
        ext_msft[["microsoft/playwright-cli<br/>playwright-cli"]]
    end

    installer ==>|fetch at install time| ext_matt
    installer ==>|fetch at install time| ext_obra
    installer ==>|fetch at install time| ext_tws
    installer ==>|fetch at install time| ext_msft

    sdlc ==>|direct install via<br/>plugin manifest or npx| ides
```

(Node shapes convey grouping so colors aren't needed: `/ /` parallelograms
for content dirs, `( )` round-ended for the installer, cylinders for the
registry, `[[ ]]` subroutines for external sources. GitHub's Mermaid
renderer uses theme-adaptive colors in both light and dark mode.)

Agents are **self-describing** — each `AGENT.md` carries its own metadata
(role, group, theme, aliases, skills, model). IDE plugin systems read it at
install time. Nothing duplicated.

Most agents and skills live inside factories (`factories/<id>/agents/` and
`factories/<id>/skills/`). The top-level `agents/` and `skills/` directories
hold only standalone-only "orphan" content: one agent (`personal-assistant`)
and eight skills (`deep-research`, `gathering-context`, `verifying-outcomes`,
`microsoft-365`, `obsidian-vault`, `tosca-automation`, `vividus`,
`xray-testing`). `skills.json` registers those orphan monorepo skills and
the external skills fetched from upstream.

External skills (Matt Pocock's `tdd`, Jesse Vincent's `brainstorming` /
`systematic-debugging` / etc., Paul Hudson's Swift skills) live in their
upstream repos. The installer resolves each agent's declared skill list
against `skills.json`, clones external repos on first install into
`~/.cache/sdlc-skills/registry/`, and copies the subdir into your project's
skills directory (or symlinks it with `--symlink`).

## What lands in your project

After `npx … init` + a scout run, your target project has two top-level
directories plus the IDE's native install location:

```
your-project/
├── .claude/                  ← IDE-native install (or .cursor/, .windsurf/, .github/)
│   ├── agents/<role>/        agent config (AGENT.md + SOUL.md)
│   └── skills/<name>/        skill content (SKILL.md + references)
│
├── .agents/                  ← IDE-neutral content — every agent reads
│   ├── profile.md            scout output: project card
│   ├── architecture.md       scout output: system design
│   ├── conventions.md        scout output: coding standards
│   ├── testing.md            scout output: test infrastructure
│   ├── team-comms.md         scout output: transport + roster
│   ├── onboarding.md         scout's audit trail
│   └── memory/<role>/        memory-skill dir: MEMORY.md index,
│                             curated entries (incl. scout-seeded
│                             project_briefing.md), daily/, snapshot.md
│
├── AGENTS.md                 scout output: full team reference
└── CLAUDE.md                 scout output: 80-line auto-loaded context
```

`.agents/` holds content every agent reads regardless of IDE. Nothing
in `.agents/` is host-specific — it works identically under Claude Code,
Cursor, Gemini CLI, Copilot CLI, and Windsurf.

Scout (`scout` agent, run once when onboarding) populates everything
under `.agents/` plus `AGENTS.md` / `CLAUDE.md` at the root. Re-run
scout whenever the stack evolves to refresh.

## Install — pick one path

There are really two paths: the **full experience** (npx installer) and
the **monorepo-only fallbacks** (native IDE plugins for people who don't
want to be happy).

| Path | Fetches external skills? | When to pick |
|---|---|---|
| **npx installer** ⭐ | ✅ Yes | Any IDE. Full catalog. One command. This is the happy path. |
| Native IDE plugins | ❌ Monorepo only | You don't want Node installed. Trade-off: no external skills, manual team assembly. |

> **Adopting a whole team?** Each factory has a deep, scenario-based onboarding
> guide under [`docs/onboarding/`](docs/onboarding/) — start at the
> [index](docs/onboarding/README.md) to pick yours:
> [feature-development](docs/onboarding/feature-development.md) (dev team),
> [manual-qa](docs/onboarding/manual-qa.md) (manual-QA team),
> [test-automation](docs/onboarding/test-automation.md) (TMS → merged-test
> pipeline: install → MCP inventory → scout seed →
> `.agents/test-automation.yaml` → single-case pilot → scale-up), or
> [product-management](docs/onboarding/product-management.md) (PO discovery team:
> raw ask → verified, prioritized hypothesis → engineering handoff).

> **Why the split?** The native IDE plugin systems (Claude Code, Cursor,
> Gemini CLI, Copilot CLI) only see skills present locally in this repo —
> they don't know how to fetch from upstream. The
> npx installer reads `skills.json` and resolves external dependencies
> automatically (Matt Pocock's TDD, Jesse Vincent's debugging skills,
> Paul Hudson's Swift skills). If you want the full catalog, use the
> ⭐ path.

### 1. npx installer (recommended)

One command installs agents, their declared monorepo skills, and their
external skills together. Works for Claude Code, Cursor, Windsurf, GitHub
Copilot, and Codex (IDE targets detected automatically). Agents install in
each host's native form — directories for Claude/Cursor/Windsurf, flat
`.agent.md` for Copilot, TOML for Codex.

```bash
# A team factory — the whole team in one shot (agents, their skills,
# per-role stack briefings, and team conventions). See factories/SPEC.md.
npx github:arozumenko/sdlc-skills init --factory feature-development   # cross-platform delivery: pick python-dev, js-dev, test-automation-engineer, ios-dev, android-dev
npx github:arozumenko/sdlc-skills init --factory manual-qa     # manual-QA team (live browser testing via Playwright MCP)
npx github:arozumenko/sdlc-skills init --factory test-automation  # TMS-driven automation pipeline (analyst → implementer → reviewer, led by Tal)
npx github:arozumenko/sdlc-skills init --factory product-management  # PO discovery pipeline (raw ask → verified, prioritized hypotheses)

# Full catalog, all detected IDEs
npx github:arozumenko/sdlc-skills init --all

# A specific team — every declared skill comes along automatically
# (monorepo + external; externals are git-cloned then copied in — add --symlink to link instead)
npx github:arozumenko/sdlc-skills init --agents ba,tech-lead,ios-dev,android-dev

# Specific skills (overrides the auto-resolve)
npx github:arozumenko/sdlc-skills init --skills bugfix-workflow,code-review

# Narrow to one IDE target
npx github:arozumenko/sdlc-skills init --agents ios-dev --target claude

# Update an existing install
npx github:arozumenko/sdlc-skills init --all --update
```

**Team factories.** A factory is a named team preset that installs a curated
set of agents (with their skills), seeds per-role stack briefings into
`.agents/memory/<role>/`, splices team conventions into `AGENTS.md` /
`CLAUDE.md`, applies per-role **skill overlays**, and can **seed reference
files** into the project — one command instead of hand-listing roles. Four
ship today:

| Factory | Roster | What it's for |
|---|---|---|
| `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. |
| `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/`. |
| `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. |
| `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. |

See [`factories/SPEC.md`](factories/SPEC.md) and each factory's `README.md` to
author your own. (`--bundle` still works as a silent back-compat alias for
`--factory` — the flag used before this repo's factories rename.)

Install locations:

| Target | Directory | Drop path |
|---|---|---|
| Claude Code | `.claude/` | `.claude/agents/<name>/`, `.claude/skills/<name>/` |
| Cursor | `.cursor/` | `.cursor/agents/<name>/`, `.cursor/skills/<name>/` |
| Windsurf | `.windsurf/` | `.windsurf/agents/<name>/`, `.windsurf/skills/<name>/` |
| GitHub Copilot CLI | `.github/` | `.github/agents/<name>.agent.md` (flat file), `.github/skills/<name>/` |

**Copilot CLI note.** Copilot CLI expects agents as flat
`<name>.agent.md` files, not as directories. The installer handles this
automatically when `--target copilot` is selected: it flattens
`AGENT.md` + `SOUL.md` into a single file with a `## Persona` section,
and rewrites `model: sonnet` → `model: claude-sonnet-4.6` so Copilot CLI
picks a concrete model. The other targets keep the directory layout.

**Skills-inventory injection (non-Claude targets).** Claude Code
preloads each SKILL.md declared in the agent's `skills:` frontmatter
directly into the subagent's context at startup, so the agent already
has the skill content before it reads its own AGENT.md. Copilot CLI,
Cursor, and Windsurf have no documented preload — Copilot silently
discards unknown frontmatter keys. The installer fills the gap only
where it exists: for Copilot / Cursor / Windsurf targets, every
installed AGENT.md gets a bracketed `<!-- SKILLS-INJECTED: START -->`
section listing declared skills with their descriptions from
`skills.json`. Claude Code agents do not receive this section (it
would duplicate the preload). The block is idempotent on `--update` —
re-runs replace in place, never duplicate.

External skills are cloned once into the shared cache at
`~/.cache/sdlc-skills/registry/<owner>__<repo>/` (override with
`SDLC_SKILLS_CACHE_DIR` or `XDG_CACHE_HOME`), then **copied** into the
project's skills dir by default — so the install is self-contained and
portable (git, zip, Docker, Windows, and sandboxed/jailed agent runtimes
that don't follow symlinks all work). Pass **`--symlink`** to symlink from
the cache instead (a live link, dedups across projects) when your runtime
handles symlinks and you'd rather not duplicate the content.

Run `npx github:arozumenko/sdlc-skills init --help` for the full flag list.

### Repairing an existing Copilot CLI install — `fix-copilot`

If a project already has agents installed as directories under
`.github/agents/<name>/` (older sdlc-skills release, manual drop,
install from upstream before this fix landed), run:

```bash
npx github:arozumenko/sdlc-skills init fix-copilot
```

This scans `.github/agents/`, flattens each directory into
`<name>.agent.md`, and rewrites the `model:` line for Copilot
compatibility. Four modes for handling the paired `SOUL.md`:

| `--soul <mode>` | What happens to `SOUL.md` |
|---|---|
| `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) |
| `inline` | Appended as `## Persona` inside the flat agent file; source directory removed |
| `keep` | Left in place at `<name>/SOUL.md`; flat agent file's reference rewritten |
| `sibling` | Moved to `<name>.soul.md` next to the agent file; reference rewritten |

Add `--dry-run` to preview, or `--no-normalize-model` to keep the
original `model:` value. Full help: `init fix-copilot --help`.

### 2. Monorepo-only fallbacks (for when you refuse to install Node)

Each of these paths reads the native plugin manifest this repo ships and
installs **only the monorepo content** — the orphan `skills/` entries plus the
factory-owned agents/skills the manifest points at. External skills (Matt
Pocock's TDD, the superpowers skills, the twostraws Swift skills) are not
fetched. If you want those, go back to path 1.

**Claude Code plugin marketplace** — `.claude-plugin/marketplace.json`

```bash
/plugin marketplace add arozumenko/sdlc-skills
/plugin install sdlc-skills@sdlc-skills
# Or individual entries: /plugin install ios-dev@sdlc-skills  etc.
```

**Cursor native plugin** — `.cursor-plugin/plugin.json`

Point Cursor's plugin manager at this repo URL; it reads the manifest
and installs skills + agents from the discovered orphan and factory dirs.

**Gemini CLI extension** — `gemini-extension.json` + `GEMINI.md`

```bash
gemini extensions install https://github.com/arozumenko/sdlc-skills
```

The `GEMINI.md` context file catalogs every agent and skill for on-demand
loading.

**GitHub Copilot CLI / generic** — `AGENTS.md`

`AGENTS.md` at the repo root describes the content for any tool that
follows the AGENTS.md convention. Copilot CLI reads it when the repo is
cloned into your project.

### 3. agentskills.io / third-party consumption

Every `SKILL.md` in this repo — the orphans under `skills/<name>/` and the
factory-owned skills under `factories/<id>/skills/<name>/` — follows the
[agentskills.io](https://agentskills.io) spec (`name` + `description`
frontmatter). Any skill runtime (Vercel, custom frameworks, other IDEs) can
point directly at a `SKILL.md` directory.

## Catalog

### Agents (catalog across factories)

| Agent | Persona | Role |
|---|---|---|
| `ba` | Alex | Business analyst — turns requirements into user stories with acceptance criteria |
| `tech-lead` | Rio | Decomposes user stories into technical tasks with dependencies; owns framework-scale decisions for test automation |
| `project-manager` | Max | Distributes tasks, tracks team state, escalates blockers, owns the merge gate |
| `python-dev` | Py | Python implementation — owns its own repo clone and branch |
| `js-dev` | Jay | JavaScript / TypeScript implementation — owns its own repo clone and branch |
| `ios-dev` | Io | iOS/Swift implementation — SwiftUI, SwiftData, Swift Testing (no simulator) |
| `android-dev` | Dan | Android/Kotlin implementation — **greenfield Compose only**, Room/DataStore, Hilt (no device or emulator) |
| `qa-engineer` | Sage | Tests PRs, reports findings, executes TMS cases and emits Automation-Friendly Specs via the `test-case-analysis` skill |
| `test-automation-engineer` | Axel | Implements automation from AFS specs in the project's existing framework (Playwright / Cypress / pytest / JUnit / NUnit / WDIO) |
| `scout` | Kit | Maps unfamiliar codebases — explores, documents patterns, flags risks |
| `test-automation-lead` | Tal | Runs the analyst → implementer → reviewer pipeline, owns the automation merge gate and test-framework architecture (`test-automation` factory) |
| `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) |
| `discovery-researcher` | Sam | Gathers and stress-tests evidence — stakeholder interviews, market/desk research, adversarial verification; dispatched by `product-owner` (`product-management` factory) |
| `personal-assistant` | Octo | Conversational assistant: vault, email, calendar, daily brief (standalone orphan) |

The **`manual-qa`** factory ships a separate live-browser manual-QA team (functional
roles rather than named personas), all driving a running app via Playwright MCP:

| Agent | Role |
|---|---|
| `test-run-lead` | Orchestrates a run — assembles the suite, dispatches a runner per case, triggers the report |
| `test-author` | Turns rough ideas / bug reports / stories into formatted `TC-NNN` cases |
| `test-sizer` | Rates case size/complexity (S/M/L) before authoring; flags Large ones to split |
| `test-runner` | Executes one case against the running app, returns a structured JSON result |
| `test-reporter` | Turns runner results into a Markdown run report |
| `app-profiler` | Onboards a web app and writes the shared `app_profile.md` every manual-qa agent reads |
| `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 |

### Skills

Most skills are factory-owned (under `factories/<id>/skills/`). Eight orphan skills
live in the top-level `skills/` dir and are available standalone. The full set
installable via factories is listed below.

**SDLC-coupled (9, factory-owned):**

| Skill | What it does |
|---|---|
| `plan-feature` | Feature planning workflow used by BA / Tech Lead |
| `implement-feature` | Feature implementation workflow used by devs |
| `bugfix-workflow` | Structured bug investigation: reproduce → root cause → fix → regression test |
| `reproducing-issues` | Turn a vague bug report into repeatable steps with a CONFIRMED / CANNOT-REPRODUCE / PARTIAL verdict (reproduction only) |
| `root-cause-analysis` | Trace a confirmed bug to its exact cause — execution-path tracing, classification, impact/regression (investigation only) |
| `test-case-analysis` | Execute a TMS case, capture stable selectors, flag defects, emit an Automation-Friendly Spec (AFS). Used by qa-engineer |
| `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 |
| `seeding-a-project` | Scout's project onboarding / configuration flow (feature-development factory; the test-automation factory's automation-specific variant is `seeding-automation-project`) |
| `completing-a-task` | Five-step task completion protocol: verify → commit → PR → comment → notify |

**Other skills (18, mix of factory-owned and orphan):**

| Skill | What it does |
|---|---|
| `code-review` | Structured code review checklist and reporting |
| `session-retrospective` | Assisted reinforcement — distill lessons from a finished session into memory (feature-development, test-automation) |
| `mobile-testing` | Manual mobile-app testing via Appium / device-farm sessions (manual-qa factory) |
| `git-workflow` | Branching, commits, PR conventions |
| `playwright-testing` | E2E browser testing with Playwright |
| `browser-verify` | Quick visual / smoke verification in a browser |
| `issue-tracking` | GitHub / Linear / GitLab issue management |
| `xray-testing` | Xray CRUD + results import — Tests, Preconditions, Test Sets/Plans, Executions, Runs. Xray Cloud (GraphQL) + Server/DC (REST). Stdlib Python CLI fallback |
| `atlassian-content` | Jira issue/comment authoring (ADF, API v3) + Confluence pages (storage format) with accountId mentions and post-creation verification |
| `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`) |
| `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/` |
| `verifying-outcomes` | Verify a task actually achieved its stated goal |
| `gathering-context` | Targeted codebase exploration before changes |
| `deep-research` | Multi-source research and synthesis |
| `memory` | Persistent file-based memory across conversations |
| `obsidian-vault` | Read / write the user's Obsidian second brain |
| `microsoft-365` | Microsoft Graph (email / calendar / Teams) integration |
| `xlsx-reader` | Read `.xlsx` spreadsheets (test cases, checklists, requirement matrices) into Markdown for agent ingestion. Owned by the `manual-qa` factory |

**Product management (10, factory-owned by `product-management`):**

| Skill | What it does |
|---|---|
| `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 |
| `define-personas` | Author and maintain canonical persona cards (surface, goals, pains, JTBD, evidence) referenced by stable slug |
| `define-outcomes` | Draft, stress-test, and ratify measurable outcome anchors (dated baseline + target + timeframe) in `outcomes.md` |
| `opportunity-tree` | Maintain the opportunity–solution tree over existing artifacts — the disguise test + Olsen scoring, regenerates the outcome-tree board |
| `journeys-to-hypotheses` | Convergence pass — classify each journey COVERED / GAP / OUT-OF-SCOPE and author missing Problem + Hypothesis stubs |
| `prioritize-bets` | Rank incubating/promotable hypotheses (RICE default; WSJF/ICE options); confidence derived from each bet's evidence band |
| `stakeholder-interview` | Prepare a VOI-ordered interview guide, or synthesize raw notes into evidence and propagate answers into hypotheses |
| `grill-decision` | Socratic one-question-at-a-time stress-test of a decision or hypothesis, capturing outcomes inline (DEC records, edits) |
| `capture-learning` | Record a problem → outcome → lesson when a hypothesis closes or an experiment concludes |
| `discovery-status` | Read-only pipeline dashboard — gate state, what's blocked and on whom, the exact next action per item |

### External skills (fetched by the installer)

Declared in `skills.json` with `repo:` + optional `subdir:`. The npx
installer clones each into `~/.cache/sdlc-skills/registry/` on first
install and copies the subdir into your project's skills dir (or symlinks
it with `--symlink`). Native
IDE plugin paths do **not** fetch these — use the installer for the full
catalog. Every entry currently tracks `ref: main` (a repo's default branch),
so upstream content can change under an installed project between installs.

| Skill | Source | Used by |
|---|---|---|
| `tdd` | [`mattpocock/skills`](https://github.com/mattpocock/skills) → `skills/engineering/tdd/` | `python-dev`, `js-dev`, `ios-dev`, `android-dev` |
| `brainstorming` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/brainstorming/` | `ba` |
| `systematic-debugging` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/systematic-debugging/` | devs + `qa-engineer` |
| `verification-before-completion` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/verification-before-completion/` | devs + `qa-engineer` |
| `requesting-code-review` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/requesting-code-review/` | devs |
| `receiving-code-review` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/receiving-code-review/` | devs |
| `writing-skills` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/writing-skills/` | `tech-lead` |
| `subagent-driven-development` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/subagent-driven-development/` | `project-manager` |
| `dispatching-parallel-agents` | [`obra/superpowers`](https://github.com/obra/superpowers) → `skills/dispatching-parallel-agents/` | `project-manager` |
| `swiftui-pro` | [`twostraws/SwiftUI-Agent-Skill`](https://github.com/twostraws/SwiftUI-Agent-Skill) | `ios-dev` |
| `swiftdata-pro` | [`twostraws/SwiftData-Agent-Skill`](https://github.com/twostraws/SwiftData-Agent-Skill) | `ios-dev` |
| `swift-testing-pro` | [`twostraws/Swift-Testing-Agent-Skill`](https://github.com/twostraws/Swift-Testing-Agent-Skill) | `ios-dev` |
| `swift-concurrency-pro` | [`twostraws/Swift-Concurrency-Agent-Skill`](https://github.com/twostraws/Swift-Concurrency-Agent-Skill) | `ios-dev` |
| `playwright-cli` | [`microsoft/playwright-cli`](https://github.com/microsoft/playwright-cli) → `skills/playwright-cli/` | `qa-engineer`, `test-automation-engineer` |
| `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 |
| `fastapi` | [`fastapi/fastapi`](https://github.com/fastapi/fastapi) → `fastapi/.agents/skills/fastapi` | `feature-development` web overlay (`python-dev`, `tech-lead`) |
| `fastmcp-server` | [`davila7/claude-code-templates`](https://github.com/davila7/claude-code-templates) | `feature-development` web overlay |
| `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`) |
| `setup-xcuitest` | [`appium/skills`](https://github.com/appium/skills) → `skills/setup-xcuitest` | `feature-development` iOS overlay (`qa-engineer`) |
| `xcuitest-real-device-config` | [`appium/skills`](https://github.com/appium/skills) → `skills/xcuitest-real-device-config` | `feature-development` iOS overlay (`qa-engineer`) |
| `appium-troubleshooting` | [`appium/skills`](https://github.com/appium/skills) → `skills/appium-troubleshooting` | `feature-development` iOS + Android overlays (`qa-engineer`) |
| `setup-uiautomator2` | [`appium/skills`](https://github.com/appium/skills) → `skills/setup-uiautomator2` | `feature-development` Android overlay (`qa-engineer`) |
| `compose-state-and-effects` | [`chrisbanes/skills`](https://github.com/chrisbanes/skills) → `skills/compose-state-and-effects` | `android-dev`, `feature-development` Android overlay (`tech-lead`) |
| `kotlin-concurrency-and-flow` | [`chrisbanes/skills`](https://github.com/chrisbanes/skills) → `skills/kotlin-concurrency-and-flow` | `android-dev`, `feature-development` Android overlay (`tech-lead`) |
| `compose-ui-testing-patterns` | [`chrisbanes/skills`](https://github.com/chrisbanes/skills) → `skills/compose-ui-testing-patterns` | `android-dev`, `feature-development` Android overlay (`qa-engineer`) |
| `testing-setup` | [`android/skills`](https://github.com/android/skills) → `testing/testing-setup` | `android-dev`, `feature-development` Android overlay (`tech-lead`, `qa-engineer`) |
| `android-cli` | [`android/skills`](https://github.com/android/skills) → `devtools/android-cli` | No agent or overlay — installs only via an explicit `--skills android-cli` |

## Using these agents and skills

These agents and skills install cleanly into Claude Code, Cursor,
Windsurf, Copilot CLI, and Codex. A BA can draft stories, a tech-lead can
review a PR, `plan-feature` and `bugfix-workflow` run end-to-end with
just `git` and `gh`.

**Context auto-injected at session start (via the `hooks/` scripts):**

- `.agents/memory/<role>/snapshot.md` — each role's persistent memory,
  injected per dispatch by the `agent-start` hook on Claude Code, Codex,
  and Copilot CLI (their per-agent start hooks); re-fires on every
  dispatch, so it survives `/clear` and compaction.
- `.agents/role-overrides.md`, `profile.md`, `workflow.md`, `testing.md`,
  `conventions.md`, `team-comms.md` — lean shared project context, injected
  by the `session-start` hook (parent session) and by `agent-start` (each
  dispatched subagent, which gets a fresh context), re-injected after
  `/clear` or compaction. Big manuals (`AGENTS.md`, `docs/`) are not
  injected — agents read those on demand.

A missing file is skipped (safe on first run). On Cursor (whose
`subagentStart` is permission-only) and Kiro (whose `agentSpawn` carries
no agent name), the `session-start` hook adds a roster reminder pointing
each role at the `memory` skill instead. See
[`hooks/README.md`](hooks/README.md) for wiring and the portability matrix.

Every agent works as a subagent dispatched by the host IDE. Every
`skills/<name>/` skill is self-contained. Developer agents work on your
working tree; coordinate merges manually when multiple devs are active.

## Repository layout

```
sdlc-skills/
├── .claude-plugin/
│   ├── plugin.json             # Claude Code plugin metadata
│   └── marketplace.json        # Claude Code marketplace entry list
├── .cursor-plugin/
│   └── plugin.json             # Cursor native plugin manifest
├── agents/                     # orphan-only personas (personal-assistant); standalone install
│   └── <agent-name>/
│       ├── AGENT.md            # frontmatter (group, theme, aliases, skills) + instructions
│       └── SOUL.md             # personality / voice / working style
├── skills/                     # orphan-only skills (8 entries); standalone install
│   └── <skill-name>/
│       ├── SKILL.md            # frontmatter: name + description
│       ├── references/         # optional supporting docs
│       └── scripts/            # optional helper scripts
├── bin/
│   ├── init.mjs                # npx installer — resolves + fetches externals
│   └── validate-factories.mjs    # factory manifest validator (CI + npm run validate:factories)
├── factories/                    # team presets — one command installs a whole team
│   ├── SPEC.md                 # factory manifest spec
│   └── <factory-id>/            # feature-development, manual-qa, test-automation, product-management
│       ├── factory.json         # roster, briefings, skillOverlays, seed, instructions
│       ├── README.md           # roster + install
│       ├── instructions.md     # spliced into AGENTS.md / CLAUDE.md
│       ├── briefings/<role>.md # seeded into .agents/memory/<role>/
│       ├── knowledge/          # reference docs seeded into the project (manual-qa)
│       ├── agents/<name>/      # agents this factory owns (real copies; divergence OK)
│       └── skills/<name>/      # skills this factory owns
├── skills.json                 # catalog: monorepo + external skill sources
├── AGENTS.md                   # generic / GitHub Copilot CLI fallback
├── GEMINI.md                   # Gemini CLI context file
├── gemini-extension.json       # Gemini CLI extension manifest
├── package.json                # bin: { init: ./bin/init.mjs }
├── LICENSE
└── README.md
```

## Adding content

1. **New factory agent** → create `factories/<factory-id>/agents/<name>/AGENT.md`
   (with YAML frontmatter: `name`, `description`, `model`, `color`, `group`,
   `theme`, `aliases`, `skills`) and a `SOUL.md`. Declare it in `factory.json`
   under `localAgents`. No separate registry needed.
2. **New factory skill** → create `factories/<factory-id>/skills/<name>/SKILL.md`
   with agentskills.io frontmatter (`name`, `description`). Declare it in
   `factory.json` under `localSkills`. No `skills.json` entry needed.
3. **New orphan monorepo skill** (standalone, no factory) → create
   `skills/<name>/SKILL.md`. Register in `skills.json` with
   `{"id": "<name>", "monorepo": "sdlc-skills", "name": "<name>"}`.
4. **New external skill** → register in `skills.json` with
   `{"id": "<name>", "repo": "owner/repo", "ref": "main", "subdir": "path/to/skill"}`.
   The installer will clone + copy on first install (or symlink with `--symlink`).
5. **Reference the new skill in an agent's `skills:` list** —
   the installer auto-resolves it on the next run.

Every factory ships a `FACTORY.md` catalog descriptor (YAML frontmatter:
`name`, `description`, `owner`, `authors`, `sdlc_phase`, `support_level`,
`use_cases`, optional `project_deployments`) — see
[`factories/SPEC.md`](factories/SPEC.md) for the schema. Any agent or skill
can opt out of the generated marketplace catalogs with `discoverable: false`
in its own frontmatter; it still installs normally, it's just not listed.

No build step, no generated manifests. The installer discovers factory content
at runtime and reads `skills.json` for orphan/external skill resolution — add
a folder or a registry entry, it shows up on the next `init` run.

## Acknowledgements

External skills are fetched from upstream at install time — this repo
re-distributes nothing, only catalogs and wires.

- **[`mattpocock/skills`](https://github.com/mattpocock/skills)** — Matt Pocock. `skills/engineering/tdd/` (vertical-slice tracer bullets, integration-style tests, interface design for testability). MIT.
- **[`obra/superpowers`](https://github.com/obra/superpowers)** — Jesse Vincent. `brainstorming`, `systematic-debugging`, `verification-before-completion`, `requesting-code-review`, `receiving-code-review`, `writing-skills`. MIT.
- **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.
- **[`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.
- **[`fastapi/fastapi`](https://github.com/fastapi/fastapi)** — Sebastián Ramírez. Official FastAPI agent skill. `feature-development` web/backend overlay. MIT.
- **[`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.
- **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.
- **[`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.
- **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.

Thanks to all maintainers.

## License

MIT — see [LICENSE](./LICENSE).

More

• More plugins on No topic detected
• Everything published by arozumenko
• Browse the whole catalog