Extend AI coding assistants with specialized expertise, procedural workflows, and task-specific resources.

SDLC Agents is a collection of reusable skills and subagents built on the Agent Skills open standard. It enhances AI coding assistants like Claude Code, Gemini, and Cursor by equipping them with the context and tools needed for complex software engineering tasks.

Skills and agents are organized into two structures:

• AI Cores (aicores/ folder): Groups of related skills and agents that work together toward a shared goal
• Standalone components (skills/ and agents/ folders): Individual skills or agents that operate independently

Components can belong to an AI Core or exist as standalone modules—they don't need to be co-located.

AI Cores are accelerators designed to help you implement AI into your software development lifecycle. They group together Agents (like Gemini, Cloud Code, Cursor, or Windsurf) and Skills (specific tasks formatted as Markdown files) to automate common workflows like Documentation, Security, Unit Testing, and Incident Management.

Here is how to set them up and use them in your daily workflow.

Before you begin, ensure you have access to the repository:

1. Link your GitHub account with your Wizeline email.
2. Create a ticket to link your account to the Wizeline GitHub organization (wizeline.org).
3. Have an AI Assistant installed in your IDE (e.g., Gemini, Cloud Code, Cursor, or Windsurf).

Instead of manually copying and pasting files, you can use the provided TypeScript CLI tool to install specific AI Cores directly into your project.

1. Open your terminal in the root directory of your project.

2. Run the following command, replacing the URL with the specific AI Core you want to install (e.g., the Documentation core):

   npx aicores add https://github.com/wizeline/sdlc-agents/tree/main/aicores/documentation-writer-agent

3. Follow the CLI prompts: The tool will ask you which specific agents/skills you want to use. You can select all of them.

4. Select your AI Assistant: Choose the assistants you are currently using (e.g., Gemini, Cloud Code, Cursor, or Windsurf).

5. The tool will automatically create a .agents (or .cursor/agents) folder in your project root containing all the necessary Markdown files.

These AI Cores are internal Wizeline accelerators to help you work faster. They should not be pushed to the client's repository.

Immediately open your project's .gitignore file and add the following lines to prevent committing the agent files:

# AI Agents & Skills
.agents/
.cursor/agents/

Once installed, your AI Assistant will automatically detect the skills.

1. List Available Skills: Open your AI Assistant's chat window (Gemini, Cloud Code, Cursor, etc.) and type the command /skills (or /agents in Cloud Code). It will list all the skills you just installed.
2. Trigger a Skill: You don't always need to call a skill by its exact name. You can simply write a prompt with a clear intent, and the AI will trigger the appropriate Markdown skill file.
   • Example: "Document the architecture of this project using the C4 model."
3. Automated Workflows: Some skills can be triggered by actions. For example, if you have the documentation core installed, you can prompt: "git commit changes and push them," and the AI can automatically trigger the skill to update the documentation alongside your commit.

• Save Tokens by Being Specific: While you can use ambiguous prompts (e.g., "Document the project"), this will consume a massive amount of tokens as the AI scans the entire codebase. Instead, use specific prompts (e.g., "Generate unit tests for auth_service.java") to save tokens and get faster results.
• Set Global Rules with Context Files: If you want to set global rules (like token limits, tone of voice, or project context), you don't need to create a new skill. Instead, create a context file in your root folder named after your assistant (e.g., gemini.md, cloud.md, or cursor.md). The AI will read this file automatically before executing tasks.
• Clean Updates: If a new version of an AI Core is released, the safest way to update is to manually delete the .agents folder and re-run the npx ai-cores add command to ensure a clean installation.
• Connect to Jira/Confluence: If you need your agents to read tickets or wikis, check the MCP Servers configuration section below on how to configure MCP (Model Context Protocol) locally to connect your agents to Jira, Confluence, or GitHub.

Skills and agents are installed via the aicore-cli — an open agent ecosystem CLI for installing agents and skills across Claude Code, Cursor, Gemini CLI, Codex, and 40+ other coding agents.

