Ansible with ChatGPT: How to Create, Review, and Optimize Playbooks with AI

Configuring servers, installing software, managing users, or rolling out security updates: Ansible lets you automate a huge range of IT administration tasks. But once playbooks get more complex, things can get messy fast. YAML indentation, module parameters, dependencies, and differences between Linux distributions can cost even experienced administrators real time.

This is where ChatGPT comes in. Instead of writing every playbook entirely by hand, you can use ChatGPT as a technical assistant. The AI helps draft playbooks, analyze existing code, make sense of error messages, and keep automations maintainable. I describe how I use ChatGPT for everyday server administration in general in How I Use ChatGPT for Linux Administration (Read article).

One thing matters here: ChatGPT replaces neither Ansible nor a safe test environment. The AI can produce configurations that look plausible but are actually wrong. Only validation and controlled testing turn a suggestion into a reliable automation.

In this practical guide, I walk you step by step through combining Ansible and ChatGPT sensibly — with working examples, ready-to-use prompts, and concrete security measures.

State of this article: October 20, 2026.

1. What is Ansible, and why combine it with ChatGPT?

Ansible is an open-source tool for automating IT infrastructure. It lets administrators bring systems into a desired state through declarative configuration files.

Typical use cases include:

• Installing and configuring software
• Managing Linux servers
• Setting up web servers and databases
• User and permission management
• Security configuration and updates
• Provisioning entire server environments

Automation instructions are described in so-called playbooks, which are mostly written in YAML. ChatGPT can help with creating and developing these playbooks further.

Division of labor between Ansible and ChatGPT

Task	Ansible	ChatGPT
Configure servers	Executes changes	Drafts configuration suggestions
Review YAML	Syntax and module checks	Analyzes structure and logic
Fix errors	Provides runtime information	Explains likely causes
Security	Enforces defined rules	Spots potential risks
Optimization	Runs tasks	Suggests improvements
Documentation	Provides metadata	Writes understandable explanations

The real strength comes from combining both: ChatGPT supports thinking and development, Ansible handles the controlled execution.

2. Prerequisites: what do you need?

A small Linux test environment is enough for the examples below. Recommended:

• A Linux system with Python 3 and Ansible
• One or more Linux test servers
• SSH access to the target systems
• A user with suitable administrative permissions
• Access to ChatGPT
• Optional: Git, VS Code, and ansible-lint

As an example, we'll use an Ansible control node running Ubuntu 24.04 and a managed Ubuntu server.

Installing Ansible

On Ubuntu, you can first install Ansible via the package manager:

sudo apt update
sudo apt install ansible -y

Then verify the installation:

ansible --version

For reproducible projects, an isolated Python environment with pinned versions of ansible-core and the required collections is recommended.

Creating a simple inventory

Create the file inventory.ini:

[webserver]
web01 ansible_host=192.168.10.20

[webserver:vars]
ansible_user=admin

The IP address and username are examples and need to be adjusted. Test the connection with:

ansible -i inventory.ini webserver -m ping

The Ansible ping module checks connectivity and whether Python is usable on the target system. It is not a regular ICMP ping. Once the connection works, you can create your first playbook.

3. Creating your first Ansible playbook with ChatGPT

Say you want to install Nginx on several Ubuntu servers, enable the service, and make sure it starts automatically at boot. You could write the playbook yourself. Or you could have ChatGPT draft a first version.

ChatGPT prompt: Nginx playbook

Create an idempotent Ansible playbook for Ubuntu 24.04 that installs Nginx via apt, enables the service, and starts it. Use fully qualified module names, become: true, and descriptive task names. Output only valid YAML, then explain possible risks.

A possible result:

---
- name: Install Nginx on Ubuntu
  hosts: webserver
  become: true

  tasks:
    - name: Install Nginx
      ansible.builtin.apt:
        name: nginx
        state: present
        update_cache: true
        cache_valid_time: 3600

    - name: Enable and start Nginx
      ansible.builtin.service:
        name: nginx
        enabled: true
        state: started

Save the code as nginx.yml.

What does this playbook do? It runs two tasks: it installs Nginx via the APT package manager, and it makes sure the service is started and enabled to launch automatically at boot. The property state: present ensures the package exists without forcing a reinstall on every run. That's an example of idempotency, one of the most important concepts in Ansible.

Running the playbook

Before actually running it, do a syntax check first:

ansible-playbook -i inventory.ini nginx.yml --syntax-check

Then you can do a check-mode run:

ansible-playbook -i inventory.ini nginx.yml --check --diff

