Claudio Skills Plugin

July 1, 2026 · View on GitHub

A Claude Code plugin that extends Claude with specialized skills for DevOps and cloud-native development workflows.

Overview

Claudio Skills Plugin provides five production-ready skills designed to streamline interactions with GitLab CI/CD, Konflux, AWS CloudWatch Logs, Slack, GitLab branch management, and Jira. Each skill provides Claude Code with domain-specific capabilities, allowing you to leverage Claude as an intelligent assistant for complex DevOps tasks.

Features

CI/CD Job Analysis - Analyze GitLab pipeline failures, parse logs, and identify error patterns
Konflux Release Orchestration - Automate stage-to-production release workflows on the Konflux platform
AWS Log Analysis - Troubleshoot and analyze CloudWatch Logs with advanced querying
Slack Utilities - Search messages, post updates, and interact with Slack workspaces
GitLab Branch Management - Create and protect GitLab branches with configurable protection rules
Jira Utilities - Manage Jira issues with JQL search, create/update issues, link issues, and fetch sprint info
Mapt Provisioner - Provision and manage cloud infrastructure using mapt (RHEL AI on AWS/Azure, OpenShift SNC on AWS, spot instances, GPU workloads)

Skills

1. GitLab Job Analyzer Skill

Analyze GitLab CI/CD job failures with structured scripts and error pattern recognition.

Use Cases:

Summarize job activity across pipelines in a time range
Analyze failures by runner type
Deep-dive into specific pipeline failures
Compare successful vs failed job runs
Extract and categorize error patterns from job logs

Key Features:

JSON-first output for programmatic parsing
Time-based and runner-based analysis
Error pattern recognition and categorization
Uses glab CLI directly through structured scripts

2. Konflux Release Skill

Work with Konflux - a build and release platform based on OpenShift and Tekton.

Use Cases:

Create production releases from successful stage releases
Query Konflux Release, Snapshot, and ReleasePlan resources
Generate release YAMLs with release notes
Orchestrate multi-component releases
Follow stage-to-production deployment workflows

Key Features:

Automates stage → production release pattern
Deterministic YAML generation with Python scripts
Self-contained with inline kubectl, glab, and skopeo commands
Supports manual mode and config-driven mode with external product configs

3. AWS Log Analyzer Skill

Troubleshoot and analyze logs from AWS CloudWatch Logs.

Use Cases:

Investigate errors and exceptions across log groups
Trace requests through multiple services
Analyze performance issues and slow queries
Monitor for specific error patterns in real-time
Perform complex log aggregations and analysis

Key Features:

CloudWatch Logs filter patterns and Insights queries
Real-time log tailing with filtering
Multi-log-group search capabilities
Efficient time range handling

4. Slack Utilities Skill

Interact with Slack workspaces using the Slack Web API.

Use Cases:

Search messages across channels
Post messages and updates
List channels and conversations
Retrieve conversation history

Key Features:

Uses Slack Web API for programmatic access
Supports message search and posting
Channel and conversation management

To get values for them the easiest way is to authenticate to your slack workspace in chrome/chromium browser

On same page go to More Tools -> Developer Tools

On Developer Tools go to:

XOXC: Application -> Storage -> Local Storage -> https>//app.slack.com -> localConfig_v2 (key) -> 'token' key inside the json value
XOXD: Application -> Storage -> Cookies -> https>//app.slack.com -> d (key)

Since it is slack enterpise we need to get value for User-Agent. To get it from same place we check Networking and check request headers to get the value, it should be something similar to Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36

Disclaimer, the first time you reuse those Tokens you will probably be signed off as precaution, the second time you sign in the tokens should last.

5. GitLab Branch Manager Skill

Use Cases:

Create release branches from main or a specific tag/ref
Apply branch protection rules (push, merge, force push, unprotect restrictions)
Verify branch protection configuration

Key Features:

Smart repo resolution (short name, full path, or URL)
Extensible protection rules with generic --rule KEY=VALUE override
Idempotent protection checks (matching rules succeed, differing rules fail)
Dry-run mode for previewing actions
JSON and human-readable output
Compatible with bash 3.2+ (macOS, RHEL, Ubuntu, Alpine)

