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).

flowchart TB
    subgraph sdlc["sdlc-skills — content + install resolution"]
        direction TB
        agents[/"bundles/<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 bundles (bundles/<id>/agents/ and bundles/<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).

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.

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).

Adopting a whole team? Each bundle has a deep, scenario-based onboarding guide under docs/onboarding/ — start at the index to pick yours: feature-development (dev team), manual-qa (manual-QA team), or test-automation (TMS → merged-test pipeline: install → MCP inventory → scout seed → .agents/test-automation.yaml → single-case pilot → scale-up).

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.

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.

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

# 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

# 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 bundles. A bundle 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. Three ship today:

See bundles/SPEC.md and each bundle's README.md to author your own.

Install locations:

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.

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:

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:

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

Each of these paths reads the native plugin manifest this repo ships and installs only the monorepo content — the orphan skills/ entries plus the bundle-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

/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 bundle dirs.

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

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.

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

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

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

SDLC-coupled (9, bundle-owned):

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

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.

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 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.

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-bundles.mjs    # bundle manifest validator (CI + npm run validate:bundles)
├── bundles/                    # team presets — one command installs a whole team
│   ├── SPEC.md                 # bundle manifest spec
│   └── <bundle-id>/            # feature-development, manual-qa, test-automation
│       ├── bundle.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 bundle owns (real copies; divergence OK)
│       └── skills/<name>/      # skills this bundle 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

1. New bundle agent → create bundles/<bundle-id>/agents/<name>/AGENT.md (with YAML frontmatter: name, description, model, color, group, theme, aliases, skills) and a SOUL.md. Declare it in bundle.json under localAgents. No separate registry needed.
2. New bundle skill → create bundles/<bundle-id>/skills/<name>/SKILL.md with agentskills.io frontmatter (name, description). Declare it in bundle.json under localSkills. No skills.json entry needed.
3. New orphan monorepo skill (standalone, no bundle) → 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.

No build step, no generated manifests. The installer discovers bundle 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.

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

• mattpocock/skills — Matt Pocock. skills/engineering/tdd/ (vertical-slice tracer bullets, integration-style tests, interface design for testability). MIT.
• 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, twostraws/SwiftData-Agent-Skill, twostraws/Swift-Testing-Agent-Skill, twostraws/Swift-Concurrency-Agent-Skill. Powers the ios-dev agent. MIT.
• 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 — Sebastián Ramírez. Official FastAPI agent skill. feature-development web/backend overlay. MIT.
• appium/skills — Appium. XCUITest environment setup, real-device config, and troubleshooting. feature-development iOS QA overlay. Apache-2.0.
• Bundle-overlay / QA skills also fetched from currents-dev/playwright-best-practices-skill (Playwright selector/wait guidance), vercel-labs/agent-skills (React best practices), and davila7/claude-code-templates (fastmcp-server) — see each repo for its license.

Thanks to all maintainers.

MIT — see LICENSE.