CI/CD Pipeline Review, Design & Migration

    1

    - **Architectural design** Drafts stage contracts, environment matrices, and release strategies like canary or blue-green deployments.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    CI/CD Pipeline Review, Design & Migration

    Example session with this skill installed

    Review our CI/CD setup and tell me how good it is.

    • Read your context and instructions
    • Compiled the ci cd pipeline

    A real, unedited Review-mode run of this skill on a seeded test repository: a fictional system built for the skill's eval, not a customer's.

    storefront-api: CI/CD pipeline review

    Mode: Review, system tier (R1–R4).

    Platform: GitHub Actions, deploying with kubectl to two EKS clusters (staging-eu, prod-eu) from one ECR registry.

    Source: the working tree as of 2026-11-03. There is no git metadata, so I can't cite a commit.

    Rubric: pipelines v1.0.

    Read in full: all 3 workflows, scripts/deploy-prod.sh, Dockerfile, k8s/deployment.yaml, package.json, README.md, config/*.json, src/, test/. There are no shared templates.

    Tools run: actionlint (which includes shellcheck on inline run: blocks) and shellcheck scripts/deploy-prod.sh. zizmor, checkov and gitleaks aren't installed, so they didn't run.

    Not done: I didn't trigger or re-run anything, didn't read any secret values, and had no CI settings or run history.

    Verdict

    The score is 2.0 / 10 with caps (3.2 without them), which is in the "Critical / unsafe" band. The gate fails on all six conditions.

    In short, this pipeline isn't safe to keep running as it is. There are three Critical problems:

    1. Anyone with a GitHub account can run their own code with your secrets. pr-preview.yml uses pull_request_target on fork PRs, checks out the PR's head commit and runs npm ci && npm run build from it. That job has NPM_TOKEN in its environment and a write-all GITHUB_TOKEN. The "preview" also produces nothing: build is an echo and no comment is posted. So the workflow adds risk and delivers no value.

    A Slack incoming-webhook URL is committed in plain text at deploy.yml:11. I'm recording only what kind of secret it is and where it is. The value looks like a placeholder, but treat it as real until someone confirms it isn't.
    3. Staging and production push to the same mutable tag, storefront-api:latest, in the same registry. The manifest deploys :latest, and for a :latest tag Kubernetes pulls the image every time a pod starts. So any prod pod that restarts after deploy-staging has pushed (and before deploy-prod overwrites the tag) runs the

    staging-configured image. That window includes any time spent waiting on a production approval. A staging build can reach production without passing any gate.

    Beyond those, the release path is mostly theoretical:

    The deploy isn't gated by tests. deploy.yml doesn't depend on ci.yml at all, and it rebuilds the image separately for each environment with that environment's config baked in.

    Deploys probably don't roll out a new version. The manifest doesn't change between deploys, so kubectl apply finds nothing to update. The change-cause annotation is on the Deployment object rather than the pod template, so it doesn't trigger a rollout either.

    Nothing checks health after a deploy, and the documented rollback (re-running an old workflow run) rebuilds and re-pushes :latest. That has the same no-rollout problem.

    When a rollout does happen, it causes downtime. The strategy is Recreate, which stops all 6 pods of a public API before starting new ones.

    Scores

    flowfeedbackreleasesecurityenvironmentsinfrastructureSystem
    2.0 (base 4.3, Critical cap)5.0 (base 5.0, High cap 6.0)0.7 (base 0.7, High cap)1.9 (base 1.9, Critical cap 2.0)5.8 (base 5.8, no cap)N/A: no IaC in repo2.0 (uncapped 3.2)

    System arithmetic. The system score is a weighted mean of the domain scores, using the number of in-scope objects in each domain as the weight:

    DomainObjectsBase
    flow34.286
    feedback45.000
    release20.714
    security81.875
    environments25.833
    • Uncapped: (3×4.286 + 4×5.0 + 2×0.714 + 8×1.875 + 2×5.833) / 19 = 60.95 / 19 = 3.2
    • With domain caps: (3×2.0 + 4×5.0 + 2×0.714 + 8×1.875 + 2×5.833) / 19 = 2.85
    • Final: the system-level Critical cap then brings that to 2.0.

    Severity tally: 3 Critical · 12 High · 8 Medium · 3 Low. 🔬 flags: 8, which is 42% of 19 objects.

    The value stream (commit → production)

    PR opened / updated
     ├─ ci.yml        lint ∥ unit ──► e2e (continue-on-error; skips itself without E2E_URL, which CI never sets)
     └─ pr-preview    pull_request_target ► checks out the fork's head SHA ► npm ci && npm run build with NPM_TOKEN + write-all token ► echo of the PR title
                      (produces no preview)
    
    push to main
     ├─ ci.yml        same as above; nothing depends on it
     └─ deploy.yml    (starts at the same moment, not after CI)
         deploy-staging  static AWS keys ► docker build --build-arg ENV=staging ► push :latest ► kubectl apply k8s/ (staging-eu)
                         no health check
         deploy-prod     environment: production (protection rules 🔬) ► static AWS keys ► docker build --build-arg ENV=prod
                         ► push :latest (overwrites staging's image) ► deploy-prod.sh (apply + annotate, prod-eu)
                         ► Slack notify via rtCamp/action-slack-notify@master
                         no health check
    

    Stages: 2 deploy stages, 0 test gates between commit and production, and 1 possible manual gate (the production environment, 🔬).

    Artifacts: two different images are built per commit. Neither is the image CI tested, because CI doesn't build an image at all. Both are stored under the same mutable tag.

    • Durations: 🔬, since there's no run history.

    Credentials and who can reach them:

    CredentialJobs that hold itTriggers that reach those jobs
    AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY (same names in both envs)deploy-staging, deploy-prodpush to main
    NPM_TOKENpreviewany fork PR
    GITHUB_TOKEN with write-all, which includes contents, packages, actions and id-token: writepreviewany fork PR
    GITHUB_TOKEN with write-alldeploy-staging, deploy-prodpush to main
    GITHUB_TOKEN with contents: readci jobspush to main, PRs
    Slack webhook (committed)anyone who can read the repo; also every step in deploy.yml, including a third-party action—

    Findings

    ✅ means provable from the files. ⚠️ means a proxy signal (an indirect indicator). P-numbers are the skill's principles in theory.md.

    Critical

    IDObjectAnti-patternConf.Theory violatedEvidence
    CI-SEC-01pr-preview.yml / previewUntrusted code with secrets. pull_request_target plus checkout of pull_request.head.sha, then npm ci (runs the PR's lifecycle scripts) and npm run build (defined by the PR's package.json). See the note below for what this exposes.✅Protect the pipeline (P18).github/workflows/pr-preview.yml:5,8,16,17,19
    CI-SEC-02deploy.yml (workflow env)Secret in a pipeline file. A Slack incoming-webhook URL is set as a literal in workflow-level env. Everyone with repo read access has it, and so does every step in both deploy jobs, including the @master third-party action. Rotate it first, then remove it, because history keeps the old value.✅P18.github/workflows/deploy.yml:11
    CI-FLO-03deploy.yml / both jobs + k8s manifestMutable artifact shared across environments. Both environments push storefront-api:latest to one registry, and the manifest deploys :latest, which defaults to pulling on every pod start. A staging-configured image can run in prod (between the two pushes, including any approval wait), and a prod-configured image runs in staging after every release. Nobody can say which build is running anywhere.✅Build once, promote (P3); integrity (P19)deploy.yml:24-25,40-41; k8s/deployment.yaml:17

    What CI-SEC-01 exposes. The untrusted code in that job can:

    • steal NPM_TOKEN;
    • use the write-all token, which actions/checkout stores in .git/config by default, to push to main. A push made with GITHUB_TOKEN doesn't trigger a new workflow run, so the commit would ship with the next normal merge, unless branch protection blocks it (🔬);
    • mint OIDC tokens for this repo, because write-all includes id-token: write;
    • poison the Actions cache for the base branch.

    High

    IDObjectAnti-patternConf.TheoryEvidence
    CI-SEC-03pr-preview.yml / previewScript injection. The PR title (controlled by the attacker) is pasted directly into run:, in a job with a write-all token. actionlint flags this too. This remains exploitable even after the checkout problem is fixed.✅P18pr-preview.yml:21
    CI-SEC-04deploy.yml / deploy-staging, deploy-prodStatic cloud credentials. Long-lived AWS keys rather than OIDC, under the same secret names for staging and prod. Whether they are environment-scoped and different per environment is 🔬.✅P18deploy.yml:20-21,36-37
    CI-SEC-05deploy.yml, pr-preview.ymlOver-broad token. permissions: write-all at workflow level.✅P18deploy.yml:7; pr-preview.yml:8
    CI-SEC-06deploy.yml / deploy-prodUnpinned third-party code in a job that holds credentials. rtCamp/action-slack-notify@master is a mutable branch. It runs after configure-aws-credentials has exported the prod AWS keys into the job environment, and it also gets the webhook. aws-actions/configure-aws-credentials@v4 is pinned only to a tag, in both deploy jobs.✅Hermetic builds (P14); P18deploy.yml:18,34,43
    CI-FLO-01deploy.yml / both jobsRebuild per environment. docker build runs inside each deploy job. What staging exercised isn't what prod gets, and CI never built either image.✅P3deploy.yml:24,40
    CI-FLO-02Dockerfile + deploy.ymlEnvironment-specific artifacts. --build-arg ENV=… selects which config/${ENV}.json is baked into the image and sets APP_ENV.✅P3; config separate from artifact (P10)Dockerfile:2,7,8; deploy.yml:24,40
    CI-FBK-01deploy.ymlNo gating acceptance stage. deploy.yml triggers on push to main in parallel with ci.yml and has no needs, no workflow_run, and no test step. Production can get a commit whose lint or unit tests fail. Branch protection with required checks would only cover the PR head, not the merge result, and its presence is 🔬.✅Fast feedback, stop the line (P5, P6); test stages (P8)deploy.yml:3-5 vs ci.yml:3-6
    CI-REL-01deploy.yml / deploy-staging, deploy-prodFire-and-forget deploy. Both jobs end at kubectl apply (prod also annotates and sends Slack). There's no rollout status, no smoke check against /healthz, and no failure condition.✅Verified, reversible deploys (P13)deploy.yml:26; scripts/deploy-prod.sh:5-6
    CI-REL-02deploy.yml / both jobsThe deploy doesn't change what is running. The manifest is identical every time (image: …:latest), so kubectl apply makes no change and no rollout starts. The change-cause annotation is on Deployment metadata, not the pod template, so it doesn't start one either. New code reaches pods only when they happen to be rescheduled. Together with REL-01, the job reports success while the old version keeps serving.✅P13; P3k8s/deployment.yaml:17; deploy-prod.sh:5-6
    CI-REL-03deploy-prodNo rollback path. The README says "re-run an older deploy workflow run". That rebuilds the old commit on today's floating base image, re-pushes :latest, and hits the same no-op apply (REL-02). There's no one-step redeploy of a known previous artifact, and none exists to point at.✅ (rehearsed: 🔬)P13README.md:7
    CI-REL-04deploy.ymlDifferent deploy per environment. Staging runs inline kubectl apply, while prod runs scripts/deploy-prod.sh with an extra annotate step. The production path is never rehearsed in staging.✅Same deploy everywhere (P4)deploy.yml:26 vs :42; deploy-prod.sh:2
    CI-REL-05k8s/deployment.yaml (prod)Big-bang rollout with downtime. strategy: Recreate on a 6-replica public API stops every pod before new ones start. Each real rollout is a full outage, and every user is exposed at once.✅Progressive delivery (P12)k8s/deployment.yaml:6-8

    Medium

    IDObjectAnti-patternConf.TheoryEvidence
    CI-FBK-02ci.yml / e2eSilenced failures. continue-on-error: true, and the only e2e test skips itself unless E2E_URL is set, which CI never sets. The acceptance stage can't run and can't fail.✅P6; P8ci.yml:37; test/e2e/checkout.test.js:2
    CI-FBK-03ci.yml / unitHollow test suite. The only unit test is assert.ok(true), and the e2e test body is empty. A green CI run means close to nothing.⚠️P8test/unit/server.test.js:3
    CI-FBK-04ci.yml / all jobsCI looks unable to pass as committed. There's no package-lock.json, yet every job runs npm ci and setup-node with cache: npm, and both require a lockfile. eslint isn't declared in package.json. If this snapshot is complete, CI is permanently red, and the next point explains why nobody would notice.⚠️P6ci.yml:19-20; package.json
    CI-FLO-04deploy.ymlCopy-pasted pipelines. The staging and prod jobs are near-copies (credentials, login, build, push) instead of one parameterized job or a matrix. They have already drifted (REL-04).✅Shared templates (P15)deploy.yml:14-26 vs 28-42
    CI-SEC-07all pipelinesNo security scanning. No SAST, dependency (SCA), secret or container scan. A secret scan would have caught SEC-02.✅Shift left (P17)job inventory
    CI-SEC-08DockerfileNon-hermetic image build. The node:22-slim base isn't pinned by digest, and npm install runs with only package.json copied and no lockfile. Every rebuild, rollbacks included, can pull different dependencies.✅P14Dockerfile:1,4-5
    CI-ENV-01staging, prodNo deploy-time config validation. Config isn't validated before it takes effect, and there's no plausibility check that the image's baked apiBase matches the target cluster.✅P10deploy.yml:26; deploy-prod.sh
    CI-REL-06deploy.ymlNo version in the deploy record. The prod annotation records only a timestamp, the Slack message names no version, and staging records nothing. With :latest there's nothing to record anyway.✅Instrument the deploy (P20)deploy-prod.sh:6; deploy.yml:46

    Low

    IDObjectAnti-patternConf.TheoryEvidence
    CI-SEC-09all workflowsFirst-party actions pinned by tag. actions/checkout@v4 and actions/setup-node@v4 use tags rather than SHAs.✅P14ci.yml:15,16; deploy.yml:17,33; pr-preview.yml:14
    CI-SEC-10deploy.ymlNo signing, provenance or SBOM for the image.✅P19job inventory
    CI-FLO-05deploy.ymlUnquoted $REGISTRY (shellcheck SC2086, reported by actionlint).✅P2deploy.yml:23-25,39-41

    Checklist results by domain

    flow covers 3 pipelines: ci, deploy and pr-preview. Criteria 2–4 apply only to deploy.yml, the one pipeline that ships.

    #CriterionSatisfied / in scopeResult
    1Triggers on every change to trunk and on PRs3/3🟢
    2Builds the artifact once, upstream of every deploy0/1🔴
    3Artifact is environment-agnostic, immutable and traceable0/1🔴
    4Later stages consume the artifact by digest0/1🔴
    5Uses templates or a matrix, not copy-paste2/3🟡
    6Each stage's logic has a local entry point2/3🟡
    7No manual handoff3/3🟢

    Base 6/14 = 4.3, capped at 2.0 by CI-FLO-03 → 2.0.

    feedback covers 4 objects: the lint, unit and e2e jobs plus the commit stage.

    #CriterionResult
    1Commit stage within ~10 minutes🟢 ⚠️ (parallel and cached; real duration 🔬)
    2Fails the build on test failure🟡 (2/3)
    3Flaky tests handled by quarantine, not blanket retry🟡 (2/3)
    4Every later stage gated on automated acceptance🔴 (0)
    5Tests in pyramid proportions🟡 ⚠️
    6Results published and visible on failure🟡 ⚠️ (log output only, no reports)

    Base 6/12 = 5.0. The High cap of 6.0 doesn't bind, so the score is 5.0.

    release covers 2 objects: deploy-staging and deploy-prod. Migrations are N/A because the service has no database. Criterion 9 (peer or automated prod gating) is 🔬 because it depends on the production environment's rules, so it isn't scored.

    #CriterionResult
    1Same deploy mechanism everywhere🔴
    2Post-deploy check that can fail the deploy🔴
    3One-step rollback🔴
    4Rollout strategy matched to risk🟡 (staging acceptable, prod not)
    5Promotion gated by health🔴
    7Deploy marker with version🔴
    8No path to prod that skips tests🔴

    Base 1/14 = 0.7.

    security covers 8 objects: 3 jobs that hold credentials or run untrusted input (deploy-staging, deploy-prod, preview), plus 5 third-party references (checkout, setup-node, configure-aws-credentials, action-slack-notify, node:22-slim).

    #CriterionResult
    1No secret literal🔴 (1/3)
    2No untrusted code or input with secrets in scope🟡 (2/3)
    3Federated cloud identity🔴 (0/2)
    4Least-privilege token🔴 (0/3)
    5Pinned third-party references🔴 (0/5)
    6Scanning🔴
    7Signing🔴
    8Ephemeral, isolated runners🟢 (GitHub-hosted ubuntu-latest)

    Base 3/16 = 1.9, under the Critical cap of 2.0 → 1.9.

    environments covers 2 objects: staging and prod. Dev is local-only config, and "preview" deploys nothing.

    #CriterionResult
    1Defined in VCS and reproducible🟡 ⚠️ (workload manifest yes; EKS clusters not in this repo)
    2Matches production's stack🟢 (same image recipe, manifest and replica count)
    3Configuration at deploy/run time🔴
    4Config changes through the pipeline🟢 (no fast lane)
    5Config validated before it takes effect🔴
    6No unmasked production data🟢

    Base 7/12 = 5.8. The environment-specific-artifact High is filed under flow (CI-FLO-02) so it isn't counted twice.

    infrastructure: N/A. The repo has no Terraform or other IaC; the EKS clusters are managed somewhere else.

    What's working well (keep these)

    ci.yml has a least-privilege default, permissions: contents: read at the top level. This is the pattern the other two workflows should copy.

    The commit stage is set up for fast feedback: lint and unit run in parallel, there's an npm cache, and npm ci is used rather than npm install.

    Production has an environment: production binding, which is the right hook for protection rules and environment-scoped secrets once those are configured (🔬 today).

    The pipeline is fully automated. There are no manual runbook steps between merge and production, and all logic is versioned in the repo.

    The container image is reasonable: it runs as non-root (USER node), and the manifest has a readiness probe on /healthz. The app exposes that endpoint, so a smoke check would be easy to add.

    • The builds run on GitHub-hosted, ephemeral runners, with no self-hosted runners exposed to fork PRs.

    Systemic issues

    1. There is no trust boundary between fork PRs and the repo's credentials (SEC-01, SEC-03, SEC-05). A single workflow added for convenience gives outsiders the npm token and write access to the repo.

    There is no artifact. Every environment gets its own fresh, config-baked build under one shared mutable tag (FLO-01/02/03, SEC-08). As a result, "what's running", "what was tested" and "roll back to X" have no answer.
    3.

    Deploy and CI are unrelated workflows, so testing doesn't gate anything (FBK-01). The tests that exist are placeholders, muted, or can't run (FBK-02/03/04).
    4. Deploys are unverified, and as written probably don't roll out a new version (REL-01/02). That also breaks rollback, and when a rollout does happen it is all-at-once with downtime (REL-03/05).

    Needs data (🔬, not scored)

    1. Real commit-stage and deploy durations, failure rates, and DORA metrics (deployment frequency, lead time, change failure rate, time to restore).
    2. Branch protection on main: required checks and reviews, and whether GITHUB_TOKEN or admins can push directly. This decides how far SEC-01 reaches.
    3. production environment protection: required reviewers, allowed deployment branches, and whether the AWS secrets are environment-scoped (and therefore different from staging's).
    4. The IAM permissions behind the AWS keys, and whether one key can reach both clusters.
    5. The scope of NPM_TOKEN: read-only, or able to publish packages.
    6. Whether any cloud role trusts this repo's GitHub OIDC tokens with a loose subject, which id-token: write in pr-preview would expose.
    7. Whether the README rollback has ever been exercised, and what the clusters are actually running now (image digests per pod).
    8. Whether the repo snapshot is complete. FBK-04 assumes there really is no lockfile.

    Gate

    ConditionResultReason
    Capped score ≥ 9.0❌2.0
    No open Critical or High❌3 Critical, 12 High
    Every prod deploy promotes an artifact built once, upstream, and verified (P3)❌Prod is rebuilt in deploy-prod with prod config, and CI never builds an image (FLO-01/02)
    Every prod deploy has an automated post-deploy check and a stated rollback (P13)❌No check (REL-01); the stated rollback doesn't work (REL-03)
    No untrusted trigger reaches a job holding a prod credential (P18)❌Fork PRs run code holding a write-all token, which can push to main and so feed the deploy. Prod AWS keys aren't in the preview job, but main is one push away, unless branch protection blocks it (🔬)
    🔬 flags ≤ 10% of objects❌8 of 19 objects (42%)

    What to do next

    A review is meant to measure, not to prescribe a fix. But the Criticals shouldn't wait for a redesign. The skill's proposal guide puts

    containment first, and that would cover:

    • disabling or deleting pr-preview.yml, since it produces no preview anyway;
    • rotating the Slack webhook (rotate first, then remove it) and rotating NPM_TOKEN, on the assumption it has already been exposed;
    • setting permissions: contents: read on deploy.yml and pr-preview.yml;
    • pinning rtCamp/action-slack-notify (or replacing it) and configure-aws-credentials to commit SHAs.

    These are small, reversible changes and don't take the path to production down.

    After that, the scores put flow, release and security in the Rebuild band (score below 5) and

    feedback and environments in Rework. The next step is

    Design, to define:

    • one image built once per commit in CI, tagged by SHA and deployed by digest, with config injected at deploy time;
    • deploy gated on CI;
    • one deploy mechanism for both environments, with rollout status, a smoke check and a digest-based rollback;
    • a rolling or canary strategy instead of Recreate;
    • OIDC roles per environment.

    Propose then sequences the change, with the new pipeline running in shadow alongside the old one until it has shipped on its own.


    Reviewed storefront-api CI (GitHub Actions) at the working tree as of 2026-11-03 (no git commit available): score

    2.0 (Critical / unsafe; 3.2 uncapped). The gate

    fails on all six conditions.

    3 Critical, 12 High. Next:

    Design to correct flow, release and security (then feedback and environments), then

    Propose for the sequence. Containment of SEC-01 and SEC-02 should happen now. No Terraform findings: this repo has no IaC.

    pr-preview.yml

    Connects securely to your tools. The creator never sees your data.

    About this skill

    CI/CD pipelines are the automated path from commit to production, but they often become slow, flaky, or insecure. This skill audits, designs, and sequences migrations for deployment pipelines using principles from the DevOps Handbook and SRE release engineering.

    What it does

    • Pipeline auditing Performs static reviews of GitHub Actions, GitLab CI, Jenkins, and others to find anti-patterns in flow, feedback, and security.
    • Value stream mapping Visualizes the path from commit to production, identifying bottlenecks, manual gates, and artifact promotion flaws.
    • Architectural design Drafts stage contracts, environment matrices, and release strategies like canary or blue-green deployments.
    • Security hardening Detects credential leaks, untrusted triggers, and supply chain risks like unpinned third-party actions.
    • Migration sequencing Generates implementation plans that ensure the path to production stays active during pipeline refactors.

    How it works

    1. Inventory The skill scans your repository for pipeline definitions, scripts, and Dockerfiles to map the current value stream.
    2. Analysis It evaluates the setup against a specialized rubric covering flow, feedback, release safety, and infrastructure delivery.
    3. Scoring It generates a 0 to 10 score based on severity and confidence, identifying if the pipeline passes or fails specific safety gates.
    4. Deliverables Depending on the mode, it produces a detailed audit, a technical design document, or a sequenced migration proposal.

    Frameworks & tools

    Works with GitHub Actions, GitLab CI, Azure Pipelines, Jenkins, CircleCI, and Bitbucket. Supports deployment and IaC tools including Argo CD, Flux, Helm, and Terraform.

    Why this beats prompting it yourself

    Generic prompts often miss the subtle "build once, promote many" nuances that cause environment drift. This skill uses a formal rubric to cite specific DevOps principles (P1 through P22) for every finding, ensuring reviews are based on theory rather than personal preference.

    Use cases

    • Audit for security Find where secrets are exposed or where untrusted code might reach production credentials.
    • Fix flaky releases Redesign a pipeline to include smoke checks, automated rollbacks, and proper artifact versioning.
    • Speed up feedback Reorganize stages to ensure the commit stage finishes within a 10 minute budget.
    • IaC delivery Design a plan and apply flow for Terraform that includes drift detection and per-environment promotion.

    Known limitations

    Does not trigger, approve, or reconfigure live CI systems. Cannot read branch protection or environment settings unless they are provided as text exports. Static analysis only.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for DevOps & Cloud.

    No live CI interaction. Cannot detect settings inside the CI UI (branch protection, etc) without exports. Static evidence only. Does not fix YAML automatically.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 14 days ago

    Software
    Git

    Permissions

    Network Access
    Read Files
    Write Files
    Terminal / Shell
    Listed14 days ago

    What's inside

    Frequently Asked Questions

    This skill provides a comprehensive audit of your CI/CD configuration files, identifies bottlenecks or security risks, and generates a structured migration plan to modernize your deployment architecture.

    The skill performs static analysis on definition files for GitHub Actions, GitLab CI, Jenkins, Azure Pipelines, CircleCI, and Bitbucket, as well as IaC tools like Terraform and Helm.

    No, for security and safety, this skill operates as a 'Read-Only' architect; it provides the blueprints and code for improvements but does not directly modify your live production settings or branch protections.

    By analyzing your value stream, the skill identifies slow feedback loops and manual gates, providing a re-sequenced stage plan designed to meet the SRE gold standard of a 10-minute commit stage.

    Yes, every audit finding is mapped to specific SRE and DevOps Handbook principles (P1-P22), ensuring your team receives theory-backed recommendations rather than generic AI suggestions.

    New in DevOps & Cloud