agentleFS
Destynova2Destynova2/cli-code-skills/cli-forge-pipeline/SKILL.md

cli-forge-pipeline

Skill5 starsChanged 8 months agoMITView on GitHub

Expert CI/CD pipeline optimizer using biomimetic patterns from nature: leafcutter ants (task partitioning), slime mold (adaptive path optimization), army ants (self-organizing parallelism), honeybees (dynamic resource allocation), and mycelium (fault-tolerant routing). Works with any CI system — examples cover both GitLab CI and GitHub Actions. Use this skill whenever the user asks to optimize, design, review, speed up, parallelize, or fix a CI/CD pipeline. Also triggers on: "slow pipeline", "flaky tests", "runners", "artifacts", "CI cache", "parallel build", "GitLab CI", "GitHub Actions", "pipeline design", "reduce build time", DAG pipelines, job dependencies, or any request mixing infrastructure + automation + deployment. Use it even when the user just pastes a YAML pipeline without asking explicitly.

1 other project uses a version of this, 1 of them edited.

Adopted by

Most recently taken up by

The file

We split this skill into the rules it gives an agent

7 rules. About 0 are common, 3 are distinctive, and 4 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈3

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 4

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Read references/patterns.md for detailed explanations, biology, and dual GitLab/GitHub examples.

    line 39
  2. Very specific:

    If the floating major tag doesn't exist, pin to the latest patch version (e.g.

    line 92
  3. Distinctive:

    Never assume a major tag exists just because patch tags do.

    line 93
  4. Very specific:

    Read ../gotchas.md before producing output to avoid known mistakes.

    line 99
  5. Very specific:

    Read references/scoring.md for detailed scoring criteria and scorecard template.

    line 133
  6. Distinctive:

    Before merging a pipeline change, imagine the failures:

    line 159
  7. Distinctive:

    If > 2 mutations pass silently, the pipeline has holes.

    line 186

≈ “Common” is an estimate: at least 1 in 5 of the 350,495 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Optimization: This skill uses on-demand loading. Heavy content lives in references/ and is loaded only when needed.

Language rule: Skill instructions are written in English. When generating user-facing output (reports, files, documentation), detect the project's primary language (from README, comments, docs, commit messages) and produce the output in that language. If the project is bilingual, ask the user which language to use before proceeding.

CI Pipeline Optimizer — Biomimetic

"The leafcutter ant colony has no project manager. Yet it optimally relocates 15% of all tropical vegetation."

The 9 biological models → CI patterns

Read references/patterns.md for detailed explanations, biology, and dual GitLab/GitHub examples.

#OrganismCI PatternKey principle
1Leafcutter ants (Atta)Stage Specialization + Artifact CacheEach job = one role. Artifacts = stigmergy
2Slime mold (Physarum)Change-Driven Path Selection + Cache ReinforcementOnly rerun what changed. Content-hashed cache
3Army ants (Eciton)Fan-out / Fan-in + Ephemeral RunnersMaximum parallelism, disposable runners
4Honeybees (Apis)Autoscaling + Priority-based Runner TaggingResources proportional to load
5MyceliumMulti-Registry Fallback + Distributed CacheZero SPOF, waterfall cache
6MitosisWorkflow FissionPipeline too big → split into independent workflows (S/M/L/XL semantics canonical in ../shared/tiering.md)
7Immune system (VDJ)Combinatorial Fuzzing + Property-Based TestingExplore the input space, not just the known cases
8Fungal sporesFull Combinatorial MatrixOS × arch × version × features, fail-fast: false
9TardigradeChaos Engineering / Fault InjectionInject failures to prove survival

Workflow for analyzing an existing pipeline

Step 1 — Map the real DAG

Draw the actual dependencies. Identify sequential jobs that could run in parallel. Compute the critical path.

Step 2 — Leafcutter audit

Does each job do ONE thing? Are artifacts properly defined (stigmergy)? Are there generalist jobs that should be split?

Step 3 — Slime mold audit (Physarum)

Are there jobs running without any relevant change? Are cache keys based on content? Are retries selective? Content-hashed keys and reproducibility are shared in ../shared/determinism.md. CI stages map onto the shared T0-T4 rungs (../shared/gate-ladder.md): the release gate fails at the lowest red rung.

Step 4 — Army ants audit

Which slow jobs can be fanned out in parallel? Are runners ephemeral? Are fan-ins happening too early?

Step 5 — Honeybee audit

Are runners sized for the right profile? Is scale-to-zero enabled? Do critical jobs have dedicated runners?

Step 6 — Mycelium audit

Are there SPOFs (registry, cache, single runner)? Does the cache have a waterfall fallback? Do multi-project pipelines share expensive artifacts?

Step 7 — Immune system audit

Is there fuzzing on parsers, serialization, auth? Do tests use property-based testing? Is the crash corpus persisted across runs?

Step 8 — Spore audit

Does the matrix cover OS × arch × version × features? Are nightly/beta combinations marked allow_failure? Are impossible combinations excluded?

Step 9 — Tardigrade audit

Are there tests under degraded network conditions? Tests under resource pressure? Tests with clock skew? Is graceful degradation verified?


Mandatory rules

GitHub Action version verification

Before recommending a version bump for a GitHub Action (e.g. @v3 → @v4), verify that the target tag actually exists:

  1. Floating major tags (@v4) are a convention, not a requirement. Some maintainers don't create them.
  2. Always verify via gh api repos/{owner}/{repo}/git/refs/tags/{tag} that the exact tag exists.
  3. If the floating major tag doesn't exist, pin to the latest patch version (e.g. @v4.1.1).
  4. Never assume a major tag exists just because patch tags do.