Note: check mode only simulates changes to the extent each module supports it. It is not a substitute for a full integration test. Only after that comes the actual run:

ansible-playbook -i inventory.ini nginx.yml

4. Reviewing existing Ansible playbooks with ChatGPT

Not every playbook is written from scratch. Organizations often have automations that have grown over years. Typical issues include outdated modules, unnecessary shell commands, hardcoded credentials, missing error handling, or hard-to-understand task structures. ChatGPT can spot these kinds of issues.

Example: a problematic playbook

---
- hosts: all
  become: yes

  tasks:
    - name: Install packages
      shell: apt-get install nginx -y

    - name: Restart nginx
      shell: systemctl restart nginx

This example isn't automatically broken in every environment, but it has several weaknesses: the installation uses a shell command instead of Ansible's package module, and Nginx gets restarted on every run regardless of whether anything actually changed.

ChatGPT prompt: playbook audit

Analyze the following Ansible playbook for YAML syntax, idempotency, security risks, outdated modules, unnecessary shell commands, missing error handling, and maintainability. First produce a prioritized list of issues, then an improved version. Explain every change. Don't make unfounded assumptions about my infrastructure.

The AI should pay particular attention to the following:

Review areas for an Ansible playbook audit

Area	Typical problem	Improvement
Idempotency	Tasks change something on every run	State-based modules
Security	Plaintext credentials	Ansible Vault
Modules	shell instead of apt	Matching Ansible module
Maintainability	Unclear task names	Descriptive names
Service management	Restart on every run	Handlers triggered by changes
Target systems	hosts: all with no limit	Precise host groups

Important: ChatGPT can support a static review, but it can't reliably judge the actual system state or the full runtime effect purely from the YAML code alone.

5. Improving Ansible playbooks with handlers

One important optimization is restarting services only when a relevant configuration has actually changed. Ansible offers so-called handlers for this. A practical example:

---
- name: Manage Nginx
  hosts: webserver
  become: true

  tasks:
    - name: Install Nginx
      ansible.builtin.apt:
        name: nginx
        state: present

    - name: Deploy Nginx configuration
      ansible.builtin.template:
        src: templates/nginx.conf.j2
        dest: /etc/nginx/nginx.conf
        owner: root
        group: root
        mode: "0644"
        validate: "nginx -t -c %s"
      notify: Reload Nginx

  handlers:
    - name: Reload Nginx
      ansible.builtin.service:
        name: nginx
        state: reloaded

Here, the handler only fires if the template actually causes a change. That reduces unnecessary service actions and improves the repeatability of the automation.

Note: This example assumes an existing, valid template templates/nginx.conf.j2 and Nginx already installed. Validating with nginx -t makes sense, but depending on included configuration files it may need extra adjustments.

6. Analyzing Ansible errors with ChatGPT

ChatGPT becomes especially useful when a playbook doesn't behave as expected. Ansible often produces lengthy error messages that can be hard for beginners to interpret at first. An example:

fatal: [web01]: FAILED! => {
  "changed": false,
  "msg": "Failed to lock apt for exclusive operation"
}

A likely cause is that another process is currently using the package manager. Instead of immediately killing processes or deleting lock files, you should first find out which process holds the lock. I show a general, structured way to work through log messages and error output on Linux servers in Analyze Linux Logs with ChatGPT: syslog, auth.log, and journalctl (Read article).

A good analysis prompt

Analyze this Ansible error message. Name the most likely causes, clearly separate confirmed facts from assumptions, and give me a safe diagnostic order. Don't suggest any destructive commands. Only show possible fixes to the playbook after the root-cause analysis.

One possible improvement is using the lock_timeout parameter:

- name: Install Nginx
  ansible.builtin.apt:
    name: nginx
    state: present
    lock_timeout: 120

That makes the APT module wait up to 120 seconds for the package manager lock instead of giving up immediately. It won't fix every cause of an APT problem, but it can help with temporary locks.

Additional information for the AI

For ChatGPT to analyze errors usefully, try to provide: the Ansible version, the target server's operating system, the affected task, a cleaned-up error message, and the relevant configuration sections.

Security rule: Before uploading anything, remove all passwords, tokens, private keys, internal hostnames, and other confidential data that isn't strictly necessary for the diagnosis.

7. ansible-lint: automatically checking AI suggestions

ChatGPT can catch errors, but it shouldn't be your only check. ansible-lint is a tool that analyzes Ansible playbooks and roles against an established rule set. Among other things, it detects problematic module usage, style issues, and certain error-prone constructs.

Installing ansible-lint