[optional] First, install the aicore-cli:

npm install -g aicores

Then use npx aicores to install both agents and skills from an aicore package in one command:

# Install all agents and skills from SDLC Agents interactively
npx aicores add wizeline/sdlc-agents/aicore-name

# Or with the GitHub URL
npx aicores add https://github.com/wizeline/sdlc-agents/aicore-name

# Install to a specific AI assistant
npx aicores add wizeline/sdlc-agents/aicore-name -a claude-code

# Install to multiple assistants
npx aicores add wizeline/sdlc-agents/aicore-name -a claude-code -a cursor

# List available items before installing
npx aicores wizeline/sdlc-agents --list

Use npx subagents or npx skills to install items independently:

# Install all agents from a specific core
npx subagents add wizeline/sdlc-agents/tree/main/aicores/documentation-writer-agent/agents

# Install a specific agent
npx subagents add wizeline/sdlc-agents/tree/main/aicores/documentation-writer-agent/agents/doc-engineer -a claude-code

# Install all skills from a specific core
npx skills add wizeline/sdlc-agents/tree/main/aicores/documentation-writer-agent/skills/

# Install a specific skill
npx skills add wizeline/sdlc-agents/tree/main/aicores/documentation-writer-agent/skills/authoring-technical-docs -a claude-code

IMPORTANT: When installing, select the option to install in the project (not globally) unless you want the agents/skills available across all projects.

⚠️ WARNING - Wizeline Usage Only: Please update the .gitignore of your client repo in which these skills and agents will be installed so they won't be part of the source code. This is Wizeline usage only.

Some tools require additional configuration to use subagents:

Subagents are currently experimental. To use custom subagents, you must enable them in your settings.json (located at ~/.gemini/settings.json or project-root .gemini/settings.json):

{
  "experimental": {
    "enableAgents": true
  }
}

Some agents fetch data from external tools and require MCP servers configured in your settings.json.

Atlassian (Jira & Confluence) — used by atlassian-sourcer, incident-commander, and others. Use the Atlassian MCP server:

{
  "mcpServers": {
    "mcp-atlassian": {
      "command": "uvx",
      "args": ["mcp-atlassian"],
      "env": {
        "JIRA_URL": "https://wizeline.atlassian.net",
        "JIRA_USERNAME": "[email protected]",
        "JIRA_API_TOKEN": "your_api_token",
        "CONFLUENCE_URL": "https://wizeline.atlassian.net/wiki",
        "CONFLUENCE_USERNAME": "[email protected]",
        "CONFLUENCE_API_TOKEN": "your_api_token"
      }
    }
  }
}

Note: To get Atlassian API tokens go to https://id.atlassian.com/manage-profile/security/api-tokens.

GitHub — used by incident-commander to inspect repos, PRs, and CI runs during incident response. Use the GitHub MCP server:

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "ghcr.io/github/github-mcp-server"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your_github_pat"
      }
    }
  }
}

Note: Create a GitHub Personal Access Token at https://github.com/settings/tokens. The token needs repo and read:org scopes for most incident response operations.

For this script to work across different languages, you must initialize your Tree-sitter configuration and "well-known" grammar locations: [6]

1. Install the CLI: npm install -g tree-sitter-cli.
2. Initialize Config: Run tree-sitter init-config to create ~/.tree-sitter/config.json.
3. Install Grammars: Clone language repos (like tree-sitter-python or tree-sitter-javascript) into the parser_directories listed in your config.json.

If you have previously installed any SDLC Agents, remove the existing skills/ and agents/ directories for your agent tool before running the installer again.

Back up first. If you have made local customizations to any templates or reference files, copy them out before deleting. The reinstall overwrites the directory completely.

Skills and agents are stored in different locations depending on the tool and whether you installed at project scope (one project only) or user scope (available everywhere on your machine).

