r/cicd • • Jan 09 '23

Congrats to /r/CICD on 2k members! 🎈🎈

22 Upvotes

Here's to a great 2023 🥂


r/cicd • • 5h ago

Building a CI/CD + AI agentic defense lab — Feedback Welcome

Thumbnail
reddit.com
2 Upvotes

r/cicd • • 5h ago

Do we have enough hands-on practice for real-world DevOps incidents?

Thumbnail
reddit.com
2 Upvotes

r/cicd • • 10h ago

Just launched: Celesto CI, faster and cheaper CI runners for agent-scale

Thumbnail producthunt.com
1 Upvotes

Today we’re launching Celesto CI, a faster, cheaper GitHub Actions alternative built for agent-scale development: ~90% cheaper than GitHub Actions, up to 25% faster builds, and 65% faster caches.


r/cicd • • 13h ago

I built a local monitor for the GitHub Actions of 100+ repos (open source, no SaaS), now at 2.0.1

Post image
1 Upvotes

I maintain a lot of repositories and kept finding red CI runs hours after they happened. So I wrote a small monitor that runs on my own machine and watches the Actions of all of them.

What it does (version 2.0.1):

- A "Now" tab with what is running, queued and failed, the compute minutes and what is left of the API allowance. Red tiles blink until the alert is solved.

- An alert counts as real until the last run of that workflow goes green again, so a transient red does not stay forever.

- Three sentinels that only read: CI, collaboration (issues and pull requests that need a person) and security (Dependabot, code scanning, secret scanning, branch protection; off by default).

- A score from 0 to 100 for each account, and the health of every repository ranked in a Team tab. It says "calibrating" or "not enough data" instead of a number it cannot stand behind.

- Team mode with viewer, maintainer and admin roles, several accounts, and a log of actions where each line carries the hash of the one before it.

- Scheduled reports (HTML and Markdown, written locally), and notification channels including Apprise. All of it is off until you switch it on.

- A way to tell an AI assistant what is happening: a plain-text brief, a JSON state, an optional live stream, MCP tools and an optional hook, with presets for hosted services and local servers. All of it is off by default.

- A Quota tab and a Low mode to spend fewer reads, with conditional requests (304) and an optional GitHub App with its own allowance.

- A read API frozen by a contract since 2.0.0, a tool that checks any running monitor against it, an official Docker image, a lite edition, light and dark themes, and eight languages.

It needs Python 3.11+ and the GitHub CLI (gh auth login). It is GPL-3.0-or-later.

Video (about 8 minutes, no voice, English captions + subtitles in 8 languages): https://www.youtube.com/watch?v=s3pBDV_lgTM

Code: https://github.com/JuanenRac/TOOLS-GITHUB-ACTIONS-MONITOR

More projects: https://github.com/JuanenRac

I would like to hear what you would want it to watch that it does not watch yet.


r/cicd • • 1d ago

I built a self-hosted workflow engine for Claude Code, Codex, and Pi

0 Upvotes

When a coding agent says it’s done, I still want to know what changed, which tests actually ran, and what I’m about to commit. I built rightcommit to make those steps explicit.

It’s an open-source workflow engine you run yourself. You design the workflow on a visual canvas, assign Claude Code, Codex, or Pi to each step, and decide where tests have to pass or a human needs to approve. You can also see token usage and available costs for each step.

One workflow I wanted was simple: have the agent make a change, run the project’s tests, then pause so I can review the diff before approving a local commit.

GitHub repo, short walkthrough, and Quickstart

If you try it with Docker or Homebrew, I’d like to know where you got stuck between installing it and running your first workflow.


r/cicd • • 1d ago

How We Slashed Our Windows CI/CD Pipeline from 14 Minutes to Under 3 🚀

Post image
0 Upvotes

https://gitlab.com/jakubrojicek11/sentinel-ir-mcp/-/blob/09b61d9dc1b90f3ebc7a37be0493d951249453cf/.github/workflows/windows.yml

