Developers don’t want to spend their time writing CI configuration, debugging flaky pipelines, or digging through logs to understand why a build failed.

They want to ship software.

That’s the idea behind sem-ai – Semaphore’s approach to building an AI-native CI experience where developers interact with CI/CD using natural language, directly from the tools they already use.

In our latest product update, we demonstrated what this looks like in practice: going from an empty repository to a fully working CI pipeline using Claude Code and sem-ai, without requiring any prior Semaphore knowledge.

And now, you can watch the full walkthrough and live demo here:

This is part of a broader direction for Semaphore in 2026: extending CI/CD with AI-powered automation that reduces developer toil while keeping developers fully in control.

Going from Zero to CI with Natural Language

In the demo, Marcos started with a fork of the GorillaMux repository after removing all existing CI configuration and GitHub Actions workflows.

Using the new sem-ai slash commands inside Claude Code, he initialized a complete Semaphore project with a single command:

/sem-ai:init

The initialization flow analyzes the repository, detects the technology stack, and proposes a tailored CI setup based on best practices.

For the Golang project in the demo, sem-ai automatically suggested:

• Golang CI linting
• Security scanning with gosec
• Matrix testing across multiple Go versions
• A recommended CI topology for the repository

Instead of manually learning Semaphore YAML, developers describe intent and review generated configuration.

This is exactly the onboarding experience we believe modern CI/CD platforms should provide:

Developers should not need to learn how to configure CI/CD systems before they can start shipping software.

Why Slash Commands Matter for AI Workflows

One of the most interesting insights from the week came from Nick, who worked on sem-ai’s onboarding and agent workflows.

Initially, the team experimented with “skills” alone — giving AI coding agents contextual information about Semaphore and hoping they would discover the right workflows automatically.

In practice, the results were inconsistent.

Agents sometimes failed to recognize Semaphore-specific concepts or didn’t know which tools to use. Success depended heavily on prompt quality.

That changed with the introduction of dedicated sem-ai slash commands.

Instead of relying purely on inference, slash commands provide a predictable interface between developers, agents, and Semaphore workflows.

The result is a much more reliable experience for agentic development.

Embedding CI/CD Best Practices into Agents

A major focus last week was improving the contextual “skills” that guide agents during CI/CD workflows.

The team expanded sem-ai understanding of:

• Semaphore pipeline structure
• Caching workflows
• Artifact management
• Test reports
• Failure diagnostics
• Pipeline optimization strategies

For example, when debugging failed jobs, agents now prioritize structured test reports instead of raw logs whenever available.

This seemingly small improvement dramatically increases the quality of automated debugging and resolution.

As Marko explained during the update:

High-quality skills with focused context dramatically improve success rates.

The result is a significantly better developer experience — one where best practices are embedded directly into the workflow instead of requiring developers to memorize them.

Self-Healing Pipelines

After sem-ai generated the initial pipeline, Marcos instructed the agent to:

“Work until the pipeline is green.”

The agent monitored pipeline execution, identified failures, applied fixes, and iterated until the build passed successfully.

Once the pipeline was green, sem-ai summarized all changes it had made and even proposed additional optimizations to improve pipeline topology and execution speed.

This is an important distinction in how we think about AI inside Semaphore.

Agents are not replacing developers.

They are automating repetitive operational work inside CI/CD workflows while developers remain in control of what gets applied and shipped.

That principle is central to Semaphore’s product strategy:

• Developers define intent
• Automation executes repetitive work
• Developers stay in control of outcomes

AI-Native CI/CD Built Around Developer Workflows

What we’re building with sem-ai is not “AI bolted onto CI.”

We believe CI/CD should evolve into a control plane for developer intent — where developers and agents collaborate directly inside the tools they already use.

That means:

• Creating CI pipelines using natural language
• Automatically diagnosing failed builds
• Optimizing workflows continuously
• Embedding organizational best practices into agents
• Running AI-driven workflows safely on Semaphore infrastructure

Over time, this becomes much bigger than onboarding.

It becomes a new interface for CI/CD itself.

Watch the Full Demo

The video includes:

• A live walkthrough of sem-ai initialization
• Setting up CI/CD from scratch using natural language
• Agent-driven pipeline fixes
• Pipeline optimization examples
• Insights into how sem-ai skills and slash commands evolved internally

If you want to see what AI-native CI/CD looks like in practice, check out the full video:

What’s Next

This update focused on onboarding and pipeline setup, but the next phase is even more exciting.

We’re continuing to expand sem-ai’s capabilities around:

• Pipeline optimization
• Failure analysis
• Workflow discovery
• Test automation
• Agent-driven development workflows

The long-term goal is simple: help developers spend less time on repetitive CI/CD work and more time building software.