6. Mapt Provisioner Skill

Provision and manage cloud VMs and services on AWS and Azure using mapt.

Use Cases:

Provision RHEL AI instances with GPU support (CUDA/ROCm)
Provision OpenShift SNC clusters with AI/NVIDIA profiles (AWS only)
Use spot instances for cost-effective testing
Destroy provisioned resources with state cleanup
Check stack status and retrieve connection details
List available RHEL AI versions on AWS and Azure

Key Features:

Natural language intent mapping
Automatic RHEL AI version discovery via mapt list-versions
OpenShift SNC with profile support (ai, nvidia, serverless, servicemesh, virtualization)
Spot eviction tolerance defaults to highest for both RHEL AI and SNC
Pulumi state backend enforcement to prevent orphaned resources
mapt + Pulumi + provider plugins auto-installed via tools/mapt/install.sh

Prerequisites:

MAPT_BACKEND_URL - Pulumi state backend (s3:// or azblob://)
AWS: AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY (or AWS_PROFILE), AWS_DEFAULT_REGION
Azure: ARM_TENANT_ID, ARM_SUBSCRIPTION_ID, ARM_CLIENT_ID, ARM_CLIENT_SECRET
SNC: PULL_SECRET_FILE (from console.redhat.com/openshift/downloads)

7. Jira Utilities Skill

Use Cases:

Fetch a single issue by key
Search issues with JQL (Jira Query Language)
Create new issues with full field support
Update fields on existing issues
Link issues with typed relationships (blocks, duplicates, relates to)
Fetch sprint information from Jira Software boards

Key Features:

Supports Jira Cloud (Basic auth) and Data Center (Bearer/PAT) authentication
Python REST API integration — no unmaintained third-party CLI required
Standalone scripts usable from other skills
Full test suite with mocked HTTP calls

Prerequisites:

JIRA_BASE_URL - Jira instance URL (e.g., https://yourorg.atlassian.net)
JIRA_TOKEN - API token (Cloud) or Personal Access Token (Data Center)
JIRA_EMAIL - User email (Cloud auth only)
JIRA_AUTH_TYPE - cloud or datacenter (default: cloud)

Installation

Prerequisites

Core Requirements:

Claude Code CLI
Git

Skill-Specific Dependencies:

Each skill manages its own dependencies through installer scripts in claudio-plugin/tools/:

Skill	Required Tools	Auto-Installed
GitLab Job Analyzer	`glab`, `jq`	`jq` only
Konflux Release	`kubectl`, `glab`, `skopeo`, `python3` + PyYAML, `jq`	`kubectl`, `skopeo`, `jq`, PyYAML
AWS Log Analyzer	`aws` CLI v2, `jq`	Both
Slack Utilities	`curl`, `jq`, `python3` + requests	`jq`, requests
GitLab Branch Manager	`glab`, `jq`	`jq` only
Jira Utilities	`python3` + requests	requests
Mapt Provisioner	`mapt`, `pulumi`	Both (via `tools/mapt/install.sh`)

Authentication:

GitLab: Authenticate with glab auth login before using (required for GitLab Job Analyzer, GitLab Branch Manager, and Konflux Release)
Kubernetes: Configure kubectl context with kubectl config use-context (required for Konflux Release)
AWS: Authenticate with AWS CLI (aws configure, SSO, or instance profile)
Jira: Set JIRA_BASE_URL, JIRA_TOKEN, and optionally JIRA_EMAIL / JIRA_AUTH_TYPE environment variables

Install Plugin

Clone this repository:

git clone <repository-url>
cd claudio-plugin

The plugin will be automatically discovered by Claude Code from the claudio-plugin directory
Verify installation by invoking a skill in Claude Code

Usage

Basic Skill Invocation

Skills are invoked automatically by Claude Code when relevant to your request. You can also explicitly reference them:

# CI/CD analysis
"Analyze failed jobs in the last 24 hours for owner/repo"

# Konflux releases
"Create a production release for tag v1.2.3 in owner/repo"

# AWS log troubleshooting
"Find errors in /aws/application/myapp from the last hour"

# Slack operations
"Search for messages about 'deployment' in #engineering"

# Branch management
"Create a branch release-1.5 on aipcc-claudio"

Example Workflows

Production Release Workflow

Using the Konflux Release skill:

"Create a production release for tag v1.2.3 in owner/repo"

Claude will:

Resolve the tag to a commit SHA using glab
Find successful stage releases using kubectl
Generate production release YAMLs with the Python script
Prepare release files for review (does not auto-apply)

Log Troubleshooting Workflow

Using the AWS Log Analyzer skill:

"Investigate errors in /aws/application/myapp from the last hour"

Claude will:

Search CloudWatch Logs for errors with time-range filtering
Extract and categorize error patterns
Analyze error distribution and provide actionable insights

CI/CD Failure Analysis

Using GitLab Job Analyzer skill:

"Analyze CI/CD failures for owner/repo in the last 24 hours, broken down by runner type"

Claude will:

Run comprehensive job analysis
Identify failure patterns by runner, stage, and error type
Provide actionable insights

Branch Management Workflow

Using the GitLab Branch Manager skill:

"Create a branch release-1.5 on owner/repo from tag v1.4.0"

Claude will:

Resolve the repository to its full GitLab project path
Create the branch from the specified ref
Apply protection rules (push blocked, merge by maintainers only, no force push, no unprotect)
Return JSON result with branch and protection details

Architecture

claudio-plugin/
├── .claude-plugin/
│   └── plugin.json              # Plugin metadata
├── tools/
│   ├── common.sh                # Shared library for tool installers
│   ├── TOOLS.md                 # Tool installation guide
│   ├── aws-cli/
│   │   └── install.sh           # AWS CLI installer
│   ├── glab/
│   │   └── install.sh           # glab GitLab CLI installer
│   ├── jq/
│   │   └── install.sh           # jq installer
│   ├── kubectl/
│   │   └── install.sh           # kubectl installer
│   ├── python/
│   │   ├── install.sh           # Python pip installer
│   │   ├── konflux-release-requirements.txt
│   │   └── slack-requirements.txt
│   └── skopeo/
│       └── install.sh           # skopeo installer
└── skills/
    ├── gitlab-job-analyzer/
    │   ├── SKILL.md             # GitLab CI/CD job analysis skill
    │   └── scripts/             # Analysis scripts
    ├── konflux-release/
    │   ├── SKILL.md             # Konflux release workflow skill
    │   └── scripts/
    │       └── generate_release_yaml.py
    ├── aws-log-analyzer/
    │   ├── SKILL.md             # AWS CloudWatch Logs analysis skill
    │   └── scripts/             # Log analysis scripts
    ├── slack-utilities/
    │   ├── SKILL.md             # Slack Web API skill
    │   └── scripts/             # Slack interaction scripts
    ├── gitlab-branch-manager/
    │   ├── SKILL.md             # GitLab branch creation and protection skill
    │   └── scripts/
    │       └── create_and_protect_branch.sh
    ├── mapt-provisioner/
    │   ├── SKILL.md             # Cloud infrastructure provisioning skill
    │   └── scripts/             # Provisioning, destroy, and status scripts
    └── jira-utilities/
        ├── SKILL.md             # Jira REST API skill
        └── scripts/
            └── jira/            # Jira operation scripts (get_issue, search_issues, create_issue, …)

Tool Management

The claudio-plugin/tools/ directory provides centralized installation scripts for CLI tools used by skills. This system ensures consistent, maintainable dependency management. Design Principles:

Simplicity: Scripts do one thing well - install the tool if not present
Reusability: Common functions shared via common.sh library
Linux-only: Focus on Linux x86_64 and ARM64 architectures

Available Tools:

aws-cli/install.sh - AWS CLI v2 installer
glab/install.sh - glab GitLab CLI installer
kubectl/install.sh - kubectl Kubernetes CLI installer
python/ - Python package installers (pip-based requirements.txt files)
skopeo/install.sh - skopeo container image inspector installer
mapt/install.sh - mapt CLI + Pulumi + provider plugins installer

Adding New Tools:

See claudio-plugin/tools/TOOLS.md for comprehensive guidelines on adding new tool installers.

Performance Optimization

When using multiple skills together (especially GitLab Job Analyzer + AWS Log Analyzer), follow these optimization patterns:

Maximum Parallelization - Execute independent data fetches concurrently
Parse JSON Directly - Use jq on existing outputs instead of multiple queries
Eliminate Redundant Calls - Extract data from existing results
Smart Targeting - Analyze first, then target specific resources

See CLAUDE.md for detailed optimization guidelines and performance benchmarks.

Development

Adding a New Skill

Create a directory under claudio-plugin/skills/<skill-name>/
Add a SKILL.md file with skill documentation
Add any required scripts under scripts/
Update claudio-plugin/.claude-plugin/plugin.json if needed
Add tool installers to claudio-plugin/tools/ if dependencies are needed

Testing

Each skill includes its own test scenarios. Run skill-specific scripts directly to test functionality:

# Test GitLab job analyzer
./claudio-plugin/skills/gitlab-job-analyzer/scripts/analyze_recent_jobs.sh owner/repo --hours 24

# Test AWS log analyzer
./claudio-plugin/skills/aws-log-analyzer/scripts/analyze_errors.sh /aws/application/myapp 24

Documentation

CLAUDE.md - Comprehensive plugin documentation for Claude Code
LICENSE - Apache License 2.0
tools/TOOLS.md - Tool installation guide

Skill-Specific Documentation:

Claude Code Permissions

When using this plugin you typically want to allow skill scripts to run without per-call prompts while keeping raw tool access (direct acli, curl, etc.) subject to approval. Copy this block into the target project's ~/.claude/settings.json and adjust paths as needed.

{
  "permissions": {
    "allow": [
      "Skill(claudio-plugin:aws-log-analyzer)",
      "Skill(claudio-plugin:gitlab-job-analyzer)",
      "Skill(claudio-plugin:konflux-release)",
      "Skill(claudio-plugin:slack-utilities)",
      "Skill(claudio-plugin:jira-utilities)",
      "Skill(claudio-plugin:jira-release-setup)",
      "Skill(claudio-plugin:jira-sprint-manager)",
      "Skill(claudio-plugin:jira-cve-tracker)",
      "Skill(claudio-plugin:jira-gap-audit)",
      "Skill(claudio-plugin:mapt-provisioner)",
      "Bash(/path/to/claudio-skills/**)",
      "Bash(mempalace*)",
      "Read(/home/$USER/.claude/**)"
    ],
    "deny": [],
    "ask": []
  },
  "enabledPlugins": {
    "claudio-plugin@claudio-skills": true
  },
  "extraKnownMarketplaces": {
    "claudio-skills": {
      "source": {
        "source": "directory",
        "path": "/path/to/claudio-skills"
      }
    }
  }
}

Key design decisions:

Bash(/path/to/claudio-skills/**) — skill scripts run without prompts; replace with your actual plugin path
Bash(mempalace*) — needed if you use MemPalace for session memory
Do NOT add Bash(acli*), Bash(curl*), or Bash(python3*) — keeping raw tools out of the allow list means a broken skill will surface as a prompt rather than silently calling tools directly
Add new Skill(...) entries incrementally as domain skills are deployed
Read(/home/$USER/.claude/**) — allows reading Claude config files (CLAUDE.md, memory files)

Releasing

Releases are fully automated via GitHub Actions — no manual commits or version bumps needed.

Go to Actions → Release → Run workflow
Enter the version (e.g. v0.5.6)
Click Run workflow

The workflow validates the version format, bumps plugin.json and the README badge, commits to main, creates a git tag, and publishes a GitHub Release with auto-generated notes.

Patch releases

If you need to patch an older release:

Create a release branch from the tag: git checkout -b release-0.5 v0.5.6
Cherry-pick the fix(es) and push the branch: git push origin release-0.5
Run the release workflow, selecting the release branch as the target

Contributing

Contributions are welcome! Please:

Fork the repository
Create a feature branch
Make your changes
Add tests and documentation
Submit a pull request

License

This project is licensed under the Apache License 2.0 - see the LICENSE file for details.