- Home
- Skills
- DevOps & Cloud
- CI/CD Pipeline Review, Design & Migration
CI/CD Pipeline Review, Design & Migration
- **Architectural design** Drafts stage contracts, environment matrices, and release strategies like canary or blue-green deployments.
$5
Works with the AI Agents you already use
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:
- Anyone with a GitHub account can run their own code with your secrets.
pr-preview.ymlusespull_request_targeton fork PRs, checks out the PR's head commit and runsnpm ci && npm run buildfrom it. That job hasNPM_TOKENin its environment and awrite-allGITHUB_TOKEN. The "preview" also produces nothing:buildis anechoand 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
| flow | feedback | release | security | environments | infrastructure | System |
|---|---|---|---|---|---|---|
| 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 repo | 2.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:
| Domain | Objects | Base |
|---|---|---|
| flow | 3 | 4.286 |
| feedback | 4 | 5.000 |
| release | 2 | 0.714 |
| security | 8 | 1.875 |
| environments | 2 | 5.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:
| Credential | Jobs that hold it | Triggers that reach those jobs |
|---|---|---|
AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY (same names in both envs) | deploy-staging, deploy-prod | push to main |
NPM_TOKEN | preview | any fork PR |
GITHUB_TOKEN with write-all, which includes contents, packages, actions and id-token: write | preview | any fork PR |
GITHUB_TOKEN with write-all | deploy-staging, deploy-prod | push to main |
GITHUB_TOKEN with contents: read | ci jobs | push 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
| ID | Object | Anti-pattern | Conf. | Theory violated | Evidence |
|---|---|---|---|---|---|
| CI-SEC-01 | pr-preview.yml / preview | Untrusted 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-02 | deploy.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-03 | deploy.yml / both jobs + k8s manifest | Mutable 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/checkoutstores in.git/configby default, to push tomain. A push made withGITHUB_TOKENdoesn'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
| ID | Object | Anti-pattern | Conf. | Theory | Evidence |
|---|---|---|---|---|---|
| CI-SEC-03 | pr-preview.yml / preview | Script 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. | ✅ | P18 | pr-preview.yml:21 |
| CI-SEC-04 | deploy.yml / deploy-staging, deploy-prod | Static 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 🔬. | ✅ | P18 | deploy.yml:20-21,36-37 |
| CI-SEC-05 | deploy.yml, pr-preview.yml | Over-broad token. permissions: write-all at workflow level. | ✅ | P18 | deploy.yml:7; pr-preview.yml:8 |
| CI-SEC-06 | deploy.yml / deploy-prod | Unpinned 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); P18 | deploy.yml:18,34,43 |
| CI-FLO-01 | deploy.yml / both jobs | Rebuild per environment. docker build runs inside each deploy job. What staging exercised isn't what prod gets, and CI never built either image. | ✅ | P3 | deploy.yml:24,40 |
| CI-FLO-02 | Dockerfile + deploy.yml | Environment-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-01 | deploy.yml | No 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-01 | deploy.yml / deploy-staging, deploy-prod | Fire-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-02 | deploy.yml / both jobs | The 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; P3 | k8s/deployment.yaml:17; deploy-prod.sh:5-6 |
| CI-REL-03 | deploy-prod | No 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: 🔬) | P13 | README.md:7 |
| CI-REL-04 | deploy.yml | Different 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-05 | k8s/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
| ID | Object | Anti-pattern | Conf. | Theory | Evidence |
|---|---|---|---|---|---|
| CI-FBK-02 | ci.yml / e2e | Silenced 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; P8 | ci.yml:37; test/e2e/checkout.test.js:2 |
| CI-FBK-03 | ci.yml / unit | Hollow 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. | ⚠️ | P8 | test/unit/server.test.js:3 |
| CI-FBK-04 | ci.yml / all jobs | CI 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. | ⚠️ | P6 | ci.yml:19-20; package.json |
| CI-FLO-04 | deploy.yml | Copy-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-07 | all pipelines | No 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-08 | Dockerfile | Non-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. | ✅ | P14 | Dockerfile:1,4-5 |
| CI-ENV-01 | staging, prod | No 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. | ✅ | P10 | deploy.yml:26; deploy-prod.sh |
| CI-REL-06 | deploy.yml | No 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
| ID | Object | Anti-pattern | Conf. | Theory | Evidence |
|---|---|---|---|---|---|
| CI-SEC-09 | all workflows | First-party actions pinned by tag. actions/checkout@v4 and actions/setup-node@v4 use tags rather than SHAs. | ✅ | P14 | ci.yml:15,16; deploy.yml:17,33; pr-preview.yml:14 |
| CI-SEC-10 | deploy.yml | No signing, provenance or SBOM for the image. | ✅ | P19 | job inventory |
| CI-FLO-05 | deploy.yml | Unquoted $REGISTRY (shellcheck SC2086, reported by actionlint). | ✅ | P2 | deploy.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.
| # | Criterion | Satisfied / in scope | Result |
|---|---|---|---|
| 1 | Triggers on every change to trunk and on PRs | 3/3 | 🟢 |
| 2 | Builds the artifact once, upstream of every deploy | 0/1 | 🔴 |
| 3 | Artifact is environment-agnostic, immutable and traceable | 0/1 | 🔴 |
| 4 | Later stages consume the artifact by digest | 0/1 | 🔴 |
| 5 | Uses templates or a matrix, not copy-paste | 2/3 | 🟡 |
| 6 | Each stage's logic has a local entry point | 2/3 | 🟡 |
| 7 | No manual handoff | 3/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.
| # | Criterion | Result |
|---|---|---|
| 1 | Commit stage within ~10 minutes | 🟢 ⚠️ (parallel and cached; real duration 🔬) |
| 2 | Fails the build on test failure | 🟡 (2/3) |
| 3 | Flaky tests handled by quarantine, not blanket retry | 🟡 (2/3) |
| 4 | Every later stage gated on automated acceptance | 🔴 (0) |
| 5 | Tests in pyramid proportions | 🟡 ⚠️ |
| 6 | Results 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.
| # | Criterion | Result |
|---|---|---|
| 1 | Same deploy mechanism everywhere | 🔴 |
| 2 | Post-deploy check that can fail the deploy | 🔴 |
| 3 | One-step rollback | 🔴 |
| 4 | Rollout strategy matched to risk | 🟡 (staging acceptable, prod not) |
| 5 | Promotion gated by health | 🔴 |
| 7 | Deploy marker with version | 🔴 |
| 8 | No 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).
| # | Criterion | Result |
|---|---|---|
| 1 | No secret literal | 🔴 (1/3) |
| 2 | No untrusted code or input with secrets in scope | 🟡 (2/3) |
| 3 | Federated cloud identity | 🔴 (0/2) |
| 4 | Least-privilege token | 🔴 (0/3) |
| 5 | Pinned third-party references | 🔴 (0/5) |
| 6 | Scanning | 🔴 |
| 7 | Signing | 🔴 |
| 8 | Ephemeral, 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.
| # | Criterion | Result |
|---|---|---|
| 1 | Defined in VCS and reproducible | 🟡 ⚠️ (workload manifest yes; EKS clusters not in this repo) |
| 2 | Matches production's stack | 🟢 (same image recipe, manifest and replica count) |
| 3 | Configuration at deploy/run time | 🔴 |
| 4 | Config changes through the pipeline | 🟢 (no fast lane) |
| 5 | Config validated before it takes effect | 🔴 |
| 6 | No 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
- 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)
- Real commit-stage and deploy durations, failure rates, and DORA metrics (deployment frequency, lead time, change failure rate, time to restore).
- Branch protection on
main: required checks and reviews, and whetherGITHUB_TOKENor admins can push directly. This decides how far SEC-01 reaches. productionenvironment protection: required reviewers, allowed deployment branches, and whether the AWS secrets are environment-scoped (and therefore different from staging's).- The IAM permissions behind the AWS keys, and whether one key can reach both clusters.
- The scope of
NPM_TOKEN: read-only, or able to publish packages. - Whether any cloud role trusts this repo's GitHub OIDC tokens with a loose subject, which
id-token: writein pr-preview would expose. - Whether the README rollback has ever been exercised, and what the clusters are actually running now (image digests per pod).
- Whether the repo snapshot is complete. FBK-04 assumes there really is no lockfile.
Gate
| Condition | Result | Reason |
|---|---|---|
| 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: readondeploy.ymlandpr-preview.yml; - pinning
rtCamp/action-slack-notify(or replacing it) andconfigure-aws-credentialsto 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-apiCI (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.
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
- Inventory The skill scans your repository for pipeline definitions, scripts, and Dockerfiles to map the current value stream.
- Analysis It evaluates the setup against a specialized rubric covering flow, feedback, release safety, and infrastructure delivery.
- Scoring It generates a 0 to 10 score based on severity and confidence, identifying if the pipeline passes or fails specific safety gates.
- 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.
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
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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
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
Requires