Inside a Python virtual environment:

python3 -m venv .venv
source .venv/bin/activate

python -m pip install ansible-lint

Then you can check your playbook:

ansible-lint nginx.yml

For a more thorough check:

ansible-lint --profile production nginx.yml

You can check whether a given profile is available in your installed version with:

ansible-lint --list-profiles

Combining ChatGPT and ansible-lint

A sensible workflow looks like this:

1. Define requirements: Linux version, desired state, security requirements
2. ChatGPT drafts the playbook: YAML code plus a technical explanation
3. ansible-lint and syntax check: automated quality control
4. ChatGPT reviews the results: fix issues and improve the code
5. Test environment and sign-off: check mode, integration test, code review
6. Controlled deployment: Git versioning, monitoring, rollback plan

This flow can also be automated in a CI/CD pipeline — for example alongside a scheduled Ansible run triggered by a cron job. I describe how to set up these kinds of recurring automations, review their logs, and get notified automatically on failure in Create Cron Jobs with ChatGPT and Analyze Errors Automatically (Read article).

8. Ansible Vault: managing credentials securely

One of the biggest risks with AI-generated playbooks is mishandling credentials. The following example should never end up in a Git repository or unprotected in an AI chat:

db_password: "MySecretPassword123"

Instead, Ansible's Vault lets you store sensitive variables encrypted.

Creating an encrypted variable file

ansible-vault create group_vars/all/vault.yml

The file could, for example, contain this variable:

vault_db_password: "EXAMPLE_PASSWORD"

Once saved, it's stored encrypted. In a playbook, the variable can be used like this:

- name: Use database password
  ansible.builtin.debug:
    msg: "The password is configured"
  no_log: true

For actual use, the encrypted variable is referenced with something like {{ vault_db_password }}. The debug task shown here deliberately doesn't print a password. You can run a playbook with Vault access like this:

ansible-playbook -i inventory.ini site.yml --ask-vault-pass

Vault protects secrets at rest. It doesn't replace access controls, secure key management, or checking log output. Importantly, --diff can also expose sensitive content. For tasks involving secrets, use protections like no_log: true and, where appropriate, diff: false. I go into much more depth on protecting secrets and API keys in AI agents in general in Protect API Keys in AI Agents: .env, Vault, and Permissions (Read article).

9. Structuring larger Ansible projects with ChatGPT

A single playbook with five tasks is quick to write. It gets harder once you're managing multiple server groups, different operating systems, and a growing number of services. That's when Ansible roles are worth using. A possible project structure:

ansible-project/
├── ansible.cfg
├── inventory/
│   ├── staging.ini
│   └── production.ini
├── group_vars/
│   └── all/
│       └── vault.yml
├── playbooks/
│   └── site.yml
├── roles/
│   └── nginx/
│       ├── defaults/
│       │   └── main.yml
│       ├── handlers/
│       │   └── main.yml
│       ├── tasks/
│       │   └── main.yml
│       └── templates/
│           └── nginx.conf.j2
└── requirements.yml

ChatGPT can help split a large playbook into smaller roles and organize variables cleanly.

ChatGPT prompt: creating Ansible roles

Refactor my existing Ansible playbook into a maintainable role structure. Separate tasks, handlers, defaults, and templates. Preserve existing behavior, identify possible side effects, and provide every needed file with full paths. Consider idempotency, security, and ansible-lint.

For larger projects, it helps to have the AI propose a structure first and then review each role individually. That makes changes easier to follow and reduces the risk of unintended side effects. The same caution applies generally to AI coding agents that modify files automatically: I describe how to use Codex safely with Git, a sandbox, backups, and approvals in Use Codex Safely: Setting Up Git, Sandbox, Backups, and Approvals (Read article).

10. Practical example: preparing Linux security updates with Ansible

Another common use case is installing security updates. A simple Ubuntu playbook might look like this:

---
- name: Update Ubuntu packages
  hosts: ubuntu_servers
  become: true
  serial: 1

  tasks:
    - name: Update package lists
      ansible.builtin.apt:
        update_cache: true
        cache_valid_time: 3600

    - name: Upgrade installed packages
      ansible.builtin.apt:
        upgrade: safe
        lock_timeout: 120

    - name: Check whether a reboot is needed
      ansible.builtin.stat:
        path: /var/run/reboot-required
      register: reboot_required

    - name: Show reboot requirement
      ansible.builtin.debug:
        msg: "Reboot required"
      when: reboot_required.stat.exists