# Project scope (inside your repo)
rm -rf .claude/skills/
rm -rf .claude/agents/

# User scope (global — affects all projects)
rm -rf ~/.claude/skills/
rm -rf ~/.claude/agents/

# Project scope
rm -rf .cursor/skills/
rm -rf .cursor/agents/

# User scope
rm -rf ~/.cursor/skills/
rm -rf ~/.cursor/agents/

Cursor also reads .agents/skills/ as a cross-tool alias. Remove it too if present:

rm -rf .agents/skills/

# Project scope
rm -rf .gemini/skills/
rm -rf .gemini/agents/
rm -rf .agents/skills/   # cross-tool alias

# User scope
rm -rf ~/.gemini/skills/
rm -rf ~/.gemini/agents/
rm -rf ~/.agents/skills/

# Project scope
rm -rf .codex/skills/

# User scope
rm -rf ~/.codex/skills/

Run the following to check all possible locations at once:

# Check project scope (run from your repo root)
ls -d .claude/skills/ .claude/agents/ \
       .cursor/skills/ .cursor/agents/ \
       .gemini/skills/ .gemini/agents/ \
       .agents/skills/ .codex/skills/ 2>/dev/null

# Check user scope
ls -d ~/.claude/skills/ ~/.claude/agents/ \
       ~/.cursor/skills/ ~/.cursor/agents/ \
       ~/.gemini/skills/ ~/.gemini/agents/ \
       ~/.agents/skills/ ~/.codex/skills/ 2>/dev/null

Any directory listed exists and should be removed before reinstalling.

New to agent skills? Check out our comprehensive resources:

• Practical Tutorial: A deep dive into skills and subagents for Gemini, Claude, and Codex.
• Subagents FAQ: A short and concise explanation of what subagents are and how they work.
• Prompt Examples: A collection of curated prompts to see our skills in action:
  • Documentation Writer
  • Code Review
  • Security
  • Unit Testing
  • Incident Support
  • QA Agent

• aicores/: Modularized AI cores, each containing its own agents/ and skills/.
• docs/: Tutorials, prompt examples, and design documents.

We welcome contributions! Please adhere to the Agent Skills standard when adding new skills, and follow Anthropic's subagent format when adding agents.

For general-purpose skills/agents (available across Wizeline projects):

• Create a branch from main using the appropriate pattern:

  • aicore/aicore_name — for both skills and agents with the same purpose
  • skills/skill_name — for standalone skills only
  • agents/agent_name — for standalone agents only

• If creating both skills and agents together, group them in a single folder within aicores/ so they can be installed via aicore-cli

• Standalone skills belong in the skills/ folder; standalone agents in the agents/ folder

For account-specific skills/agents (e.g., UTA, KOF):

• Create a branch using the pattern: account_name/aicore/skill/agent_name

An AI Core follows this directory structure:

my-aicore/
├── agents/
│   └── agent-name.md        ← Required: YAML frontmatter + instructions
└── skills/
    └── skill-name/
        ├── SKILL.md          ← Required: YAML frontmatter + instructions
        ├── references/
        │   └── reference.md  ← Optional: reference documents
        ├── assets/
        │   └── template.md   ← Optional: template files
        └── scripts/
            └── helper.py     ← Optional: helper scripts

Required files:

• agents/*.md — Agent definitions with YAML frontmatter and instructions
• skills/*/SKILL.md — Skill definitions with YAML frontmatter and instructions

Optional directories:

• references/ — Supporting documentation and reference materials
• assets/ — Template files and reusable assets
• scripts/ — Helper scripts and utilities

• Each AI Core uses independent semantic versioning (vMAJOR.MINOR.PATCH)
• GitHub Actions automatically increments patch versions on every push to main for modified AI Cores

Initialize a new AI Core directory with an initial version tag:

git tag "aicores/aicore_name/v1.0.0" && git push origin --tags

This project is licensed under the MIT License. See LICENSE for details.