Waiting 14 minutes for a Windows CI job kills developer flow. For our Model Context Protocol server (Sentinel-IR-MCP), we refused to tolerate that bottleneck anymore. Here is exactly how we optimized our Windows test suite across Node 20, 22, and 24, dropping the total job runtime to 2 minutes and 44 seconds without sacrificing a single check.

Source (GitLab, Apache-2.0): https://gitlab.com/jakubrojicek11/sentinel-ir-mcp Package (npm): https://www.npmjs.com/package/sentinel-ir-mcp The analyzer behind it: https://www.npmjs.com/package/sentinel-ir

The Bottleneck (GitLab Shared Windows Runners)

A standard run on GitLab SaaS Windows took 13.6 minutes, even though our 118 unit tests executed in just 1.6 minutes. The rest was pure infrastructure drag: • VM Provisioning: 3.5 minutes (unfixable) • Real-time Antivirus: Windows Defender choked on npm ci and execution scripts, dragging out our compat-smoke test to 2.9 minutes.

The Fix: Strategic Split & Target Optimization

Instead of fighting the slow runner environment, we re-architected where and how the jobs run:

  1. Shifted Dev Push Matrices to GitHub Actions: GitHub's windows-latest images spin up in seconds (1–2 s) instead of minutes.

  2. Built-in Security Clearance: Real-time scanning (RealTimeProtectionEnabled) is off by default on GitHub's native dev images. This instantly cut our compat-smoke step down to seconds.

  3. Smart Caching & Selective Runs: We enabled direct Node/npm caching and added strict rules to completely skip the Windows matrix if a commit only modifies the README.md.

  4. Kept GitLab strictly for Releases: The heavy GitLab Windows job was moved to run only on release tags as a final gate before publishing to npm.

The Result

Step (Node 24) Old GitLab Pipeline New GitHub Actions Pipeline VM Boot / Wait ~3.5 min 1–2 s npm ci 84 s 4–9 s Test Execution 95 s 22–28 s Total Job Time 13.6 min 2.7 min

![Image description](https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/rdyfp4vs3soo307hpa2k.jpg) The code quality remains identical. All 118 tests run flawlessly across all Node versions, but now the feedback loop takes less than 3 minutes. If your Windows pipelines are killing your productivity, look closely at VM spin-up times and real-time antivirus hooks. The performance lift is hiding right there.

*** Independent Engineering Projects

Built as independent engineering experiments across AI, software analysis, security, and autonomous systems.

Evaluated by reproducible evidence, not by the number of layers.

Explore the projects:

Sentinel Ecosystem: AutoDoc-Sentinel, Sentinel-IR, Sentinel-IR-MCP and related tools. Agentix Lite: Independent security and system-observation project. Find the projects: GitLab repositories | NPM packages

Support the work: ⭐ Star the repositories on GitLab.

Connect: Follow me here on DEV Community or explore the Playground.

Each project is distributed under its own license. Check the corresponding repository or NPM package for licensing terms.

Copyright © 2026 jackymenCZ. All rights reserved. Written for the community.


r/cicd • • 1d ago

Sentinel-IR and Sentinel-IR MCP are open for sponsors (and yes, an AI writes most of the code)

Post image
0 Upvotes

*A 5-minute read. One maintainer, two Apache-2.0 packages, zero venture capital, a mildly embarrassing amount of honesty.*

The short version