This playbook updates installed packages, works through the hosts one at a time, and reports whether Ubuntu requires a reboot. It deliberately doesn't perform an automatic reboot. Production environments still need further safeguards, such as defined maintenance windows, upfront service-health checks, and a coordinated rollback strategy. upgrade: safe also doesn't guarantee an update happens without any service interruption — package updates can restart services or trigger configuration changes. This is exactly where ChatGPT can help by formulating additional security requirements and turning them into a more complete maintenance plan.

11. The five most common mistakes with AI-generated Ansible playbooks

Common mistakes and better approaches

Mistake	Why it's a problem	Better approach
Running unreviewed AI code	Unexpected changes are possible	Syntax checks, linting, and tests
Using hosts: all	Unintentionally affects many systems	Targeted groups and --limit
Using shell everywhere	Idempotency hard to guarantee	Native Ansible modules
Pasting credentials into prompts	Confidential information can leak	Remove secrets, use Vault
No version control	Changes hard to trace	Git, reviews, and approvals

Another common mistake is asking ChatGPT for a complete playbook without sufficiently describing the target environment. The more precisely you define the operating system, Ansible version, desired end state, and constraints, the better you can evaluate the generated code.

12. Best practices: using ChatGPT and Ansible professionally

For day-to-day operations, a consistent review process pays off. Checklist before a production deployment:

• Define target systems and OS versions
• Review AI-generated code from a subject-matter perspective
• Validate the playbook with --syntax-check
• Run ansible-lint and assess any warnings
• Check for secrets and sensitive output
• Use check mode and, where appropriate, diff mode
• Run it for real in an isolated test environment
• Check a second run for unexpected changes
• Prepare a Git review, sign-off, and rollback plan

For especially critical automations, such as database migrations, firewall rules, or cluster changes, it's worth having a second administrator review the code as well.

Conclusion: ChatGPT makes Ansible administration more efficient — as long as a human stays in control

Ansible and ChatGPT complement each other particularly well. While Ansible reliably brings target systems into a defined state, ChatGPT can help develop, analyze, and document the automations behind it.

The biggest benefit isn't generating as much YAML code as possible automatically. What matters is developing better playbooks faster, catching errors earlier, and automating recurring administration tasks in a traceable way.

For newcomers, ChatGPT lowers the barrier to Ansible. Experienced administrators benefit especially during code review, refactoring, and troubleshooting. If you consistently test AI-generated code, protect sensitive data, and roll out changes in a controlled way, you can use Ansible significantly more productively without losing sight of operational safety.

The most important rule stays the same: AI can help prepare automation — responsibility for production changes stays with the administrator.

FAQ: Ansible with ChatGPT

Can ChatGPT create complete Ansible playbooks?

Yes. ChatGPT can generate complete playbooks including tasks, variables, handlers, and templates. Whether they work correctly in a specific environment still needs to be verified.

Can ChatGPT run Ansible playbooks automatically?

Not just by writing a ChatGPT prompt. Actually running a playbook requires a suitable runtime environment, the right tools, permissions, and an authorized connection to the infrastructure.

Is ChatGPT better than ansible-lint?

The two tools serve different purposes. ChatGPT helps with analysis, explanation, and development. ansible-lint checks code against defined rules. Together they're more useful than either alone.

Can I use ChatGPT for production Linux servers?

Yes, as a supporting tool. Production changes should still go through controlled processes with testing, approvals, and permissions kept as limited as possible.

Can ChatGPT improve existing Ansible roles?

Yes. ChatGPT can review roles for clarity, reusability, idempotency, and possible security issues. There's no automatic guarantee of functional equivalence, though.

How do I prevent ChatGPT from generating unsafe commands?

Define clear security requirements in the prompt. For example, require no destructive shell commands, no plaintext passwords, and no uncontrolled restarts. Also verify the result with technical tools and manual review.

Sources and currency

This article reflects the state of Ansible, ansible-lint, and ChatGPT as of October 2026. Technical details were checked against the official Ansible playbook documentation, the docs on check mode and diff mode, the ansible-lint documentation, and the Ansible Vault guide.

Related topics

How I Use ChatGPT for Linux Administration (Read article)

Analyze Linux Logs with ChatGPT: syslog, auth.log, and journalctl (Read article)

Create Cron Jobs with ChatGPT and Analyze Errors Automatically (Read article)

Debug Docker Compose Errors with ChatGPT: A Systematic Approach (Read article)

Use Codex Safely: Setting Up Git, Sandbox, Backups, and Approvals (Read article)

Protect API Keys in AI Agents: .env, Vault, and Permissions (Read article)

Updated: October 2026.