How to Create a Jenkins Pipeline Using Claude

In short: a Jenkins pipeline runs your build and tests by itself every time you push code. Claude is an AI assistant that can write the pipeline file for you. You check it, paste it, and run it.

Why use a pipeline (and why let Claude help)

Doing build and test by hand is slow and easy to forget. A pipeline does the same steps the same way every time. That means fewer mistakes and faster releases.

Writing the pipeline file can feel scary for a beginner. Claude turns your plain words into the correct file. You still read it and stay in control — Claude helps, you decide.

What these words mean

• Jenkins: a free, open-source tool that runs your build and test steps automatically. It is called a CI/CD server.
• CI/CD: Continuous Integration / Continuous Delivery. Simple meaning: every code change is built, tested, and made ready to ship, automatically.
• Pipeline: the list of steps Jenkins runs in order, for example: get code → build → test → deploy.
• Jenkinsfile: a text file in your project that describes the pipeline. Jenkins reads it.
• Stage: one named part of the pipeline, like "Build" or "Test".
• Claude: an AI assistant. You type a request; it writes code or text back.

The pipeline, top to bottom

Here is the flow you will build. The dot moves down to show the order the stages run.

Setup — install Jenkins

Pick one way. The Docker way is fastest for practice.

# run Jenkins in one container; opens on http://localhost:8080
docker run --name jenkins -p 8080:8080 -p 50000:50000 \
  -v jenkins_home:/var/jenkins_home \
  jenkins/jenkins:lts

sudo apt-get update
sudo apt-get install -y openjdk-17-jre   # Jenkins needs Java
curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key \
  | sudo tee /usr/share/keyrings/jenkins-keyring.asc >/dev/null
echo "deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \
  https://pkg.jenkins.io/debian-stable binary/" \
  | sudo tee /etc/apt/sources.list.d/jenkins.list
sudo apt-get update && sudo apt-get install -y jenkins
sudo systemctl enable --now jenkins   # start now and on boot

docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword
# or on Ubuntu:
sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Settings you need (one time)

1. Install the Pipeline plugin. Go to Manage Jenkins → Plugins → Available, search "Pipeline", install. (The suggested plugins already include it.)
2. Add Git. On the Jenkins server, make sure git is installed so Jenkins can fetch your code.
3. Add credentials. Go to Manage Jenkins → Credentials → System → Global → Add Credentials. Add your Git token or deploy key here. Never type secrets inside the Jenkinsfile.
4. Point to your repo. You will create a "Pipeline" job and give it your Git URL in the next section.

How to build it with Claude

1. Open Claude (the chat app, or the Claude extension in VS Code).
2. Describe your project in plain English. Say the language, the build tool, and the test command. Use the prompt below.
3. Read what Claude writes. Check the stages make sense and no secret is hard-coded.
4. Save the file as Jenkinsfile in the root of your project, then push it to Git.
5. Create the job in Jenkins: New Item → Pipeline → name it → Pipeline from SCM → Git → paste your repo URL. Set Script Path to Jenkinsfile. Save.
6. Click "Build Now". Watch the stages turn green. If one is red, open its log and go to the fix step below.

The prompt to give Claude

Worked examples (simplest first)

Example 1 — the smallest pipeline

Start here to prove Jenkins works. It just prints a message.

pipeline {
  agent any
  stages {
    stage('Say hello') {
      steps {
        echo 'Hello from my first pipeline!'
      }
    }
  }
}

Create a Pipeline job, paste this in the box (or in a Jenkinsfile), click Build Now. You should see one green stage.

Example 2 — build and test a Node.js app

Now do real work: install packages and run tests.

pipeline {
  agent any
  stages {
    stage('Checkout') {
      steps { checkout scm }      // get the code from Git
    }
    stage('Build') {
      steps { sh 'npm ci' }       // clean install of packages
    }
    stage('Test') {
      steps { sh 'npm test' }     // run automatic tests
    }
  }
}

Example 3 — full pipeline with deploy and a secret (the real one)

This is the complete, working file Claude gives for the prompt above. Deploy runs only on main, and the secret comes from Jenkins credentials, not from the file.

pipeline {
  agent any

  // read a stored secret by its credential id; never write the real value here
  environment {
    DEPLOY_TOKEN = credentials('deploy-token')
  }

  options {
    timestamps()                 // add time to every log line
    timeout(time: 20, unit: 'MINUTES')
  }

  stages {
    stage('Checkout') {
      steps { checkout scm }
    }
    stage('Build') {
      steps { sh 'npm ci' }
    }
    stage('Test') {
      steps { sh 'npm test' }
    }
    stage('Deploy') {
      when { branch 'main' }     // only deploy from the main branch
      steps {
        sh 'npm run deploy'      // this script uses $DEPLOY_TOKEN
      }
    }
  }

  post {
    success { echo 'Pipeline passed. Build is ready.' }
    failure { echo 'Pipeline failed. Open the red stage log.' }
  }
}

When a stage turns red — ask Claude to fix it

Which pipeline style should you pick?

Jenkins has more than one way to write jobs. For almost everyone, use Declarative.

Rule of thumb: ask Claude for a Declarative Jenkinsfile unless you have a special reason.

Quick quiz

Save tokens and money

Every word you send and get back costs tokens (small pieces of text). Fewer tokens means lower cost and faster answers. Here is how to stay cheap while building pipelines.

1. Ask for one thing. "Write a declarative Jenkinsfile for a Node app" beats a long story. A clear, short ask gives a shorter, better answer.
2. Paste only what matters. For a failed stage, send the last 20 log lines, not the whole log. Share placeholders like deploy-token, never real secrets.
3. Start a new chat per task. Long chats resend old text every time, so tokens add up fast. A fresh chat keeps the context short and cheap.
4. Use a smaller model for easy jobs. A light model is fine for a hello pipeline; save the strong model for tricky fixes.
5. Practise with a local model. Run Ollama on your own machine for endless free tries, then use a paid or free-tier API only for the final check.

Save these cards

Three cards to revise fast (same style as the Excel and cyber cards).