Reference incident: bumping cosign-installer@v3 → @v4 broke CI because the v4 tag didn't exist (2026-03-27).

Gotchas

Read ../gotchas.md before producing output to avoid known mistakes.


Anti-patterns to identify

Anti-patternBroken biologyGitLab fixGitHub Actions fix
Sequential jobs with no real dependencyGeneralist antDirect needs: DAGneeds: between jobs
Cache key = branch or dateSlime mold with no memorykey: files: [Cargo.lock]key: rust-${{ hashFiles('Cargo.lock') }}
Retry on everythingSlime mold retracing wrong pathswhen: [runner_system_failure]nick-fields/retry with retry_on: error
Full rebuild on minor changeSlime mold with no pruningrules: changes:on.push.paths or dorny/paths-filter
Single runner for everythingNo caste divisiontags: + autoscalerRunner labels + larger runners
Registry without fallbackMycelium without redundancycmd1 || cmd2 || cmd3same
Huge artifacts passed everywhereForager carrying everything to everyoneScoped artifacts, selective needs:Named artifacts + selective download-artifact
Non-sharded testsArmy ants with no flanksparallel: N + shardingstrategy.matrix + sharding
Tests only on hand-written casesImmune system with no VDJcargo fuzz + proptestsame
Single OS/version combinationSingle spore, no dispersalparallel: matrix:Combinatorial strategy.matrix
No tests under degraded conditionsSedentary tardigradeToxiproxy + stress-ng + faketimesame

Success metrics

  • Critical path: < 50% of the theoretical sequential total time
  • Cache hit rate: > 80% on dependencies
  • Runner utilization: > 70%
  • Flaky test rate: < 1%
  • SPOF count: 0

Pipeline Scoring (15 dimensions)

Read references/scoring.md for detailed scoring criteria and scorecard template.

#Dimension04
D1DAGAll sequentialDAG + dynamic pruning
D2CacheNoneCross-pipeline + GC
D3Parallelism1 runnerAuto-scale + spot
D4ResilienceNo retryMulti-provider + self-healing
D5Feedback> 15 min< 2 min (smoke)
D6PruningRebuild everythingPredictive skip
D7ArtifactsEverything sharedContent-addressed
D8SecurityNo scanSBOM + signing
D9ObservabilityRaw logsAnomaly detection
D10Mitosis1 mega-pipelineEvent-driven mesh
D11CostNo measurementFinOps optimized
D12DXManual configGitOps + preview envs
D13FuzzingNonePersistent corpus + regression
D14Matrix1 envFull combinatorial + nightly
D15ChaosNoneChaos Monkey in prod + observability

Target score: > 45/60 (75%) for a production project.


Pipeline Pre-Mortem

Before merging a pipeline change, imagine the failures:

  1. Poisoned cache (malicious artifact)
  2. Compromised runner (secret leak)
  3. Registry down (no fallback)
  4. Flaky job retry-masked for 3 months
  5. Cache miss → 45-minute pipeline
  6. Cross-workflow dependency silently broken
  7. DAG dependency diamond (C fails silently)

For each scenario: what mitigation ALREADY exists? If none → accepted risk, document it.


Pipeline Mutation Testing

The mutation set + scorecard threshold is this skill's post-verification gate; the 3-phase definition-of-done structure (pre → during → post) is canonical in ../shared/done-gate.md.

MutationExpectedIf it passes = bug
Remove a needs:Job runs too earlyDAG misconfigured
Cache key always-hitPoisoned cache detectedNo validation
Remove paths: filterEverything rebuilds (slow)OK (conservative)
continue-on-error: true everywhereRelease despite failureMissing gate
Remove security scanRelease without scanNo security gate
Double timeout-minutesSlow job not detectedNo duration alert

If > 2 mutations pass silently, the pipeline has holes.


Reference templates

  • references/patterns.md — The 9 biological models in detail with GitLab + GitHub Actions examples
  • references/scoring.md — Detailed 15-dimension scoring + scorecard
  • references/gitlab-ci-biomimic.yml — Complete GitLab pipeline
  • references/github-actions-biomimic.yml — Complete GitHub Actions pipeline
  • references/runner-autoscaler.toml — GitLab Runner autoscaler config (honeybees)
  • references/cache-strategy.md — Advanced cache strategies (slime mold + mycelium)

Dynamic Handoffs

Condition detectedRecommendWhy
Shell scripts used as pipeline entrypoints/cli-audit-shellAudit the scripts
Tests referenced in CI but not audited/cli-audit-testTest strategy audit
Pipeline builds containers/cli-forge-infraContainer/image audit
Pipeline has > 10 jobs with complex dependencies/cli-audit-tangleCI dependency topology
Pipeline lacks a perf budget gate, or A/B benches are not reproducible/cli-forge-perfNative bench protocol (Criterion/benchstat/hyperfine) + content-hashed cache → reproducible perf gate
Jobs rebuild far more than the change (image layers or caches invalidated on every run)/cli-audit-hanoiOrdering/layering audit of build steps and image stacks

Rule: Recommend, don't auto-execute.

Integration with other cli-* skills

SkillRelationship
cli-audit-testD13 covers drift detection within tests. cli-forge-pipeline covers the CI that executes those tests
cli-audit-codeAudits code quality. cli-forge-pipeline audits pipeline quality
cli-forge-perfPipeline is the natural home of the perf gate: content-hashed cache (../shared/determinism.md) makes baselines reproducible; A/B bench jobs run on every PR; lowest red rung of ../shared/gate-ladder.md includes T4 perf stress
cli-cycleCalls cli-forge-pipeline as part of the full review

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.