[`sentinel-ir`](https://gitlab.com/jakubrojicek11/sentinel-ir) and [`sentinel-ir-mcp`](https://gitlab.com/jakubrojicek11/sentinel-ir-mcp) now accept sponsorship. Both READMEs have a **Sponsor** section, both repos have a GitHub Sponsor button, and `sentinel-ir` publishes a [`funding.json`](https://gitlab.com/jakubrojicek11/sentinel-ir/-/blob/main/funding.json) manifest that funds and tools can read.

What these two things are, in one paragraph each

**`sentinel-ir`** reads a source file and gives an AI agent a small fact sheet instead of the whole file: risk level, network, filesystem, process and environment calls, routes, imports and exports, and for Rust also `unsafe`, FFI, `build.rs` and proc-macro behaviour. It covers JavaScript, TypeScript, Python and Rust. It's static analysis: it never runs the code, and a "low" risk is a hint, not a safety certificate.

**`sentinel-ir-mcp`** plugs that fact sheet into Claude Desktop, Cursor, Windsurf and other MCP clients as a read-only stdio server. It only opens supported source files inside the folders you allow, refuses traversal, symlinks and hard links, has file-size, file-count and time limits, and can keep an audit log of what it read (paths and hashes, never source).

One analyzer, one shared IR, the same facts in npm, the MCP server and the [browser playground](https://sentinel-ir-playground-dc30c8.gitlab.io/). Adding a language once adds it everywhere.

The honest part

I'm Jakub, the only maintainer, and I'm not a professional developer. I decide what Sentinel should do, test it on my own machines and approve every release. **Most of the code is written by an AI coding agent working from my specs.** Every change still has to pass the test suites and CI on Linux and Windows before it ships.

Some grant programmes don't fund AI-generated work, and I'd rather lose a grant than pretend. If that's a deal-breaker for you, fair enough. If you think "one person plus an agent shipping audited, tested releases" is exactly the kind of thing worth backing, read on.

What it saves you (measured, not vibes)

Every time an agent "just takes a quick look" at a file, you pay for every token of it, comments, licence header and the 400-line date formatter included. Sentinel hands the agent the fact sheet instead. Measured on Sentinel's own source with the `o200k_base` tokenizer:

filethe whole fileSentinel's fact sheet
src/ast-facts.js8,439 tokens120 tokens
src/sentinel-ir.js2,084 tokens133 tokens
src/tree-parser.js891 tokens121 tokens
examples/basic.js150 tokens120 tokens

That's up to about 70 times less on a big file. On a tiny file it saves almost nothing, because the fact sheet has a floor of about 120 tokens, and we'd rather tell you than let you find out.

**A back-of-the-envelope example** (an illustration, not a measurement): your agents open a file the size of `ast-facts.js` 200 times a day across the team. That's about 1.7 million tokens a day you don't send. At an example price of $3 per million input tokens, that's about $5 a day, or roughly $100 a working month, for **one** file. Your repo has more than one file. Your agents are not shy.

The time part is simpler: a model that reads 120 tokens gets to the point sooner than one that reads 8,439, and its context window stays free for the work you actually asked for. It's the difference between asking a colleague "does this file touch the network?" and making them read it aloud first.

And the part that doesn't show up on an invoice: the agent sees `network: outbound` and `process: spawn` before it trusts a file, instead of discovering them three tool calls later in a `postinstall` script.

Why monthly, not one-off

A code analyzer is less like a hammer and more like antivirus definitions. The day it stops being updated, it starts going stale:

  • **Ecosystems keep inventing new doors.** A new HTTP client, a new way to spawn a process, a new Rust build crate. Each one Sentinel doesn't know about is a door the agent walks past without noticing. Version 0.4.4 alone taught it axios, got, undici, superagent and fs-extra.

  • **Languages keep coming.** JavaScript, TypeScript, Python and Rust today; Go is next. Because everything sits on one shared IR, every new language shows up in the npm package, the MCP server and the playground at once. You pay for it once and get it three times.

  • **Security work never finishes.** The MCP server reads files on your machine for an AI. Path checks, size limits and parser robustness need regular adversarial testing, not a one-time audit framed on the wall.

  • **The platforms move.** New Node versions, new MCP clients, new MCP spec revisions. Somebody has to keep `setup` and `doctor` working on Monday morning.

A one-off donation is a very kind pizza. A monthly sponsorship is the kitchen. We're grateful for pizza. The kitchen is what keeps the releases coming.

For companies the maths is short: if Sentinel saves your team even one engineer-hour a month in review time or token spend, the $5 Supporter plan paid for itself before lunch. The Development plan is less than many companies spend on coffee for the people who'd otherwise read those files.

Where the money goes

whatwhy
AI agent timeit writes the code, the tests and the release checks
CI and test machinesLinux and Windows CI on Node 20, 22 and 24, plus macOS test runs
Go supportthe next language for the shared IR
security hardeningmore adversarial tests for the parsers and the MCP path checks

The `funding.json` lists two plans: **Supporter, $5/month** (helps cover CI) and **Development, $12,000/year** (a year of agent time, test machines, Go and security work on both packages). One-time sponsorship is fine too.

Where we are today

Can't sponsor? Still helps

Thanks for reading. If Sentinel ever saves your agent from reading `/etc/passwd`, you know where the button is.


r/cicd • • 1d ago

Optimized CI, 2 mins cache to 40 seconds

Post image
0 Upvotes

r/cicd • • 1d ago

How do you handle prod promotion with Argo CD + Image Updater when CI is triggered by a git tag?

Thumbnail reddit.com
1 Upvotes

r/cicd • • 2d ago

How do companies manage staging and production environments? What's the industry best practice?

5 Upvotes

Hey everyone!

I'm trying to understand how companies typically manage staging and production environments, and what the industry best practices are.

I've mostly worked on smaller projects, but I'm now working on a project where I need to introduce a proper staging environment alongside an existing production environment. I want to make sure I'm approaching this correctly rather than creating unnecessary complexity.

A few questions I have:

  1. Repository structure: Do companies typically keep staging and production code in the same Git repository, using separate branches (e.g., main for production and staging for staging)?

  2. Separate repositories: Is it ever common to have two completely separate repositories, one for staging and another for production? If so, how are changes migrated between them?

  3. Deployment: Do both environments usually have their own deployments, servers, and domains/subdomains (e.g., staging.example.com and example.com)?

  4. CI/CD: How is the deployment process typically handled? For example, would pushing to a staging branch automatically deploy to staging, while merging into main triggers a production deployment?

  5. Promoting changes: Once a feature has been tested and approved in staging, what's the standard way to promote those exact changes to production without introducing unexpected differences?

Or am I misunderstanding the concept entirely, and is there a completely different approach that most companies follow?

I'm particularly interested in how this is handled in real-world projects, not just theoretically.

I'd appreciate any explanations, examples of actual workflows, or resources you could recommend.

Thanks in advance!


r/cicd • • 2d ago

I built ci-parity to catch GitHub Actions workflows bypassing shared build tasks

1 Upvotes

I've run into repos where task test runs go test -race -tags integration ./..., but GitHub Actions runs go test ./... directly. Someone updates the local task, and the workflow keeps its own copy of the old command.

I built ci-parity to check for this. It reads GitHub Actions workflows alongside Taskfile, Makefile, justfile and mise files without executing anything.

It flags build, test and lint commands written directly in workflow steps. When an existing task runs the exact same command, the finding points to that task. It also catches calls to tasks that have been renamed or removed, suggests the closest name, and flags calls to internal or private tasks. Unsupported steps, such as PowerShell, produce warnings.

For an existing repo, you can record a per-workflow baseline of the current findings. That lets you move commands into tasks gradually while preventing the count from growing. The baseline only shrinks. There's also ci-parity fix for steps it can safely rewrite.

Setup commands such as docker login, version checks and pinned tool installs are allowed by default.

Before tagging 1.0, I tested it against pinned commits from 10 public repos and reviewed every finding by hand. The first run had 32 false positives among 312 errors. After fixing those cases, the rerun reported 226 errors, with no false positives that I found in that set.

You can add it to a GitHub Actions job with:

- uses: actions/checkout@v7
- uses: jimmykurian/ci-parity@v1

GitHub repo

I'm interested in where other teams draw the line: which commands should go through a shared task, and which belong directly in the workflow? I'd also like feedback on whether the shrinking baseline would work for your existing pipelines.


r/cicd • • 2d ago

how are you orchestrating Playwright, Selenium and Appium suites plus AI agent tests in one pipeline?

1 Upvotes

We’ve ended up with 3 suites and 1 pipeline that pretends they’re the same thing.

Playwright covers web, Appium covers the mobile app, and there’s an old Selenium suite nobody wants to touch that still guards 2 legacy screens. then we added agent based tests for the desktop client because none of the first 3 reach it. so the pipeline is now 4 jobs, 4 report formats, and a merge step I wrote myself and do not trust.

What I want is one thing that triggers all of it and gives me a single verdict per build instead of me stapling junit xml together at the end. we tried ReportPortal to pull the results into one place, which helps with the view but still doesn't give me one pass or fail I'd gate a release on. most vendors who say orchestration mean orchestrating their own product. AskUI at least positions itself as sitting alongside the suites you already have rather than replacing them, which is the right shape, but it's still another runner producing its own report, so I'd be merging at the end either way.

for anyone running a mixed stack: are you orchestrating from the CI tool and treating each suite as a job, or is there something above it that genuinely unifies the results? and if you’ve put an agent based suite in the same pipeline, how did you deal with the runtime gap? ours takes a lot longer per step than the scripted jobs and it’s already shaping when we’re allowed to run it.


r/cicd • • 3d ago

The sixth public beta of kinhin, the mindful CI for your Mac. What is new in beta 6, what changes when you upgrade, what has been run, what has not, and where I need your help.

1 Upvotes

kinhin.dev/blog/beta-6

kinhin watches your CI queue and, for each queued job, starts a fresh VM or container on your Apple Silicon Mac, registers a one-job runner, lets it run, then deletes it. By default nothing idles and nothing is left over; the exceptions are runners you keep with min_idle and the Docker Hub cache. It is free, open source (Apache-2.0), and sends no telemetry unless you point it at your own OpenTelemetry server.

Beta 6 is a reliability release. It adds outbound alerts, fixes a kernel panic that hit a Mac running eight Tart VMs, makes sure only one engine scales a host's fleet, and fixes a demand bug on GitHub. It has no breaking change. The Buildkite, Azure Pipelines and Bitbucket Pipelines work did not make this beta and moves to beta 7. This post covers what is new, what to do when you upgrade, what has been run, and what has not.


r/cicd • • 4d ago

Trying to understand how security tooling fits into CI/CD, for a uni case study. Would love your take!

Thumbnail reddit.com
2 Upvotes

r/cicd • • 4d ago

I built a Mac app that shows what a CI change does to other branches' pipelines - before you merge

Thumbnail
reddit.com
1 Upvotes

r/cicd • • 4d ago

CALLING ALL DEVS- NEW TOOL

Post image
0 Upvotes

AI agents are getting better at writing code, but there's still a problem nobody seems to talk about enough.

Just because a task is marked complete doesn't mean the underlying issue was actually resolved.

Dependencies remain open. Root causes go unaddressed. Fixes get merged without verifying the intended outcome.

I'm curious how developers, engineering teams, DevOps, QA, and technical leads are handling this.

Are you relying on CI/CD pipelines, automated rescans, manual reviews, or something else?

I've been working on this exact problem, which led me to build Rebel Verified at Rebel Tech Labs.

The idea is straightforward:

Detect → Diagnose → Remediate → Verify → Close the loop.

Identify gaps, support remediation with human approval, and verify that the fix actually worked.

We've launched a free scanner, CLI, and GitHub Action for teams interested in integrating verification into their development workflows.

https://rebeltechlabs.io/developers

I'd genuinely love feedback from people working in engineering environments.

Where are you seeing the biggest gaps between reported completion and actual verified results?

And what are you doing to close them?


r/cicd • • 5d ago

A high cache hit rate doesn't necessarily mean faster CI

0 Upvotes

One thing that often gets missed when optimizing CI is that cache hit rate and pipeline speed aren't the same metric.

A few things worth checking before celebrating a high hit rate:

  • How much of the pipeline is actually cacheable? Queuing, checkout, dependency installation and uncached integration tests still take time.

  • Is downloading and extracting a cached output cheaper than running that task again? Large artifacts can make this a bad tradeoff.

  • Are the hits on the critical path? Saving five minutes of work across parallel jobs might barely change the PR completion time.

A useful comparison is the same commit on equivalent clean runners, with and without a warm remote task cache. Keep runner size and parallelism consistent. Record elapsed time, transferred bytes, cache misses and actual billed minutes. Affected-project execution is also worth enabling before adding another cache layer.

Disclosure: we build Cachely, a managed remote build cache. We think measuring the real effect matters more than impressive-looking hit percentages.

What metrics does your team use to decide whether caching is actually paying off?


r/cicd • • 6d ago

Does a bigger macOS runner pay off for iOS CI? We timed 12 build and test steps on 10 Apple silicon machine types

Thumbnail
benchmarks.bitrise.io
2 Upvotes

r/cicd • • 7d ago

Which certificate should I choose?

Thumbnail reddit.com
1 Upvotes

r/cicd • • 7d ago

CBP - A release-evidence gate that verifies your green CI actually means something

Thumbnail
github.com
1 Upvotes

r/cicd • • 7d ago

Open-source Test Impact Analysis for Java/Maven CI: Cut test runs by 61.4% across 800 Apache commits without missing regressions

1 Upvotes

Commercial predictive test selection tools (Gradle Develocity, Launchable, etc.) work well, but they come with SaaS lock-in and rarely publish reproducible safety numbers.

I built an open-source Apache-2.0 Maven/Gradle plugin (blastradius) to get dependency-based test selection in standard CI pipelines (GitHub Actions, GitLab CI, Jenkins) using only existing CI caches or S3.

How it fits into a CI pipeline:

  • main branch (TRACK): Runs the full JUnit 5 suite with a lightweight Java agent that records which classes each test touches, saving the map to .blastradius/ (cached via actions/cache or an S3 bucket).

  • PR branches (SELECT): Restores the main index, diffs against the Git merge base, and passes only affected tests to Surefire/Failsafe via -Dtest=—no custom test runners, and no conflicts with JaCoCo.

  • Safety guardrails: New/modified tests, non-source changes, or missing cache snapshots automatically fall back to running the full suite.

800-Commit Historical Replay + Mutation Benchmarks:
I replayed 200 consecutive commits each across four open-source repos with synthetic fault injection enabled:

  • apache/shenyu: 71.0% tests skipped (0 missed regressions)

  • apache/commons-io: 62.7% tests skipped (0 missed regressions)

  • apache/httpcomponents-client: 59.4% tests skipped (0 missed regressions)

  • jhy/jsoup: 45.0% tests skipped (0 missed regressions)

Caveat: Reflection and deep string-dispatched DSLs can still hide dependencies, so the intended trust model is PR selection backed by a scheduled daily full-suite run.

Are you using test selection or test splitting in your CI pipelines right now, and how do you balance faster PR feedback against escaped regressions?


r/cicd • • 10d ago

What's the strangest "passes locally, fails only in CI" bug you've tracked down?

9 Upvotes

I’ve been collecting the usual suspects for CI-only failures. Most of the time it turns out CI isn't the problem, it's something my local machine was quietly giving the test for free:

- Speed: the CI runner is slower, so any check that doesn't wait or retry (isVisible(), reading text straight after a click) passes locally and fails there.
- Leftover state: locally I'm already logged in or the test data already exists. CI starts clean.
- Environment: a .env that only exists on my machine, or the runner being on UTC so date assertions break.
- Parallel workers: tests that pass alone but fight over the same data when run together.

My rule now is to open the trace from the failed CI run before touching retries. It usually points at one of these within a few minutes.

What am I missing? Curious about the weird ones: fonts, screen size, locale, DNS, anything.